Rahim Nathwani

Custom statistics for Anki flashcard reviews

Tue, 14 Jan 2025 16:02:08 GMT

Anki stores a record for each review. This powers the built-in stats page, which is quite limited. Luckily, it’s easy to get the data:

File -> Export
Choose Anki Deck Package, Include Scheduling Information and Support older Anki versions
Unzip the resulting file

Extract the review log into a CSV:

sqlite3 collection.anki21 -header -csv "SELECT * FROM revlog;" > output.csv

Load the CSV into pandas

Add date, datetime and week columns:

df['datetime'] = pd.to_datetime(df['id'], unit='ms')
df['date'] = df['datetime'].dt.date

Now you can do things like see the median number of cards per session, seconds per card etc. for a particular period:

(df.groupby('date')['time']
.agg(['sum', 'count'])
.assign(minutes=lambda x: round(x['sum'] / 1000 / 60, 0).astype(int))
.assign(seconds_per_card=lambda x: round(x['sum'] / x['count'] / 1000,0).astype(int))
.tail(21)
).median()

Aggregation

(df.groupby('date')['time']
.agg(['sum', 'count'])
.assign(minutes=lambda x: x['sum'] / 1000 / 60)
.assign(seconds_per_card=lambda x: x['sum'] / x['count'] / 1000)
.tail(21)
)

Custom percentiles (instead of histogram)

custom_percentiles = [0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95, 0.99]
df['values'].describe(percentiles=custom_percentiles)

College textbook scams

Fri, 23 Apr 2021 20:17:00 GMT

College textbooks aren’t just books any more

When I went to university (a long time ago…) books were just books. Paper with printed words. When you bought a book, you were entitled to read the book. Nothing more, nothing less.

Today’s textbooks are often a wrapper for a bundle of services. When someone buys a textbook, they’re often buying:

a physical book
a token to access some other services

Students are forced to buy a bundle of services

This might seem fine, except when you consider that:

the services can only be used once, or by one student
the services are often not for the benefit of the student, but for that of the professor (more on that below)
the student is forced to buy this bundle, even if they already know everything the book teaches

The background

Let’s say I’m a professor, and it is an accepted part of my job to set homework, and provide feedback on that homework in the form of grades (or a % score) and some comments.

Assume the subject I’m teaching doesn’t change much year to year (as far as undergraduates are concerned anyway). So for the last 10 years my course has been based on the same edition of the same textbook. As it’s now 10 years old, there are plenty of used copies available for 20 USD, even though new copies are 50 USD.

The offer

Let’s say a publisher approaches me with an offer that provides ME with more value: a textbook that comes with a code for online access to homework and automatic grading, good for one student for one year only. The catch? The students need to buy the textbook for 50 USD and, because it’s the only way to get a code to allow students to submit homework, they can’t buy a used copy.

If I accept, then:

my students need to shell out 50 USD each for a new textbook (vs. the existing one which would have been effectively free, as they could recoup their 20 USD outlay by selling it at the end of the year)
I get paid the same, but the textbook company takes over some of my work (and I still get paid the same!)

The incentive and the bribe

If I’m the professor in this case, the textbook is offering me something of value (doing some work that I’m already being paid for through students’ tuition fees paid to my employer) in exchange for me forcing my students to give the textbook company money.

This seems no different from a bribe: the publisher will do all your homework marking, if the professor will use their position of authority to funnel student money to the publisher.

Debits and Credits

Fri, 23 Apr 2021 19:36:13 GMT

People are confused by debits and credits

A lot of people (approximately all people who are not accountants!) don’t understand debits and credits. I suspect even many professional book-keepers and accountants just memorise some rules. It’s easier than trying to understand things, especially when many explanations are difficult to understand, or just plain wrong.

There is no need to be confused, and no need to memorise anything

You don’t need to memorize which accounts are negative and which are positive. Just relate them to the English words ‘debtor’ (someone who owes money) and ‘creditor’ (someone who is owed money), and you can work out the right entries for any transaction.

You credit (CR) an account when you’re recording:

an increase in the amount your company owes, or
(equivalent) a decrease in the amount some other entity owes your company

The other entity could be a supplier, a customer, or one of your own shareholders. Shareholders are just like creditors, except that they’re last in line.

Examples of credits that can be identified by the above rule:

A customer pays you some money they owed you: CR Assets - Accounts Receivable
A supplier sends you an invoice: CR Assets - Accounts Payable
You send an invoice to a customer: CR Revenue

The last example might be confusing at first. Why is revenue like something you ‘owe’ someone? Because any profit the company you make does not really belong to the company, but to the shareholders.

If you can work out whether one side of a transaction is a debit or a credit, you know the other side is the opposite. So, for the above transactions:

CR	DR
Assets - Accounts Receivable	Cash
Assets - Accounts Payable	Expenses
Revenue	Assets - Accounts Receivable

Building AGI Using Language Models

Fri, 23 Apr 2021 19:31:44 GMT

This article is great. You should go and read it. Afterwards, if you’re scratching your head about the overall point, this might be helpful:

tl;dr Language models like GPT-3 include incorporate some model of the world. That’s why they can generate plausible-sounding text. Future language models will be larger, more powerful, and have more complete models of the world. So we will be able to ask the language model questions, like ‘what will happen if we do X?‘. By compiling the answers to many such questions, we can figure out the best[0] thing to do.

[0] Assuming you have some utility function you can maximize.

Reading epub files

Fri, 23 Apr 2021 19:06:09 GMT

ePub is a popular format for electronic books. Just like the mobipocket format (used for Kindle books), ePub is a container for HTML and CSS. For this reason, you’d think that reading ePub books on any platform would be as easy as opening a web page.

Sadly, this isn’t the case. On any platform, it’s easy to find an ePub reader, but you won’t necessarily get a good one. An ePub is much easier to read if the reader renders sharp text without distractions, and lets you change the font size and padding.

My favourites for each major platform:

Linux: Foliate
MacOS or iOS: Books (formerly known as Apple iBooks, this comes pre-installed)
Windows: Sumatra PDF (don’t let the name fool you!)
Android: Moon+ Reader

Monty Hall Problem

Fri, 23 Apr 2021 18:53:03 GMT

The game

The Monty Hall Problem is a brain teaser that is (was?) often used in investment banking interviews. If you’ve never heard of it, here’s a summary:

You’re on a TV game show. There are three closed doors:

One door has a car, which will be your prize if you choose that door
The other two doors each have a donkey

The aim of the game is to choose the door with the car. The game mechanics are thus:

You choose a door
Monty (the host) opens one of the other two doors, revealing a donkey.
Now there are two unopened doors. You choose whether to stick with your original choice, or switch to the other unopened door.
All is revealed.

The question is: at step 3, should you switch?

The mistake

Most people, when encountering this problem for the first time, think there’s no benefit to switching. But, oddly, this isn’t right.

Another way to think about it

Assuming you understand the rule (that Monty will always open a door you didn’t choose, and that door always has a donkey behind it), then one way to understand the game is:

You can choose to have:

The most valuable prize that’s behind door A, or
The most valuable prize that’s behind doors B or C

When you look at it this way, it’s obvious that you would rather have the most valuable prize from the ‘other’ doors, and the way to do that is to switch.

The intuition above is easier than trying to compute probabilities, and thinking about whether the probabilities change once Monty opens the door with the donkey.

If you need convincing, here’s a simple python script based on the above:

import random

donkey = 0
car = 10  # car is worth more than a donkey
prizes = [car, donkey, donkey]  # there's always exactly one car
N = 1000000

def pick_a_door(prizes):
    random.shuffle(prizes)
    my_pick, *other_doors = prizes
    return [my_pick, other_doors]

def keep_or_swap(my_picks, keep=False):
    if keep:
        return my_picks[0]
    else:
        # if you switch, and one of the other doors had the car, you
        # will definitely get it, so you get the max() of those two doors
        return max(my_picks[1])

print(sum([keep_or_swap(pick_a_door(prizes)) for i in range(N)]) / N)

print(sum([keep_or_swap(pick_a_door(prizes), keep=True) for i in range(N)]) / N)

If you’re still thinking about whether the probabilities change, consider whether ‘Monty opens a door with a donkey behind it’ is new information. It’s not because he always does that. And the two doors you picked are fungible/identical except for physical position, as both are in the set of doors you didn’t pick. So which one he opens is irrelevant.

Central Bank Digital Currencies: A common misunderstanding

Fri, 23 Apr 2021 18:05:00 GMT

There has been a lot of talk recently about Central Bank Digital Currencies (CBDCs)

Central banks around the world, including those in China (People’s Bank of China) and the UK (Bank of England) have shared plans or ideas about how they will make their currencies digital.

The idea of a digital pound (or digital Yuan, or digital dollar) is often misunderstood. Many people have virtually stopped using cash:

In China, people use AliPay or WeChat for virtually all daily transactions
In the UK and US, people use credit/debit cards to pay businesses, and apps like Venmo or Zelle to pay individuals

People’s day-to-day experience with money is that it’s all digital: numbers on computers. So how might CBDCs be any different?

Let’s take a simple transaction: I send money from my UK bank account to someone else’s UK bank account. This sure seems like I’m transferring digital pounds. But this transaction simply transfers an obligation (a debt) denominated in pounds between parties. Before the transaction, the bank owed me some money. Now, the bank (or some other bank) owes a different customer some money. No actual pounds (i.e. no central bank currency) changed hands.

The fact that a payment happens electronically doesn’t mean that the thing you’re trading is digital

You can trade ‘pork bellies futures’ quickly, and using nothing but a computer. But no one claims pork bellies are digital. When people trade, they’re effectively trading IOUs, and not the actual bellies.

CBDCs already exist, but not everyone can use them

Retail banks and other important financial institutions already have digital central bank money. In the UK, these are called ‘central bank reserves’. They’re just like bank accounts that you and I have, except that the ‘bank’ where the account is held is the Bank of England, i.e. the entity that issues the money in which the account is denominated.

If you have a piece of paper signed by the Bank of England governor, saying that the Bank owes you 50 GBP, this is actually 50 GBP. The same goes for a numbers on a screen (say if the Bank of England gave you an account, along with a way to see your balance online). But the ‘money’ shown in your regular bank account is not central bank money: it’s an obligation/debt of your bank (HSBC, Barclays, etc.).

Bank balances are similar, but not the same

Maybe you’re not convinced by what I’ve written above. Maybe you think that, because the money in your current account (aka checking account) is just as useful as central bank money, that it really isn’t any different.

If so, consider this question: If you have 200k GBP in your current account, and the bank goes bust, do you still own 200k GBP? (BTW I chose 200k GBP as as the figure here, because then any arguments about FSCS, the UK’s FDIC equivalent, are irrelevant.)

Summary

A Central Bank Digital Currency would allow individuals to hold and transfer ‘real’ pounds (M0). Currently, only banks and selected other financial institutions can open accounts at the Bank of England.

Learning Python for Data Analysis

Mon, 05 Oct 2020 02:11:00 GMT

A friend-of-a-friend who recently graduated from a great university with a non-STEM degree asked how to learn python for data analysis and data science. After understanding their level (zero programming experience) and initial goal (be able to analyse structured data in Python), I suggested they work through these resources, in this order, doing all exercises suggested in the text:

Learn Python 3 the Hard Way, exercises 1-39
Data Science from Scratch, chapters 1-3
Pandas for Data Analysis, chapters 1-6
These pandas exercises
Pandas for Data Analysis, chapters 7-12

I also told them…

If, after the first two items above, you want a slower introduction to Python, this coursera course would do the trick.

The Coursera course on Data Analysis covers some of the same ground as the above, and has good reviews. I’ve not used it myself so can’t say how the sequence of topics covered is different.

Most important:

Do the exercises. You will not learn otherwise.
Find some data you want to analyse yourself, and apply what you’ve learned to find answers to questions
Next time you reach for Excel to analyse some data, try to do the same analysis using python/pandas

Finding a technical co-founder

Mon, 05 Oct 2020 00:49:00 GMT

A smart friend recently emailed me about a business idea, and asked for my advice. I realised the reply I sent would be equally helpful (or unhelpful!) to anyone in a similar situation, so here it is:

Glad to hear you’ve found something you want to work on! Exciting times ahead.

I’ve written some initial thoughts and included some links below. But it’s probably best if we find some time to talk. My calendar is here.

Regarding finding a technical co-founder, a few immediate thoughts:

There are many more people who have an idea but little/no ability to execute independently, than there are engineers who lack an idea. So you will need luck and/or a compelling pitch.
When you say ‘technical co-founder’, I assume you mean ‘engineer willing to work with zero cash compensation’. (Maybe I’m mistaken, but this is usually what people mean.) Given that good engineers are in high demand (at least here in North America), the opportunity cost needs to be worthwhile. So you need to be willing to see them as a partner, with a decent chunk of equity. Many people think that just by bringing an idea, they should have 95% of the initial equity, whilst the technical co-founder (whose skills are equally, if not more, valuable) should get 5%. So it’s important to be realistic about this. When you co-found a company with people, it’s important for founders’ equity to vest. Otherwise, if one person leaves, they have a large chunk of equity even though most of the work is still to be done.
The most impactful things you might do to to attract and close a co-founder:
- have committed seed money (either your own, or from an angel or VC)
- have built a prototype of the thing that you can shop around to potential customers
- have several years of domain experience in the specific industry or problem space, and a network of people you can tap for learning about customer needs, or sales pitches
- have some potential customers who have signed letters of intent, or have given you money

The more of the items in #3 you have, the higher chance that someone good would agree to be a co-founder with you. Those things will appear valuable to a potential co-founder exactly because they’re valuable to the business (i.e. increase the chance of the business succeeding).

As far as sourcing people, I don’t know anyone who’s looking for an opportunity like this right now. One good place to find people is Hacker News (https://news.ycombinator.com), a discussion forum for startup/engineer folks. It’s worth spending an hour reading:

how other people have pitched when looking for technical co-founders
how engineers have reacted
how (some) engineers think about the decision

You can search previous discussions here:

https://hn.algolia.com/?dateRange=all&page=0&prefix=false&query=Technical%20co-founder&sort=byPopularity&type=story

and here:

https://hn.algolia.com/?dateRange=all&page=0&prefix=false&query=Technical%20co-founder&sort=byPopularity&type=comment

Some common perspectives worth reading:

Understanding your target co-founder profile better will help you refine your pitch, anticipate objections and, most importantly, help focus your current effort on things that are most valuable. Those things will be valuable to a potential co-founder precisely because they’re valuable for your startup.

Learning about Machine Learning

Sun, 04 Oct 2020 23:57:00 GMT

A friend recently asked for pointers to learn about machine learning. I’m not an expert, but have spent a bunch of time learning and experimenting, using many different resources. The list below is for people who can already code well enough to build products, but have little/no background in machine learning.

I wrote this list in Fall 2020.

To learn how to do stuff:

(free online course; excellent pedagogy) Practical Deep Learning for Coders

To learn about what’s possible:

The Hundred Page Machine Learning Book

To learn from fundamentals - books:

To learn from fundamentals - video courses:

Machine Learning (this is Andrew Ng’s original machine learning course, and has stood the test of time). NOTE: even though the course says to use Matlab/Octave, you can do all the exercises using python/pandas, using these jupyter notebooks
Deep Learning Specialization (this is newer, and is less theoretical than the one above, with more focus on modern tools)

If you’re not sure where to start, start with Deep Learning for Coders.

Converting a server-rendered Python app into a single page Progressive Web App

Wed, 29 May 2019 07:25:57 GMT

I wrote before about a simple web app I created to teach my son maths. You can find the article here, the code here, and the live app here.

Looking at the code, you might wonder: why would you require server round-trip for every new card? Why can’t you just generate the next set of random dots on the client side?

I had the same thought, so I set about translating the code to client-side JavaScript. If you’re impatient, you can see the result here. If you want to know what I did, it was mostly these pretty painless steps:

Paste the existing code into a <SCRIPT> tag in an HTML file
Add parentheses around if conditions
Change the format of function definitions and if clauses, by using {} instead of :
Convert list comprehensions into for loops
Instead of assembling the DOM using string interpolation, do it piece by piece using document.createElementNS() and .setAttribute()
Replace some random.normalvariate(0,1) with Math.random() * 2 - 1, which doesn’t do the same thing, but works well enough
A very small amount of other cleanup

The above was enough to make the app work, but I was unhappy with needing to enter the min/max values in the URL. So I also used the excellent Tailwind CSS to add a footer and some buttons to increment/decrement these values. I wanted two-way binding between the values shown in the UI, and the values in the URL. Using a sophisticated mechanism (or a library) for such a simple app would be overkill, so I wrote some ugly code instead:

    function get_values_from_hash() {
      if (location.hash.length > 0) {
        [lower, upper] = location.hash.split("#")[1].split('/');
        lower = parseInt(lower);
        upper = parseInt(upper);
      } else {
        [lower, upper] = [1, 5]
      }
      return [lower, upper]
    }

    function set_values(lower, upper) {
      location.hash = "#" + lower.toString() + "/" + upper.toString();
      document.getElementById("lower").innerHTML = lower.toString();
      document.getElementById("upper").innerHTML = upper.toString();
    }

    function adjust_lower(n) {
      [lower, upper] = get_values_from_hash();
      lower = Math.max(1, lower + n);
      upper = Math.max(upper, lower + 4);
      set_values(lower, upper);
    }

    function adjust_upper(n) {
      [lower, upper] = get_values_from_hash();
      upper = Math.max(5, upper + n);
      lower = Math.min(lower, upper - 4);
      set_values(lower, upper);
    }

Now the code doesn’t need a server, I figured I should make it work offline, and installable as a PWA. It turned out this was pretty simple, using some example service worker code from Google, and adding a simple web manifest and icon.

There’s one thing left to do: make the bottom bar stick to the bottom of the screen. Currently, I’m using the CSS style height: 100vh via Tailwind’s h-screen utility class. This works fine on desktop, and when the app is installed and launched via a mobile launcher icon.

But, when the app is opened on a mobile web browser (e.g. Chrome on Android), the visible part of the page is shorter than the screen (due to the address bar and browser navigation bar), so part/all of my bottom bar scrolls off the page. This is a well known problem with using height: 100vh and there are lots of workarounds. I had a quick look, and none of the workarounds I saw look elegant, so I’ll fix this another day.

The app is at https://dots.twilam.com/. To see the source, just view source in your browser.

Persistent State in Vue/Svelte NativeScript apps

Thu, 09 May 2019 16:13:00 GMT

What is NativeScript?

NativeScript is a framework for building mobile apps with JavaScript. At the time of writing, there’s official support for Angular, Vue and plain JavaScript/TypeScript.

There’s also a community project to allow you to build native apps with Svelte v3. Svelte has a beautiful and detailed tutorial that is run entirely in the browser. Be careful if you click this link: once you start the tutorial you’ll want to spend the time to get to the end.

What do I mean by persistence?

Let’s assume we have a ‘to do’ app. When a new item is added, we would like:

The new item to be shown on the screen, in the list of todos
The new item to be stored somewhere, so it can be used by other parts of the app (e.g. maybe we have a ‘summary’ screen which shows stats about how many todos we have)
Be saved on the device, so that when the app is quit and re-opened, all our todos are still intact

How do we persist things now?

In components

If you’re using Vue, then your state is maintained in the component tree. You know it’s there, because otherwise the data shown on your screen would never change. Many people use Vue to add a little interactivity to specific pages/forms in a traditional web app. If that’s how you use Vue, then you probably persist your data by POSTing the results to a form or something, and you don’t need to worry about maintaining state in some clean way.

Using a global state store

If you’re developing a single-page app (SPA) or more complicated Vue application, then you’re probably using Vuex to maintain a single state across all your components. (For those new to Vue: Vuex does a similar job to Redux or MobX).

So how do we keep our state even when the app quits?

When you’re developing for a browser, you use the LocalStorage key-value store. That’s fine as it goes, but you probably don’t want to have calls to LocalStorage.setItem and LocalStorage.getItem all over your code.

If the application state (stored in e.g. Vuex) isn’t too large, then you might want to persist the whole thing in LocalStorage. That’s where a couple of handy packages come in:

Both of these packages will automatically sync your Vuex store with the browser’s LocalStorage

Can we use the same approach in native apps?

Almost. Native apps developed with NativeScript don’t have LocalStorage. Thankfully, there’s a package that fixes that: nativescript-localstorage. After importing this package, you can do LocalStorage.setItem etc. Under the hood, it uses file system access to create and maintain a file called localStorage.db which contains a JSON string of your app’s state.

What about Svelte?

There’s a nice example of how to do this with the previous version of svelte. The code below is from https://github.com/sveltejs/template-store:

export default function useLocalStorage(store, key) {
	const json = localStorage.getItem(key);
	if (json) {
		store.set(JSON.parse(json));
	}

	store.on('state', ({ current }) => {
		localStorage.setItem(key, JSON.stringify(current));
	});
}

This code does two things:

When it’s first imported, it checks if the old state was stored in LocalStorage. If so, it parses it adds it into the store.
Whenever the state changes (store.on), it writes the entire state to a JSON string, and writes it to local storage again.

To make it work, this file needs to run once after the store is created. From main.js in the same repo as above:

import { Store } from 'svelte/store.js';
import useLocalStorage from './useLocalStorage.js';

const store = new Store({
	name: 'world'
});
useLocalStorage(store, 'my-app');

All that is needed to make the above work in a NativeScript app is to add import localStorage from 'nativescript-localstorage'; before using localStorage.

The API for Svelte has changed a lot in the run-up to v3, and on doesn’t appear in the documentation. However, you can use store.subscribe instead of store.on.

Here’s a repo with a simple Svelte Native app with persistent state.

Quick Add for Monica CRM: A simple app I developed

Mon, 06 May 2019 07:13:57 GMT

Monica CRM is a great open source contact manager, but at the time of writing (early 2019) there’s no official mobile client.

I made a simple ‘Quick Add’ app for Android that works well for me. It might work well for you, too. Get it here.

Why

Adding contacts via the web interface is a little slow for me, because:

I live in China, and connections to servers outside China aren’t always fast or reliable.
I often want to add notes for a new contact, and
I sometimes want to add contacts when I have no internet connection, and this isn’t possible via the web UI.

What the app does

It lets you enter a person’s name (forename and surname) and some notes about that person. When you’re done, just tap ‘Save’ and you can continue adding someone else, or just do something else.

There’s no waiting, because the new contact and new notes are uploaded in the background. And if you have a bad network connection (or are on a plane), the information is saved on your phone temporarily. Once you have an internet connection, it’s just one tap to upload all the pending contacts to Monica.

How you connect the app to your Monica account

In order to use the app, you need a ‘Personal access token’, which you can create in the Monica web app. Just click the settings icon in the menu bar, then click ‘API’ on the left hand menu. You will see a button ‘Create New Token’ which generates a new token.

Here’s a short (4 minute) video showing installation, configuration and usage: https://youtu.be/6SsJ5QSDglg

How I built the app

I wanted to build a cross-platform app that wasn’t just a wrapped WebView, which meant choosing between Flutter and React Native. It wasn’t an easy choice, but I decided to go with React Native as it’s been around for longer and there are lots of good resources on Udemy, Stack Overflow etc.

React Native itself has many many dependencies, and I tried to add direct dependencies only when I had a real need:

react-native-navigation: to provide a bottom-tabbed UI
react-native-elements: to get some nicer default styling, and a pre-built component for list items
react-native-vector-icons: easy access to icons for bottom tab navigation, and also required by react-native-elements
redux: added only after I created a mess trying to pass state between two tabs that were based on two components in different files
redux-persist: added to reduce the amount of code needed to store some state in both redux and local storage
redux-thunk: added to make it easy to trigger network requests

This was my first time developing a mobile app with React Native, and I took a few wrong turns. Notably, I spent a bit too much time trying to structure the code for state management and networks requests properly. Once I started using redux, everything became easier.

If I were to do something similar again, I would take a look at these:

redux-saga as an alternative to redux-think (it has more features, so maybe it’s better?)
ant-design-mobile-rn as an alternative to react-native-elements (it has more components and built-in styles, so maybe it’s better?)

BTW - This app has no relationship with Monica CRM or its creators. If it works for you, great! If not, please don’t bother Monica’s developers for support, as they likely can’t help.

How to learn Chinese

Fri, 26 Apr 2019 02:58:58 GMT

Chinese is not easy, but mostly success depends on:

Active study: Putting in the time and effort to master basic sounds, basic vocabulary and sentence structures
Practice: Listening and speaking with native speakers. Don’t be afraid to make mistakes, or you’ll never practice, and never get better; don’t fall back to English unless absolutely necessary)
Drilling vocabulary: Using flashcards to drill new vocabulary

Getting practice

Living in China

Consider coming to China for a couple of months, after you’ve learnt the basics. You’ll improve much more if you make the effort to hang out with Chinese people in the evenings, after spending the day studying or working with a teacher.

Language exchange over Skype:

Check out italki.com to find language partners and/or language tutors in China

Audio courses

These can be good as a supplement to book learning and practice. They’re not a substitute. I found audio-only courses helpful when I started learning Chinese, as I could listen to them when on public transport or when driving. I have a friend who spent >10 years in China, and he would always listen to ChinesePod when commuting, even after he’d been through each lesson >10 times. His Chinese is better than mine.

CD sets

These are both good for the early stages:

Online audio courses

ChinesePod.com (really good subscription-based service, with a free trial)
Pop up Chinese (similar to Chinesepod, but I’ve not tried it)
Yoyo Chinese (similar to Chinesepod, but I’ve not tried it)

Learning to write

There are three main reasons for a foreigner to learn to write Chinese:

Because you expect writing by hand to be useful in daily life (not applicable to most people, even most Chinese people)
Because writing Chinese characters helps to recognise written characters, especially to distinguish between characters that look similar
Because it’s fun/interesting/cool/authentic/whatever

You don’t need to be able to write by hand if you just want to be able to type in Chinese. You can use a Pinyin (romanised) input method on your laptop/phone/tablet.

If you want to learn characters, you can use a book and copy out the characters repeatedly. But if you want to maximise efficiency, then Skritter is worth a look. I used it years ago, using a Wacom tablet. But I think they have phone/tablet versions now. It uses spaced-repetition, and very clever hinting. It’s surprisingly engaging and useful.

Dictionary / Flashcards (essential)

Pleco for iPhone or Android

The free version is good. There are in-app purchases for additional dictionaries and flashcard functionality. Using flashcards within Pleco (vs. a standalone flashcard app) is great: whenever you look up a word in the dictionary, you can add it to your flashcard queue with a single tap.

Other flash card programs:

Memrise (iPhone or Android)
AnkiDroid (free for Android)
Anki (free for desktop, but paid for iPhone/iPad).

Pronunciation:

The basics of pronouncing tones, You really need to get your pinyin and tone pronunciation down. Just search google for ‘learning pinyin’ and you will find lots of free resources. BUT you need a native Chinese speaker to listen/correct you once you think you’ve got it. If you live in a big city, go to meetup.com to find a Chinese language learners/exchange meetup.

Books that are worth considering

Modern Chinese Mandarin Grammar (Routledge)

Excel best practices for financial models

Fri, 12 Apr 2019 11:34:25 GMT

If you use Excel for financial modeling, you have probably had one (or more) of these things happen to you:

You give your model to someone else (e.g. an investor) and they come back with many questions because they can’t understand the logic
You feel stressed when you’re making changes because there is a lot of information to hold in your head
You open a model you last used months/years ago, and you need a bunch of time to figure out what you were thinking

The tips below can help. When you read through the list, your reaction to each item will likely be one of:

Yup, I already do this
Yup, I know about this, and I do it when I have enough time
I don’t see the point

I’ve designed and delivered training courses in accounting, financial modeling and Excel to engineers, product managers (and finance professionals!) at companies you’ve heard of. When people who’ve attended ask for help to improve a spreadsheet, or advice on how to add some feature to a complicated model, the answer almost always is to make the functioning of the model more obvious, logical and, most of all, transparent.

Apply the tips below to one of your models. It will make your life easier.

Formulae

Use `INDEX` and `MATCH` instead of `VLOOKUP`

Don’t do this: Use VLOOKUP to find the value in a particular column/row of a table

Do this instead: Use MATCH to search in the lookup column, and INDEX to pick out the value

Why: If you use VLOOKUP, then you need to reference a whole table, and specify the column by it’s sequence. But if you insert a new column anywhere to the left of that column, the column number in your VLOOKUP formula will be wrong, and your formula will return the wrong value. Using INDEX and MATCH is better because you reference only the 2 relevant columns (not the whole table), which means they are more efficient to calculate, and that the formula doesn’t break when you add new columns.

Good example: https://exceljet.net/index-and-match

Positive and Negative numbers

Don’t do this: Make all numbers positive. Use addition/substraction as appropriate.

Do this instead: Use both positive and negative numbers, e.g. revenues should be positive, and costs should be negative. When making totals or subtotals, use only addition (either + or SUM).

Why: Formulae with lots of + and - symbols are hard to read. Showing all numbers as positive makes it hard to understand what’s going on, without inspecting the formulae that calculate subtotals or totals.

Separate inputs from formulae

Don’t do this: Hard-code numbers in a formula (e.g. =A13/365)

Do this instead: Put any input (hard-coded number) into its own cell, e.g.

A1: Number of days in the year

B1: 365

A10: Annual Revenue

A11: Daily Revenue

B11: B10/B1

Why: The model will be easier to understand, easier to audit, and easier to fix.

Use `$` to fix row/column within formula

Don’t do this: Modify individual formulae by hand when copying them across a row, or down a column

Do this instead: Use the $ symbol to fix references to a particular row or column

Why: If you have ‘interest rate’ in cell B1 (among inputs at the top of your sheet), and you have a formula that references it:

=B1*B11

When you copy that formula and paste it to the right, the pasted formula will be:

=C1*C11 (and C1 is probably empty!)

But what you probably wanted was:

=B1*C11 (i.e. apply the same interest rate, but to C11 instead of B11)

You could avoid this hassle in the first place if your first formula were instead:

$B$1*B11

Then, when you paste it one cell to the right, it will be:

$B$1*C11

The reason we fix both the column (B) and the row (1) is because we are referring to a specific global input, not a row or column of values. In other examples, you might just fix one or the other (using just a single $ symbol).

How: Select the cell reference within your formula, and press F4. Press it again, and again, until the $ signs are in the right places.

Simplify formulae

Don’t do this: Use complicated formulae (e.g. containing multiple IF/OR/AND functions)

Do this instead: Split complicated formulae between separate cells or separate rows.

Why: Complicated formulae frequently hide complicated logic, e.g.

=IF(AND(MONTH(A1)>5,MONTH(A1)<9),C4,D4)

is harder to understand than two separate formula:

Is summer?

=AND(MONTH(A1)>5,MONTH(A1)<9)

Rainfall per month:

=IF(B2,C4,D4)

Circular References

Don’t do this: Use circular references to optimise a value

Do this instead: Don’t use circular reference unless you really really know what you’re doing. If you’re not sure if this applies to you, then don’t use circular references.

Why: There are very few cases in which circular references are the right way to solve a problem. In all other cases, circular references will make the output of your model hard to reason about, and will increase the chance that you make an error.

Named cells and Named Ranges

Don’t do this: Use named ranges and names

Do this instead: Don’t use names or named ranges.

Why: If a formula refers to a named cell, anyone looking at the model needs to use the ‘Trace Precedents’ command to find where that cell is, making the model harder to understand and audit.

Balancing items

Don’t do this: Use ‘plugs’, i.e. formulae for balancing items

Do this instead: Calculate every item directly when possible

Why: If you calculate an item as a balancing item, then:

you can’t do an error check on your total, and
no one can reason about the components of that figure.

One of the few cases when a balancing item is acceptable is when you’re building a financial model and each period has a ‘new debt/equity funding’ line. In this case, the funding requirement is a direct result of the other items in the column, so it’s OK.

Formatting

Colour coding

Don’t do this: Leave all cells as black-on-white

Do this instead: Colour code any cell that contains inputs (hard-coded numbers), with either (i) yellow background, blue text, or (ii) orange background, grey font

How: Use the ‘Cell styles’ section in the ‘Home’ ribbon to use the pre-defined styles. You can customise these styles if you don’t like them. Or you can just change each cell’s background colour and font colour as you normally would (not recommended, as it’s hard to stay consistent).

Number precision

Don’t do this: Display numbers with many digits of precision

Do this instead: Display numbers with a maximum of 4 significant figures (but usually 3)

Why: The 4th or 5th significant figure is usually insignificant (do you care about less than 0.1% difference?), and every additional number on the page makes your spreadsheet harder to read, and therefore less useful.

Left/right alignment

Don’t do this: Centre numbers

Do this instead: Leave Excel to align things automatically

Why: Numbers in a column are easier to compare when right-aligned. Text labels in a column are easier to scan when left-aligned. The default in Excel is to left-align text, and right-align numbers, so there’s usually no need to change anything

Signifying negatives

Don’t do this: Use the default number formatting in Excel

Do this instead: Signify negative financial values using brackets, and maybe also red font

Why: Brackets are larger and much more obvious than the dash that normally signifies numbers.

Borders / Underlining

Use borders consistently:

Single line at the top of a cell indicates that this cell is a subtotal
Single line at top, and double line at the bottom, indicates this is a grand total

Model Structure

Single input only

Don’t do this: Enter the same input (hard-coded value) in more than one cell

Do this instead: Enter any input (hard-coded value) only once in the whole workbook, and reference it using a formula anywhere else it is needed

Calculations across sheets

Don’t do this: Reference values from another sheet in a calculation

Do this instead: Use formulae to link the values from the other sheet in a separate row/column in the current sheet, and then (in a separate row) write your formulae to reference this row of values on the current sheet.

Why: It is easier to audit a formula when you can see the number it depends on, without flipping between sheets

Hidden rows/columns

Don’t do this: Hide rows to make your spreadsheet easier to read

Do this instead: Don’t hide rows.

Why: People using your spreadsheet want to know how it works. If you hide rows, they cannot trust the calculations, because they cannot see them.

Multi-purpose columns/rows

Don’t do this: Mix different types of values in a row (e.g. GAAP and non-GAAP)

Do this instead: Keep different types of values in different rows (e.g. one row for GAAP, and another for non-GAAP). Even if some columns don’t include values for some rows, that is better.

Why: People assume things in the same column or row are comparable. Mixing different types of things means that neither the column nor the row contain the same type of value.

Arrange sheets in a logical order

Don’t do this: Arrange your sheets in the order in which you created them Do this instead:

Arrange Assumptions sheets to the left of Calculations sheets
Arrange Calculations sheets to the left of Output sheets
If you have a cover sheet, obviously put that as the first (left-most) sheet

Check for errors

Don’t do this: Hope that everything adds up

Do this instead: Use error check rows to check that key identities hold (e.g. Capital - Assets - Liabilities = 0)

How: Make a formula that shows ‘ERROR’ if the identity doesn’t hold, but shows nothing if it does. Use a red font or red background for that cell.

Macros

Don’t use macros

Do this instead: Just use formulae instead.

Why: Macros make the logic of your spreadsheet harder to understand, both for others and for your future self.

Scenarios

Don’t do this: Make copies of sheets for scenarios Do this instead: Use the same input, calculation and output sheets for all scenarios, and use a single input cell to choose which scenario you want to run

Why: Having multiple copies of the ‘same’ sheet makes it hard to make changes to your model, as you need to update structure and formulae in different places. It also makes it hard to audit, as there are more sheets to audit.

How: Arrange your spreadsheet like this:

Column A: Input labels
Columns C, D, E: Input values for scenarios 1, 2, 3
In column B:
- An input cell at the top, that contains the current selected scenario #
- All other cells use an INDEX() function to choose the correct current input from the cells to the right
- All calculation sheets refer only to column B

Numbers

Billions

Don’t do this: Store numbers in thousands or millions

Do this instead: Store numbers in units (i.e. enter 1MM as 1000000) and use number formatting to display them as 1MM or however you want

Why: If you store some numbers in thousands, and some in millions, and some as units, then your formulae will be complicated. For example, if your revenue is in billions, but your number of shares is in millions, then your EPS calculation will be something like X1/Y1*1000

Good example: https://www.ablebits.com/office-addins-blog/2016/07/07/custom-excel-number-format/

Enter numbers as numbers

Don’t do this: Enter column headings like ‘2018 FY’ as text

Do this instead: Ensure all years are entered as numbers, and use number formatting to add any extra text

Why: Excel can automatically increment numbers when a range of numbers is extended, but cannot do the same for text. This reduces the risk of error.

Presentation

Empty columns

Don’t do this: Include empty columns to create space between columns

Do this instead: User proper alignment and column width

Why: The more cells a model has, the harder it is to audit and understand it properly. Adding blank columns doubles the number of cells, and anyone reading your model will need to verify that those columns are actually empty, and don’t have numbers that affect formulae.

Printing

Don’t do this: Send a spreadsheet to someone without making sure it prints properly

Do this instead: Set up each page to print how you want it to appear

Why: Some people print spreadsheets or convert them to PDF, to share with others. If someone tries to do that with something you send them, and it looks bad, it will just make them annoyed at you.

How: On each sheet, use the Page Layout tab:

Margins (set to normal or narrow)
Orientation (set to landscape)
Size (check that it’s A4)
Width (set to ‘1 page‘’)
Height (set to ‘Automatic’ or a specific number of pages)
Print Titles - set ‘Rows to repeat at top’ and, if applicable, header+footer (with name of file and name of sheet)

Comments

Don’t do this: Let people guess where numbers came from

Do this instead: Use comments to explain specific terms or the source of an input

Sheet names

Don’t do this: Leave worksheets named as Sheet1, Sheet2 etc.

Do this instead: As soon as you add a second sheet to a workbook, rename Sheet1 and Sheet2 to sensible names

Why: Make your stuff easy to use!

How to transform capability growth into compensation

Fri, 12 Apr 2019 08:51:25 GMT

A friend of mine joined startup that later started going through rapid growth. His responsibilities went up, and he got the chance to increase his capabilities and contribution rapidly. He wanted his compensation to grow as well, whether he stayed at the same company or not. This is what I told him…

Caveat: All of these things are easier said than done!

As an employee, there are 3 ways to get paid more:

Negotiate a better package when you join
Be awarded (or negotiate) a better package (or more equity) after you join
Get a compensation bump/surprise due to your already-awarded equity (e.g. your employer’s stock goes up in price) or beating some sales compensation formula target

#3 is either about picking a company whose share price is going to rise (if you can reliably do this, become a full time investor!), or applies mainly to sales-related jobs [not relevant to my friend’s situation].

#2 is common at large tech companies if you land in a good team and are able to grow your scope and role. Obviously this doesn’t work out for everyone. But somewhere like Google, they have salary bands for each role at each level, and try to have a fair promotion process. So if you get promoted (not necessary a role change) then your salary won’t be below the lower bound for that level.

#1 is the time you have most ability to influence, because:

You’re considering more than one company. So, assuming all companies don’t value you equally, one of them might value you higher. (compared with when you’re already in a job, your current employer might not happen to be the one that values you highest)
You’re not fighting any internal HR policies about how much of a % raise they can give in a certain period. These are not universal, but many companies have these policies. (Some companies have a policy of how much they can offer above previous salary, but that’s much less common. Normally it’s just a data point to estimate your market value.)
The company may need someone with your skill set immediately, and it may be harder to find than you think. So their alternative isn’t not giving you the right compensation, and having a risk that you leave in 6 months. It’s not hiring you now, and missing out on what you would contribute to the bottom line now.

Practically, this means your chances of a good outcome are maximised if you can:

Get multiple offers
Get offers from multiple companies at around the same time. Then you can gently but confidently discuss your situation with the recruiter (or whoever is negotiating).
Find a role that fits like a glove
Find a role for which you’re the perfect fit, or at least a very close one. The fastest job offer I got was for a role where, I found out later, no other applicant came even close to meeting the requirements. To me it was an attractive role, and I really enjoyed the interview process (maybe because they were testing things I was strong on!), but I still felt they could find someone else. But it turned out it had been really hard.
Use time to your advantage
If you’re in a hurry to get a new job, then that makes it harder to follow the first two pieces of advice. But It also goes the other way: if the company is in a rush, then they should be willing to pay more to close. An extra 10% salary can be a lot to an individual, but it’s much less than the cost of paying a 25% fee to an external recruiter every year or two.
Don’t forget the small things
Itemize as best you can the cash value of benefits you get from your existing employer, e.g. free food or gym membership or whatever. If moving cities, ask for relocation allowance if not already offered. See if they can give you a signing bonus or similar, to make up (partly) for the unvested equity you’re giving up.
Appeal to fairness
Give objective comparable information, and appeal to fairness. This is most useful if the company just has unrealistic ideas about compensation for certain roles/levels. Smaller companies may not do external benchmarks so might need educating.
Align incentives
At a smaller company, or for a senior role, you can also try to negotiate some very specific and challenging performance-based bonus, making it low risk for them. But that’s really tricky even if they agree, because it’s unlikely you have 100% control over the output, so you could miss it even if your performance is awesome.

The advice above doesn’t apply as much to companies that care a lot about fairness. Those companies try not to penalize you for having a low salary in the past; they will evaluate your level as best they can, and pay according to that. So going to work for a ‘fair’ company like this can be a good thing if you’ve been underpaid in the past and don’t want to fight to get what you’re worth.

This all assumes you’ve done your best to find a role that’s a good fit, and wowed the team with what a good fit you are, got them excited to work with you etc. If they really want *you* rather than just another similar person, then it makes it easier for them to pay more than they were initially expecting.

Your point about new employers initially anchoring on past salary is absolutely true. But they generally look mostly at the most recent salary, so a low salary at one job doesn’t follow someone around forever, so long as they can convince one employer at some point of their value. Then the next employer will look at that one.

Teaching your toddler maths

Thu, 11 Apr 2019 16:12:45 GMT

The book How to Teach your Baby Math, by Glenn Doman, recommends teaching babies/toddlers numbers by showing them cards with dots on them, one at a time, whilst saying aloud the number of dots.

Instead of making your own cards and using your own voice, you can run this web app and use your smartphone and thumb.

https://doman-236804.appspot.com/5/10

The initial screen is blank. Tap anywhere on the screen to show some dots and hear the number. After about a second, the screen will again be blank, ready for you to tap again.

The URL above will show numbers from 5 to 10. Change the numbers at the end of the URL if you want a different range.

If you want to host this yourself, or improve it, you can find the source code on GitHub.

Books about OKRs

Thu, 11 Apr 2019 16:02:08 GMT

Measure what Matters by John Doerr
By the guy who introducted OKRs to Google. Has lots of stories.
Move by Patty Azzarello
A really great book on executing strategic change, that has a section about setting ‘Control Points’, which are roughly equivalent to what Intel/Google etc. refer to as ‘Key Results’. I keep coming back to this book.
Radical Focus by Christina Wodtke
A light read about OKRs. Good as a first book on OKRs, but not as detailed as the two books above.
Introduction to OKRs by Christina Wodtke
A very short book on OKRs. Good as a first book on OKRs if you have a very very short attention span.

Books for product managers

Thu, 11 Apr 2019 15:27:21 GMT

Overview books:

Interview preparation (good for breadth, even if you’re not applying for jobs):

Other good books for PMs:

All PMs should have a 101-level understanding of these topics:

User research
Financial Models (cash flow, NPV, payback period)
Writing (how to structure documents and sentences; use something like The Pyramid Principle)
Marketing/growth (different channels, CAC, LTV etc.)
Presenting data (use Say it with charts by Gene Zalazny, or something by Stephen Few (Show me the numbers, or Information dashboard design)
Software architecture (including how code talks to databases and APIs; concept of technical debt and how trade-offs are made)
Data networking (OSI model, how it relates to TCP/IP)
Scripting (bash/sed/awk or perl or python)
Coding (in some high level OO or functional language; ideally Python or Java)
Project Management (it’s not your job, but sometimes you have to do it)

Tools PMs should be comfortable using, in order to analyse stuff and/or communicate their ideas:

Something for rough mockups, e.g. Balsamiq
(optional) Something for finer mockups, e.g. Sketch 3
Something for quickly drawing flow charts (PowerPoint or Google Slides will do)
Excel (and basic best practices like highlighting inputs, not mixing inputs and calculations, etc.)
Using Powerpoint or Google Slides) to create slides to support a presentation (not just decks for people to read offline or, worse, a deck that is made for presentation, but is so wordy that people focus on the slides instead of the presenter)
SQL (to help you answer your own questions)
A high-level language (e.g. Python, Ruby, JavaScript, Java)
Google Analytics (or MixPanel or whatever your company uses)