Illusion Slopes

PageRanking People and Blogs interviews

2026-05-06T00:00:00+00:00

I recently learned about PageRank, the original Google algorithm for ranking webpages. It works by constructing a Markov chain on links between pages and computing the stationary distribution. The stationary probability of a given page measures the page’s centrality in the web, an index of popularity.

I wanted to try implementing the algorithm myself and fiddle with a few Rust libraries, so I wrote a script that runs PageRank on interviews from the People and Blogs series. P&B interviews are a tidy dataset for the algorithm, because Manu always asks interviewees to recommend other blogs, then he uses these recommendations to pick subsequent interviewees. This means the graph is well connected despite its small size.

I was going to share the results here, but ranking blogs by popularity seems against the spirit of the indie web ethos, so you’ll have to run the program yourself. (But to make it clear I’m not covering anything up, let me acknowledge that my interview is in a 61-way tie for last place, with all the other blogs that had no links to them.)

A few observations from this exercise below.

I computed the stationary distribution explicitly using ndarray_linalg::eig because that’s one of the libraries I was fiddling with, but for a graph with a large number of nodes, storing the $O(n^2)$ Markov array in memory is impractical; you’d be better off just simulating the random jumps instead.
A Monte Carlo simulation would yield cleaner code than my solution, too. Most of the bugs I had to fix in my implementation had to do with constructing the Markov matrix, normalizing columns, and handling edge cases like nodes with outdegree zero. If all you’re doing is walking the graph one node at a time, you can address the edge cases procedurally in a way that’s more obviously correct (e.g. “if a page has no links, jump randomly to any page”).
The hard work in Google’s implementation would surely have been the data engineering. You have to find the “content” part of every page to avoid overrepresseing header and footer links like About and Privacy, but semantic HTML wasn’t a thing yet. And it would take a lot of work to normalize URLs to handle synonyms that differ only by a www. prefix or trailing slash (not to mention redirects and permalinks).

Like many developers, the LLM era is interfering with my motivation to post brain coded projects like this. That’s especially true when, as here, I’m exercising a language or concept that I’m still learning—my PageRank implementation is neither performant nor educational. But as I told Manu in the P&B interview, I use my blog and GitHub more for accountability than publicity: The goal is to simply keep myself writing and coding.

Publish post.

Find your perfect match with integer programming

2025-12-19T00:00:00+00:00

Owen Lacey blogged about a reality game show called Are You the One? in which contestants win a prize by guessing the soulmate ordained for them by the show’s producers. Specifically, there are $n$ men and $n$ women, and each one has an unknown “perfect” match; to win the prize, the contestants (as a group) must pair everyone up correctly.

During each episode, the contestants get two kinds of clues:

Truth Booth, where the contestants submit a single couple and learn whether that couple is a perfect match.
Match Up, where the contestants submit a matching (assigning everyone to a couple) and learn the number (but not the identity) of perfect matches present in their matching.

The game ends after Match Up if all $n$ couples in the matching are correct. Definitely check out Owen’s post, which has a better (and illustrated!) explanation of the rules.

Below, I present an efficient algorithm for playing Are You the One. It exploits both the informational clues and contestants’ intuitions to find perfect matches quickly. With modest assumptions on the quality of players’ intuitions, my algorithm wins by episode 10 in 100% of simulated seasons.

(I will style the name of the show as Are You the One? and the name of the underlying game as just Are You the One.)

Owen’s algorithm: Eliminate alternatives with information theory

To set the stage, let me summarize Owen’s approach. In short, he chooses Truth Booth and Match Up submissions on the basis of the expected information to be gained.

Imagine writing down a list of all $n!$ possible matchings at the beginning of the season. If, in the episode 1 Truth Booth, we learn that Alice and Bob aren’t a perfect match, we can cross off all $n! / n$ matchings that include this couple. That’s progress.

Similarly, after we get our Match Up score at the end of the episode, we can examine each possible matching and ask, “If this were the ground truth, what would have been our guess’s Match Up score?” If the observed score differs, then that rules out that matching.

As the season evolves, Owen’s goal is to narrow things down as quickly as possible by submitting the guesses that eliminate the most matchings. Thus, in both subgames, his algorithm has us simulate each potential guess against each potential matching. We count up the average number of matchings that each guess would cross out. The logarithm of this value is called the guess’s entropy. We play the guess with the highest entropy.

This algorithm won the game by episode 10 in 98% of Owen’s simulations—convincing evidence that Are You the One? is “pretty much free money.”

My design objectives

Owen’s post left me with two questions.

First, the information-theoretic algorithm is pessimistic. It assumes zero intuition about which couples belong together; every matching is equally likely. But what if we do have some intuition about compatibility—can we exploit this knowledge to win sooner, or more consistently?

Objective 1: Exploit both clues and contestant intuition to maximize the win rate.

Second, computing entropies entails a lot of math. In Truth Booth and Match Up alike, to count the number of eliminations, we have little choice but to scan the full, long list of potential matchings. There’s no shortcut, because previous eliminations interact with new clues in complicated ways. And we have to run that scan for every possible guess. Owen applied a few clever optimizations to avoid provably wrong guesses, but it’s hard to salvage factorial time complexity:

I ran this information theory simulation 41 times (for no other reason than I got bored waiting)

Can we make our algorithm computationally efficient? Here’s an arbitrary benchmark that I totally didn’t come up with until after testing my code.

Objective 2: Simulate 100 seasons in under 1 minute on an unremarkable desktop (AMD Ryzen 5 4600G processor, 16GB of RAM).

Point of emphasis: With these objectives, my algorithm and Owen’s aren’t really in competition. My problem setup is more generous (players have additional information at the outset), and my goals (win more, simulate faster) are therefore more ambitious.

My algorithm: Balance intuition and informational constraints

My model of Are You the One includes three components:

A statistical model of the “vibes” that contestants get about each couple’s compatibility
An algorithm for choosing which couple to guess for Truth Booth
An algorithm for choosing which matching to guess for Match Up

The statistical model lets us slide the strength of contestants’ intuition up and down to experiment with how it affects the win rate. The guessing algorithms are based on integer programming (IP), an operations research technique that lets us optimize for a goal (my guess reflects my intuition) while applying logical constraints (my guess doesn’t contradict any clues). IP solvers don’t need to iterate every possible solution or matching, because they leverage the problem’s mathematical structure to prune whole families of suboptimal solutions from the search space.

Statistical model of contestant intuitions

To generate random instances, my model first assigns each couple a compatibility score $c_{ij}$ drawn from a standard normal distribution. These values represent the “true” compatibility of man $i$ with woman $j$ (according to the show’s producers). We then solve the maximum-weight bipartite matching problem to obtain the ground-truth perfect matching.

This computation sounds fancier than it is; the idea is to match everyone up in a way that maximizes the overall sum of compatibility scores. More sophisticated matching algorithms exist, but the maximum-weight procedure suits our purposes well. It generates each of the possible $n!$ matchings with equal probability, and it comes with extra data $c_{ij}$ that we can use to drive intuitions.

Contestants don’t get to see $c_{ij}$ , but instead observe $v_{ij}$ , which is $c_{ij}$ plus a normal variate with mean zero and standard deviation $2^{-s}$ . Here $s$ represents the strength of contestants’ intuition. If $s \ll 0$ , then their intuitions are essentially random noise; if $s \gg 0$ then their intuitions are spot-on.

The strength parameter $s$ enables us to test how bad players’ intuitions can get before a pessimistic algorithm like Owen’s has better odds of winning than one based on vibes. I chose to scale $s$ exponentially on the hunch that this would yield a roughly linear relationship between $s$ and the number of turns to win (which turned out to be true).

Match Up algorithm

I’ll present my algorithm for Match Up first, because the Truth Booth algorithm builds on it.

In my algorithm, we pick the guess for Match Up that best resonates with our vibes without contradicting any of the clues we’ve gathered. Formally, we compute the maximum-weight bipartite matching using the $v_{ij}$ values as the weights, while applying logical constraints generated by previous rounds of Truth Booth and Match Up.

Let the binary decision variable $x_{ij}$ equal one if man $i$ matches with woman $j$ in our Match Up submission, and zero if not.

Let $P$ denote the set of couples $(i, j)$ known (from the Truth Booth) to be perfect matches, and $\cancel{P}$ the set of couples known not to be perfect matches.

Let $\mathcal{M}$ denote the set of Match Up results. The elements of $\mathcal{M}$ are tuples $(M, k)$ , where $M$ is the set of couples $(i, j)$ submitted, and $k$ is the score.

The solution to the following IP is called the best matching:

\begin{aligned} \text{maximize} \quad & \sum_{i=1}^n \sum_{j=1}^n v_{ij} x_{ij} \\ \text{subject to} \quad & \sum_{j=1}^n x_{ij} = 1 & \forall i \in \{1 \dots n\} \\ & \sum_{i=1}^n x_{ij} = 1 & \forall j \in \{1 \dots n\} \\ & x_{ij} = 1 & \forall (i, j) \in P \\ & x_{ij} = 0 & \forall (i, j) \in \cancel{P} \\ & \sum_{(i, j) \in M} x_{ij} = k & \forall (M, k) \in \mathcal{M} \\ & x_{ij} \text{ binary} & \forall (i, j) \in \{1 \dots n\}^2 \end{aligned}

The first two constraints define the bipartite matching polytope. The following three constraints require that $x_{ij}$ agree with our clues. The final constraint just says that $x_{ij}$ is binary (not a fraction).

Truth Booth algorithm

The Truth Booth is purely informational; we don’t win anything with a correct guess. However, in the absence of other clues, a correct guess in Truth Booth rules out more matchings than an incorrect guess. So, for the Truth Booth, my algorithm tries to make a guess that is not certain, but still likely to be correct.

First, we compute the best matching using the IP above. Any of the $(i, j)$ pairs in the best matching is a valid guess for truth booth. But some of them are silly guesses, because we already know they are a perfect match; we should filter these out (hence the “not certain” criterion above).

The easiest couples to filter out are those that were already revealed as a perfect match in a past Truth Booth. No sense submitting them again.

Among the remaining couples, even without a Truth Booth result, we may know implicitly that they go together, because all matchings in which they don’t are contradicted by the sum of our clues. To detect if $(i, j)$ from the best matching is an implicit perfect match, we can solve another IP, which consists of the best matching IP with the additional constraint $x_{ij} = 0$ . If this adjusted IP is infeasible, then $(i, j)$ is an implicit perfect match, so we shouldn’t submit that couple to the truth booth.

The couples that survive these filters are flexible couples, i.e. we can identify a matching, compatible with our clues, in which they pair with someone else. Among the flexible couples, my heuristic is to guess the couple with the highest vibes. This satisfies the “likely” criterion above.

(I experimented with choosing the flexible couple with the poorest vibes. There isn’t much of an impact to the bottom-line win rate, but the script spends longer solving the integer programs.)

Implementation and experiments

I implemented the algorithm in Julia using the JuMP.jl modeling language and SCIP solver. You can find all the source code here on GitHub.

I ran three experiments to verify that my algorithm fulfills the design objectives.

Experiment 1: Intuition strength vs. turns to win

For this experiment, we sample $s$ uniformly between $-5$ and $5$ . These endpoints represent signal-to-noise ratios of 1:32 and 32:1, respectively, so the x-axis in the plot below runs the gamut from “virtually no intuition” to “spot-on intuition.”

Each point in the scatter plot below corresponds to one full game (one season). The y-axis represents how many turns contestants took to make a correct guess in Match Up.

We see a roughly linear, negative relationship between intuition strength and turns taken. We win by episode 10 most of the time, even on the noisy side of the plot.

Experiment 2: No intuition

To stress-test my algorithm, let’s focus on the left edge of the experiment 1 plot and slide the intuition strength all the way down to $s = -\infty$ . (What I actually do is delete $c_{ij}$ entirely from the expression for $v_{ij}$ and sample the vibes as pure Gaussian noise.)

This case is similar to Owen’s setup. Participants have no intuition about which couples are perfect matches, and their vibes $v_{ij}$ serve only to give the IP solver something to optimize.

The histogram below shows how many episodes contestants typically need to win.

In the challenging environment of experiment 2, my algorithm wins by episode 10 only 93% of the time, compared to Owen’s 98%. However, 93% is still appreciably better than the 74% and 71% accuracy obtained, respectively, by random guessing and actual Are You the One? contestants (according to Owen’s post). And it takes just under two minutes to run all 500 simulations reflected in the plot above.

Experiment 3: Weak intuition

The conditions of experiment 3 cater best to my algorithm’s objectives. Here, we fix $s = -1$ (a signal-to-noise ratio of 1:2), meaning that contestants have some intuition, but it’s not particularly strong.

In this case, we eke out a win 100% of the time! And again, running all 500 simulations takes less than two minutes.

Best we can do?

Above, we devised an algorithm for Are You the One that balances competing objectives:

Exploit clues from Truth Booth and Match Up
Capitalize on contestants’ intuition about compatibility
Compute efficiently

Under favorable conditions, the algorithm wins 100% of simulated games. Under unfavorable conditions with scrambled contestant intuitions, the algorithm still wins 93% of the time. In every case, it’s fast enough to simulate many seasons without getting bored.

Like Owen, I find Are You the One to have charming similarities to Wordle. In Wordle, you must balance the information gained by exploring unused letters against the win potential of exploiting clues already provided. In the New York Times version of Wordle, a pessimistic strategy informed by information theory is the only way to guarantee a win. But in two-player Wordle, where an opponent chooses the word, you can leverage intuition about the opponent’s favorite words to guess the answer more quickly.

Many numerical optimization problems feature such an explore/exploit tradeoff. In classic cases of the multi-armed bandit problem, for example, we can prove that certain strategies strike an ideal (in a technical sense) balance between exploration and exploitation.

I doubt that my algorithm attains the optimal probability of winning for my problem setup, even in the special case of experiment 3 (where the 100% figure is merely empirical; if you keep running my script, you’ll see losses here and there). The information-theoretic concepts introduced in Owen’s blog post can be applied to arbitrary, not just uniform, distributions over matchings, including the conditional distribution of the ground-truth matching on the vibes $v_{ij}$ . If you can estimate that distribution (more simulations …), then you can compute the entropies in Owen’s algorithm as weighted averages over matchings. That algorithm would be, you know, optimal optimal. And very slow.

Pytest + Ruff + Mypy

2025-12-10T00:00:00+00:00

There is a pytest-ruff plugin for Pytest (a Python testing framework) that will automatically run ruff format --check and ruff check as part of your test suite. The pytest-mypy plugin does the same thing for Mypy. These plugins are handy, but for some reason , the tests they generate are exempted from the pytest -k ... logic. Normally, you can use -k to select a subset of tests to run, but if you install one of the plugins mentioned, that plugin’s tests run no matter what. This can slow you down if, like me, you develop on a slow computer.

So, here’s what I use instead of pytest-ruff and pytest-mypy: A humble test/test_qa.py file with three functions.

import subprocess import sys from pathlib import Path import mypy.api REPO_ROOT = Path(__file__).parent.parent def test_mypy(): stdout, stderr, returncode = mypy.api.run([str(REPO_ROOT)]) sys.stdout.write(stdout) sys.stderr.write(stderr) assert returncode == 0 def test_ruff_format(): subprocess.run( [sys.executable, "-m", "ruff", "format", "--check"], cwd=REPO_ROOT, check=True, ) def test_ruff_lint(): subprocess.run( [sys.executable, "-m", "ruff", "check"], cwd=REPO_ROOT, check=True, ) 

(I run Mypy via its Python API instead of the command line to save a tiny bit of subprocess.run() overhead, but it doesn’t make a massive difference.)

This gets you all the functionality of the plugins, but with two fewer dependencies, and the -k flag works:

# Run tests for an in-progress feature and skip QA pytest -k test_some_feature # Run only the QA tests pytest -k test_qa # Run all tests pytest 

Person of the Year 2006

2025-11-26T00:00:00+00:00

If you need a fun fact for a corporate icebreaker activity, you can always say, “I was Time magazine’s Person of the Year in 2006,” then stand around awkwardly waiting for someone to Google it.

The official announcement of “your” accomplishment makes for good reading in 2025. In tech circles, we often regard the early days of Web 2.0 as a time of naivety when we thought that letting anyone post on the internet would democratize media and unlock an era of creative expression. Of course, we know now that it isn’t so simple—that open platforms can amplify extreme views, for example, or serve as vectors for misinformation. But apparently we also knew this then, in the earliest days of YouTube and Facebook:

Web 2.0 harnesses the stupidity of crowds as well as its wisdom. Some of the comments on YouTube make you weep for the future of humanity just for the spelling alone, never mind the obscenity and the naked hatred.

But that’s what makes all this interesting. Web 2.0 is a massive social experiment, and like any experiment worth trying, it could fail.

Obviously, the course we chose twenty years ago led us to the world of today. But we didn’t select this path arbitrarily, or without regard for the challenges it would present; we examined the risks and decided the experiment was worth it.

I got a similar sense from reading Thomas Friedman’s The World is Flat (2005), which lays out a theory of globalization based on the convergence of technological development (the internet) and trade liberalization. Some of the passages feel quaint:

If there is a skilled person in Timbuktu, he will get work if he knows how to access the rest of the world, which is quite easy today. You can make a Web site and have an e-mail address and you are up and running. (Ch. 3)

(In the ebook, I commented, “Taxes? Immigration law?”) But elsewhere, Friedman anticipates critiques of globalization which have now become standard:

In the flat world, the balance of power between global companies and the individual communities in which they operate is tilting more and more in favor of the companies, many of them American-based. These companies command as much if not more power than many governments. (Ch. 13)

Not to mention “What the world has never witnessed is an old-style pandemic in a Wal-Mart world,” later on in the same chapter.

Urban Arts Career Pathways Takeover

2025-11-23T00:00:00+00:00

My team at work recently got to host a Career Pathways Takeover at Urban Arts, a nonprofit based in New York that teaches programming, animation, and storytelling education to high schoolers to prepare them for success in college and beyond.

I was so impressed by the students’ thoughtfulness and engagement. We walked our group of Game Academy students through our team’s event planning process, and in less than an hour they put together a rock-solid plan for a community arts program to raise awareness about mental health issues, including how they’d use data to capture the event’s positive impact (where I fit in). I hope the vision can become a reality before long…!

Massive thanks the Urban Arts team for hosting us and for all that you do through the Game Academy.

Apply for CLS

2025-10-21T00:00:00+00:00

This year’s application for Critical Language Scholarship from the US State Department is now open. (Thanks, group chat!)

CLS is a fully funded summer language immersion program for American undergraduate and graduate students. I strongly encourage any interested in learning one of the nine critical languages to apply. Some languages require prior language study; others accept beginners.

Feel free to email me if you are considering the CLS program or have questions about the experience. I completed CLS Korean in 2016 and have kept in touch with participants from lots of cohorts since then. Here is my advice post.

Good CLS blogs:

Bethany Maz
The Good Things Coming (Paula Zhang)

Python scripts

2025-09-24T00:00:00+00:00

I cleaned up a few utility Python scripts for the GitHub:

fetch_python_docs.py sets up a local mirror of docs.python.org on http://localhost:8004 for offline reference. It can also provide and enable a systemd unit file, so you can run the script once, bookmark the local URL, and forget about it.
typography.py (which I mentioned here) checks for ASCII typography that can be better rendered as Unicode. For example, it recommends changing the hyphen in the page range 278-81 to an en dash.
dated.py applies my obnoxious filename convention to create a dated working copy of a file—useful when collaborating with people who aren’t comfortable with version control systems.

Tensions rise in the condaverse

2025-09-18T00:00:00+00:00

GitHub has a tool called Dependabot that automatically finds outdated package versions pinned in project configuration files and issues a pull request to update them. Support for conda environment.yml files has long been one of the most requested features in the Dependabot repo. At long last, GitHub has now added partial support for conda to Dependabot, first as a beta announced last week, and now generally available. But there have been some issues with the rollout.

The main appeal of conda over something like Poetry, uv, or just plain-old requirements.txt is that conda can manage arbitrary dependencies, not just Python packages. You can conda create --no-default-packages git micro compilers to set up a Fortran dev environment if you want. Dependabot’s conda support includes only Python packages. A few folks grumbled about this limitation in the GitHub issue comments, but it’s understandable: The space of “all conda installable packages” is vast indeed, and the Dependabot devs had to start somewhere.

A more compelling criticism of the new feature stems from the fact that Dependabot determines the latest versions of Python packages by looking up the names given in environment.yml on PyPI. This is a problem because PyPI is an entirely different package ecosystem from conda. Some package versions are released on PyPI well before they appear in conda repos, and some packages have different names between the two.

For a nasty example, Ipopt is a nonlinear programming solver written in C, and cyipopt provides Python bindings. conda install ipopt installs the C library, and conda install cyipopt installs the Python wrapper. But pip install ipopt actually refers to cyipopt. The upshot, if I understand correctly, is that if you pin ipopt in your environment.yml, then Dependabot will check its version number against that of the latest version of cyipopt, a flawed comparison.

Luckily, Ipopt/cyipopt is the only such case I could find in this Rosetta stone (the fact that this exists …) mapping package names across ecosystems. But anyone(ish) can post packages on PyPI, so the current behavior of Dependabot creates new opportunities for typo-squatting attacks on conda users. As Jannis Leidel (a conda maintainer) put it, “This premature rollout makes the conda ecosystem less secure and shouldn’t have occurred.”

I’m not sure what the right move is for Dependabot. For a start, they could use the Rosetta stone to map conda packages to the correct PyPI names, but this would only solve the naming issue, and not the possibility of different versions between the two repositories.

Is ABC-SMC just an evolutionary algorithm?

2025-09-03T00:00:00+00:00

Suppose we have data $D$ and a model that expresses $D$ as a noisy function of a parameter vector $\theta$ . We want to determine a value of $\theta$ that fits the data. For the purposes of this post, we’re concerned with models that are “difficult,” meaning we cannot write down a simple expression for the likelihood function and maximize it, whether analytically (as in ordinary least squares) or numerically (as in nonlinear regression). In fact, all we really know how to do is sample data from the model when given an arbitrary $\theta$ . (We’ll get a different $D$ every time, because the model is nondeterministic.)

If you enjoy Bayesian statistics, then you may have already pattern-matched this problem statement to the ABC-SMC algorithm. But if you are like me and view parameter estimation as an optimization problem (there is no reason to privilege this view; it’s just how I turned out), then you might instead apply an evolutionary algorithm. Below, I describe such an algorithm, then argue that ABC-SMC is a special case. This insight suggests improvements to the implementation and usage of both evolution and ABC-SMC.

Evolutionary algorithm

OK, so the basic template for an evolutionary algorithm looks like this:

Guess $N$ different parameter vectors $\theta_i$ (e.g. by sampling them from a distribution or applying a heuristic to the data).
For each $\theta_i$ , simulate the model to generate a bunch of data $D'_i$ .
Compare each instance of simulated data $D'_i$ to the real data $D$ , perhaps with a distance measure $d(D'_i, D)$ like the 2-norm or summary statistics.
Pick a subset of the $\theta$ values, perhaps the $k$ with the lowest distance measure.
Generate a new sample of size $N$ , perhaps by sampling randomly from the $\theta_i$ s that “survived” the previous step and adding random noise.
Repeat an arbitrary number of times from step 2.

There are a lot of details to fill in, particularly in the choice of loss function and resampling method.¹ But essentially, we try to sample new $\theta$ values in a way that is biased toward the winners identified in step 4 (exploitation), while maintaining enough random noise in step 5 to escape local optima (exploration). If we strike the right balance between exploitation and exploration, evolutionary algorithms like this can be quite effective in practice. Free textbook (PDF).

ABC-SMC motivation

As an operations researcher who tends to neglect Bayesian statistics, I am half content to stop here. But the setup given above—a model, a sampler—is common enough that we should expect to find a solution more tailored than evolution (a rather blunt technique). Well, that solution is called approximate Bayesian computation (ABC).

(Depending on the order in which you learned things) an intuitive way to think about ABC is as an alternative to Markov Chain Monte Carlo (MCMC). Algorithms in the MCMC family take a likelihood function $l(\theta)$ and produce a sample of the probability distribution implied. This is useful because for many statistical models, we can easily construct a likelihood function (PyMC will do it for us), but maximizing $l(\theta)$ is hard (for example, due to nonconcavity or expensive gradient computations). With MCMC, we can just draw samples from the posterior $P(\theta | D)$ , which produces not only a point estimate for each entry of $\theta$ , but also confidence bounds, their covariance … indeed, an estimate of the entire distribution.

Unfortunately, MCMC proves inadequate for regression problems (many involving rank and order statistics) where we cannot write out the likelihood function in a computationally tractable form. Consider, for example, a model where we draw $X$ from a multivariate normal distribution (whose mean and covariance matrix are part of $\theta$ ), clamp these values to unknown lower and upper bounds (more parameters in $\theta$ ), then observe (as $D$ ) the third order statistic. I don’t think this will yield a useful likelihood function (although I admit I haven’t tried). Thus, we turn to ABC.

ABC rejection sampling and the ABC-SMC algorithm

ABC is a sketchy alternative to MCMC which works even when we cannot compute a likelihood function. All we need is the ability to sample data from the model for given values of $\theta$ , just like our problem. The ABC rejection algorithm is basically this:

Sample a $\theta$ vector from a prior distribution.
Sample data $D'$ from the model.
Compare the data $D'$ to the sample $D$ using a distance measure $d(D', D)$ .
If the distance is less than tolerance $\varepsilon$ , accept $\theta$ . If not, repeat.

I call this algorithm “sketchy” because before running it, we don’t know how many times it will loop before accepting $N$ posterior samples. To maximize the sample’s accuracy, step 4 tempts us to set $\varepsilon$ close to zero. But doing so might drive the acceptance rate down to 0.1%, in which case we must draw millions of samples from the prior to get thousands from the posterior. (We might as well just figure out how many iterations we can afford to compute—say, 100,000—and accept the 1000 samples of $\theta$ with the lowest distance measure. Sound familiar?)

We can tame the ABC rejection algorithm using a modification called sequential Monte Carlo (SMC); here is a good tutorial (PDF). Instead of picking a huge sample size and tiny $\varepsilon$ and crossing our fingers, ABC-SMC has us gradually ease the tolerance $\varepsilon$ toward zero as the sample converges to the “true” posterior. The algorithm looks like this:

Sample $N$ vectors $\theta$ from a prior distribution; call this the “population.”
Construct a new population using ABC rejection sampling, with a tweak:
1. Sample a $\theta$ vector from the population.
2. Tweak: Add random noise to $\theta$ .
3. Sample data $D'$ from the model.
4. Compare the data $D'$ to the sample $D$ using a distance measure.
5. If the distance is less than tolerance $\varepsilon$ , accept $\theta$ and add it to the new population.
6. Repeat from step 2.1 until the population has size $N$ .
Keep repeating step 2 with decreasing values of $\varepsilon$ .

This algorithm is more practical than pure ABC because we can log the acceptance rate at each iteration in order to see how it is doing. If the acceptance rate is too small, then we restart with a less aggressive tolerance schedule (i.e. $\varepsilon$ decreasing more gradually).

The tweak in step 2.2 (adding extra noise) is necessary to enable ABC-SMC to search beyond the $N$ samples initially drawn from the prior. The scale of this extra noise—call it $\sigma$ —is an additional free parameter in the algorithm design. If $\sigma$ is too large, then the algorithm won’t converge, because each pass through step 2 resembles a fresh run of the ABC rejection sample (poor exploitation). If $\sigma$ is too small, then the algorithm gets stuck in the neighborhood of whichever $\theta$ from the initial sample happened to be the best (poor exploration). So, like the evolutionary algorithm, ABC-SMC is no turnkey solution; it requires parameter tuning to balance exploration and exploitation effectively.

It’s the same picture

The similar “user experience” of evolution and ABC-SMC suggests we consider what else these algorithms may have in common. Upon examination, we can recognize step 2 in the ABC-SMC algorithm as another way of implementing steps 2 through 5 in the evolutionary algorithm. The difference is that in the evolutionary algorithm (or at least the way I wrote it out), we choose the acceptance rate $k / N$ at the outset, and the acceptance threshold $\varepsilon = \max\{d(D'_i, D)\}$ (over the surviving indices $i$ ) is implied. In ABC-SMC, it’s just the opposite; we commit first to a tolerance $\varepsilon$ , then keep sampling until we’ve filled up the population.²

Recognizing the similarity between evolution and ABC-SMC might lead us to discover new algorithms by mixing features from each. For example, in ABC-SMC, instead of imposing a series of decreasing tolerance, we could choose a fixed, large sample size from which we always accept the top $N$ by distance. Because the samples converge,³ the sequence of (implicit) tolerances still decreases, so this algorithm should still afford the Bayesian interpretation of producing a sample from the posterior (not just a point estimate of $\theta$ ). But this modification makes the algorithm’s runtime and memory usage deterministic, a desirable property (for example, it lets us preallocate all the arrays for a performance boost).

Another idea we can transplant from evolution to ABC-SMC is forced exploration. In evolutionary algorithms, a common practice is to always include a few totally random samples in each new population. In ABC-SMC, this could look like modifying step 2 to construct a new population using $\lceil 0.9 N \rceil$ ABC rejection samples, and filling the rest with fresh draws from the initial prior. This should reduce the ABC-SMC’s propensity to get stuck in a local optimum (a real problem, in my experience), at the cost of a lower acceptance rate and longer runtime.

What about going the other way—incorporating ideas from ABC-SMC into evolution? In evolutionary algorithms, the custom is to return the global best solution, but one can argue that the entire final population, as a “sample” of parameter values that survived the top- $k$ filter repeatedly, deserves more attention. Like a Bayesian posterior, this population conveys the distribution of good $\theta$ estimates, which could have properties such as clustering or correlation that warrant further investigation.

And we should take care to ensure that the size of each sample $D'_i$ is sufficiently large to ward off a winner’s curse outcome where the $\theta$ you return is actually a good estimate, not just a “lucky” instance where all the noise happened to point in the right direction. ↩
Another difference between the algorithms as I laid them out is that in my evolutionary algorithm, you upsample the $k$ “survivors” into a size- $N$ population at the end of the inner loop (step 5), whereas in ABC-SMC the upsampling occurs implicitly in steps 2.1 and 2.2. I think this difference is superficial—it’s a matter of setting up each iteration at the end of the previous iteration versus at the start of the current one. Note that $k$ (not $N$ ) in the evolutionary algorithm corresponds to $N$ in ABC-SMC. ↩
Well, if the samples converge—which depends on tuning $\sigma$ . ↩

Full of types

2025-08-20T00:00:00+00:00

I’m obsessed with this essay “Raising a person in a culture full of types” by Dan Brooks. Before we get to the author’s message, let’s take a moment to appreciate his sense of comedic timing, e.g.:

My son talks incessantly about VSCO girls and Karens and other categories of people he has learned about from YouTube. He described a classmate as “the kind of person who borrows your pencil and doesn’t give it back,” i.e. she borrowed his pencil and didn’t give it back. For a while he tried to propagate a type of his own invention, “the Suzan,” whose behavior was ill-defined but tracked closely with that of my mother of the same name. It did not catch on, and eventually he concluded that he was not the kind of person who could come up with memes.

Is it just me, or is this a highly clever paragraph?

Brooks’s point, expressed better there than I will here, is that our culture’s emphasis on “being“ over “doing” prevents us from separating people’s actions from their destiny. At best, the idea that people belong to fixed, inescapable categories is merely the antithesis of the growth mindset; it saps motivation from our desire to try new things (why learn programming if I am not a “math person”?). At worst, as Brooks points out, “The illusion of a fixed nature gives us an excuse to repeat bad behavior,” because every mistake is like a movie trailer for the rest of your life. And like a TV commercial, the fixed mindset is an illusion with a slope (sorry): it inclines us toward the most automatic decision instead of assessing the alternatives on their merits.

I will not pretend to be a paragon of the growth mindset. I talk myself out of good ideas, such as learning how to actually cook, all the time. But if I could choose to have one impact on the world, it would be to motivate those around me to reject limiting beliefs and embrace challenge—even at the risk of failure. And if linking you again to this essay, which has a wonderful subplot about fatherhood, is the way to do it, then, OK.

Jekyll plugin to recommend related posts

2025-07-09T00:00:00+00:00

I wrote my first plugin for the Jekyll static website builder: a tool that recommends related posts at the end of each page. It determines the similarity between post pairs using a fairly unremarkable token-counting algorithm, so it’s fast enough to rerun on every site build. You can configure the number of posts to recommend and a parameter factor which determines the algorithm’s sensitivity to rare vs. common words.

I made a little demo of the plugin with a fake blog whose posts are the articles of the UN Universal Declaration of Human Rights. You can also see a demo on the current version of this site if you click the “read more” link below to go to this post’s individual page. I think it works pretty well!

There are still some tweaks I want to make before I publish this plugin to RubyGems.org. Currently, jekyll-related depends on this ancient tokenizer gem, which I want to inline so I can add more configurable options for things like whitespace and capitalization handling.

Some things I tried recently

2025-07-02T00:00:00+00:00

Kagi Search: It’s a paid search engine that promises to give better results than Google and friends. Indeed, the search results are a little more relevant, especially when researching technical topics. I made great use of the ability to filter and promote entire domains. However, the pricing doesn’t work for me: $5/month gets you 300 searches, which isn’t enough (I burned through the free 100 searches in a week), and for unlimited searches, you have to pay $10 for a bundle deal that also includes AI stuff I don’t care about. Kagi wants to become an everything app (probably adding email soon), which a tough sell while claiming to be a privacy-focused company. (Same issue with Proton, by the way.)

Fender Studio: Fender, the guitar company, just kind of threw this over the fence in May. It’s a free (but not open source) digital audio workstation, so it competes with the likes of Ardour and GarageBand. But Fender Studio runs on Linux, and quite well at that. On my machine, it supports JACK with minimal configuration and achieves lower latency than Guitarix while doing a lot more. The vendored backing tracks are a bit cheesy but well engineered.

Proselint: It’s a prose … linter, i.e. you feed it your draft blog post and it complains about vague wording and common typography problems like curly vs. straight quotes. I like that Proselint uses regex instead of an LLM, so there’s no creative interference; it’s more like an automated style guide than a chatty editor. But my homegrown typography.py script (I need to upload this to GitHub sometime) enforces a few lesser irks, such as en dashes in numerical ranges, that Proselint lets be, so I’m still using both.

CLS advice nobody asked for

2025-06-26T00:00:00+00:00

Awesome people occasionally reach out to ask me about the US State Department’s Critical Language Scholarship (CLS) program. I participated in CLS Korean in 2016, and I still find myself learning from the experiences I had in Gwangju all those years ago (and that’s with four additional years of living in Korea and several visits in between).

This year’s CLS cohort is getting started now or so, so I thought I would write up a couple of tips for making the most of the program that I’ve collected and shared over the years.

Contribute ideas for activities to do with your language partner, because they may run out of them before long. Your outsider perspective might generate interesting adventures like visiting a family with young kids or sneaking into a college lecture.
Embrace a Zen attitude with respect to the language policy. Understand that some cohort members may need space to process new experiences and cultural differences in English; this doesn’t mean they are not getting the most of the program. Language acquisition doesn’t have to be your only goal. (Context: CLS is famously an immersion-based program and requires participants to sign a language pledge saying that they won’t use English for the duration or the program. In retrospect, I was too much of a stickler about it.)
Identify and recognize your own stress responses and consider how they may contribute to or ameliorate the stress experienced by others. This is especially true for “elder” CLS participants (grad students and up), whom younger participants tend to see as role models in adapting to unforeseen challenges.
Buy an umbrella in Korea and thank me later.

And please email me if you are on CLS this year and have any stories to share! I still have a few posts around from my CLS days, but nothing profound.

Is using a thesaurus cheating?

2025-06-18T00:00:00+00:00

I remember taking mild offense when my middle school language arts teacher introduced our class to the thesaurus. I thought, if I let the thesaurus choose my words for me, then is it even my writing anymore? This seems like a flaw in my temperament: I always regard technology with suspicion when it threatens to supplant human creativity.

Inevitably, as I progressed through high school and college, I made peace with the thesaurus, and now I rely on it. A typical use case would be: “What’s that word that means deferential but like, in an obnoxious way?” I plug the obvious profanity into Merriam-Webster and it hands me back obsequious. I’ve trained myself not to regard it as a creative failure if I accept this sort of help. After all, it’s not like the thesaurus tells me which word to use; it just brings it forth from the tip of my tongue.

OK, so this post had to be about generative AI, right? After a few years of watching the world use and abuse large language models, I’m beginning to find ways to accept an LLM’s assistance without feeling like I’ve outsourced my creative process. Mostly, I use LLM chat as a better search engine. For example, one of my first questions was “Is there a NumPy built-in that does this?” with a quick example. The machine pointed me immediately to numpy.unravel_index(), which was exactly what I needed. It would have taken me much longer to get to the same answer with Google.

Sometimes, I have tried more involved discussions with the chatbot to improve my understanding of a technical concept. In lengthy conversations, I try to put a lot of thought into my questions. I ask the LLM to check my assumptions, issue corrections, and supply keywords I can look up in an official reference—but never to generate code, text, or ideas. (Sometimes it does that anyway, which I find highly annoying.)

“We use tools to embody their virtues,” writes Fernando Borretti. I guess I value authenticity or craftsmanship—my fingerprints on the finished product—more highly than laying down as much code or text as I can in a fixed amount of time. This value judgment (and it really is just that) precludes more aggressive uses of LLM tech that, yes, might make me more productive in the short term. I’ll own that tradeoff. When it comes to new technology, we often speak of “early” and “late” adopters—as though tech literacy means no more than finding the smooth part of a hype wave. My goal is to adopt tools not on the basis of urgent marketing or the fear of being left behind, but because I can use that tool to make myself smarter.

My poorly automated Kubuntu setup

2025-06-04T00:00:00+00:00

The target audience for this post is myself. I recently set up a new (old) laptop and tried to bring it to parity with my main Kubuntu workstation in as few steps as possible, which turned out to be … a lot of steps, most of them manual. I wanted to document the full process and see if I can find worthwhile opportunities for automation.

Install Kubuntu the usual way. Configure LUKS disk encryption and user account. sudo apt update -y && sudo apt upgrade -y.

🎨 Difficult to automate because I make different partitioning and file system choices for every device.
Copy password vault manually via USB drive. Installed KeePassXC via apt because I will need it for basically everything that follows.

🔐 Won’t automate. If you trust the KeePass security model, then in theory you should be willing to put your KeePass vault on a public URL and download it automatically … but I don’t think anyone’s that bold.
Generate SSH keys (ssh-keygen) for various Git hosts. Add entries like this in ~/.ssh/config:
```
Host github.com IdentityFile ~/.ssh/id_just_generated 
```
Log into GitHub and others in Firefox and add the new SSH keys manually.

🔐 Won’t automate. I guess I could script this a little more with the GitHub CLI, but at some point I would still have to manually enter the MFA token, so the benefit would be marginal. (Some people choose to use the same SSH key for every client, which would simplify this step greatly, but I like the ability to scope and revoke keys individually for different workstations.)
Install Syncthing (apt install syncthing). Run Syncthing manually (we will configure autostart in step 8) and set up folder connections with other devices.

🧪 Hope to automate via a script that automatically finds my main Syncthing server and prompts for authentication. For later reference.
Run a configuration script setup.sh (see below) to automatically install various tools, do some basic configuration, and clone a few git repos.

💻 Automated. I created this script for the first time as part of this setup. In the past, I just installed packages as I thought of them. Eventually I want to integrate setup.sh with my dotfiles.
Set up Nextcloud using the desktop client (installed in setup.sh). Configure offline folders.

🎨 Difficult to automate. You can kind of predefine the Nextcloud server connection parameters, but there’s no getting around the MFA step, and I choose different offline folders for each device.
Install dotfiles: I have a private git repo (cloned in setup.sh) with a custom shell script that does this. It’s basically three steps:
1. Apply fish shell configuration: aliases, universal variables, a few custom functions.
2. Copy dotfiles for some command-line programs: topgrade, micro.
3. Apply git configuration: git config --global user.name, etc.
4. Copy some utility scripts: Borg backup with preferred options, a primitive Markdown linter (I should clean this up and post it sometime).
My dotfiles repo is private because it hardcodes a bunch of parameters like my name and email address that would only cause confusion for someone else.

💻 Automated enough for me.
Configure Korean keyboard input with fcitx5. This is always the hardest step when I try a new Linux distro. For Kubuntu, setup.sh installs all the necessary packages, but a few additional setup steps are needed to get Korean input working with KDE under Wayland. Basically, the trick is to repeatedly log out and back in again and follow the instructions in the notification that automatically pops up from the automatic diagnostic tool.

These are the changes I had to make this time around:
1. Set the XMODIFIERS, GTK_IM_MODULE, and QT_IM_MODULE variables according to the latest recommendations in the Fcitx wiki.
2. In KDE’s settings, under Virtual Keyboard, choose Fcitx5 Wayland Launcher (Experimental).
3. Run the im-config GUI, let it run its diagnostic, and follow the prompts.
4. Open the fcitx5 settings by clicking the system tray icon and set up preferred keybindings for switching between Korean and English input.
After doing all this, I still got a notification upon login saying that I should unset the GTK_IM_MODULE and QT_IM_MODULE environment variables. But it seems like this was a false positive, because I can verify from the shell that these variables are empty (as recommended). Anyway, Korean typing works fine everywhere I’ve tried.

🧪 Hope to automate.
Configure Syncthing (again): Run Syncthing Tray (installed in setup.sh) manually and follow prompts to let it autostart itself and Syncthing.

🧪 Hope to automate.
Generate SSH keys (again): This time for shell access to remote servers. Add HostName, User, and IdentityFile entries for each host to ~/.ssh/config.

All the servers I use allow only key-based access, so I used Nextcloud (hence waiting until now) to copy the public keys over to a client that already had access, then ran ssh-copy-id -f -i path/to/id_whatever.pub server-hostname on that client to vouch for the new one.

🧪 Hope to automate. I could write a script to prepare the keys on the client that already had access, then run this script prior to setting up the new machine and transfer the keys as part of step 1.
Install Miniforge: curl then bash and follow interactive prompt. I install it to ~/.local/miniforge3 instead of the default ~/miniforge3. Say yes when asked to update shell profile. This seems to only affect bash so I went ahead and ran ~/.local/miniforge3/bin/conda init --all. Make sure I can configure and build my website.

🧪 Hope to automate in setup.sh. If setup-miniforge can do it, then presumably I can too.
Set some weird keyboard preferences: Menu key (if unavailable, right Alt instead) as compose key, swap Esc and Caps Lock, a few other keyboard shortcuts for window management. I do this in the KDE settings GUI.

🧪 Hope to automate.

These steps are in a woefully illogical order. But I think that the dependencies among these actions simply necessitate some jumping around between manual and automated configuration, GUI and command line, and different physical computers.

I gaze in awe upon setup guides like Brian’s that proceed monotonically from bottom (disk partitioning) to top (configuring backups). I have to admit, I doubt that his real process is as clean as his guide suggests: Surely Brian must backtrack and make some changes to his desktop environment config after installing all those bespoke fonts, right? Anyway, it’s an ideal to strive toward.

Setup script

Contents of setup.sh, slightly redacted to make myself look better:

#!/usr/bin/env bash # Cache sudo credentials sudo -v # apt packages sudo apt install -y \ keepassxc fzf curl pipx git fish \ nextcloud-desktop dolphin-nextcloud \ fcitx5 fcitx5-hangul fcitx5-config-qt \ syncthing syncthingtray syncthingtray-kde-plasma # snap packages snap install --classic codium # ... # pipx packages pipx ensurepath pipx install topgrade # ... # Configure/enable firewall sudo ufw default deny incoming sudo ufw allow syncthing sudo ufw enable sudo ufw reload # Change shell to fish chsh -s /usr/bin/fish # Git repos (assumes SSH keys already set up) mkdir -p "$HOME/gits" pushd "$HOME/gits" || exit 1 git clone 'git@github.com:maxkapur/maxkapur.github.io.git' # ... 

Still playing guitar like piano

2025-05-28T00:00:00+00:00

I still play the guitar like a piano. It’s most obvious when I try to play along with the lead guitar part in a recording of a two-guitar band. Often, the lead guitar just has a simple single-note riff or triads in the upper register, but I cannot resist the impulse to insert bass notes in the “left hand” (often grabbing them with my thumb). It doesn’t feel like a complete part without them.

Of course, there is already a bass in the recording, so playing in this way does not add any value, and comes at the cost of less fluidity in the actual guitar melody. I am trying to discpline myself to double lead guitar parts exactly, but it’s hard to break the habit of embellishment.

Another way my piano training interferes with playing guitar is an instinctual aversion to the capo. On the piano, if you want to play a song in a different key, you play it in a different key. (Actually, a lot of keyboards have a transposition feature, but using it is frowned upon.) But a guitar capo is sometimes musically necessary access open chord voicings in flat keys.

My pianist problem is that when I play the guitar with a capo, I can never decide whether to think in the transposed or concert key. The open chord voicings certainly are easiest to remember in the transposed key, but as soon as I need to play a melody higher on the neck, it’s like the capo isn’t there, and I have to think in concert key to make any sense of it. Most often, I just get really confused and put away the capo.

First impressions after moving to Tennessee

2025-05-21T00:00:00+00:00

Honey, baby, etc.
Even young people have the accent. This surprised me because I thought that regional accents were slowly melting away thanks to mass media. In Korea, kids may have picked up a few regionalisms from family, but for the most part they spoke like the video game streamers they watched on YouTube. In Tennessee, you can hear an accent even in young toddlers.
Frequency of conversations with strangers is somewhat higher than on the coasts, but more noticeable is the length and depth of the conversations. I spoke for five minutes with a guy in the elevator and we kept having to stick our arms in the door to reopen it. We finally stopped talking when the elevator starting beeping at us and forced the door closed. Didn’t even find out his name.
Haven’t heard any cool aphorisms like “it’s all grist for the mill” yet, but my ears are open.

How I organize browser tabs

2025-04-30T00:00:00+00:00

I didn’t realize I had a system for this until I did.

My system: I only ever open one browser window (OK, two on my work computer where I use MS Edge profiles for different Microsoft accounts).

When I open a new tab, I scan the tabs already open and move it left or right so that the tabs remain ordered by decreasing priority. “Priority” means something like, how annoyed would I be if I closed this by accident?

High priority: Things that I keep open all day (email, GitHub issues).
Medium priority: Documentation or reference material for the current task.
Low priority: Random ephemera, landing pages from clicking a confirmation email, article I already read but just need to copy a quote from, etc.

Whenever I start to have more than 15 or 20 tabs, I get a cramped feeling and start axing tabs from right to left until I arrive at one that I still want open. Usually, this leaves two or three tabs.

Sometimes I accidentally close things that I still needed, but I tell myself that the time wasted reopening them is offset by the time saved searching through dozens of tabs to find the right one.

Is this system any good?

Music videos

2025-04-23T00:00:00+00:00

A side effect of my refusal to subscribe to Spotify (I just buy albums on Bandcamp or used CDs) is that when someone sends me a song to listen to, I usually look it up on YouTube and end up watching the music video. Because of this, there are some songs or artists that I like more than I might have without the video because the video adds an additional layer of interpretation.

I think I had mentally blocked myself from verbalizing this thought before because of my background as a musician. I would like to think of myself as someone who values the music itself and whose opinion of a song isn’t swayed by the addition of a video track. After all, a music video is kind of like an advertisement for the song or artist, a reference rather than the thing itself.

But then, I should have realized my susceptibility to music videos sooner, because a big part of jazz school was learning how to watch jazz performances: Musicians on stage employ a wide vocabulary of visual and bodily cues to steer the ship while improvising.

And I went to a school whose music buildings were right next to the film school—I think they actually had a small scoring stage somewhere. Lots of my classmates did collaborations with film or animation students, but I went the other way, preferring to incorporate “analog” art like poetry and fiction into my music by setting texts to melodies. A missed opportunity.

Reasons it’s hard to abandon a smartphone

2025-04-16T00:00:00+00:00

Reasons (excuses?) that I cannot downgrade to a dumbphone:

2FA apps. You can set up a generic TOTP program on your computer, but that’s not very convenient, and some organizations explicitly require you to use Microsoft or Google Authenticator. (I don’t know how they enforce this given that the algorithm for generating TOTP codes from the secret is an open standard.)
My apartment building used to require an app to unlock the package room. The app is proprietary and probably not secure. The only alternative to the app is to bother the staff to open the package room for you.
During the pandemic, Korea adopted a contact tracing system that involved scanning a QR code in an app on your phone at every business you entered. Many businesses would let you just write your phone number on a clipboard as an alternative, but some (Starbucks) required the app. Was the app secure? Has the database ever been breached? I sure hope not.
Concert tickets from dice.fm. They have an exclusive deal with many venues that makes them the only place you can buy tickets, and their system requires you to store your tickets in their app, for anti-fraud reasons or whatever. (At smaller venues, if you don’t have the app, they can manually verify your name on the guest list.)

I don’t like that a smartphone has become a de facto requirement participation in society. Smartphones have only existed for a few years. The main purpose of the “prove you own a (smart)phone” tests that most commercial and government services put you through these days seems to be to combat spam: Acquiring and maintaining a non-VOIP phone number that can receive SMS messages is too expensive for most spammers to do at scale. But again, I resent that the burden of proof is on me to prove I’m not a spammer instead of on the service to prove I am.

Circular regression when you already know the period

2025-04-06T00:00:00+00:00

This Stack Exchange answer reminded me of a useful data science trick. In short, if you try to model $y$ as a sinusoidal function of $x$ , you obtain a regression formula that is nonlinear in the parameters. However, if you know the period, you can use a trig identity to linearize the formula and compute an exact least-squares fit.

Background

Suppose you are trying to create a regression model for data that looks like this:

$y$ is clearly a sinusoidal function of $x$ (plus noise), so there are three parameters we need to estimate:

The period $T$ (distance between peaks)
The amplitude $A$ (height of the peaks)
The phase $\phi$ (where in the cycle the peaks occur)

For some data, there’s really only one value for the period that makes sense. For example, if $x$ represents “day of the year” (as in the Stack Exchange question), then we are clearly expecting a yearly cycle (or else we would have collected exact dates). Thus, $T = 365.25$ (or however you want to handle leap years), and we have only to estimate the amplitude and phase that best fit the data.

Problem statement

Without loss of generality, we can assume that $T = 2 \pi$ (if not, multiply each $x_i$ by $2 \pi / T$ ). Then our objective is to minimize the error in the system of equations

y_i = A \sin( x_i + \phi )

for each $(x_i, y_i)$ in the input data.

Unfortunately, this model is not linear in the parameters to be estimated ( $A$ and $\phi$ ), so we can’t estimate it using ordinary least-squares regression.

The trick

The trick is to estimate the following model instead, which is linear in the parameters $\beta_0$ and $\beta_1$ :

y_i = \beta_0 \cos x + \beta_1 \sin x

To see that this model is equivalent, apply a trig identity to find that

A \sin( x_i + \phi ) = A \cos x_i \sin \phi + A \sin x_i \cos \phi.

Matching coefficients on $\sin x_i$ and $\cos x_i$ , we have

\begin{aligned} \beta_0 &= A \sin \phi \\ \beta_1 &= A \cos \phi . \end{aligned}

Dividing the first equation by the second, we recover $\phi = \operatorname{atan2}(\beta_0, \beta_1)$ . Then $A = \beta_0 / \sin \phi = \beta_1 / \cos \phi$ .

Demo

The following Python script demonstrates our technique.

#!/usr/bin/env python import numpy as np import matplotlib.pyplot as plt rng = np.random.default_rng() if __name__ == "__main__": # Make fake training data  size = 128 # Number of points  x = rng.uniform(0, 10, size) A = rng.standard_exponential() phi = rng.uniform(0, 2 * np.pi) sigma = 0.20 * A # Scale of random noise  y = A * np.sin(x + phi) + rng.normal(size=size, scale=sigma) # First plot showing what the data looks like  plt.scatter(x, y) plt.savefig("cyclical-data-before.svg", transparent=True, bbox_inches="tight") # Transform x to its cos and sin, then solve  # y = x_transformed @ beta  # by least squares.  x_transformed = np.stack([np.cos(x), np.sin(x)]).T (beta0, beta1), *_ = np.linalg.lstsq(x_transformed, y) # Discard other outputs  # Recover A and phi using the transformation we derived. Estimate A using  # both expressions and take the average.  phi_pred = np.atan2(beta0, beta1) A_pred = (beta0 / np.sin(phi_pred) + beta1 / np.cos(phi_pred)) / 2 # Plot the estimated model using regularly spaced values of x  x_pred = np.linspace(x.min(), x.max(), 500) y_pred = A_pred * np.sin(x_pred + phi_pred) plt.plot(x_pred, y_pred) plt.savefig("cyclical-data-with-fit.svg", transparent=True, bbox_inches="tight") 

Here is what the predicted model looks like:

Notes

When to retain the linearized parameterization: In the Python code above, we computed $\phi$ and $A$ just to demonstrate that the technique actually works. But the code will throw a zero-division error at the computation of A_pred if $\phi$ is a multiple of $\pi / 2$ (which happens when one of the $\beta_j = 0$ ). In practice, I recommend discarding the $A$ and $\phi$ values and running predictions using the $y_i = \beta_0 \cos x + \beta_1 \sin x$ model instead. Experienced data scientists will recognize this transformation, but you could add a comment along the lines of “this is a linear reparamaterization of $A \sin( x + \phi )$ .”

Linear combination of sinusoids: You can also use this technique if your $y$ variable is a linear combination of sine waves of known periods. For example, if $x$ is “minute of day” and $y$ is “volume of emails,” you might expect an overall daily trend (period of 24 hours) with smaller variations within each hour (due to scheduled emails going out at the top of each hour). Then you can set $w_i = 2 \pi x_i / (24 \cdot 60)$ , $z_i = 2 \pi x_i / 60$ , and minimize the error in

y_i = A_w \sin( w_i + \phi_w ) + A_z \sin( z_i + \phi_z )

using the transformation above.

Fourier transform: If you don’t know the period $T$ and your $x_i$ are evenly spaced, then what you’re looking for is probably not a regression model but a discrete Fourier transform.

pipx install topgrade

2025-03-19T00:00:00+00:00

Many Rust projects, such as Topgrade, also publish themselves on PyPI. This means you can install them using pip or pipx as follows:

pipx install topgrade pipx install zizmor

This pulls a binary (wheel) directly from PyPI, which obviates the need to compile from source—handy on low-powered machines where cargo install can take a while to run or exhaust the memory (ask me how I know).

If you maintain a Rust project, it looks pretty easy to enable this installation method using Maturin.

Speaking of Topgrade: Topgrade is a helpful command-line tool that automatically updates everything it can on your system (think sudo apt update && sudo apt upgrade && flatpak update && ...). I recently got a PR accepted that enables Topgrade to run conda clean, which can free up gigabytes of space on a well-used conda installation. I also have an open PR (perhaps merged or rejected by the time you read this) that lets you configure additional conda environments to upgrade besides base.

Authenticity and the Illusion Slopes AI policy

2025-03-12T00:00:00+00:00

I attached my real name to this site. That means that above all, this site must represent me authentically.

Authenticity is why I don’t use any generative AI tools in authoring or editing my posts. Heck, I barely even use spellcheck. The 2006 Adam Sandler movie Click pretty clearly spelled out the risks of letting an AI autopilot your life: Such technology promises to augment the self, but dilutes it instead. I would rather document my ideas, even if they aren’t very good, than some weird average of my thoughts and every Reddit comment GPT has ingested.

Authenticity also requires that I abandon any pretenses about what happens after I inject my thoughts into the world. I don’t use AI, but I don’t use any countermeasures against AI scrapers either, such as blocking OpenAI’s domains in robots.txt. If the scrapers don’t get the text from here, they’ll get it from GitHub, or from someone quoting me on another blog. Although I do not welcome plagiarism, it’s a risk I accept as the price of participating in an interconnected society. (If you want to reuse text from Illusion Slopes, LICENSE.txt gives the terms.)

Finally, on the internet, it appears difficult to combine authenticity with marketing. So, I don’t use Illusion Slopes to try to sell anything, nor do I employ any marketing cookies or user fingerprinting tech to collect statistics about the people who visit the site. Back when I used Blogger, I used to get some “dumb” analytics about post views by IP geolocation, but now that I use a static site generator, I don’t even know which posts are more or less popular. I like it that way; it ensures I am writing for myself.

Putting this all together, I realize that the Illusion Slopes AI policy is really a non-policy. I’m neither for nor against AI; it’s just “there,” a technology that doesn’t have much to do with what this site is about. That could change in the future, as the technology becomes more pervasive and harder to opt out of (and hopefully more useful). But for now, I am happy with the incidental benefits of failing to reposition my website for the AI era:

Without AI-generated filler images or heavy JavaScript analytics, the site loads quickly (I hope?).
Everyone who wants to read the site, can. I don’t have to worry about an aggressive anti-scraping filter that accidentally blocks legitimate users.
If I write something wrong, then won’t have to issue shallow excuses about how “the model told me so.” For better or worse, I own my errors.

Check this box to prove you are a human

2025-03-04T00:00:00+00:00

Why is the burden on me to prove that I’m not a robot instead of on the server to prove I am? This is a vain question if you reflect on the adversarial nature of internet spam, but I am asking anyway. Here’s a fun game: Prove you are a human.

How to type an em dash

2025-02-20T00:00:00+00:00

Phone (Android): Long press the hyphen button
Desktop (Linux): Compose key sequence ---
Work computer (Windows):
- If in Word or Office: Type two hyphens and let it autocorrect
- If Markdown: Use the HTML character entity —
- Otherwise: ⊞ Win + . character chooser, or just Google “em dash” and copy/paste

People and Blogs interview

2025-02-14T13:00:00+00:00

Manuel Moreale, a tireless indie web advocate, recently had me as a guest on his People and Blogs series (local mirror). Welcome to anyone visiting this site via Manu’s feed! Take a look around and let me know what you think.

I was super excited to be interviewed by Manu, as many of his writings have sharpened my thinking around why I prefer blogging, email, and group chats to brand-name social media:

Manu has compiled a lot of useful information for people trying to pivot from social media, such as his list of blogging platforms. If you are one of the friends I’ve been trying to talk into creating a personal site, definitely check out Manu’s list.

Conda updated?

2025-02-12T00:00:00+00:00

Using a tip from Travis Hathaway, here is a shell one-liner to check if a Conda environment is up to date:

conda update --all --dry-run --json | jq -e '.success and (.actions | length) == 0' 

It exits (-e) with 0 if the environment is already updated and 1 if updates are available.

I use this in CI so that I get an email if my environment.yml file is holding any packages back.

Because this command actually executes the dependency solver, it won’t report the environment as out of date unless a package both has an available update and can be updated while satisfying all the other dependencies’ version constraints.

Newly excavated posts about teaching

2025-01-11T00:00:00+00:00

When I migrated from Blogger to Jekyll a few years ago, I left a bunch of posts behind, with the vague resolution of importing them at some point. Today, I excavated a few more from the archives, all about teaching:

The benefits of a nonnative teacher (2020): A very long-winded way of saying that language learners often benefit from having a teacher who isn’t a native speaker of the target language, because then the teacher has empathy for the student. I think I stand by this take.
Things that are a thing here (2018): Just a few days into my Fulbright job, I was enamored with how seriously Korean teachers took their profession—and still am. But knowing what I do now, I would not write “Art, music, literature, and ‘morality’ class matter [in Korean schools] just as much as the STEM subjects.” Of course, all these subjects factor into your GPA, but as in the US, many Korean teachers and parents believe that the best jobs go to STEM graduates. And thus, even if it’s not their intention, they tend to celebrate students’ success in those subjects with a bit of extra energy.
Centering students as creators (2017): Notes from my undergrad internship. I think I see the germ here of an idea I’ve grown more certain of since: When you don’t know how to proceed, the first thing you should do is start. You know—open a document, put your name and the date, choose a font. These first steps shake off the fear of failure and assure the brain that it is safe to proceed.

Server-side KaTeX rendering with Jekyll

2024-12-26T00:00:00+00:00

This post explains how I set up server-side KaTeX rendering to improve the load time on pages that include mathematical notation.

KaTeX is a math typesetting library that lets you render nice-looking math equations like $f(t) = e^{rt}$ inside of an HTML document. As the KaTeX documentation describes, the easiest way to use KaTeX is to import their CSS and JavaScript from your website’s <head> element by adding these three lines:

<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.11/dist/katex.min.css" integrity="sha384-nB0miv6/jRmo5UMMR1wu3Gz6NLsoTkbqJghGIsx//Rlm+ZU03BU6SQNC66uf4l5+" crossorigin="anonymous"> <script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.11/dist/katex.min.js" integrity="sha384-7zkQWkzuo3B5mTepMUcHkMB5jZaolc2xDwL6VFqjFALcbeS9Ggm/Yr2r3Dy4lfFg" crossorigin="anonymous"></script> <script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.11/dist/contrib/auto-render.min.js" integrity="sha384-43gviWU0YVjaDtb/GhzOouOXtZMP/7XUzwPTstBeZFe/+rCMvRwr4yROQP43s0Xk" crossorigin="anonymous" onload="renderMathInElement(document.body);"></script> 

With this client-side setup, visitors to your site only receive the KaTeX “source” (something like $$f(t) = e^{rt}$$) from your server, and then their computer runs the code (KaTeX) that transforms this into MathML and tells the browser how to style and arrange the individual symbols.

However, by running KaTeX on the server instead of the client, you can send readers the MathML code directly, which removes the need for redundant computations and queries to the KaTeX CDN. Guillaume Endignoux and Xuning Yang explain how to achieve this setup using Jekyll, the static site generator I use. In summary:

Add the duktape, execjs, katex, and kramdown-math-katex gems to your Gemfile. (You can leave out duktape if you already have Node.js on your path.)

Set the following options in _config.yml:

markdown: "kramdown" kramdown: math_engine: "katex" 

Add the following line to your site’s <head> element:
```
<link rel="stylesheet" href="/assets/katex.css"> 
```
Download a KaTeX release from GitHub and extract katex.css and fonts/ to your source repo’s assets/ directory.

The last step left me unsatisfied. As I described in a previous post, I want to avoid introducing a third-party code dependency to my source tree—especially one like the KaTeX CSS that I’d have to keep manually in sync with the version of KaTeX installed by the Ruby katex gem. Instead, I tweaked my configure.sh script to automatically retrieve the KaTeX fonts and CSS from within the katex gem after installing it with Bundler:

function install_katex_resources () { KATEX_CSS_SRC="$(find ./vendor/ -ipath "*/vendor/katex/stylesheets/katex.css")" KATEX_CSS_DEST="./assets/katex.css" rm "$KATEX_CSS_DEST" 2> /dev/null if [ ! -f "$KATEX_CSS_SRC" ] then echo "E: Failed to locate source katex.css" >&2 return 1 fi ln -v "$KATEX_CSS_SRC" "$KATEX_CSS_DEST" KATEX_FONTS_SRC=$(find ./vendor/ -ipath "*/vendor/katex/fonts/*.woff2") KATEX_FONTS_DEST="./assets/fonts" rm "$KATEX_FONTS_DEST"/*.woff2 2> /dev/null # shellcheck disable=SC2068 # splitting intended for f in ${KATEX_FONTS_SRC[@]} do BASENAME=$(basename "$f") ln -v "$f" "$KATEX_FONTS_DEST"/"$BASENAME" done } 

This puts the files in the assets/ directory—right where they need to be—but keeps Bundler in control of their versions. Using a hard link (ln a b) instead of copying (cp a b) the files spares a few unnecessary disk operations when rerunning configure.sh.

I admit that the maintenance burden this eliminates isn’t large, but in a project with many dependencies, the little things add up.

Two novels to understand Korea’s political turmoil

2024-12-08T00:00:00+00:00

On Tuesday night, South Korean President Yoon Suk Yeol imposed martial law across the country for six hours. He retracted his declaration only after the National Assembly passed an emergency resolution ordering him to back down. As of this writing, the Assembly has drafted but failed to vote on articles of impeachment. Instead, Yoon’s party has announced a plan for the president’s “orderly resignation.” Many details remain up in the air.

As an American, it is not my place to take sides or say what Korea should do next; I can only observe and interpret. With that as my goal, I would like to discuss two novels that may supply context to the current political situation.

First, to understand the images that Koreans associate with “martial law,” we must discuss Han Kang’s 2014 novel Human Acts (한강, «소년이 온다»), which is available in an English translation by Deborah Smith. The novel portrays 1980’s 5/18 movement and the ensuing government crackdown in which public officials killed, sexually assaulted, arrested, and tortured pro-democracy activists in Gwangju on false charges of communist sympathy—crimes that the Korean government has since acknowledged.¹ As Friday’s New York Times explains (paywall), Han Kang’s recent Nobel Prize offered a moment of catharsis and vindication for victims of the 1980 incident; the recent turmoil has cut short their celebration.

Next is 28 by Jeong You Jeong (정유정). Set in Hwayang, a fictional city on the outskirts of Seoul, this 2013 novel imagines the outbreak of a highly infectious disease transmitted between humans and dogs. Once the Korean government grasps the infection’s contagiousness and lethality, the president imposes a swift military blockade on the city. Within, anarchy prevails. As the citizens of Hwayang clash with the occupying troops, 28 makes transparent reference to the crimes of 5/18, but pushes further to ask how martial law would unfold with modern technology and social media. Jeong also raises difficult questions about the transactional relationship between humans and animals. (And, because it is a Jeong You Jeong novel, there is a serial killer running around.) It looks like Chi-Young Kim translated this novel into English at the Literature Translation Institute of Korea, but all I can find is an excerpt.

These modern novels remind us that in Korea, the concept of authoritarian rule is more than a rhetorical foil, but a living memory than looms over public policy and civic life. At this moment, martial law is no longer in effect, President Yoon has apologized, and the democratically elected National Assembly controls the government. That means that Korea’s future is, for now, safely in the hands of its people.

It took until 2018 for the Korean government to acknowledge that soldiers sexually assaulted civilians during the crackdown. ↩

How I self-host fonts on this blog

2024-12-06T00:00:00+00:00

I recently transitioned this blog to self-host its fonts (IBM Plex Sans, Sans KR, and Mono) from within the GitHub Pages artifact instead of calling the Google Fonts API. This makes the site a little more “static” by eliminating the need for your browser to download font files from an external domain. Here, I explain how (and why) I self-host fonts without bringing them into the source tree.

The easiest way to self-host fonts with a static site generator like Jekyll is to store the .ttf or .woff2 font files and their CSS inside of the assets/ folder of the source repo. But this turns the font into an in-tree dependency, which I wanted to avoid: Although IBM’s SIL Open Font License appears to permit this sort of vendoring, I have an (admittedly puristic) desire for my repo to consist only of code I wrote myself. And I wanted to try automating the process of downloading and installing a dependency without using a package manager like conda or apt.¹

My source repo already has a configure.sh script that installs Ruby, Jekyll and friends to the local workstation so that it can build and preview the static site. To this script, I added curl and unzip commands to automatically download the latest IBM Plex release and extract the fonts to the assets/ directory (where they are .gitignored).

Now, as long as IBM follows semantic versioning in its font releases, updating to a new version of IBM Plex requires no more than changing the version number in these lines from configure.sh:

IBM_PLEX_MONO_SRC="https://github.com/IBM/plex/releases/download/%40ibm%2Fplex-mono%401.1.0/ibm-plex-mono.zip" IBM_PLEX_SANS_SRC="https://github.com/IBM/plex/releases/download/%40ibm%2Fplex-sans%401.1.0/ibm-plex-sans.zip" IBM_PLEX_SANS_KR_SRC="https://github.com/IBM/plex/releases/download/%40ibm%2Fplex-sans-kr%401.1.0/ibm-plex-sans-kr.zip" 

(It is also possible to modify these URLs to automatically pull the latest release instead of pinning a version.)

I already use conda as part of my configure.sh script, so installing a font with conda wouldn’t be a heavy lift, but only the Sans variant of IBM Plex is available in conda-forge, and I need the KR and Mono variants, too. (The conda package also doesn’t include CSS font definitions.)

These fonts are available in the Ubuntu apt repositories, but then my build script would no longer function on other Linux distros, and I’d still have to use ./configure.sh to copy the files from /usr/share/ to my site’s assets/ directory. ↩

Replacing rbenv with conda

2024-11-29T00:00:00+00:00

Why I am using conda instead of rbenv to install Ruby inside of the CI job that builds this static site.

The problem

I wanted to make the GitHub Action that builds this static site more portable by replacing the parade of third-party GitHub Actions with simple shell scripts.

With a self-contained build process, I can match my local build workflow to the one used to deploy the site from GitHub without going to (IMO) extremes like running the GitHub Actions Docker image locally. It also makes it easier to migrate my hosting away from GitHub Pages if I ever should desire to.

However, in my previous attempts to make a portable build script, I kept having difficulty with what should be the easiest step: Installing a Ruby version of my choice (currently v3.2) and pulling in all of Jekyll’s dependencies.

The normal solution

Most of the guides I consulted recommend rbenv, which is a Ruby version manager that lets you specify your desired Ruby version in a .ruby-version file and install it with rbenv install.

Unfortunately, installing rbenv itself is not that simple: On Debian stable and Ubuntu 22.04 (which is currently ubuntu-latest in GitHub Actions), the version of rbenv in the repos is too far out of date to install the version of Ruby I want. The rbenv developers recommend using the rbenv-installer script to install the latest rbenv from Git instead, but then the rbenv-installer README advises against usage in a CI pipeline, which is exactly what I want to do:

For automating installation across machines it’s better to avoid using this script in favor of fine-tuning rbenv & ruby-build installation manually.

This gets at another difficulty with rbenv, which is that it builds Ruby from source when you rbenv install a version that isn’t in your local cache. This means installing ruby-build in addition to a bunch of dynamically linked development libraries. On some of my workstations, I struggled and failed to put together a functional ruby-build toolchain; on my laptop, I finally got it working, only to have the build fail because I ran out of memory.

For those who have the time and computational resources to compile from source, rbenv is a great tool, but for me, what I really needed was a precompiled binary. (Thus, I also ruled out RVM, another popular recommendation.)

The conda solution

Enter conda-forge::ruby. Conda is a cross-platform package management and virtual environment system that is generally associated with the Python world (because it is written in Python) but supports generic binary packages. I used to be skeptical of conda because the most popular distributions (Anaconda and Miniconda) are proprietary, but Miniforge is an open-source alternative that covers all my use cases.

After installing conda (and mamba because why not), I created build scripts configure.sh, build.sh, and so on that simply wrap mamba create and mamba run. The GitHub Action that builds the site is now basically just this:

./configure.sh # Create the conda environment and run bundle install ./info.sh # Log package versions ./build.sh # Build the site ./check.sh # Lint scripts with ShellCheck; might add more checks 

This workflow takes an average of two minutes to run on the GitHub cloud runners, which makes it faster, on average, than the parade of GitHub Actions I had before, which took about three minutes (except when running the workflow several times in a row, in which case caching would bring the runtime down to 20 or 30 seconds).

Alas

Alas, my GitHub Action workflow still has one third-party dependency: The Setup Miniconda action. Despite the name, it can set up either Miniconda or Miniforge, and it is a little easier to work with than Miniforge’s interactive installer script.

I think this is a sustainable solution, although those are probably bold words from the guy who just set all this up last week.

Media literacy chat at 88.9 Gwangju FM

2024-11-06T00:00:00+00:00

I wanted to follow up on my previous post about the CLS alumni seminar in Gwangju to spotlight my favorite excursion of the week: our visit to the 88.9 Gwangju FM community radio station. Gwangju FM has no particular theme, but they dedicate part of their schedule each week to programming related to the Gwangju international community. When our group of twenty-five showed up, the staff divided us into five groups and gave us two hours each to produce a one-hour broadcast on a topic of our choice.

The task seemed impossible when the guide explained it to me (at work, we routinely spend weeks choreographing what amounts to a brief slideshow presentation), but the time pressure worked to our group’s advantage: all we could really do was create a list of discussion questions and songs to provide forward motion, then improvise from there. We ended up having a spirited discussion about media literacy and news consumption. (Email me if the link breaks and I will upload an MP3 instead.)

After our group disbanded in Gwangju, I got to spend a few days in Naju, my “second hometown” where I taught English for two years as a Fulbright grantee. I tried a new (to me) gomtang place called 나주곰탕사매기, which has a cool aquarium, a garden, and even birds! A few pics below.

Here is their garden:

And here is the soup:

Gwangju again: CLS Media Literacy and Democracy seminar

2024-11-02T00:00:00+00:00

I had the honor this week of participating in the first ever Critical Language Scholarship Alumni Seminar (archive.org mirror) at Chonnam National University in Gwangju, South Korea. The seminar focused on media literacy and democracy, and I can’t think of a better time or place to study the topic.

Koreans take their democracy very seriously, as evidenced by the high degree of civic participation (there is virtually always a protest going on in front of all the major government buildings in Seoul) and high voter turnout (77% in the 2022 presidential election). One reason is that Korea didn’t adopt a democratic constitution until 1987, which puts Korea’s long struggle against authoritarian rule well within living memory. The memory is especially fresh in Gwangju, the site of the 5/18 (1980) independence movement, in which hundreds of activists (many of them CNU students) lost their lives to state violence.

As we learned, throughout the 1980s, citizen journalists played a pivotal role in resisting media censorship and spreading the true narrative of 5/18 via informal publications; their contributions were arguably a key factor in the eventual success of the 1987 democracy movement. I was encouraged to hear from a panel of CNU student journalists about their efforts to document important issues in the community and carry forward CNU’s tradition of advocacy through journalism.

Our discussions during the seminar also reminded me of the important role that art plays in shaping the collective narratives that energize and sustain a democratic society. Today is another special moment in Gwangju’s history as the city celebrates the author Han Kang’s receipt of the Nobel Prize in Literature. Han Kang was born in Gwangju, and one of her novels, Human Acts (소년이 온다), memorializes the 5/18 independence movement. I have to add this book to the stack, as I have only read The Vegetarian (채식주의자), and only in translation. Our group also viewed, at the Gwangju Museum of Art, a pair of paintings by a then student activist, now senior citizen who began in retirement to paint scenes from the 5/18 movement to preserve his memory and perspective. (Unfortunately, I can’t find this artist’s name on the website.) Such images create a relationship between the viewer and the events of 5/18 that rings “true” in a way that journalistic accounts cannot.

As for me: Participating in this seminar meant that I got to return to the exact institution where I did CLS in 2016—my first visit to Korea—with the added perspective of eight more years of Korean study and four years of living in the country. It was a delight to show the other participants around and see Korea again through the eyes of a newcomer.

During CLS in 2016, I was too shy to explore much of the city, but on this visit the only limiting factor was time. After the seminar, I took a day to walk all around the Asian Cultural Center, an endless arts complex. My highlight was Delivery Dancer’s Arc: Inverse, a massive video installation from the studio of science fiction creator Ayoung Kim (김아영). I also enjoyed the ACC’s library, which has a slick reference area with art magazines and comfy chairs.

Bimatrix game equilibrium via nonlinear programming

2024-09-24T00:00:00+00:00

These lecture notes (PDF) from Asu Ozdaglar give a bilinear program whose solution is the mixed-strategy equilibrium for a two-player, non-zero-sum game with finite action spaces—also known as a bimatrix game. I wanted to reproduce this highly practical result in a more accessible format and offer some implementation notes.

Definitions

A bimatrix game is characterized by two matrices $A, B \in \mathbb{R}^{n \times m}.$ When Alice chooses strategy $i$ and Bob chooses strategy $j$ , their payoffs are $A_{ij}$ and $B_{ij},$ respectively. Mixed-strategy probability vectors $x$ and $y$ yield expected payoffs of $x^T A y$ and $x^T B y,$ respectively.

$(x^*, y^*)$ is an equilibrium if $x^T A y^* \leq x^{*T} A y^*$ and $x^{*T} A y \leq x^{*T} A y^*$ for all probability vectors $x$ and $y.$

Result

Theorem: $(\implies)$ If $(x^*, y^*)$ is an equilibrium, then there exist $p^*$ and $q^*$ such that $(x^*, y^*, p^*, q^*)$ is the optimal solution to the following bilinear program:

\begin{aligned} \text{maximize} \quad & f(x, y, p, q) = x^T A y + x^T B y - p - q \\ \text{subject to} \quad & A y \leq p \mathbf{1} & \text{(OptA)} \\ & B^T x \leq q \mathbf{1} & \text{(OptB)} \\ & \sum x_i = \sum y_i = 1 & \text{(ProbVec1)} \\ & x \geq \mathbf{0}, y \geq \mathbf{0} & \text{(ProbVec2)} \end{aligned}

$(\impliedby)$ Conversely, the optimal solution of the bilinear program is an equilibrium for the game.

Proof: $(\implies)$ For any feasible solution to the bilinear program, each element of $x$ is nonnegative (by ProbVec2), so we can use $x$ to combine the rows of the condition OptA to obtain a new valid inequality $x^T A y \leq x^T p \mathbf{1} = p \sum x_i = p$ (by ProbVec1). Applying the same logic to $y$ and $q,$ we find that $f(x, y, p, q) \leq 0.$

Now consider the equilibrium probability vectors $(x^*, y^*)$ and set $p^* = x^{*T} A y^*$ and $q^* = x^{*T} B y^{*}.$ Then $f(x^*, y^*, p^*, q^*) = 0,$ and we have only to show that this solution is feasible. To be an equilibrium, $x^*$ must earn Alice a better payoff against $y^{*}$ than does the $i$ th pure strategy: $p^* = x^{*T} A y^* \geq (A y^*)_i.$ This is precisely the $i$ th row of OptA. OptB follows similarly.

$(\impliedby)$ The bilinear program is clearly feasible and bounded (as shown a moment ago). Let $(\bar x, \bar y, \bar p, \bar q)$ denote the optimal solution. By Nash’s theorem on the existence of mixed-strategy equilibria, we know that an equilibrium exists, and from the first part of the proof, we know how to use this equilibrium to produce a feasible solution to the bilinear program with an objective value of zero. Thus, $f(\bar x, \bar y, \bar p, \bar q) \geq 0,$ which rearranges to

(\bar x^T A \bar y - \bar p) + (\bar x^T B \bar y - \bar q) \geq 0.

By the constraints OptA and OptB, each of the terms in parentheses is less than or equal to zero; thus, the inequality on $f(\bar x, \bar y, \bar p, \bar q)$ can hold only when each of these terms equals zero exactly.

Now consider any probability vector $x$ and use it to combine the rows of OptA: We have $x^T A \bar y \leq x^T \bar p \mathbf{1} = \bar p = \bar x^T A \bar y,$ which says that $\bar x$ is a best response to $\bar y$ . Applying the same logic to $\bar y$ and $\bar q$ completes the proof. ◼

Remarks

Solving the bilinear program is not necessarily easy. If merely solving a bimatrix game of this form is your goal, then mitigations against local optima such as iterated local search are essential. You can check whether a solution is local or global by comparing the objective value to zero, which is the global optimum guaranteed by Nash’s theorem.

In practice, I have used the bilinear program above when implementing the double oracle algorithm for games with complex action spaces. For example, in a modeling problem I am working on, pure strategies are subsets of $\mathbb{R}^n$ with additional inequality and integrality constraints.

The “first oracle” in the double-oracle algorithm has you compute the equilibrium of a subgame with discrete action sets and uses the bilinear program above. In the second oracle (typically the hard part), you then augment these action sets by computing a pure-strategy best response for each player against the mixed-strategy equilibrium obtained from the first oracle. You can use the double oracle algorithm to approximate either pure- or mixed-strategy equilibria by checking convergence and terminating after either the first or second oracle, respectively.

In my use case, the open-source solver Ipopt gives acceptable results for the first oracle. I also learned about cyipopt, a nice set of Python bindings for Ipopt that lets you @jit your functions with Numba or Jax for performance.

Advanced café techniques

2024-08-13T00:00:00+00:00

Most cafés have separate lines for placing your order and picking it up. After you order, you move to the next line, and since drinks come out in more or less the order they were requested, the barista usually announces your drink around the time you get to the front of the second line.

However, for simple drinks like drip coffee, all the barista has to do is fill the cup, so they can often hand it to you right at the order counter. This also applies to pastries. If you are a rule-follower and immediately move to the second queue after ordering one of these items, it can actually slow things down, because your drink will typically be ready before those of the people ahead of you in line, and you’ll need to elbow your way to the front.

Advanced combinations such as “coffee and a hot croissant” are marginal. This could be a one- or a two-queue order. Such situations require careful planning and deft execution.

Driver’s ed should teach error recovery

2024-06-23T00:00:00+00:00

I live near a one-way street, and drivers keep turning into it the wrong way by mistake. Most react by getting flustered and backing dangerously into the arterial, perhaps following an instinct to “undo” the error. The safer solution (in my eyes) is to park the car, wait for traffic to clear, then use a driveway to point yourself in the right direction.

Unfortunately, driver’s ed doesn’t teach you how to recover from mistakes like this—at least, mine didn’t. Instead, driver’s ed teaches the rules of the road and how to follow them. Once you have violated the law, even if by accident, you are in undefined territory. Hence, drivers develop a strong impulse to immediately “reverse” errors rather than identify a safe course of action.¹

The Federal Aviation Association has invested considerable effort into identifying the root causes of safety incidents and increasing safety baselines. They promote an idea called “just culture” as the alternative to a punitive culture that addresses each safety violation with swift discipline. Instead,

Safety inspectors must understand the difference between accountability, which accepts responsibility and looks forward, and blame, which focuses on punishment for what has already occurred. The key to a just safety culture is the ability to determine where the line should be drawn between unsafe acts that can be effectively addressed by using compliance tools (accountability) and unacceptable behavior that requires the use of enforcement action (blame).²

In the car world, many safety violations, such as drunk driving, street racing, cell phone use, and so on, fall squarely into the “blame the driver” category. But others are better understood as symptoms of inexperience, reasonable reactions to other drivers’ unsafe actions, or simply the inevitable consequences of poor signage. (Here I have deleted two paragraphs complaining about the placement of the ONE WAY signs in my neighborhood.) The blame belongs to multiple parties, and punishing only one yields only a marginal improvement in safety.

Another example we often see in city traffic is drivers who get stuck in the middle of an intersection when the light turns red. Of course, the driver’s manual says plainly that you should never enter an intersection unless you have the time and space to clear it. But this open-and-shut perspective doesn’t account for the real-world practice that drivers need to hone the timing instinct. Nor the pressure received from other drivers (sometimes imagined, other times real honking and yelling) to advance into an unsafe position. Nor how the previous factors interact with the frequent anxiety new drivers experience on the road. I am not saying that we should legalize running red lights, only pointing out that the perception that every unsafe situation flows from an individual’s culpable act makes it harder to identify safety improvements that require coordinated action.

I still don’t know the safe way to get out of the red light situation, nor how best to react (e.g. as a pedestrian crossing the street) when I see someone make that mistake. So, yeah, as the title suggests, I wish that driver’s ed taught strategies for dealing from these common errors, even a simple suggestion such as “Try to focus on how to make the situation safe now rather than what you shouldn’t have done.“

Generalizations to corporate governance, cybersecurity, academia, and so on are left to the reader.

Well, my driver’s ed course did talk about what to do after you get in a collision: Exchange phone numbers, take lots of pictures, call the police, and get clear documentation of who was at fault. ↩
LeRoy Stromenger, “Understanding the Compliance Program: One Bite at a Time!” FAA Safety Briefing, January/February 2024, 7, https://www.faa.gov/sites/faa.gov/files/JanFeb2024.pdf. ↩

Sports idea

2024-06-07T00:00:00+00:00

A footrace, but the objective is to run as far as possible in a fixed amount of time rather than speeding through a fixed distance. The catch is that the time limit is drawn randomly at the start of the race, so you cannot strategize around it being a sprint or distance event.

I think a good choice of distribution would be an log-normal distribution with a mean of around four or five minutes and a fairly high variance. Perhaps we could clamp the maximum time at eight hours, out of respect for the athletes’ work-life balance.

I ran (ha) this idea by a friend who is a competitive marathoner and he said, “That sounds like hell.” This makes me think I am really onto something, because many popular sports sound like hell to those who are not yet good at them.

New logo

2024-05-12T00:00:00+00:00

I created a new logo for the site today:

The old one was just a square with my initials, MK, which seemed a little too self-indulgent (not to mention that I share these initials with half of my extended family, so I can hardly claim them as my own):

The new logo still kind of forms a stylized letter m, if you imagine the three theme-colored vertical segments as hanging from the horizontal segment on top. It also kind of recalls the shape of the word Ill, which spells the start of the blog title and doubles as a fun bit of retro slang.

The best thing about fish

2024-05-03T00:00:00+00:00

The best thing about fish is probably the lateral line, which sort of like ears for underwater that enable fish to sense and locate predators even in dark or murky conditions.

The best thing about the fish command-line shell, on the other hand, has to be its “fuzzy” completions. In most other shells (like Microsoft PowerShell, which I use every day at work), you can tab-complete a filename like blog_post_idea.md by typing blog (the first part of the filename) and pressing Tab. If there are multiple matches, you use the arrow keys to scroll through them until you get the one you want.

This works fine if you put the most-unique part of your filenames at the beginning. But I like to begin my filenames with ISO dates, so to tab-complete 2024-03-06_blog_post_idea.md in PowerShell, I have to type 2024 and then jab the arrow key a bunch of times, which is like using a phone book that is sorted by phone number. In fish, I can just type blogpost (even without the underscore) and it will autocomplete to 2024-03-06_blog_post_idea.md.

Similar completions work for the options of most command-line programs, and it’s (relatively) easy to extend the built-in completions with your own configuration files (but I’ve never needed to).

Why I put ISO dates in filenames

2024-04-26T00:00:00+00:00

I am one of those obnoxious people who begins his filenames with an ISO date, like 2024-03-06_blog_post_idea.md. I know that file metadata already tracks creation and revision dates, but I don’t like those: The creation date is misleading when you duplicate a file to reuse its format or content, and the revision date is all but meaningless because modern software modifies files on disk in all kinds of spurious ways. I put an ISO date in my filenames to assign them a canonical date. The canonical date means something like “the last date at which this file underwent a significant change,” and I alone (not software) can determine what that means.¹

Another reprehensible habit of mine is that I often duplicate files (creating a new, ISO-datestamped copy) before making big changes despite knowing I can roll things back in our sync software (OneDrive). I do so because I have essentially unlimited storage space (1TB), and visiting the web UI means leaving the comfort of my local file manager for a terrible, laggy web app. But this practice is not just a matter of personal preference; it’s also a crucial mitigation against the version-control issues wrought by the collaboration features of the “modern office tech stack.” See, I have colleagues who, at the end of their work day, leave their computer on with all their Office files open.² A few hours later, their VPN session expires, which disconnects OneDrive. So, if I log in before them in the morning and make some edits, their version of the file goes out of date, but their OneDrive is powerless to detect it or show them my changes. This results in an instant version conflict when they come back online, make an edit, and reflexively press Ctrl + s. I munificently prevent this problem by copying each file and advancing the ISO date before making edits so that everyone can see that my version is the newest.

Ironically, the VPN vs. OneDrive fight would never arise on an old-school NAS or “S:// drive,” because (assuming the shared drive is behind the VPN), when the VPN lease expires, the ~$whatever.docx lock file (a hidden file that indicates when a file is being edited, and is completely ignored by OneDrive) would stay on the NAS, and I would be forced to make my edits on a copy of the file instead of the original—which is exactly what I already do, manually, now that I’ve learned never to trust software.

An example of the spurious ways in which modern software modifies files on disk: If you open a Microsoft Excel worksheet, adjust the zoom, and try to close Excel, it will issue a “Do you want to save your changes?” warning. I’m not sure why the zoom level is stored in the .xlsx file at all. In Word (as far as I can tell), the zoom level, like scroll position, belongs to your session state and will thus be remembered separately for different viewers of the document.

I have had some funny moments in client meetings where I pulled up an Excel sheet and it loaded at an illegible 50% because my last edit was to finalize the layout. 100% is the default for a reason! ↩
When I sign off for the day, I like to shut my computer all the way down to purge the demons. But I can’t fault others for not doing so, because cold-booting Windows with all the bloat, reopening all your files and email, and logging into Workday is a fifteen-minute process at best. ↩

New old device

2024-04-14T00:00:00+00:00

On a recent visit home, I dug this 2007 Sansa Clip out of a box.

It’s battery life is shot, but everything works, and I unearthed some critical throwback jams from the built-in 4GB of flash memory (among other things, the first four Brad Paisley albums in .wma format). As the picture shows, I also installed a bit of custom firmware called Rockbox.

I remembered Rockbox from using it on a different MP3 player (a Sansa e200) prior to the Clip. It runs on dozens of classic ’00s devices (including some of the early iPods) and provides a wide range of features and customization options beyond the stock firmware—things like support for the FLAC audio format, a dynamic equalizer, and better tools for managing playlist and the “now playing” queue. There are additional plugins for games, translations, font selection, and image viewing.¹

Rockbox distributes an installation wizard for Linux platforms, but I couldn’t get it to work (it 404’d trying to download the fonts package²). Fortunately, the “manual” installation isn’t hard. You just download one of the official firmware updates from Sandisk, then apply Rockbox’s patch and transfer the result to the device’s root directory. By design, the Clip attempts to execute any file in the root directory whose name matches a certain pattern. This firmware update mechanism was a welcome convenience for tinkerers, but it’s probably too insecure for today’s internet-mandatory smartphones.

Playing with the Clip has renewed my excitement for the Tangara, an open-source, crowdfunded MP3 player slash nostalgia platform that aims to combine the hackability of those 2000s devices with such modern comforts as Bluetooth and USB-C. I don’t fault Tangara for writing their own firmware, but I really hope that Rockbox gets ported to it, too, as Rockbox basically defined the “handheld music player” interface for me at a formative age. Nothing else feels quite as flexible or obvious.

Image viewing works even on the Clip’s simple two-color display. It uses random dithering to represent fractional lightness values, and rerolls the randomness with each screen refresh to produce a nice composition effect. This kills the battery in short time. ↩
I wasn’t sure how best to spell 404’d, and couldn’t find the verb form in any of the dictionaries I checked, but I settled on this spelling by comparison with a reference to 86’d in this Merriam-Webster article. The more you know. ↩

Recent reading

2024-03-18T00:00:00+00:00

Mostly novels this time:

조남주, «82년생 김지영», a 2016 novel about (I have struggled to phrase this in a way that isn’t too dead-on) why it is so hard to be a woman in contemporary Korean society.

The movie version from 2019 is better known, perhaps thanks to the sanitized resolution in which the title character learns to channel her resentment into creative energy—and writes the novel that the movie is based on. In the novel, however, the final chapter reveals the narrator as 지영’s therapist, and he comes within inches of a feminist awakening as he weighs different diagnoses for her, then reverses course. Witholding spoilers, I suspect that much of the hand-wringing around the book turns on its withering, cynical last sentence.
장강명, «한국이 싫어서», a novel about a woman’s decision to migrate from Korea to Australia, and for reasons that are no surprise if you’ve read the book above. This one has a happy ending.
Mishele Maron, “Anger Management” (paywall), a memoir by a psychologist whose job was to “goad men with a history of violence into wanting to punch me” and create the opportunity for them to examine their feelings in group counseling.
Greg Egan, Permutation City.
Philip K. Dick, The Man in the High Castle.

I am looking for Korean bookstores that deliver within the US. So far 반디북US has proven reliable, but I’d like to have a backup option in case their rickety website finally gives way. Write if you know of any others.

Housekeeping

2024-03-10T00:00:00+00:00

Completed some overdue site maintenance over the past few weeks:

RSS feed styling: With help from a template found on GitHub, I created a stylesheet for the RSS feed so that it looks nice when viewed in the browser. Ctrl+F “via RSS” on this page to find the link, or just scroll all the way to the bottom, or maybe try this link.

I am not a big consumer of RSS feeds myself; I prefer to just bookmark blog URLs and read posts in their original context. But RSS is an important bit of plumbing for the indie web, and probably covers accessibility use cases that I haven’t anticipated.

(Technically, I am serving an Atom feed rather than RSS, but people use the terms interchangeably.)
Upgraded to Jekyll 4: Jekyll is a tool for building a static HTML site out of Markdown files. The built-in GitHub functionality for hosting a Jekyll blog uses an old version of Jekyll which has some end-of-life dependencies, and they are stuck searching for an upgrade path that doesn’t break existing sites.

I followed this wonderful guide to switch my publication workflow to a GitHub Action that lets me manually manage my Ruby and Jekyll versions. It’s a great tutorial that also helped clear up several misunderstandings about Ruby, Gems, and rbenv.
Removed embedded YouTube videos: I replaced embedded YouTube videos with simple links to improve page load times and user privacy.

A handy class of submodular functions

2024-01-01T00:00:00+00:00

In this post, we will show that functions of the form

f(X) = 1 - \prod_{i \in \Omega \setminus X} (1 - p_i) \prod_{i \in X} (1 - q_i)

are submodular for $p_i, q_i \in [0, 1]$ where each $p_i \leq q_i,$ and examine an application of this small result that demonstrates its practical value.

Background on submodular functions

Given a ground set $\Omega,$ a function $f: 2^\Omega \mapsto \mathbb{R}$ is called submodular if, for any $X \subseteq Y \subseteq \Omega$ and $j \in \Omega \setminus Y,$ we have

f(X \cup \{j\}) - f(X) \geq f(Y \cup \{j\}) - f(Y).

In plain language, this says that the marginal value of adding $j$ to $X$ is greater than when adding it to $Y$ . Thus, submodularity expresses a form of diminishing marginal returns (for set functions) that is analogous to concavity (for continuous functions).

Submodular functions have a number of desirable traits. A famous result of Nemhauser et al. (1978) holds that when maximizing a monotone¹ submodular function over a cardinality constraint, the greedy algorithm that iteratively adds to $X$ the element that yields the greatest increase in $f(X)$ is $1 - \frac{1}{e} \approx 63.2\%$ optimal.² Efficient algorithms that provide the same approximation ratio for more complex constraint structures have also been identified (Badanidiyuru et al. 2014, Chekuri et al. 2014, Kulik et al. 2013). See Vondrák (2017) for an introduction to submodular functions with many examples.

Preliminary interpretation of $f(X)$

The function $f(X)$ defined above can be used to model the probability of a parallel system failing when optional repairs are made to its components. For example, suppose there are a dozen roads between our town and the next, and the probabilities of each road being open in the coming winter are given by $p_1$ through $p_{12}$ . For each of the roads, we can engage in repairs to increase the availability to $q_i$ . Letting $X$ denote the set of roads that we repair, the probability of at least one road being open in the winter is one minus the probability that all of them are closed, which is $f(X).$

With this interpretation in mind, we are tempted to give $f(X)$ a tortured-but-accurate name such as the “parallel process success probability with quality upgrades” function—but we’ll just stick with $f(X)$ for now.

The applicability of $f(X)$ in its current form is, admittedly, a bit narrow. The versatility of this functional form shows itself more clearly when we start taking conic combinations—see the examples below.

Monotonicity and submodularity proof

Theorem: $f(X)$ as defined above is a monotone submodular function.

Proof: The monotonicity of $f(X)$ is clear from the constraints on $p$ and $q$ : Adding any element $j$ to $X$ replaces the $1 - p_j$ term with the (smaller) $1 - q_j$ term, increasing the overall function value.

To prove submodularity, pick any $X \subseteq Y \subseteq \Omega$ and $j \in \Omega \setminus Y.$ If $p_j < 1,$ we have

\begin{aligned} f(X \cup \{j\}) - f(X) &= \biggl[1 - \frac{1 - q_j}{1 - p_j} \prod_{i \in \Omega \setminus X} (1 - p_i) \prod_{i \in X} (1 - q_i) \biggr] - \biggl[1 - \prod_{i \in \Omega \setminus X} (1 - p_i) \prod_{i \in X} (1 - q_i) \biggr] \\ &= - \biggl(\frac{1 - q_j}{1 - p_j}\biggr) \prod_{i \in \Omega \setminus X} (1 - p_i) \prod_{i \in X} (1 - q_i) + \prod_{i \in \Omega \setminus X} (1 - p_i) \prod_{i \in X} (1 - q_i) \\ &= \biggl(1 - \frac{1 - q_j}{1 - p_j}\biggr) \Bigl(1 - f(X)\Bigr) \\ &\geq \biggl(1 - \frac{1 - q_j}{1 - p_j}\biggr) \Bigl(1 - f(Y)\Bigr) \\ &= f(Y \cup \{j\}) - f(Y). \end{aligned}

The penultimate inequality follows from monotonicity, and the final equality is just applying the first three steps in reverse, with $Y$ instead of $X.$

In the $p_j = 1$ case, $f(X \cup \{j\}) = 1$ for any $X$ and the inequality collapses to $- f(X) \geq - f(Y),$ which is just monotonicity. ◼

Application: Optimal scrum velocity, aka the $m$ -dimensional Zeno walk

Let’s examine a plausible(ish) application of this functional form.

The Zeno walk: Consider a Zeno walk between an arbitrary origin and destination. Let $\Omega$ provide a set of possible steps that we can take toward our destination. Each step’s size is $s_i \in [0, 1],$ which means that if you choose to take step $i,$ you get $100 s_i$ percent of the way from your current location to the destination.³ If $X$ is the set of steps you choose to take, you will make it

g(X) = 1 - \prod_{i \in X} (1 - s_i)

of the way to the destination from your starting point. This $g(X)$ is just $f(X)$ where each $p_i = 0$ and $q_i = s_i$ .

The multidimensional Zeno walk: Now, consider a process optimization problem. We have a set $\Psi$ (indexed by $j$ ) of goals to achieve, as well as a set $\Omega$ (indexed by $i$ ) of tasks we can complete in service of the goals. Tasks can advance multiple goals at once. Let $v_{ij}$ denote the effectiveness of task $i$ against goal $j,$ meaning that if you engage in task $i,$ then $v_{ij}$ of (whatever remains of)⁴ goal $j$ will be completed. Each goal is worth $t_j \geq 0$ story points, and goals can be completed fractionally.

We would like to choose the set of tasks $X$ that maximizes the team’s velocity in the current planning period, defined as the total number of story points completed, which is

h(X) = \sum_{j \in \Psi} \Bigl( t_j - t_j \prod_{i \in X} (1 - v_{ij}) \Bigr).

Tasks are subject to a variety of constraints due to considerations such as cost, scheduling, and dependency. It is not immediately obvious which tasks we should prioritize—for example, should we favor tasks that advance many different goals, or those that have high effectiveness against the most important goals? Well, the $j$ th term of $h(X)$ is just $t_j g(X)$ where $s$ is the $j$ th column of $v$ . Thus, $h(X),$ as a conic combination of submodular functions, is itself submodular,⁵ and we can compute the optimal velocity using any of the well-known techniques for submodular maximization.

Returning to Zeno’s paradox, the business process described above is akin to a multidimensional Zeno walk in which $t_j$ gives your distance from the target in the $j$ th coordinate axis, and each step $i$ moves you $v_{ij}$ of the way towards the target along that axis. The function $h(X)$ measures the one-norm distance between your final position and the target.

Remarks

Linearization: To maximize $f(X)$ as written, in typical cases, it will be simplest to minimize $1 - f(X),$ which is a modular function after taking the logarithm.⁶ The logarithm trick doesn’t work, however, for conic combinations of $f(X)$ ; the best we can do is introduce helper variables and reformulate the problem as an integer convex program.⁷ Thus, recognizing the submodularity of $f(X)$ (and the strong approximation results implied) is worthwhile.

Serial processes: It is not difficult to show, using a similar proof as above, that the “serial process success probability with quality upgrades” function

\tilde f(X) = \prod_{i \in \Omega \setminus X} p_i \prod_{i \in X} q_i

with $p_i \leq q_i$ is monotone and supermodular; that is, $- \tilde f(X)$ is monotone decreasing and submodular. Note that $1 - \tilde f(X)$ has the same functional form as the original $f(X),$ but the inequality on $p_i$ and $q_i$ comes out backwards. This turns back into the original result (that $f(X)$ is increasing and submodular) if you interchange the roles of $X$ and $\Omega \setminus X$ .

References

Open access:

Badanidiyuru, Ashwinkumar and Jan Vondrák. 2014. “Fast Algorithms for Maximizing Submodular Functions.” In Proceedings of the 2014 Annual ACM–SIAM Symposium on Discrete Algorithms, 1497–1514. https://doi.org/10.1137/1.9781611973402.110.
Vondrák, Van. 2017. “Submodular Functions.” Lecture 14 from Math 233B: Polyhedral Techniques in Combinatorial Optimization. https://theory.stanford.edu/~jvondrak/MATH233B-2017/MATH233B.html.
Wikipedia, s.v. “burndown chart.”
Wikipedia, s.v. “submodular set function.”
Wikipedia, s.v. “velocity (software development).”
Wikipedia, s.v. “Zeno’s paradox.”

Paywall:

Chekuri, Chandra, Jan Vondrák, and Rico Zenklusen. 2014. “Submodular Function Maximization via the Multilinear Relaxation and Contention Resolution Schemes.” SIAM Journal on Computing 43, no. 6: 1831–79. https://doi.org/10.1137/110839655.
Kulik, Ariel, Hadas Shachnai, and Tami Tamir. 2013. “Approximations for Monotone and Nonmonotone Submodular Maximization with Knapsack Constraints.” Mathematics of Operations Research 38, no. 4: 729–39. https://doi.org/10.1287/moor.2013.0592.
Nemhauser, George, Laurence Wolsey, and Marshall Fisher. 1978. “An Analysis of Approximations for Maximizing Submodular Set Functions—I.” Mathematical Programming 14: 265–94. https://doi.org/10.1007/BF01588971.

A set function is called monotone if $X \subseteq Y$ implies $f(X) \leq f(Y)$ . ↩
This means that if $X^*$ is the set that maximizes $f(X)$ and $\tilde X$ is the set produced by the greedy algorithm, we are guaranteed to have $f(\tilde X) \geq 0.632\,f(X^*)$ . In practice, the optimality gap is often much narrower. ↩
In the original Zeno walk, each $s_i = \frac{1}{2},$ and the (supposedly unachievable) “goal” is to reach the destination rather than to get as close as possible to it. ↩
Depending on the context, it may be more appropriate to have tasks advance goals additively—but that would just be a knapsack problem. Here, we are interested in the more difficult case where tasks make diminishing marginal contributions against the goals. One way this arises in real life is when tasks address goals in redundant ways. For example, against the goal “get rid of all the junk in my house,” the tasks “throw away any items not used in the past six months” and “throw away any items that spark fewer than $k$ units of joy” may separately elicit a 50 percent reduction in the total junk, but doing both tasks won’t necessarily remove all the junk, because there is some overlap in the junk removed by both operations. ↩
The fact that a conic combination of submodular functions is submodular isn’t mentioned on the Wikipedia article, but it falls right out of the second definition. ↩
A set function is modular if it is both submodular and supermodular. This means that each item’s marginal value is constant—and thus modular functions are equivalent to linear functions of the characteristic vector. The knapsack objective function is an example of a monotone modular function. ↩
Email me if you would be interested in a follow-up post explaining how to do this. ↩

Recent reading

2023-11-05T00:00:00+00:00

Finished reading, but still thinking about:

정유정, «종의 기원», a thriller.
김연수, «이토록 평범한 미래», a collection of short stories.
권여선, «레몬», a thriller.
신경숙, «엄마를 부탁해», a classic.
Cory Doctorow, The Internet Con: How to Seize the Means of Computation, a tinkerer’s manifesto.
Paul Abel, “I thought I wanted to be a professor. Then, I served on a hiring committee.”
From the September issue of The Sun, “No Small Wonder” (paywall), an interview with psychologist Dacher Keltner, a student of awe. It pairs nicely with Bewilderment below.

Currently reading:

Richard Powers, Bewilderment, a novel of astrobiology, biofeedback, and conservationism.
정유정, «내 심장을 쏴라», a thriller.

Guitarix troubleshooting

2023-07-22T00:00:00+00:00

For the past few updates of Guitarix, I have been having issues where changing the JACK server latency causes the audio output to go crazy. This seems to stem from changes that the developer has been making to the config files, because the following commands usually get things working again:

mv ~/.config/guitarix ~/.config/guitarix.backup mkdir ~/.config/guitarix cp -r ~/.config/guitarix.backup/banks ~/.config/guitarix/banks 

These commands backup your amp/effects presets from ~/.config/guitarix/banks (which are the hard part to restore manually), and let the default settings take over the next time the application is launched.

fzl.fish

2023-06-17T00:00:00+00:00

I’ve been using the following fish alias fzl (“fuzzy list”) to run fzf (“fuzzy find”) in the current directory with a bat preview. It’s just a couple of light tweaks to the examples listed in the fzf README.

~/.config/fish/functions/fzl.fish:

function fzl # `bat` is aliased to `batcat` on Debian if type -q batcat set -f bat_command "batcat" else set -f bat_command "bat" end # Set the overall width of the `bat` preview to # 50% the width of the current terminal set -l bat_width $(math ceil $COLUMNS x 0.5) # My preferred `bat` options set -f bat_command \ $bat_command \ --style numbers \ --color always \ --italic-text always \ --wrap auto \ --terminal-width $bat_width fzf \ --preview "$bat_command {}" \ --preview-window right,$bat_width,nowrap end 

Example below.

Learning Korean idioms with UNIX fortune

2023-02-05T00:00:00+00:00

fortune is a classic UNIX program that displays random fortunes, pithy quotes, and the like:

$ fortune If you think last Tuesday was a drag, wait till you see what happens tomorrow! 

Today, I repurposed fortune (really fortune-mod) as a language study tool by scraping some Korean idioms from Wikiquote from Wikiquote):

$ fortune korean “쇠귀에 경 읽기.” 아무리 좋은 말을 하면서 가르치려고 하여도 그 뜻을 제대로 헤아리지 못하는 사람을 두고 하는 말. 

This one says “Chanting sutras into the ears of a cow,“ defined as “A phrase used when someone fails to understand what you are trying to teach them no matter how well you choose your words.”

I set fortune korean (with some gentle text styling) as my fish greeting, so I can learn a new idiom every time I open a terminal—see below.

You can find my database and fish_greeter.fish script on GitHub.

Applying the KISS principle to amp modeling

2023-01-27T00:00:00+00:00

I’ve been playing electric guitar using only computer modeling software (without a physical amplifier) for about five years now. I started out with Garageband and Mainstage, then briefly experimented with Amplifikation Vermilion, and for the last year and half have turned to a free, open-source package called Guitarix and a small collection of impulse response files culled from guitar forums. In my experience, a good impulse response file fed into a basic convolver does a lot more for your sound than trying to optimize the countless parameters on an expensive simulator.

The hardest thing about playing through an amp modeler is overcoming the desire to replicate the sound of a classic physical amp. Modern software is powerful enough to get you asymptotically close to a reference tone, but only with some know-how and a lot of fiddling. For a hobbyist, it’s better (for your sanity) to treat the simulated guitar amp as a distinct instrument from a vintage combo, and try above all to create sounds that are interesting and dynamic on their own. This goes doubly for people (like me) whose understanding of classic guitar tones draws more from listening to carefully mastered recordings than firsthand experience.

The second-hardest thing about amp modeling is creating a sense of physical space. With a physical amp, you experience each note in several different ways: the physical vibration of the instrument against your body, the sound coming from the amp, the vibration of the floor in response to the amp’s low end, and the echoes of the sound off the walls of the room. A digital amp model, even one with low latency and good dynamic response, can sound sterile and distant when fed into headphones or bookshelf monitors because it doesn’t provide these rich audiospatial cues. I rely on three devices to create a sense of physical space in my simulated guitar sound:

Delaying the right channel by 20–40 ms. Just a simple sample delay at any point in the signal chain will do. It creates the sense of an amp sitting just to the left of your head, but still filling the room with sound.
Judicious use of a chorus effect. This also helps cut through the mix when playing along with recordings.
Rolling off the bass a little. The principle here is that if your overall sound has a heavy low end, then your body will expect to feel sympathetic vibrations through the floor and chair. By opting for a warmer tone, you remove this cue.

My primary goal is to keep my setup as simple and portable as possible. I don’t subscribe to a particular chorus or reverb effect, nor do I have any impulse response files I couldn’t live without. I have trained my fingers to make the most of middle-of-the-road settings.

This year’s reading

2022-12-17T00:00:00+00:00

A subset of the books I enjoyed this year:

Barbara Kingsolver, The Poisonwood Bible, a novel about evangelical Christianity and cultural arrogance.
손원평, «아몬드», a novel debating whether or not emotions are a distraction.
Walter Isaacson, The Codebreaker, a biography of biochemist Jennifer Doudna.
Michael Lewis, The Undoing Project, a biography of behavioral economists Daniel Kahneman and Amos Tversky.
황보름, «어서 오세요, 휴남동 서점입니다», a slice-of-life novel about a bookstore owner overcoming the loneliness of urban life.
Ayoko Sono, Ningen no Bunzai, a “collection of writings” (according to Wikipedia, and I cannot come up with a better description). I read the Korean translation «약간의 거리를 둔다» by 김욱.
김애란, «달려라, 아비», short stories about the legacy of childhood experience.
Jia Tolentino, Trick Mirror, essays about identity, authenticity, and social media.

In progress:

김금희, «너무 한낮의 연애», short stories about people at the margins of society.
David Foster Wallace, Infinite Jest.

Two truths and one lie

2022-11-06T00:00:00+00:00

A puzzle based on the icebreaker game.

Two truths and one lie:

I have a twin.

I used a random number generator to decide whether to place a true or false statement in #1.

I do not understand the rules of “two truths and one lie.”

Solution inside.

Hint

The solution to the puzzle consists of assigning a truth value (true or false) to each of the three statements.

Solution and explanation

Start by taking cases; there are eight:

Suppose I used the RNG. Then we have 2: true and
- 1: false and 3: false is an inconsistent assignment, because I claimed to understand the rules but broke them by writing two lies and one truth.
- 1: false and 3: true is an inconsistent assignment, because I denied understanding the rules but followed them.
- 1: true and 3: false is a consistent assignment, because I claimed to understand the rules and followed them.
- 1: true and 3: true is a consistent assignment, because I denied understanding the rules and broke them.
Suppose I didn’t flip a coin. Then we have 2: false and (applying similar logic)
- 1: false and 3: false is inconsistent.
- 1: false and 3: true is consistent.
- 1: true and 3: false is inconsistent.
- 1: true and 3: true is inconsistent.

The consistent assignments are as follows.

Statement:	1	2	3
Assignment A	true	true	false
Assignment B	true	true	true
Assignment C	false	false	true

It appears that any of the statements could be true or false under a consistent assignment. However, since I could not know the result of the RNG in advance, I could only have used it if I knew that the three statements would admit at least one consistent assignment whether the RNG returned 1: false or 1: true.

But this is not the case: There is no consistent assignment in which I used the RNG and got the result 1: false. Therefore, I must not have used the RNG at all, which rules out assignments A and B and leaves assignment C, namely 1: false, 2: false, and 3: true, as the only option.

See Wikipedia, “Boolean satisfiability problem.”

Master’s graduation and two free optimization courses

2022-09-04T00:00:00+00:00

On September 29, I received my master’s degree in industrial engineering from Seoul National University!

It’s been a wonderful two years. Despite the challenges of social distancing, I was able to take a diverse assortment of courses in optimization, economics, and human factors; participate in research projects in two different labs; present at a conference in Jeju; and write (in both Korean and English) a thesis I’m rather proud of.

As part of my duties in the Management Science/Optimization Lab, I had the opportunity to serve as the course TA for two of my advisor’s optimization courses, both of which have now been published as free online courses:

선형 및 비선형 최적화 (Linear and Nonlinear Optimization) is an upper-division undergraduate course on linear programming and convex optimization.
Introduction to Optimization is an edX course targeted at undergraduates and working professionals, which we created with the support of a grant from SNU’s center for teaching and learning.

Developing the edX course was especially fun: edX has an open platform for online courses that lets you create an interactive classroom with videos, captions, automatically graded exercises, and plenty more. Setting up the student activities with automatic grading in a way that is both user-friendly and rigorous was a neat challenge. I hope these courses can bring the theoretically grounded, practically oriented education that I received at SNU to a wider audience of optimization students.

Apply to fifty colleges

2022-09-01T00:00:00+00:00

In this post, we’ll use fake numbers and a simplified model to argue that the most college applicants should apply to far more colleges than they actually do. You can probably extend the argument to job applications and the dating game. I’ll also compute a few fake comparative statics and speculate about why real students don’t apply to more schools.¹

Fake numbers and a simplified model

We’ll start by making a few simplifying, conservative assumptions about the college admissions process. Here “conservative” means that we will err on the side of understating the value of applying to college, thereby arriving at an underestimate of the optimal number of college applications. Thus, our choices make it challenging to arrive at this post’s headline conclusion, such that if we nonetheless draw the conclusion that students should apply to more colleges, we have some degree of confidence that this statement applies to the actual numbers, too.

First, let’s assume that you always have the option of attending a “safety school.” The safety school could also represent a community college or entering the workforce directly after high school. In addition, there are many “reach schools,” or elite universities, with competitive admissions. It is better to attend a reach school than the safety school, but applying to a reach school takes time and effort.

Let $t$ denote the utility of attending an elite university, measured in monetary units relative to the safety school. By a conservative estimate, an elite university might offer us an expected salary increase of $20,000 per year, at a tuition cost of $30,000 dollars per year higher than the safety school. Thus, aggregating over 40 years of employment and 5 years of college attendance, we can estimate

t = 40 \times 20000 - 5 \times 30000 = 650000.

Let’s assume, for simplicity, that all the reach schools are equally competitive, and let $p$ denote the probability of getting into an elite university. Assume that admissions at each school are probabilistically independent. Let’s pick $p = 0.1$ , which is near the acceptance rate (and therefore, the average admissions probability across all applicants) at many elite US universities. If you apply to $x$ reach schools, the probability of getting into at least one is $1 - (1 - p)^x$ , in which case you receive $t$ units of utility.

However, applying to college is not free: You have to pay an application fee, various clerical fees for submitting transcripts and test scores, and then there are time costs associated with writing essays, requesting recommendation letters, and filling out the online form. Let $c$ denote the cost of applying to a reach school, so the cost of applying to $x$ schools is $cx$ , and the expected utility of the entire college application process can be written as follows:²

f(x) = t\bigl(1 - (1 - p)^x\bigr) - cx.

Typical college application fees are $50 or so; let’s take $c = 200$ to account generously for the other costs. Our goal is to maximize $f(x)$ .

The model says apply to fifty colleges

With these values of $t$ , $p$ , and $c$ , here’s the graph of $f(x)$ . As you can see, the maximum occurs at about $x^* = 55$ applications!

We can solve for the maximum analytically using a method you might have learned in high school calculus: $x^*$ represents the point where $f(x)$ stops increasing and starts decreasing. That is, the point where its slope $f'(x)$ is zero.

With a little bit of legwork, you can check that the derivative of $f(x)$ is

f'(x) = -t (1-p)^m \ln(1-p) - c

and setting this equal to zero and solving for $x$ yields

x^* = \frac{\ln c - \ln t - \ln \bigl(- \ln\left(1-p\right)\bigr)}{\ln\left(1-p\right)}.

(It’s a pleasant surprise to encounter a nested logarithm somewhere other than computer science.) Plug in $t$ , $p$ , and $c$ to obtain $x^* = 55$ , as promised.³

Checking our work with comparative statics

The reflexive economist move is to stick the expression for $x^*$ in a Desmos box as follows, start dragging the sliders around, and see if we can spot any patterns. For example, click the “edit graph on Desmos” box and try increasing the value of $c$ slightly: You should see the vertical line, which represents the optimal number of applications, move to the left.

If we’re feeling especially inspired, we might take the derivative of $x^*$ in each of the parameters. Computing these so-called comparative statics will help us verify that our “conservative” assumptions are actually conservative in the way that we think we are. For example,

\frac{\partial x^*}{\partial c} = \frac{1}{c \ln (1- p)} < 0

(since $1-p$ is less than one, its logarithm is negative) tells us that increasing the costs decreases the optimal number of applications. But (in my opinion) the linear function $cx$ is an overestimate of the cost, and the true optimum $x^*$ should be even higher: conservatism fulfilled.

Similarly, $\partial x^* / \partial t > 0$ , meaning that in the (probable) case that an elite college degree is worth more than $650k, the central argument of this post is even truer.

$p$ is where we get into trouble. I lowballed $p$ above on the assumption that the “value” of a college application correlates with how likely it is to yield an admission letter. However, the marginal value of a college application is actually greatest when colleges are hard to get into, and therefore so is your willingness to invest in an additional application. In other words, I should have tried to overshoot $p$ instead.

To understand this counterintuitive result, let’s compute

\frac{\partial x^*}{\partial p} = \frac{ \ln{c} - \ln{t} - \ln{\bigl(- \ln{\left(1 - p \right)} \bigr)} + 1}{\left(1 - p\right) \ln^2{\left(1 - p \right)}},

whose sign tells us whether the optimal number of applications is increasing or decreasing in the admissions odds $p$ . The denominator of this expression is positive, so the overall sign depends on the sign of the numerator, which is positive only when

p < 1 - \exp(-ce / t).

But in college admissions, this is seldom the case: Typically, $t$ is much larger than $c$ , meaning that $1 - \exp(-ce / t) \approx 1 - \exp(0) = 0$ , breaking the condition. Lowballing $p$ is only conservative if $p$ is very small in the first place, and $c$ is large relative to $t$ .⁴

Oops, apply to thirty colleges

So, if we are being conservative, we should try to overestimate $p$ . If we double our previous estimate to $p = 0.20$ and repeat the calculation above, we get a more modest result of $x^* = 30$ . But this is still much higher than the number of colleges real students apply to, right?

We have to increment $p$ much further before $x^*$ starts to align with typical applicant behavior: When $p = 0.7$ , for instance, you get $x^* = 7$ . Now, you might object that $p = 0.7$ sounds like a perfectly reasonable admissions probability for an ambitious student. To this, I offer two responses:

As someone who reads blog posts about economics in their free time, your social circle may have instilled in you an biased sense of what is achievable for the typical student.
Some students have high admissions odds, but others don’t: The odds have to average out to around 10 percent for elite colleges to maintain acceptance rates in that neighborhood.

In other words, our comparative statics analysis revealed an error in our so-called conservative fake numbers, but the error wasn’t quite large enough to undermine our central argument.

Why don’t students apply to more colleges?

Most students apply to ten or so colleges. Why not more? What do they know that our model doesn’t?

One idea that might come to mind if you’ve played with Mulberry is that most students apply not just to elite schools and a safety school, but also to a continuum of “target schools” in between. Target schools have higher admissions odds, and indeed make up the bulk of the admissions market. This observation isn’t enough to explain real students’ small application portfolios, however, because elite universities also are (perceived as) much more valuable than target schools.

The model above can also be applied to a student who has already applied to safety and target schools and is trying to decide how many reach schools to add to her portfolio: Simply discount $t$ to reflect the value of a degree from an elite school relative to the (actuarial) value of a degree from a target school. Conservatively, if we hack $t$ all the way down to $200k, take $p = 0.2$ , and $c = 200$ , we still get a hefty $x^* = 24$ .

Here’s what I think is really going on: Students don’t apply to zillions of colleges because they aren’t optimization machines. When I was a senior in high school, I categorically refused to apply to more than five colleges because I didn’t want to look like a tryhard.⁵ The psychological costs of college application are really large, because they include not only the exhaustion of composing and submitting applications, but also the cost of imagining the disappointment of being rejected from a dream school.

Revealed cost of college application

What, in dollar terms, is the value of the subjective cost students associate with college application, after taking into account this risk aversion? Let’s stick with our conservative $t = 200000$ and $p = 0.2$ scenario, and turn the question around: Given that most students apply to about a dozen colleges, what application cost $c$ makes this number of applications optimal?

To figure this out, we just need to solve our $x^*$ equation for $c$ . The answer is

c = - t (1 - p)^x \log{\left(1 - p \right)}

and plugging in the numbers yields $c = 3067$ dollars per application.

Remember: These numbers are fake. But we have made a plausible argument that the majority of the costs incurred in the college application process are psychological, rather than material. If you can overcome the psychological costs, then by applying to thirty or fifty colleges, you may be able to reap significant material rewards.

Reader exercises

Repeat the calculations above for another situation, such as job application. How many jobs should you apply to? Is the model a good choice?
Identify a regime in which $\partial x^* / \partial p$ is positive and explain, in qualitative terms, why this is the case.
If every student adopts the optimal application strategy, then everyone might apply to twice as many schools. But then each school will become twice as competitive, changing the admissions odds and therefore the optimal strategies. Can you sketch the equilibrium criteria for this market? What other information would you need? (Paywalled academic paper about this.)
Suppose that the admissions probabilities and utility values for the reach schools are all different. What is the utility expression in this case? Hint: Replace $x$ with a set indicating which colleges you apply to. You can find the answer here or in my master’s thesis.

We will avoid the obvious argument that goes, “If you are willing to spend six figures on an a college education, then what’s a few hundred extra in application fees?” This argument is incorrect, because it assumes that each additional application is worth the value of attending that college times the probability of getting in. In actuality, you can only attend one of the colleges you get into; thus additional applications make a sublinear contribution to the overall expected utility. Our model will account for this. ↩
Note that our assumption that the cost is linear in $x$ is conservative: In reality, since you can recycle essays and recommendation letters, the marginal costs diminish as $x$ increases; a function like $c \ln x$ or $c \sqrt{x}$ is arguably more realistic. ↩
The exact answer is $x^* = 55.39$ , but you can only apply to a whole number of colleges. Since $f(x)$ is a concave, univariate function, the optimal integer solution has to be either 55 or 56, and you can verify that $f(55) > f(56)$ . We’ll use the same approach for the rest of the post. ↩
For example, to see a regime where $x^*$ is increasing in $p$ , try setting $t = 10000$ and $c = 1000$ in the Desmos box, and vary $p$ between 0.1 and 0.2. ↩
It didn’t work. ↩

Grading multiple-selection questions

2022-08-18T00:00:00+00:00

Consider the following test question:

Which of the following are US States? (select multiple)

Washington

Delaware

Frankfurt

Memphis

This is a multiple-selection question, so the correct answer is a and b. How would you grade a question like this on an exam?

When I was in school, the Scantron machines we used supported these kinds of multiple-selection questions, but they were graded all or nothing: You got one point if your answer matched the key exactly, and zero points otherwise. I have it on good authority that the MOOC site edX works the same way.

In the era of floating-point arithmetic, all-or-nothing grading for multiple-selection questions is a hard practice to defend. A student who answers a is clearly more correct than a student who answers c and d, because the question above is really four questions:

Is Washington a US state?

Is Delaware a US state?

Is Frankfurt a US state?

Is Memphis a US state?

An alternative to all-or-nothing grading

I propose grading multiple-selection problems as $n$ true-or-false questions, each weighted $1/n$ points. In this example, a response of a is correct with respect to questions a, c, and d, and receives 0.75 points. A response of c and d is correct with respect to none of the items and receives zero points.

What about students who guess randomly? A student who guesses randomly receives, in expectation, 0.5 points under my proposal and $1/ 2^n$ points under the all-or-nothing method. Therefore, one objection to my proposal is that it provides students with a strong incentive to guess. I contend that this is not a real problem, because

The incentive for students to guess is still positive under all-or-nothing grading,
In creating examinations, there is no objective reason to make “discourage students from guessing” a design goal,
Even if you insist that reducing the incentive to guess is a good thing, you can accomplish this by instating a penalty (of 0.5 points) for incorrect answers.

Wrong-answer penalties, however, are a potential source of bias (open-access article) in testing because students vary in their risk aversion.

Better yet

Multiple-selection questions are not very user friendly to begin with. Some students fail to realize that they are allowed to choose more than one answer and agonize over technicalities (Maybe he means Washington, DC?). Others (mistakenly) assume that they will be graded all or nothing, recognize the slim chances of success, and just skip the question to pursue lower-hanging fruit.

Therefore, as long as you accept my argument that multiple-selection questions should be regarded as $n$ true-or-false questions for grading purposes, why not simply write them out that way on the test sheet? Then there is no way to misread the question as a single selection, and the grading scheme is obvious.

Mulberry: A college application strategist

2022-08-02T00:00:00+00:00

I recently created Mulberry, a web app students can use to compute their optimal college application strategy. It is a free, open-source, user-friendly interface to Algorithm 1 from my MS thesis.

Why Mulberry? There are boatloads of “chance me!” websites (some more trustworthy than others) that help students gather information about colleges and estimate their chances of admission. But when it comes to the question of where to apply (given that you can’t apply everywhere), many people resort to folk wisdom, risk-averse heuristics, and gut feelings.

Mulberry complements these introspective techniques with dispassionate, numbers-driven advice. You input estimates of your admissions chances at each school and the amount of utility you associate with going there, and Mulberry sorts the schools in the order you should apply to them to maximize your expected utility.

The interface is at maxkapur.com/mulberry, and the code is on GitHub.

Python utility for manipulating subtitle timings

2022-07-15T00:00:00+00:00

One of my current projects involves editing several hours’ worth of subtitle files in the .srt format to accompany an online course in numerical optimization. Because we haven’t decided exactly how we want to break up the videos, I needed an efficient way to delay or advance all the subtitles in time, so I wrote a small Python program called srt_delay.py today to help me with this task.

Usage examples below the cut, or you can just go straight to the README in the GitHub repository.

Usage

We will demonstrate srt_delay.py using the subtitles for the open-source movie Elephants Dream. The file can be downloaded from the repo linked above (sample_input.srt) or from Wikimedia Commons.

Here is what the input file looks like:

$ head sample_input.srt 1 00:00:15,000 --> 00:00:17,951 At the left we can see... 2 00:00:18,166 --> 00:00:20,083 At the right we can see the... 3 00:00:20,119 --> 00:00:21,962 

Each line contains either an index number for the subtitle (1), the subtitle’s timing (00:00:18,166 --> 00:00:20,083), or the subtitle text itself.

Suppose we want to advance the subtitles by 1.5 seconds. We can pass this interval in .srt timestamp format (00:00:01,500) to srt_delay.py with the -a or --advance flag:

$ python3 srt_delay.py sample_input.srt -a 00:00:01,500 | head 1 00:00:13,500 --> 00:00:16,451 At the left we can see... 2 00:00:16,666 --> 00:00:18,583 At the right we can see the... 3 00:00:18,619 --> 00:00:20,462 

By default, srt_delay.py prints to standard output. In most cases, you will want to save the output to another file:

$ python3 srt_delay.py sample_input.srt -a 00:00:01,500 > sample_input_advanced_by_1.5s.srt 

Opening Pandora’s Box

2022-07-01T00:00:00+00:00

A harrowing thing that happens in research is that occasionally, you stumble upon a paper from 1979 (paywall) that appears to solve the exact problem that you’ve been working on for months, but that escaped your attention because it used different terminology or notation.

That almost happened to me this week, but mercy was on my side. The paper linked above, Martin Weitzman’s “Optimal Search for the Best Alternative,” considers a problem called the Pandora’s Box problem that resembles my college application problem except for one crucial difference: The Pandora’s Box problem has a time dimension, whereas the college application problem is static.

The unusual thing is that the static problem appears more difficult.

College application vs. the Pandora’s Box problem

If we apply the Pandora’s Box problem to college application, we get the following scenario: Pandora applies one by one to colleges in the admissions market. At each point in time, she can either submit a new college application (which costs money), in which case she will observe her admissions outcome after a time delay, or she can enroll at one of the schools she has already gotten into (and receive a payoff). The problem is to determine an optimal stopping rule for when Pandora should halt her search and accept the payoff she has on hand. Weitzman showed how to calculate a reservation price—roughly, the expected value of application—for each of the colleges. The optimal policy is to halt the search when the value of the current best offer exceeds the reservation price of all the colleges left to apply to.

Weitzman’s model is a dynamic model because under the optimal strategy, there is no way to predict Pandora’s application decisions from the problem data alone. The set of schools she ultimately applies to, or her application portfolio, depends on the values of the random variables observed in a given “round” of the admissions game. On the other hand, in the static model of college application considered in my master’s thesis, the decisionmaker commits to her entire application portfolio at the outset.

Arguably, the static model is more hostile to students than the Pandora’s Box problem. If, for example, an unlucky Pandora is rejected from a safety school at an early round of application, then she can compensate for the unexpected loss by applying to new safety schools in subsequent rounds. By contrast, the static college application problem does not allow students to modulate their risk allocation after observing some of the random variables.

The admissions process used in the United States can be viewed as the concatenation of both problems: In the fall, students solve the static problem, send out a batch of applications, and pray for a good outcome. Then, after observing their first-round admissions outcomes in March, they use the Pandora strategy to pursue additional opportunities by negotiating their financial aid offers¹ and applying to schools that offer rolling admissions.

Static models aren’t necessarily simpler

Often, when we are presented with two optimization models and told that one is “static” and the other is “dynamic,” it is safe to guess that the static problem is a special case of the dynamic one. College application breaks this intuitive principle. In the dynamic Pandora’s box problem, any given moment, you are only asking two questions:

Should I apply to another school?
If so, which one?

To answer correctly, you only ever need to compute the marginal utility of individual college applications relative to the offers you already have on hand, which is not terribly difficult. But in the static college application problem, the expected payoff depends on the combination of schools in the application portfolio. This yields a larger array of choices, and a more challenging decision problem.

In my thesis, I prove that the college application problem is hard in a mathematical sense called NP–completeness, which means that barring an unprecedented computational breakthrough, there is no way to solve it that is both fast and accurate. The NP–completeness proof exploits the interaction among simultaneous applications in order to make the objective function misbehave.

For the uninitiated—yes, you can negotiate college financial aid offers. ↩

Migrating to Jekyll

2022-06-25T00:00:00+00:00

After reflecting on my unsustainable dependency on Google services, I have decided to bite the bullet and migrate my blog from Blogger to the open-source Jekyll, with hosting provided by GitHub. In the full version of this post, I explain some of the technical reasons for making this change.

Advantages of Jekyll

The Jekyll workflow offers several advantages over Blogger. For one thing, when writing a post in Blogger, I was forced to choose between a buggy WYSIWYG editor and raw HTML. To obtain granular control over the post formatting, blockquote styles, image sizes, embedded video behavior, and so on, I came to favor the HTML editor over time. However, since Blogger’s interface offers only limited control over the blog’s stylesheet, in order to obtain the post layouts I wanted, I always had to bob and weave among inline CSS styles, a custom stylesheet I appended to the Blogger theme, and various sliders in Blogger’s config GUI that let me indirectly modify the underlying template. It was yucky.

By contrast, the Markdown/Jekyll workflow creates a clear distinction between writing and typesetting tasks. I can compose my posts in Markdown with minimal distraction from all those HTML tags, and format everything from above by tweaking the well-organized stylesheets from Jekyll’s templates. For readers, I hope this means I will be able to maintain a more consistent voice in my writing, and because the formatting, typesetting, and layout will be stable from post to post, you can expect less visual “noise” from the website itself.

Because I have total control over every bit of code on this new website, I also can ensure that it is free of the cookies, UA sniffers, and other tracking devices that were embedded in Blogger. As someone who aggressively uses browser extensions to nerf these devices when another site deploys them on me, it felt hypocritical to subject my readers—both of them—to the same surveillance.

Finally, since Jekyll builds everything to static HTML on the server side, the load times should be faster. And later on, if I want to switch hosting providers or set up my own web server in my basement, future migrations should be much easier than this one.

Pain points

If you are reading this post shortly after it went up, chances are that I am still configuring things and repairing links. For example, old.maxkapur.com should take you to an archive of the old blog, but the links embedded on that blog may 404.

Another difficulty with this migration is that to host a Jekyll blog using GitHub pages, you have to create a GitHub project named maxkapur.github.io (or whatever your GitHub username is). But I already had a project with that name, which I used to host various one-off essays and coding projects at the URL misc.maxkapur.com. Now, I have overwritten the maxkapur.github.io repository with the code for this site and created separate GitHub repositories for the projects that felt worth preserving. If I set things up correctly, then the old links should forward to correctly to their new homes. Of course, you can also dig into the commit history for maxkapur.github.io and find the source code for those pages that way. But this will probably break some of the links on the old blog that used absolute paths instead of relative ones.

Jekyll offers some tools for automatically importing past posts from other blogging services, but I have decided against importing the full history, both because it is a nuisance, and because the design and layout of the old Illusion Slopes concords with the tone and content of those posts in a way that (in my view) the new design does not. Nonetheless, because it is easy to create backdated posts, I will probably pull in a couple of the most recent posts and some of the “greatest hits” (i.e. posts that were major drivers of search engine traffic) from the old Illusion Slopes site. This will help me practice the new workflow and get a feel for where I need to apply further customizations to the Jekyll CSS.

New license

The previous instance of Illusion Slopes featured a prominent copyright notice in the footer. Going forward, this blog will be licensed under CC BY-SA 4.0, a copyleft license that grants you the right to remix and reuse these materials without asking for permission as long as you credit me (preferably by linking to maxkapur.com) and release your work under a similar open license.

Thesis defense

2022-06-19T00:00:00+00:00

This week, I defended my master’s thesis at Seoul National University. My thesis concerns an NP-hard portfolio optimization problem that I call the college application problem. My slides, presentation script, and the thesis itself live on this GitHub repository, and all are provided in both English and Korean versions. I also have a very brief deck of reveal.js slides introducing the problem, and I recently wrote some documentation for OptimalApplication.jl, the Julia implementation of my solution algorithms.

The defense process was relatively painless: I received some very helpful comments and reference suggestions from the professors on my committee, and I was pleased that they were persuaded by my argument that the model of the college admissions process I have chosen represents the best tradeoff between realism and tractability.

I also was able to give a brief presentation about my research at a conference in Jeju at the end of last month. Here’s a terrible photo for Mom:

The college application problem, presented in Korean

2022-05-13T00:00:00+00:00

I gave a brief presentation about the college application problem at a research fair hosted by our department. English subtitles are included.

“College Application” on arXiv

2022-05-04T00:00:00+00:00

In advance of a conference I will be attending with my labmates next month in Jeju, my thesis advisor and I have posted a preliminary version of “The College Application Problem” on arXiv. Here’s the abstract:

This paper considers the maximization of the expected maximum value of a portfolio of random variables subject to a budget constraint. We refer to this as the optimal college application problem. When each variable’s cost, or each college’s application fee, is identical, we show that the optimal portfolios are nested in the budget constraint, yielding an exact polynomial-time algorithm. When colleges differ in their application fees, we show that the problem is NP-complete. We provide four algorithms for this more general setup: a branch-and-bound routine, a dynamic program that produces an exact solution in pseudopolynomial time, a different dynamic program that yields a fully polynomial-time approximation scheme, and a simulated-annealing heuristic. Numerical experiments demonstrate the algorithms’ accuracy and efficiency.

Rolling updates to the paper as well as various slideshows presenting the research are available on GitHub.

The school location problem

2022-04-14T00:00:00+00:00

I’ve spent a few days thinking about a facility location problem that we might call the school location problem. The goal is to place $n$ schools to serve $m$ families, such that the furthest distance between any family and their nearest school is minimized. This problem is almost a $k$ -means or ellipsoid fitting problem, but its unusual “minimin” form makes it computationally challenging.

In the video below, and associated Jupyter notebook (GitHub, HTML viewer), I discuss the formulation of this problem, show to express it as a mixed-integer second-order convex program, and then solve a small instance using the Julia/JuMP/Juniper/SCS stack.

Here’s the video link.

Administrative vs. allocative efficiency

2021-10-21T00:00:00+00:00

This fall marks my final semester of coursework, and penultimate semester overall, of the master’s course in industrial engineering here at Seoul National University. I’m taking courses in combinatorial optimization and advanced microeconomics, as well as continuing my study of college admissions markets as a research assistant in the Management Science/Optimization Lab.

Recently, I have been focusing on risk-averse behavior in college applications. In an ideal universe, college applications are completely standardized and there are no constraints on students’ ability to apply to many schools or on schools’ ability to assess a large number of applicants. In reality, many highly qualified students fail to apply to top schools because they doubt their ability to get in or receive a sufficient financial-aid package. For these students, the time and money required to submit an additional application to a so-called reach school takes away from time that could be spent refining an application to a target school. This opportunity cost is not trivial, because modern admissions offices strongly prefer students who tailor their personal statement to the characteristics and interests of the target school or program.

In Korea, such strategic behavior is baked into the college admissions process at the policy level: No student may apply to more than six colleges in a given year, and colleges are allowed to adopt more generous admissions standards for students who list the college as their first choice. A student who wishes to apply to a top university therefore needs more than just confidence in her academic talent; she must also be willing to accept the risk of being rejected and ending up at the bottom of the pile at her second choice.

We know, however, that risk aversion is not homogeneous across the population. Some of the variance is just temperamental: There are people who will continue working at an unsatisfying job because they fear that whatever job they switch to will be even worse, and there are other people who happily take the leap (paywall). But some of the variance in risk aversion is correlated with demographic traits. For example, all other things being equal, women are less likely than men to guess randomly on a hard multiple-choice test like the SAT that penalizes wrong answers (paywall). And we know that kids from low-income backgrounds tend to fail the marshmallow test; perhaps it is not stunted patience, but deliberate, risk-mitigating behavior that makes them favor the sure bet.

In college admissions, administrative efficiency requires any practical admissions procedure to put up some minimal barriers to application; otherwise, truly underqualified students will spam top universities with vain applications, wasting everyone’s time. However, if the application barriers are too high, they may force marginally admissible students—that is, qualified students—to engage in strategic behavior that does not reflect their actual preferences or abilities. A highly qualified, risk-averse student may list her second choice as her first, or neglect to apply early decision to her dream school (early decision increases admissions likelihood but arguably entails financial risk). And as a result, a less qualified but more cocksure student can step into her place.

The scenario above—which, to be clear, is speculative—suggests that market features designed to produce administrative efficiency, like requiring students to express a specific interest in their target school or indicate whether the school is their top pick, trade off with allocative efficiency in the composition of top universities’ entering classes. Moreover, if the psychological findings above on risk-averse decisionmaking also hold with respect to applicant behavior, then it is possible that the social cost falls most heavily on precisely the marginal groups whom we are trying hardest to recruit.

An economic view of the Korean college admissions market

2021-05-16T00:00:00+00:00

Existing computational models of admissions markets tend to fall at one of two extremes: Either they envision a centralized admissions process in which the school board runs an algorithm that says which students go where, or a decentralized process in which colleges compete for the best students. But the Korean college admissions process cannot be adequately described in either of these terms.

The Korean admissions process is decentralized in the sense that students ultimately can choose which college to attend from the subset to which they are admitted. However, the application procedure is facilitated by the government, which enforces a limit on how many schools each student can apply to (currently six) and requires a certain distribution of applications across three tiers of selectivity. This means that the Ivy League sweep is theoretically impossible in Korea.

In addition, the government assigns each college a quota, meaning the maximum number of students it can “recruit” in each academic major. In smaller universities, the quota for a given program may be as small as a single-digit number. To ensure that no college exceeds its quota, students are admitted over the course of several rounds of acceptances, with different scoring criteria and cutoffs in each round. Because colleges are not allowed to use empty seats in one major to admit extra students in another, this creates endless possibilities for strategic application. As an applicant, if you can identify an underdemanded program at your target school, you will be guaranteed admission in the final round as long as you meet the minimum application requirements. And, as many have probably heard, a signature feature of the Korean admissions process is a big test called the Suneung or CSAT. Whereas American universities have begun to discount standardized test scores, a typical Korean university determines about 80 percent of applicants’ composite score using the Suneung; the remainder comes from high school grades, an interview, and/or an admissions test specific to the program the student is applying to. It is from this weighted average that the college defines its final ordering of the applicants and sets its score cutoff. As a result, students’ admissions probabilities are highly correlated across universities.

The argument for this design is twofold: First, it is cost-efficient, because it caps the total number of applications and therefore reduces the number of applications that each college has to read. (However, we ought to question the amount of reading actually involved, since very few universities require anything as textually substantial as the American “college essay.”) Second, it is fair in the sense that it evaluates all students on the same, quantitative metrics.

The most obvious and common argument against the semicentralized admissions procedure used in Korea is that it is actually unfair, because evaluating students in approximately the same way at every college means that winners take all. A student with low test scores but a high degree of motivation does not have the chance to prove herself by actually taking college courses alongside high-achieving peers. You have to get smart by the end of high school, or it’s game over. A related argument says that the Suneung is unfair because wealthy students receive private tutoring in order to increase their score. However, I find these arguments to mistargeted, because (to my knowledge) the high priority colleges give to the Suneung in their admissions decisions is not mandated by the government. In theory, if a college wants to admit students purely on the basis of high school grades or tennis ability, it can, but colleges stick to the Suneung because they like it. It’s a legible (if unreliable) indicator of academic ability, it avoids the appearance of corruptibility, and it’s easy for the college to track year over year as it tweaks its admissions standards in response to market conditions.

However, even if we set aside the Suneung and the attendant debate about fairness, I argue that the Korean admissions process is economically inefficient because of the limits it imposes on students’ application strategies. If an outstanding student from a rural area knows that she can only apply to two schools ranked within the top fifty, she may be inclined to hedge her bets by applying to schools ranked in the thirties and forties rather than wasting an application on (what Americans would call) a “reach” school in the top ten. Because of situations like this, in any admissions process that circumscribes students’ ability to consider a broad range of colleges, the outcome is highly sensitive to students’ ability to intuit their rank in the broader distribution of academic talent.

I hypothesize that students who don’t have role models who attended top universities will tend to adopt a minimax strategy, and end up attending a university that’s worse than where they could theoretically get in under an efficient allocation. On the other hand, students who have the financial means to take a gap year can afford to apply to reach schools, and reapply to a more conservative set of schools next year if they don’t get in. With the right computational model, we can attach numbers to these hypotheses; for example, if the number of allowed applications increases from six to seven, we can try to predict the change in the number of students who decide to take a gap year.

Why study the Korean college admissions market from an economic perspective? Anyone familiar with the computational models typically used to study admissions markets should have raised an eyebrow at the monolithic notion of better and worse schools implied by the previous two paragraphs. In fact, the very thing that makes the classical school-choice problem interesting is the possibility that students have diverse preferences (based on individual variations in geography, academic interest, family alumni, etc.). Thus, in the canonical problem, there is not necessarily a global ordering of better and worse schools. Nor is there a global ordering of students, like the one that arises when all universities grade students based on standardized test scores. Korea is exceptional on both of these points. Most schools rank students in a similar way, and because of the high degree of vertical differentiation, most students have a similar preference order over the 300ish universities in the market.

Loosely speaking, when the preference orders are more or less random, the set of possible stable assignments is relatively large, and we can start to “play” with other distributional goals, like trying to obtain gender parity at each university while preserving overall stability. This is what a lot of current papers in stable assignment are doing now. However, in a stylized Korean admissions market in which most students have a similar preference order over the schools and all schools assess students in the same way, there is only one stable assignment (as I can show mathematically). Although we don’t get to play with distributional goals, because the stable assignment is unique, we can examine it in greater detail, and compute comparative statics such as the marginal effect of a change in student population on the selectivity of each university.

Another reason to take a closer look at correlated admissions procedures like the one used in Korea is that such market designs are common around the world, not just in Asia, but also in many European countries and in local school-choice markets in places like New York City. It’s cool, if you know how to program, that we have a simple algorithm for computing stable assignments in arbitrary discrete admissions markets given lists of student and school preferences. But by narrowing our focus to the case of correlated admissions, we can make more ambitious quantitative predictions about the long-run behavior of the market, including, hopefully, computing the efficiency cost of admissions quotas and limits on the number of applications each student has.

Stable matching on Planet Money

2021-03-07T00:00:00+00:00

Planet Money, an NPR show about economics, recently ran an episode entitled “The Marriage Pact” that deals precisely with my research topic. It’s a great episode that discusses both the basic ideas behind stable assignment as well as its applications in organ donation, job placement, and (my area of focus) school choice.

The episode begins with an interview with a Stanford econ student who designed a marriage market for his peers and managed to get 4111 of them to sign up for it. What a cool project! The student makes a few minor misstatements about the Gale–Shapley proposal algorithm that Planet Money leaves uncorrected. In this post, I want to offer a few corrections, not just because I can, but because in my opinion these marginal details are what make stable assignment an interesting and profitable research topic.

The interviewee says that because the proposal algorithm produces a stable matching, it is guaranteed to provide participants with their “best” match. But it turns out that even when the participants in the proposal algorithm have strict preferences, there can actually be more than one set of stable matchings, and which stable matching you get depends on which form of the algorithm you use.

If you run the algorithm in the male-proposing form, you get a match that is simultaneously male-optimal and female-pessimal. This means that among all of the women Fido could be stably matched with, the male-proposing algorithm is guaranteed to pair Fido with his first choice, and to pair Fido’s mate with the male she likes least among the males she could stably match with.

Likewise, if you run the algorithm in the female-proposing form, you get a match that is female-optimal and male-pessimal.

In the episode, the hosts mention that the algorithm provides the participants with no incentive to lie about their preference order (notwithstanding misrepresenting basic facts about themselves like height). But an important corollary of the result above is that the male-proposing algorithm is actually not strategy-proof for the female participants—by lying, they may end up with a male better than their worst match.

I don’t know how the Stanford match works, but it’s likely that (for the straight participants) they used an extension of the Gale–Shapley algorithm developed in the 1980s that finds the “male–female optimal stable match”—a sort of compromise between the male- and female-proposing forms. This extended algorithm, while egalitarian, isn’t strategy proof for either group of participants, precisely because it gives both groups a slightly suboptimal match.

The good news it that in the one-to-one matching case with strict preferences, the differences between the male- and female-optimal matches are quite minimal (usually just a shuffling a few pairs around at the edges, if any), and the “strategy” you need to use to beat the market is not at all obvious.

But when we relax the assumption of strict preferences and start to work with many-to-one matching, as is the case in school choice, the set of stable matches becomes very large, and coming up with a good way to maximize participants’ outcomes while maintaining incentive compatibility is an interesting challenge. The dominant contenders in this space are randomized “tiebreaking” (lottery) mechanisms, including those used in school markets in New York, Boston, and elsewhere. I’ve run a bunch of computational experiments on these mechanisms, and you can see some fun graphs on the GitHub page for my Julia package DeferredAcceptance.

(I sent a version of this to the Planet Money team, but I’m not betting on a response.)

2020-07-07T00:00:00+00:00

They say that we perceive time by the accumulation of novel experiences, so that if you want to have a subjectively long life, you ought to do many spontaneous and hard-to-repeat things, but if you want to have a happy life, you ought to find one or two high pleasures that you can enjoy on a spiritual level and repeat the hell out of them, because they also say that on average, people derive more happiness from repeating a good experience than from trying something new.

You could write a linear program that targets your ideal mix of longevity and happiness and it would tell you exactly how many times to do this or that activity before moving onto something new. But what this calculus leaves out is the feelings of uncertainty that stain the transitions.

I am leaving Naju, after having grown accustomed to this routine, this commute, these faces, and I cannot say with any confidence that I have reached a joy plateau. Every week of teaching here has been better than the last: my skills have improved, my confidence has grown, and the teachers and students have become only more important to me. I could be happy like this for a long time. But.

But too much comfort has a way of smearing all the time together, so that the things that take place in a given day feel less like events and more like footnote references to proto-events hovering in the firmament of the distant past. I have already seen the river clog itself with duckweed; I have already looked down the street from all four of the intersection’s corners, trying to make the buildings line up with the trees. Upon inspection, a more sensitive man might look at these rhododendrons and see something more than last year’s blossoms in a different configuration, but I am a pattern-matcher by nature, too easily bored to remain a recluse. It is time for a new challenge.

As I wrap up my Fulbright grant, I am delighted to share that I have been accepted into the Government of Korea Scholarship program, through which I will be returning to Korea in the fall to pursue a fully funded master’s degree in industrial engineering at Seoul National University.

Thank you to all who have encouraged me.

The benefits of a nonnative teacher

2020-05-06T00:00:00+00:00

In addition to the myth that it’s impossible for adults to “really” learn a foreign language, a widely held misconception about language learning is the notion that beginners must learn from native speakers. Many are willing to allow that a nonnative English speaker could make as good a teacher as a native speaker, but fewer recognize the pedagogical advantages offered by someone who has learned the target language as an adult and can understand what it looks like from the student’s perspective.

In the ELL classroom, we often encounter questions like: Why is it correct to say I am going to school but wrong to say I am going to home? A native speaker has to think about this: Is there a reason we drop the to before home, maybe something to do with the fact that you can attend, in theory, multiple schools but can have only one true home? Or is it because it just “sounds better”? Or maybe it’s just a random exception, but then, which one is the exception and which one is the rule?

Someone who learned English as an adult can tell you immediately that I am going home is a random exception, and that to is the rule when you are going to a specific, named place. The only reason I, a native English speaker, know this is that a similar exception exists in German: Ich bin zu Hause. When I asked my German teacher (a nonnative English speaker) about that sentence, she asked, rhetorically, “Why is it correct to say I am going to school but wrong to say I am going to home?”—having learned this very thing in school.

With some effort, you can generate sentence pairs that demonstrate the opposite case, where a native speaker feels inclined to call the difference a random exception when in fact there’s a grammatical rule in play. Here’s a test question that I’ve encountered in various forms:

I think dogs are awesome. I think cats are OK. Circle all correct sentences:

I like dogs more than cats.

I like dogs better than cats.

I like more dogs than cats.

I like cats less than dogs.

I like cats fewer than dogs.

The answer is choices B and D. Most native speakers see nothing wrong with A, because it’s something that we actually do say, but according to a strict interpretation of the rules of English grammar, A is wrong for the same reason that C and E are wrong: more is for comparing quantities of things, but like expresses a binary preference. By an even stricter interpretation of the rules, you can argue that choice D should have worse instead of less, but the prescriptivists who write Korean standardized tests of English grammar have moved past that archaism even as they’ve resisted allowing choice A.

Native English speakers who teach in Korea are often given test questions like these, along with the answer key, and asked to explain the correct choice. Because the answer key disagrees with our intuition, we tend to grasp for an explanation and fail. On the other hand, a Korean teacher can reference the textbook page that discusses more than and better than and be done with it.

You might argue that memorizing these kinds of formalisms falls short of actual language acquisition, and you would be correct—language learners need also to engage with authentic texts and audio, experiment with the target language in roleplay scenarios, and practice speaking freely without worrying about errors. But teaching the more than/better than distinction, even if the student will eventually discard that rule as they encounter English in the wild, is useful because it primes the student’s awareness of the different kinds of comparisons available in the language.

Consider: You can allow choice A in the above question, but then students will ask why its parallel, choice E, is wrong, and you’ll teach them the fewer than/less than distinction, but then you’ll have to explain why there isn’t a more than/better than distinction as well. Yuck! It’s better (more?) to avail beginners of a consistent set of principles that mostly work, while maintaining a mental inventory of exceptions, and exceptions to the exceptions, in case a smart kid asks a good question.

Most native teachers long to do away with multiple-choice questions like the above. At best, they make for interesting illustrations of how English grammar is a moving target and there’s no universal set of rules obeyed by all English speakers everywhere forever. At worst, they make for frustrating illustrations of how English grammar is a moving target and there’s no universal set of rules obeyed by all English speakers everywhere forever. A nonnative speaker, who can detach herself from personal feelings about what constitutes “natural” English, can distinguish between language usage and test-taking strategy. A savvy test-taker, confronted with the above question, doesn’t have to know whether I like dogs more than cats is admissible in Korean Standard English; she merely recognizes that this question is “about” the more than/better than distinction and eliminates choice A because standardized examinations test rules, not exceptions.

Now, native speakers can learn to speak abstractly about grammar like nonnative speakers do, but it’s an acquired skill, just like algebra. While it’s theoretically possible for a native speaker to deduce the rules of his language’s grammar from first principles, a speaker who learned the language as an adult learned those rules at the same time, whereas native teachers like me have to scramble through Google to find answers or make up rules that seem right at first but collapse upon inspection.

I have learned a great deal of Korean from native speakers, but my foundation in the Korean language was established in a class at the UW taught by an American. After that, I had Korean professors and TAs who had invested considerable time in learning to speak about Korean, and they understood the utility of abstract grammar because they had relied on it themselves in learning English. To the extent that I’m good at Korean now, I attribute my success more to the many opportunities I’ve had to carefully examine Korean grammar and etymology than to my friendships with native speakers. That part’s just fun.

Accidental signals

2020-04-16T00:00:00+00:00

It is a well-known result in psychology that measures of intelligence correlate across domains. If you are good at math, you are probably also good at verbal reasoning, and vice versa. Therefore, if a company is hiring for a position that requires a variety of skills (as most jobs do), it should pick a candidate who has demonstrated impressive skill in one domain over someone who has demonstrated middling proficiency in a number of different domains.¹

Hiring managers’ preference for specialists is widely known. So, smart people, who tend to be good at estimating job-market incentives (thanks to the correlation between domains of intelligence), gravitate toward programs that award narrow, in-demand credentials—even when the credentials are nominally equivalent (a BA in linguistics vs. a BA in English). This can create a feedback loop in which fields that are perceived as “challenging,” like computer science, attract challenge-seeking entrants, raising the standards of proficiency within the field and making it more difficult for a newcomer to rise above average. On the other hand, majors that are perceived as relatively easy, like sociology, may attract less-ambitious students, leading to deflated expectations and dissuading hard workers. (I have met a few people who told me that they majored in the liberal arts because they were “bad at math.” I have never met a STEM major who chose their field because they were “bad at writing.”)

(National Center for Education Statistics, Undergraduate Degree Fields)

Nothing in this argument depends on the skills actually conferred by a given degree program or the skills actually required by an employer. A tech company needs managers and product designers just as much as it needs engineers, but positions in management and product design are typically reserved as rewards for distinguished engineers rather than handed out to people who majored in management or design. This is because a coder’s science degree(s), plus a few years of demonstrated commitment to the company, signals greater potential for success in the new role than some stranger’s design credential, which may relate more to the job but is also easier to obtain.

The problem comes when we confuse these signals of potential with the thing itself. To depart from credentials for a moment, one such signal is “grit” (tenacity, work ethic, passion), which Angela Duckworth argues is the best predictor of career success. This conclusion is obvious if taken as a prescription for moneymaking. But the book (Grit: The Power of Passion and Perseverance, 2016) becomes more interesting if we read it as a diagnosis: an attempt to organize American capitalism’s scattered, ever-changing incentives under a handy label. It is this explanatory power that makes grit conceptually coherent. Successful people come from a range of economic and educational backgrounds, but what they all have in common is—see book title.

However, grit’s conceptual strength comes at the cost of moral clarity. In a later chapter, Duckworth begins to caution that grit is morally neutral: good and bad people (she mentions Hitler) alike can be possessed of grit, so we should not regard someone as morally virtuous just because they are gritty. This is correct, but Duckworth fails to take the further step of disclaiming the converse: she assumes that moral people will see value in grit and pursue it for its own sake. On the contrary, we (moral people, presumably) ought to question the value of grit, because the positive traits by which Duckworth defines it can be easily reframed as negatives: Where does tenacity end and stubbornness begin? What about work ethic and workaholism, or passion and temper? We can think of a few geniuses whose “passion” had disastrous consequences for their personal and professional lives.

While you may cultivate success through grit (and leverage your success for moral good), will you, in your power, recognize the worth of someone who is highly intelligent and hardworking but has not developed grit as a signal of this potential? Under a different incentive structure—an unstable family environment, for example—an effective learner might develop, in place of tenacity, the ability to recognize a losing battle; in place of discipline, flexibility; in place of passion, consideration of communal needs. These latter traits are not incompatible with grit’s essence, but they may interfere with grit’s signal when it is measured by prompts like, “I finish whatever I begin” (to which the respondent answers on a scale from “not like me at all” to “very much like me”). Grit is an abstract concept that attempts to unify many disjoint values under one label. It may reliably indicate career potential—it may even be the most reliable such indicator available—but it does so only “by accident”: it signals the presence of a collection of traits that employers value, not the merit that undergirds the traits themselves.

So it goes with credentials. Achieving a high level of expertise in any field is hard. But the accidental arrangement of the job market at a particular moment in time has stiffened competition in some fields and weakened it in others. Today, it is relatively easy to parlay a STEM degree into a number of careers. That is not because everyone “needs” to know differential equations, but because knowing that someone passed a differential equations (MATH 235) tells us more about their overall intelligence than knowing that they can speak intermediate French (FREN 235). A STEM degree is a proximate signal of being good at following directions, which is in turn a proximate signal of career success.

Ideally, employers, grad schools, and other such gatekeepers would shun such imperfect signals. Instead, they ought to evaluate each candidate on an individual basis, combing through their background in search of desirable traits. But this is cost-intensive, so gatekeepers bet on the reliability of cheap signals like credentials and test scores instead. They do not work perfectly, but they work well enough, most of the time.

You may have heard that the instruments we use to measure “intelligence” are biased toward people from dominant cultural backgrounds and people of financial means. This is a good argument against the use of standardized testing in college admissions, but it does not contradict the claim that I am using here, namely, that intelligence between domains (and within an individual) is correlated. ↩

What you learn in a humanities degree

2020-01-19T00:00:00+00:00

The more I learn, I find myself with fewer and fewer things to say.

As a humanities student, I studied many “theories.” One theory is historicism, which says that things are the products of their historical settings. Example: At a career mixer, a well-dressed alumnus, class of ’70, approaches a sophomore journalism major. “The first thing you should do once you’re financially independent and you’ve got some money saved up is make a down payment on a house. Nobody will ever stop needing houses,” he says. The advice is a historical artifact, extruded from a certain moment in American politics and a certain set of assumptions about credit scores and work contingency and citizenship status. The student may react with with doubt; her doubt is also historical. It encodes her upbringing, and a different relationship with houses and banks and the word independent.

We could apply any number of other theories to this interaction. There is a theory that explains why the man feels no reservation in handing out unsolicited advice, and another that explains why the student smiles and sips her iced tea instead of challenging him. There is another theory that explains why conversations about what to do with wealth are appropriate at a university career mixer—what the conversation implies about the prestige of the university, the status of the alumnus, the prospects of a nascent journalism career. Given a set of questions about a situation, or “text,” we can use contrasting theories to harvest competing answers to the questions. Then the merits of the theories can stand in for the merits of the answers. (If we are especially cunning, we might presuppose which answers we want to find and then focus on the theory that guides us there. You can bring up this point as a lazy counterargument next time I say I am using an “interdisciplinary approach” to argue for an idea you disdain.)

When I was a student, my favorite theory was what we might call discursivism, a literary theory that says, essentially, that language is simultaneously “about” both language itself and whatever it is that the language at hand is talking about. “Nobody will ever stop needing houses” is not just a phrase, but a catchphrase, an idea whose snappy wording embeds a claim about its salience. The secret message is something like: If what I am telling you right now isn’t true, then how come I can say it so succinctly? Indeed, anytime we raise our voice, we are secretly transmitting a claim about our own act of speech: I am able to put these thoughts into words, therefore they must have some merit.

Theories are quite powerful, because they allow us to convert small amounts of information into large amounts of information. (More words have been written about Shakespeare than Shakespeare ever wrote.) We use theories to put words into others’ mouths. For example, Americans tend to think of themselves as formidable amateur psychoanalysts. It is not uncommon to hear Americans dismiss each other by saying they are “projecting” or “deflecting” or “repressing” something. Psychoanalysis is a theory, a theory according to which we spend life restaging traumatic incidents from childhood in a hopeless search for resolution. Like many theories, psychoanalysis rejects the possibility of objective observation; thus you can talk in circles by telling your opponent, “No, I think you’re repressing!” Without realizing it, we are two levels of abstraction away from the issues at hand, but because culture has made us comfortable with pushing theories around like pieces on a chess board, both parties proceed in the illusion that material gains are at stake. In fact, when we pit theories against each other, what we are gaining is information: about the matter in question, yes, but also about the theories themselves, their breadth and depth.

We cannot break free of theories. Whether or not you have received a traditional education, your thought patterns have been shaped by your experiences of people and your interactions with “texts.” A theory doesn’t need to have a Wikipedia entry for it to color your thoughts. Thus, one of the goals of a liberal education is to equip you with a wide range of theories, so that in an unfamiliar situation, you can try out various theories in succession as a corrective against your default narrative, the hope being that you will test out various responses and select the best one. However, being theoretically versatile—I have called this narrative fluency—is more likely to make us good at justifying our prior beliefs (whether or not they are correct) than at reexamining and overturning them.

Thus, I am finding myself with less and less to say, because I am paralyzed by the sense that if I manage to say something convincing, it will be so only because I have applied a theory in a novel or resonant way, and not because the underlying idea has merit. I have spent so much time playing with theories that nowadays, I sometimes myself testing facts against beliefs rather than beliefs against facts, so that when I encounter a set of facts that resist one of my beloved theories, I search for better facts instead of modifying my assumptions.

In courtroom dramas, lawyers begin their closing arguments by saying, “Let’s let the facts stand on their own,” and then they proceed to enumerate the facts, thereby preventing them from standing on their own. When—not if—the facts are inventoried, curated, rehearsed, ordered, voiced in a measured tone, calibrated for this trial and these jurors, then the facts are being coerced to an invisible theory. We are awash in theories, and the only way to let the facts stand on their own is to say nothing.

Houseplant measurements

2020-01-02T00:00:00+00:00

I have been measuring the leaves of my houseplants.

It is surprising how normal these distributions are.

I’m putting my stats notes here.

Note: I imported this post from my Blogger archive on April 27, 2024. The original title was “Aretha and Brad”—the names of the houseplants (after Franklin and Mehldau, respectively) whose measurements are pictured. This mindfulness project was likely inspired by the beloved iris dataset.

I’ve updated the “my stats notes” link to point to the latest version of that Jupyter notebook in GitHub’s view of the Git source tree for this site, in the unlikely event that it is useful to anyone.

With four years of additional perspective, I would be remiss not to point out that leaf geometry in which both the area $XY$ and the aspect ratio $X/Y$ are both normally distributed would be serendipitous indeed—and that the plots above don’t look particularly linear to me anymore.

Using data to understand ELL students

2019-10-18T00:00:00+00:00

In August, I surveyed my students about their motivation for learning English, their opinions about our class and my teaching style, and what resources they were using to study English outside of class. By analyzing the results using some of the statistical tools I’ve taught myself this year, I came up with some effective strategies for reaching the disengaged students in my classroom.

At the moment this post goes up, I’ll be giving a presentation about that project at Fulbright Korea’s fall conference in Gyeongju. Here’s a digital version of the talk.

And here’s a detailed write-up of my survey design and results.

Things that are a thing here

2018-08-25T00:00:00+00:00

They say that major lifestyle changes—even positive ones, like starting a new job or moving—are one of the biggest stressors out there. By that measure, it’s been a wild week: I’ve moved in with my host family in Naju, set up a Korean bank account and phone number in my name, and started teaching English at two middle schools. Unfamiliar digs, unfamiliar language, unfamiliar students and coworkers. But on all sides, I’ve been fortunate to find myself surrounded by supportive, understanding, and hardworking people.

Skip these two paragraphs if I already told you about my weekly schedule. I spend Monday through Thursday at an all-boys’ middle school in Naju’s old town. At about forty students in each grade (divided into two classes), it’s smaller than average, but our students more than make up for it with their rambunctious energy. Fridays, I’m out in the countryside in an actually tiny one-building school that has only twenty-five or so students (it’s the satellite of a school in a neighboring city), all very proper and devoted to their grade-level classmates. The second school is in a gorgeous setting: epic mountains pouring down fog from all sides.

At my main school, each homeroom gets English class two or three times a week; I teach one class and my supervising coteacher teaches the other. After school, I teach a smaller group of students an English conversation class (the students are all required to participate in a club class but they get to choose from various school subjects). I expected the large classes to be the hard part because of, you know, crowd control. But the club classes have proven more challenging because they expose the students whose English isn’t as strong. Half of the students are bored because they understand nothing, and the other half is bored of waiting for the former to catch up. This situation calls for creative pedagogy. I don’t know what that’ll look like yet, exactly.

Now, I’ll do my utmost not to be that foreigner who windbags about “how the Koreans do it.” So, with the caveat that I do not intend to define cultural differences comprehensively, let me share two things have stood out to me this week: First, it’s really striking how much authority teachers have here. Despite my youth and inexperience, my fellow teachers place a lot of faith (certainly undue) in my ability to plan solid classes. They’ve given me a textbook to follow, along with ample supplies and auxiliary materials, but nobody has nagged me for any bureaucratic nonsense like a tabular correlation of my lesson plans with those of my supervisor. The team trusts that I’ll do the work well, and I do my best to meet their expectations.

Observation number two: There’s a stereotype that Korean schools teach everything by rote, but to me, this appears to be more of a generational difference than a cultural one. If anything, it’s kids in the US who suffer truly tedious classes, structured the same way every day (“I will be able to … ”), because American teachers’ livelihood depends so desperately on their students’ standardized test scores. While standardized tests are also a big deal in Korea, teachers themselves seem to assign (and are permitted to assign) students’ overall learning and well-being more importance. Additionally, my students in Korea take a much wider variety of subjects than their American counterparts. Art, music, literature, and “morality” class¹ matter just as much as the STEM subjects, whereas the schools I’ve worked at in the States seemed to treat anything that isn’t quantitative as an ancillary. (But then, I did grow up in the shadow of Microsoft, Boeing, and Amazon.)

In short, I really love my job. Call this the honeymoon phase, but I want to gush about one more thing while I’m riding high: On my first day, I received from the vice principal a tabbed, leather-bound notebook labeled “Teacher’s Diary.” I chuckled at the odd English, thinking it was just a regular planner, but it isn’t. Many of the teachers at our school actually keep a journal, in prose, reflecting on their daily lessons and pondering ways to improve their pedagogy. I’ve started doing the same. And I can already feel it making me more present in the classroom, more aware of how my students are faring. I mean, why wasn’t this a thing in my high school?

I really want to observe this one. I was leafing through the morality textbook and it consists mostly of short parables and comic strips, which students read and then respond to with brief journal entries. When I remarked to another teacher that there are no such classes in America, she asked if we just learned morality during philosophy class. I told her we don’t normally have philosophy classes in grade school either. She turned back to her computer, looking perplexed. ↩

Fulbright

2018-05-02T00:00:00+00:00

Fun fact: the most-viewed post on this blog, by a long shot, is the one where I shared that I’d received a Critical Language Scholarship from the US Department of State to study Korean in Gwangju. Today, I’m pleased to announce there will soon be another addition to the State Department–mandated disclaimer at the bottom of this blog.

Beginning early this July, I’ll be spending a full year in South Korea as a Fulbright fellow. I’ll be serving as an English teaching assistant at the elementary level. After our six-week orientation in Seoul, I don’t yet know the city I’ll be working in. That said, though Korea isn’t a small country, it possesses an excellent transportation infrastructure. If you’ll be there at all during the next year, send me an email so we can catch up!

Here’s a spotlight on the website of the Thornton School of Music about me and my friend Geetha, also a new Fulbright fellow.

Centering students as creators

2017-08-31T00:00:00+00:00

In an influential article reimagining how we teach art in the modern classroom, Olivia Gude observes that when students set about “looking for and developing images from inkblots, smoke marks, or wax drippings,” even the artistically checked-out ones begin to recognize themselves as creators:

Initially, students may be confused and suspicious—claiming they don’t see anything in the blurs and blobs, but as peers and teachers model an experimental attitude, soon the classroom is filled with exclamations as new images and combinations are spontaneously discovered. Students who are taught to access the creative unconscious don’t drive teachers mad complaining, “I don’t have an idea.” These students have learned the important artistic lesson that artists do not know the outcomes of their works before they begin. Artists immerse themselves in a process of making and sensitively interact with images and ideas as they emerge.

We would do well to follow Gude’s lead in other fields of art education, too. When I interned at The Greater Seattle Bureau of Fearless Ideas this summer, I noticed the staff was well prepared for students who would claim, “I’m really not the creative type.” In our workshops, we sometimes had students brainstorm on paper as a warm-up activity, but the proper beginning would always involve dissecting a story or film clip and bouncing original ideas around in a group discussion.

This works great for elementary schoolers, whose boundless imaginations seldom need more than a push-start. It’s insecurity about speaking in front of unknown students (these were summer day camps, after all), not insecurity about their creative facility, that holds them back.

High school students are another story, though. By tenth or eleventh grade, a subset of kids now identifies as “ambitious.” They are eager to see their name at the top of a page filled with text—especially if they can send it off as a college or scholarship application—and they like the idea that they have a story to tell. And they all do. But early on in our college essay workshop at BFI, when asked to describe their apprehensions about writing their applications, all also said some version of: “I have a vision for myself, but I’m not sure how telling the story of my past adds up to it.”

The lead teacher on that workshop, a professional essay counselor who volunteered to do this workshop for free, was excellent at helping students connect their future ambitions with narratives of their past. Her process seemed like a formula at first, until you looked closer and realized it was the exact opposite. The students filled out surveys to get their superficial interests out of the way—things like sports and music, or what Gude would call “‘symbols of themselves’ [that] promote narrow, limited, socially pre-defined categories of identity.” Having found this rhythm, the students next did a similar questionnaire asking about their values and social concerns.

The task of the workshop (and, I suppose, the college essay broadly) was to use storytelling to bridge column A with column B, and this central how question of writing was left to the students’ creativity. There was, of course, the obligatory read-over of successful application essays to top universities. But this teacher didn’t ask the students to count the number of anecdotes, have them calculate the ratio of “showing to telling,” or make any other such cruel attempt to reduce writing to a mathematical exercise (as if words weren’t intimidating enough without numbers). Instead, she led the students in a discussion focusing on the emotional impact of specific phrases within each essay. The students picked out the writerly gestures they found interesting; there was no judgment if they favored a passage others deemed corny or wordy or mathy. They were recognizing writing as a subjective undertaking. They were seeing the faces in the inkblots.

As I prepare to be teaching music music again after a summer of creative writing, I’m finding Gude’s article an impactful synthesis of this summer’s implicit realizations. In arts education, we can do more than turn up the volume on existing channels of students’ personas. Rather than asking that stereotypical music-teacher question, “What kind of music are you into?” I think we can arrive at a more innovative—and more stylistically robust—pedagogy by asking students (and ourselves), “What kind of musician do you want to be?” People, after all, are at art’s center.

By way of a soft ending: The next stop on this train of thought is Huib Schippers’ Facing the Music: Shaping Music Education from a Global Perspective, the core text for an elective I’m taking in our music education department. To decenter western models of music teaching and learning, Schippers favors the anthropological term transmission in describing how people encounter music. “What we hear, learn, and teach is the product of what we believe about music,” he writes. We believe music can inform a positive self-identity, an emotionally attuned lifestyle, and the construction of stronger communities, but what message do we send students when we spend forty minutes of a precious hour’s general music class memorizing solfege syllables?

Sorites

2016-08-07T00:00:00+00:00

We pretend stability by tracking our life’s progress as a series of marginal changes, so that from each day to the next we can see that we are still ourselves, changed perhaps in substance, but never in identity.

But sample two days, say, ten or twenty years apart within the spread of a life—could you recognize the images as of the same person? Over time the marginal changes penetrate to the being’s core. The transformation becomes comprehensive.

In seven or ten years’ time, nearly all of the cells in our bodies regenerate. They either fall off, as in the case of skin and hair cells; die, as in the cells living in the acidic environment of the stomach; or are “willfully” (to the extent that our body has a sense of will) killed by the immune system to fight or prevent infection.

Similarly, in the chrysalis, a caterpillar digests itself into a loosely differentiated soup. It emerges a butterfly. Its new appearance is entirely unrecognizable; the only way the observer can know that the caterpillar and butterfly are the same is by witnessing the whole process—maybe you tried this in an elementary school science class. Moreover, if you perform classical conditioning on a caterpillar, the butterfly retains the memory. Few would deny that the caterpillar and the butterfly are the same organism.

It is self-observation, in the form of memory, that preserves our identity as we pass through the many transformations (willful or otherwise) that constitute life. Memory is what gives life a sense of flow; it enables us to compress the many different forms our existence takes into a comprehensible narrative. Memory gives continuity to life’s many interruptions and breaks.

Animators know that using continuity is the smart way to model a dynamic process. Modern animators do not draw each frame from scratch, the way you would make an animated flipbook. Instead they draw the first image, and then make several small changes to it to produce the next frame.

Digital video compression works in the same way. The first frame, called a keyframe, is stored much the same way as a still image. Then, each subsequent frame is rendered by describing how it is different from the keyframe—something along the lines of, “The image darkens by 10% and the block of pixels in the corner moves slightly to the right,” but in computer language. After a certain number of frames pass in this way, the change becomes too drastic to account for in so few words. The video encoder determines mathematically that it would be more space-efficient to snap a new picture, so it creates a new keyframe and proceeds from there.

This special point at which the computer decides it would be better to encode a new keyframe then to narrate its progress since the last one has, I think, an analogue in the human experience. When we change our life abruptly or in a major way, we often speak of being “reborn” or “finding a new life.” But we lack the computational diligence of a computer to tell us when a transformation could be more efficiently accounted for with a new raw description than a description of changes.

This is perhaps easier to understand if we imagine describing someone other than ourselves. If we take two snapshots of different points from an individual’s life, at how many years apart do the snapshots become unrecognizable as the same person? In other words, in the video of that person’s life, how often and where would we insert keyframes?

A picture of them from last week and from this week would look quite similar. If last Monday was a keyframe, the description of today’s frame may read, “Weight increases by two pounds and facial hair is removed.” It may also read, “Slightly less anxious about finding a job, but more strongly longing to make up with his ex.” Straightforward. We practice making these sorts of descriptions every day, even about ourselves, when we answer questions like, “Are you feeling better today? You looked pretty down after evals came out.”

But describing our transformation as a continuous process becomes a much more awkward process when we try to trace changes in our lives over several years. If you and I had attended kindergarten together but never met since, and I asked you to describe yourself today by comparing your current self with your four-year-old self, would I be able to deduce an accurate picture of who you now are? You might say, “I whine a lot less,” but of course, given that four-year-olds are prone to excessive whining, the description is hardly informative. You could be a whiny person still, as long as you are less so than you were at age four.

In this case, I would be better off asking you for a keyframe description of who you are. If I asked you, “Are you happy with your work?” your answer would probably give me a better understanding of whether or not you are whiny person than even the most precise comparison of your four-year-old and present day habits—and that’s with a sideways question.

After a certain point, the transformation simply becomes too comprehensive to be accounted for in the language of continuity. You have been born anew. Outside of the perception of those who know you closely and have watched you evolve through every stage of your being, there is no way for me to verify that you are, in fact, yourself.

I am interested in the location of this point, a simultaneously knowable and unknowable point. As in the sorites paradox, in which some unknowable minimum number of grains lumped together eventually produce a “heap,” the changes that shape our lives and identities are so marginal and nameable that a close observer would never be able to name a point at which one has comprehensively transformed. That’s because in the process of observing, the observer becomes keenly aware of the continuity between the original and transformed object, such that a transformation that any outsider would call comprehensive is to the observer recalled as only the sequence of marginal changes that it actually was.

So we arrive at a problem: Our memory—the set of observations of our own transformation—is what confirms to us that we are ourselves. That’s because without observing continuity between two apparently different objects, we cannot identify them as the same. But how can we know that our memory is itself continuous? As above, the brain is constantly recycling its own cells. Even on a psychological level, we sometimes rewrite our memory, underlining and punctuating emotionally intense moments and lumping similar experiences together into generic memories (“my commute”). We are perhaps not ourselves, but figments of our own imagination, a cluster of observations that exist only to verify their own existence.

First week of class at CNU

2016-06-25T00:00:00+00:00

I’ve just finished my first week of class at Chonnam National Universty here in Gwangju with CLS and everything is amazing! I am staying with a host family in a suburb about 40 minutes from school by bus, so I get to practice my Korean 24/7.

Speaking in a new language can feel like doing the dishes with chopsticks. One of the conditions of the CLS scholarship is that students use only the target language when they are on campus, even outside of class, which is both exhausting and rewarding. Listening and speaking are my weakest language areas, and trying to explain a multi-step process in Korean or politely make a request of my host family often leaves all parties frustrated and confused. I am committed to the language policy, but it seems to worry my host family that I come home each day exhausted of my Korean abilities rather than more fluent.

Life in Gwangju is really nice. Gwangju is the sixth largest city in Korea, so although most people here have interacted with foreigners, we are by no means common. I certainly feel the preen of cautious eyes turning toward me when I get on the bus or enter a restaurant. The questions I most often receive from strangers are whether or not I can eat spicy food and whether I know how to use chopsticks.

CLS Korean

2016-03-12T00:00:00+00:00

I am blessed and honored to have received a Critical Language Scholarship from the US Department of State to study Korean language this summer at Chonnam University. This will be my first visit to Korea, and I am incredibly excited as well as anxious about becoming a study abroad student for the first time.

I feel very grateful for the professors who wrote my references for this program and all of those who provided me with guidance during the application. I am fortunate to live in a country that values the study of foreign languages enough to sponsor students like me using public funds. Thank you for paying your taxes.

As many of you know, visiting Korea is a dream I have been cultivating for years. That dream has now come true. Although this is mainly my poetry blog (and I will continue to post poetry), when I am in Gwangju this summer I will also share about my experiences and thoughts in a traditional blog format. Thanks for reading.

Illusion Slopes

PageRanking People and Blogs interviews

Find your perfect match with integer programming

Owen’s algorithm: Eliminate alternatives with information theory

My design objectives

My algorithm: Balance intuition and informational constraints

Statistical model of contestant intuitions

Match Up algorithm

Truth Booth algorithm

Implementation and experiments

Experiment 1: Intuition strength vs. turns to win

Experiment 2: No intuition

Experiment 3: Weak intuition

Best we can do?

Further reading

Pytest + Ruff + Mypy

Person of the Year 2006

Urban Arts Career Pathways Takeover

Apply for CLS

Python scripts

Tensions rise in the condaverse

Is ABC-SMC just an evolutionary algorithm?

Evolutionary algorithm

ABC-SMC motivation

ABC rejection sampling and the ABC-SMC algorithm

It’s the same picture

Full of types

Jekyll plugin to recommend related posts

Some things I tried recently

CLS advice nobody asked for

Is using a thesaurus cheating?

My poorly automated Kubuntu setup

Setup script

Still playing guitar like piano

First impressions after moving to Tennessee

How I organize browser tabs

Music videos

Reasons it’s hard to abandon a smartphone

Circular regression when you already know the period

Background

Problem statement

The trick

Demo

Notes

pipx install topgrade

Authenticity and the Illusion Slopes AI policy

Check this box to prove you are a human

How to type an em dash

People and Blogs interview

Conda updated?

Newly excavated posts about teaching

Server-side KaTeX rendering with Jekyll

Two novels to understand Korea’s political turmoil

How I self-host fonts on this blog

Replacing rbenv with conda

The problem

The normal solution

The conda solution

Alas

Media literacy chat at 88.9 Gwangju FM

Gwangju again: CLS Media Literacy and Democracy seminar

Bimatrix game equilibrium via nonlinear programming

Definitions

Result

Remarks

Advanced café techniques

Driver’s ed should teach error recovery

Sports idea

New logo

The best thing about fish

Why I put ISO dates in filenames

New old device

Recent reading

Housekeeping

A handy class of submodular functions

Background on submodular functions

Preliminary interpretation of f(X)f(X)f(X)

Monotonicity and submodularity proof

Application: Optimal scrum velocity, aka the mmm-dimensional Zeno walk

Remarks

Preliminary interpretation of $f(X)$

Application: Optimal scrum velocity, aka the $m$ -dimensional Zeno walk