Words - Luna McNulty

Make a Personal Offline Subset of Wikipedia

2023-02-04T00:00:00

Today's personal computing devices have at least dozens of gigabytes of storage, and usually much more. When you think about it, that's pretty amazing: You could probably store your nearest library's entire book collection on your laptop's hard drive, maybe even your phone.

But do you actually carry a library collection in your pocket? Probably not. Most people nowadays carry devices that provide an endless supply of information – until they go offline, at which point they become not much more than glorified digital cameras.

Even if you're rarely offline, you have to admit that this state of affairs is pretty lame. You have a library in your pocket, but there's nothing to read on the shelves.

How can you fix that?

Enter Kiwix. It's a program for viewing Zim files, which are compressed collections of web pages that can be accessed offline. You can get the full Project Gutenberg library of public domain books in 75GB. You can get a text-only copy of English Wikipedia in 50GB.

But even if you're enthusiastic about having offline reading material, 50 or more GB of it that might be too much. You can instead get the top 50,000 most important articles for a few hundred megabytes in text-only or a couple GB with images. That should be enough for most people.

But you're not most people, are you?

I found that the top 50,000 articles was good enough for general topics but that the depth wasn't sufficient in particular areas of interest. So I did what anyone would do and researched how to make my own Zim files. What I wanted was to the top N Wikipedia articles, plus a large selection of articles in my areas of interest.

I found mwoffline, which takes a list of pages on a Wiki and produces a zim file containing those pages. E.g. for a text-only collection:

mwoffliner </span>
     -mwUrl=https://en.wikipedia.org/ </span>  --adminEmail=foo@bar.net </span>  --articleList articleList </span>  --format nopic

Where articleList is a text file listing Wikipedia articles by the part of the url the comes after https://en.wikipedia.org/wiki/. So for instance:

Wikipedia Kiwix Wikimedia_Foundation …

Note that the pages listed in this file can't contain url-encodings, so it needs to be Germaine_de_Staël and not Germaine_de_Sta%C3%ABl.

That's cool, but how do you get a list of articles you want? I wrote a quick script to query the Wikipedia API for a several pages with a large of number of links I'd be interested in and output those links in a list.

#!/usr/bin/env python3  # get-articles-list.py  from urllib.parse import
    unquote from bs4 import
    BeautifulSoup import requests import json from sys import
    argv 
    pages = argv[1:] 
    encountered = set() 
    for page in pages:
     try:  response = requests.get( 
    'https://en.wikipedia.org/w/api.php?' + '&'.join([
     'action=parse', 
    'prop=text', 
    'format=json', 
    'formatversion=2',  'page=' + page
     ])
     )
     json = response.json() 
    text = json['parse']['text'];  soup = BeautifulSoup(text, 'html.parser') 
    for a in
    soup.find_all('a'):  href = a.get('href')
     if href and
    href.startswith('/wiki/') and not ( 
    href.startswith('/wiki/Category:') or 
    href.startswith('/wiki/Wikipedia:') or 
    href.startswith('/wiki/File:') or 
    href.startswith('/wiki/Template:') or 
    href.startswith('/wiki/Special:') or 
    href.startswith('/wiki/Portal:') or 
    href.startswith('/wiki/User:') or  href in encountered 
    ): 
    encountered.add(href)  print(unquote(a['href'].replace('/wiki/',
    ''))) 
    except: 
    pass

There are a lot of Wikipedia pages that are mostly links to other pages. To find ones for your interests, try searching "outline," "portal," "history of," "index of," and "list of". For general topics, there are five levels of "vital articles", with a larger number at each level. I took all of the level 4 articles plus extras in my areas of interest.

Example usage:

./get-articles-list.py >articleList </span>  History_of_computer_science </span>  History_of_philosophy </span>  Index_of_computing_articles </span>  Index_of_language_articles </span>  List_of_philosophical_concepts </span>  List_of_language_families </span>  Outline_of_chess </span>  Outline_of_computer_science </span>  Outline_of_computing  
    Outline_of_linguistics </span>  Portal:Free_and_open-source_software </span>  Portal:Visual_arts </span>  wikipedia:Vital_articles/Level/4/Arts </span>  wikipedia:Vital_articles/Level/4/Biology_and_health_sciences
    </span> 
    wikipedia:Vital_articles/Level/4/Everyday_life </span>  wikipedia:Vital_articles/Level/4/Geography </span>  wikipedia:Vital_articles/Level/4/Mathematics </span>  wikipedia:Vital_articles/Level/4/People </span>  wikipedia:Vital_articles/Level/4/History </span>  wikipedia:Vital_articles/Level/4/Philosophy_and_religion </span>  wikipedia:Vital_articles/Level/4/Society_and_social_sciences
    </span> 
    wikipedia:Vital_articles/Level/4/Technology

This will run pretty fast, since it only needs to query the pages you specify. I edited the resulting articleList file to add every Wikipedia article in my browser history/bookmarks and remove some that seemed unlikely to be useful.

The last step is to run mwoffliner. This can take hours depending on the size of your list.

mwoffliner </span>
     -mwUrl=https://en.wikipedia.org/ </span>  --adminEmail=foo@bar.net </span>  --articleList articleList </span>  --format nopic

The resulting zim file will appear in a directory called out. You can load it into Kiwix and finally have, if not a library, a fantastic collection of information available offline.

A bonus I found is that the "random article" button for my offline Wikipedia subset is much more useful than the one on full Wikipedia. The latter usually takes you to something like "Lands administrative divisions of New South Wales", whereas the former generally results in something of interest to me.

How to Calculate Resonance

2022-12-20T00:00:00

Since developing AcousticGender.space, a lot of people have asked me how the resonance calculation works.

The brief explanation is that the system finds the formants in each vowel sound. Then it measures how high or low they are compared to the average for that vowel. The higher they are, the higher the resonance score, with with F₁ counting for about three times as much as F₂ and F₃ counting for little-to-nothing.

Formants are bands of concentrated energy in the sound spectrum. They're created by sound waves bouncing around as they move through a passage, such as a vocal tract. The smaller the psasage, the more they bounce around and the higher the frequency. The base frequency of the sound is called F₀, or pitch. The first formant above F₀ is called F₁, the second is called F₂, etc.

For my Master's project, I wrote a formal definition with math that looks like this:

However, the notation makes it look way more complicated than it actually is. It's really just high school-level statistics.

Walking through an example, in the "please call Stella" example recording, the formant frequencies you get from Praat for the "a" in "call" (= /ɔ/) were

F₁: 620Hz F₂: 1077Hz F₃:
    3079Hz

Given that, can we find how far above or below the average for an /ɔ/ each of those values are. The unit we use is standard deviations (σ).

F₁: 620Hz vs average 612Hz = 0.053σ = just barely above
    average for an /ɔ/ F₂: 1077Hz vs average 1097Hz = -0.042σ = just barely below average for an
    /ɔ/ F₃: 3079Hz vs average 2522Hz = 1.234σ = above average for an /ɔ/

Now, each of the three formants aren't equally significant to how we perceive gendered resonance. So we have to multiply each normalized frequency by a certain a certain constant "weight". The set of weights that that most accurately distinguished between male and female recordings in a sample dataset was:

F₁: 0.732 F₂: 0.268 F₃:
    0.000

So the weighted average is

 0.732 × 0.053 + 0.236 × -0.042 + 0.000 × 1.234 =
    0.027

I didn't realize in advance that the weight for F₃ would be zero, so it could also be considered a weighted average of just F₁ and F₂. However, using different data or outlier removal schemes can change this so that F₃ has a small but non-zero value, so who knows.

Now, the number 0.027 is on a scale where 0 is the average, 1 is moderately above average, and 2 is far above average. For below average, it's the same but the numbers are negative. So at 0.027, the resonance in this recording is slightly above average. Technically we can stop there, but I thought people would find it easier to think of 50% as the average, 75% as above average, and 100% as far above average. For that to be the case, we just add 2 to each result, then divide by 4 and multiply by a hundred.

(0 + 2) / 4 × 100 = 1/2 × 100 = 50% (1 + 2) / 4 × 100
    = 3/4 × 100 = 75% (2 + 2) / 4 × 100 = 4/4 × 100 = 100%

So, the percentage for 0.027 is:

(0.027 + 2) / 4 × 100 =
    50.68%.

That's for a single syllable. When you're not playing back a clip, the application shows you the median resonance across every syllable – that's typically what you want to focus on, especially when starting out.

One Brain, Two Minds

2022-01-15T00:00:00

This is a post I made in the forum of my Spring 2021 class on Language Processing in Humans and Machines. It was be written late at night while I felt enlightened after finishing an assigned reading – as a result, it should be taken with a grain of salt.

The paper in question was Connectionism and cognitive architecture: A critical analysis, a 1988 critique of connectionism by Jeremy Fodor and Zenon Pylyshyn. Connectionism was then a popular theory viewing cognition in humans as fundamentally similar to computations done in neural networks. Fodor and Pylyshyn argued that some of the brain's capabilities could only be explained if it was doing symbol processing in the manner of classical Turing machines.

I just finished the Fodor and Pylyshyn reading, and throughout I was pre-occupied with one idea that was only addressed briefly at the end: the possibility that a connectionist and classical models of cognitive processing could co-exist in the same brain. F&P mention throughout the paper that connectionist models could serve as an implementation for a classical architecture / Turing machine. Only at the very end, they suggest that

A good bet might be that networks sustain some cognitive processes as can be analyzed as the drawing of statistical inferences; as far as we can tell, what network models really are is just analog machines for computing such inferences. Since we doubt that much of cognitive processing does consist of analyzing statistical relations, this would be a quite a modest estimate of the prospects for network theory compared to what the connectionists themselves have been offering.

This possibility seems much more significant today, where we can see that neural nets can do all sorts of tasks, and the question is whether they can do everything the brain can do. Supposing that they can't, it still seems plausible that brains use a network-like architecture for many tasks in addition to a neurally-implemented Turing machine that handles what networks can't. The answer to the question of "how do you combine them?" mentioned in Monday's lecture then might simply be "you don't." The network system doesn't have access to symbols, and the symbolic system doesn't have access to nodes. There would be, essentially, two largely-independent minds in one brain.

Indeed, a lot of people have the intuition that the brain has two systems, one of which is precise and methodical and the other of which is more fuzzy and intuitive. In pop psych these are called the left and right sides of the brain. We know that these systems aren't actually divided in the brain this way, but it's conceivable the mythology reflects some real aspect of how the brain works. In Thinking Fast and Slow, Daniel Kahneman talks in similar terms about how human behavior can be understood in terms of a fast, automatic "system one" and a slow, logical "system two." The existence of two systems explains why almost everyone has intuitions like "if 2 chickens can lay 2 eggs in 2 days, 4 chickens can lay 4 eggs in 4 days" even though we can pretty easily work out that it's wrong. The fast, associationist system gives the wrong answer before the slow, methodical system gives the right answer. That would make perfect sense if system one were a massively-parallel neural network and system two was a serial Turing machine (at some level of representation).

This would also seem to explain certain observations about language processing if we suppose that both systems are involved in overlapping but disconnected language-related tasks. For instance, Rumelhart and McClelland gave the example of "The man the boy the girl hit kissed moved" to show that we have trouble understanding the deep recursive structures that the classical model says are so important. However, even though most people would fail to comprehend this sentence on the first pass, we can understand it if we think about it a little longer. Again, this makes sense if we suppose that the "first pass" is carried out by a fast, connectionist-like neural architecture and the second is carried out by a slow neural Turing machine. This would also explain why the different levels of language processing seem to happen in parallel even though we have trouble formulating rules that work on a partial input: first-pass processing is done with a parallel architecture, while the rules are carried out on a serial one.

The presence in the brain of a slow, rule-based system for processing language might also enable the network-based system to do more with less data. The systems could be independent of each other in terms of their representations, but could potentially take as input the output of the other system. This would enable the rule-based system to generate valid sentences which could be fed as input to the network system, allowing it to get really good at quickly performing most, but not all, language-related tasks. (I'm not sure if a two-system model of cognition could explain the data problem on other tasks, though.)

This also seems consistent with biological evolution. A connectionist network can do some useful tasks with just a few neurons, so it's easy to imagine a mutation creating a proto-brain of just a few neurons that grew over many generations, to the point where it was large enough to implement a Turing machine (in addition to its other functions). By contrast, if the brain were just a Turing machine, it's hard to imagine how it would evolve from more rudimentary structures, especially without maintaining any residual functions.

If the human brain in particular evolved to implement a Turing machine, that would also explain the leap between what human brains can do and what other animals can do. A chimp's brain doesn't seem all that different from a human brain, but no matter how hard we've tried, we can't teach a chimp to use recursive syntactic structure. That would make sense if human brains have, and chimp brains lack, a system that fundamentally works by processing symbols according to recursive constituent relations.

Likewise, my understanding is that humans started to do all the things we associate with our cognitive sophistication over animals—like language, religion, art, technological development—at around the same time on an evolutionary scale. That too would make sense if all of those things are a result of the ability to process symbols, which appeared all at once when the human brain evolved to implement a Turing machine.

Fodor and Pylyshyn claimed that it's implausible that human cognition is systematic and the cognition of other animals is not. However, I wasn't convinced by their argument. They state:

It is not, however, plausible that only the minds of verbal organisms are systematic. Think what it would mean for this to be the case. It would have to be quite usual to find, for example, animals capable of representing the state of affairs aRb but incapable of representing the state of affairs bRa.

I don't find it at all obvious that this isn't usual among non-human animals, at least if I'm understanding what's being said correctly. I've heard that Galapagos tortoises don't fear larger animals (like humans) because they don't have any natural predators. It seems reasonable to suppose, then, that they can't conceive of something eating a tortoise. However, presumably they can conceive of a tortoise eating something else, seeing as they haven't all starved by now.

I've since learned that the idea I proposed here is known as "Dual Process Theory." A TA referred me to this paper which makes similar arguments more formally, and with reference to cognition in general more than just language.

No One is “Non-Technical”

2022-01-15T00:00:00

As I've been searching for jobs, I've noticed that many postings list as a requirement the ability to communicate with "non-technical" people. While it's important for those with certain technical expertise to be able to communicate their ideas to those without it, this goal is not helped by characterizing some people as "non-technical."

First off, many supposedly "non-technical" people in fact have advanced technical skills – just ones that don't concern computers. Someone who can repair cars is still very technically capable even if they don't know how to send an email. There's nothing special about computers that makes people who understand them uniquely capable, important, or "technical".

Even if we take "technical" as referring narrowly to computer skills, almost everyone in a modern workplace is technical at some level. If you know what a file is, that's a technical skill – one that many people lack. To be sure, some people have more computer skills than others – but it's a difference of degree, not of kind. When you're trying to communicate technical ideas, not everyone who you might consider "non-technical" is at the same level. An octogenarian just learning to send a text message is different from an Art History PhD who recently got into Digital Humanities is different from that kid in the "what's a computer" commercial. Communicating with these three "non-technical" people is likely to require different strategies.

Furthermore, calling people "non-technical" underrates their ability to learn. We're all at a certain level of technical proficiency, and we all have the potential to reach a higher one. Some people are discouraged from doing so because they think of that they're not "technical" – that they're not "computer people." But in fact, there are no "computer people." There are only regular people who accumulated bits of computer knowledge little by little – sometimes from being taught in school, but more often from facing their own computer problems with the confidence and will to learn. Far too many people lack that confidence because they learn to think of themselves as "non-technical." It's true that not everyone has time or energy to devote specifically to learning about computers – and they shouldn't have to. However, anyone who uses computers at all will at times encounter organic opportunities to learn: we should avoid encouraging people to squander these in a fit of learned helplessness.

When we explain a technical concept to someone who lacks some of the requisite background, we should do so in a way that facilitates their own technical growth. This requires us to recognize that everyone is a technical person – some of us are just at different places in our journey than others.

Using Code to Intuit the Monty Hall Problem

2020-06-23T00:00:00

The Monty Hall problem is a famous puzzle that shows how statistical facts can be unintuitive. It's based on a game show in which the contestant selects one of three doors, receiving whatever prize is behind it. One door has a desirable prize behind it, which is usually a car, and the others have a gag prize, usually a goat. My father told me about this problem when I was probably under 10, and at the time I neither understood the math, nor why anyone would want a car when they could have a goat. So for the rest of this article, assume that the preferred prize is a goat, and the others are, say, bags of sand.

Anyway, after the contestant selects a door, the show host (originally named Monty Hall) opens another door, revealing a bag of sand. The contestant then has the option to switch to the remaining door. The question is: Is it better to switch or does it make no difference?

The answer, as you may have heard before, is that it's better to switch, because the probability of getting the goat when you initially pick a door is ⅓, which doesn't change until you switch. This is confusing, however, because it seems like after the host shows you the bag of sand, there's one door with a goat behind it, and one door with sand behind, so the probability of winning should be ½, regardless of which door you pick. There are a zillion articles explaining why this isn't the case, which comes down to the fact that this is a conditional probability, not just a choice between two random options. However, depending on your background, you may have a better intuition for code than for math, in which case the easiest way to understand the problem is by seeing it as a program.

Take the following Python script. If you're new to Python, don't be intimidated by the list comprehensions, which is where you have fors and ifs inside brackets: they are not hard to understand and they will make your life much easier if you learn to use them.

import random, statistics  def simulate(switch):  """Return True if the contestant wins the goat, False
    otherwise."""   #
    Shuffle the doors and pick one at random  doors
    = ['goat', 'sand', 'sand']
    
    random.shuffle(doors)  choice = random.randint(0, 2)   # Pick
    one of the doors with sand behind it to show   remaining_sand = [i for i in range(3) if doors[i] == 'sand' and i != choice]
     shown = random.choice(remaining_sand)   # If
    switch is selected, switch choice to the remaining door  if switch: choice = [i for i in range(3) if not i in (choice, shown)][0]    return doors[choice] == 'goat'  trials = 100000 print("Switch: ",
    statistics.mean([simulate(True) for i in range(trials)])) print("Stay: ",
    statistics.mean([simulate(False) for i in range(trials)]))

Run the program, and we see that indeed, you win twice as often if you switch than if you stay:

Switch: 0.66462 Stay:
    0.33362

But we already knew that. However, the key insight is on line 16:

if switch: choice = [i for i in range(3) if not i
    in (choice, shown)][0]

This is the line that changes the choice to the remaining door. If switch is False, it won't run. Comment out line 16, and your IDE or your linter will tell you something like this:

monty-hall.py:13:4: W0612:
    Unused variable 'shown' (unused-variable)

When the contestant doesn't switch, the information provided by opening the door isn't used at all. In fact, the Python VM will probably skip over the lines computing shown because it's not used. In other words, choosing not to switch is exactly the same as picking randomly from three options.

I decided to write this article because after writing the problem in code, the answer seemed completely obvious. Before, I was sort of able to understand the standard stats textbook explanation, but the answer still seemed sort of opaque. Hopefully, there will be a few other people out there to whom code is a more native language than math who will find this as clarifying as I did.

A Better Solution for Married Surnames

2020-06-19T00:00:00

In my country, tradition dictates that when a couple gets married, the woman takes her husband's last name, which is also passed on to any children they might have. This has two benefits:

You can usually refer to a household by name, as in: "let's invite the Tooks and the Baggins' for dinner."
You can sort of use it to trace your patrilineal ancestry.

However, it has a bunch of problems:

It's associated with the now widely-rejected idea that the man is supposed to be the head of the household.
Not every marriage has a man and a woman anymore.
Changing your last name may be detrimental in certain careers.
Over time, it results in fewer and fewer last names, because a surname goes extinct if there are no male children to carry it. This has had a particularly strong impact on China, where people have had names like "Li" or "Zhang" since at least 2,500 years ago, which was before the West even had surnames, let alone settling whether they would be Latin or Greek. Thus, Chinese names have had more time to go extinct, which is why I ended up calling both of my Chinese teachers in school Li lăoshi¹.

Some people have taken to hyphenating their last name with that of their spouse. This is probably more egalitarian and mitigates the career damage that comes with a name-change. However, it has the serious issue that it gets unreasonable over multiple generations. For instance, if Alice Abrams and Bob Bell get married and name their daughter "Carol Abrams-Bell," that works fine. But what happens when Carol marries Frank Delaney-Edwards? They could proceed recursively and adopt the name Abrams-Bell-Delaney-Edwards, but that's monstrous. Alternately they could follow the Iberian tradition and use the first name from each pair, yielding Abrams-Delaney. But that has the same problem as the traditional system: half the names get lost.

But this problem is inevitable, isn't it? Everyone has 4 grandparents, 8 great-grandparents, and 2ⁿ⁺² great₁-great₂…great_n-grandparents. You can't share a name with all of them. So at some point one parent's name has to predominate, right?

Wrong. There's a way for everyone to share a name with both of their parents, their children, and their spouse. Just follow these rules:

When a couple gets married, they invent a new name.

Romeo Montague and Juliet Capulet get married. When he's giving the vows, Friar Lawrence asks them "What will be the name of this union?" Together they answer "Starcross."
This name gets added to their current last names with a hyphen.

"Romeo Montague-Starcross" and "Juliet Capulet-Starcross"
When a couple has children, they inherit only the new name.

This is an alternate reality where Romeo and Juliet act much more sensibly, so they survive and have a child, whom they decide to name after the Friar who married them. The child is thus named "Lawrence Starcross"

This means you won't share a name with your grandparents, but you already don't share a name with half of your grandparents, so surnames were never a very meaningful reflection of your family beyond one generation anyway. Furthermore, since each child's name carries a "reference" to their parent, you get a "linked list" tracing your ancestry matrilineally and patrilineally.

Here, suppose that Alice and Bob decided to make their household name a combination of their original names (another good solution, with which this is "backwards-compatible"). However, Frank was so turned off by this that he decided not to marry Carol, who was then so upset that she teleported through time and space to 16th-century Verona and married Lawrence Starcross. Realizing that they both had incredibly un-Italian names, they then decided that their household name would reflect their home, and their child would be named "Antonio."

This solution combines the benefits of both the traditional and hyphenated systems. Like the traditional system:

It preserves household names (even distinguishing between the households of male siblings!)
It allows tracing ancestry, in a less direct but more complete way.

Like the hyphenated system:

It's egalitarian.
It keeps a reasonable number of different names in usage.
It doesn't require anyone to abandon their own family name.
It signals that you're the type of person to break with tradition. (Which may or may not be desirable)

Finally, it has several unique benefits:

It gives people more choice over their own name
It's a gender-neutral way of indicating marriage status. Eg. Miss vs. Mrs. indicates whether a woman is married, but there's no equivalent for men. If this system were widely-adopted, a hyphen would mean married, and no hyphen would mean unmarried.

Assuming that you're willing to accept that you won't share a name with one of your 32 great-great-great-great-grandfathers, I can think of three disadvantages:

Hyphenated names are slightly more cumbersome and could be mistaken for a middle name plus a last name when pronounced.
You'd end up with "fad" family names. For instance, you can imagine that many couples who married in the year 2000 might have decided to choose the name "Millennium." This isn't necessarily bad, but I don't personally like the sound of it, and I hope that people would try to choose unique names.
Both partners would "have to" go through the bureaucracy of adding to their name. This would preferably be mitigated by reducing the amount of bureaucracy required, but I wouldn't hold my breath on that.

I am not married and do not intend to marry anytime soon. However, if I ever do, I hope to convince my partner to go along with this idea. In the unlikely event that this article convinces you and you go along with it, please let me know! My preferred email address can always be found on my résumé.

In Chinese, you address your teacher by their family name + lăoshī (老师), which means "teacher".↩︎

How to Pronounce “th” in English

2020-05-19T00:00:00

In my article on French vowels, I explained how different languages have different phonemes, giving the example of how native French speakers have trouble with the "th" sounds while learning English. In fact, these sounds are quite unusual cross-linguistically, appearing in only about 4% of the world's languages —so they give trouble to a huge number of English second-language learners, not just the French. I'm a native English speaker, so I don't remember learning to pronounce these sounds as a toddler —but I thought it would be an interesting phonetics exercise to try and describe their pronunciation. I refrained from publishing this until I heard back from one of my French friends that this was helpful to them, so hopefully it will be to others as well.

The first thing to understand is that there are actually two 'th' sounds in English. Although most English speakers aren't aware of the difference, they can tell between the words "thigh" (part of the leg) and "thy" (an old-fashioned way of saying "you").

The 'th' in "thigh" is /θ/ in IPA.
The 'th' in "thy" is /ð/ in IPA.

I'll explain the difference later, but let's start with /θ/

When non-native speakers don't know how to make this sound, they usually produce a /f/ or a /s/ instead: eg, they'll sometimes say "fink" or "sink" instead of "think." This isn't arbitrary: they choose these sounds because they are both fricatives, just like /θ/. A fricative is a sound that's made by making a closure between two parts of the mouth and letting out a small stream of air.

When you make an /s/, you touch the tip of your tongue to the alveolar ridge (the little bump on the top of your mouth behind the teeth). Hold the /s/ in "yessssssss—". You will feel how you are releasing a little bit of air between your tongue and the roof of your mouth.

Now try the same thing with /f/. You make an /f/ by touching your front teeth to your bottom lip. Now if you hold the /f/ in "stufffffff—", you'll feel how you are letting the air pass between your lip and your teeth. Notice that a little bit of air also goes around the sides of your teeth.

/θ/ is the same, only instead of making the closure with your teeth and your lips, you make it with your teeth and your tongue. To make the /θ/, touch the tip of your tongue to your two front teeth. Then blow a little air between your teeth and your tongue, just as you do to make an /f/, just substituting the lips for the tongue. The opening of your mouth should not be too wide, or else all the air will go around and not between the tongue and the teeth. However, you should have a little opening at the sides of your mouth, or else the sound will not be loud enough. Once you're doing this, you should be able to transition to saying "—thhhhhhhhigh."

/ð/ is exactly the same, only you also vibrate your vocal folds. To understand what this means, put your hand on your neck. Then hold a /v/ sound as in "slavvvvvvvvvvvv—" you will feel a vibration in your nest. Now do the same thing but holding /f/, like in "struff". You'll notice that you don't feel the same vibration in your neck when you make the /f/ sound.

Linguistics call this property voice. Languages differentiate between sounds depending on whether they are voiced or not. /v/ is the voiced version of /f/, /z/ is the voiced version of /s/, /d/ is the voiced version of /t/, etc.

To learn how to control the voicing, try to transition between a /s/ sound and a /z/ sound. They are exactly the same except for the voicing. Keep your hand on your neck and go "ssssssss zzzzzzzzs ssssssss zzzzzzzz." As you do this you can become conscious of how your vocal folds are vibrating.

To make a /ð/, try and hold a /θ/. A good word that ends with this is "bathhhhhh—". Now, as you hold the /θ/ sound, start vibrating your vocal folds, the same way you did as you transitioned from /s/ to /z/. If you do it, you'll be making the /ð/ sound and you can transition to "—thhhhhy"

Some words that use /θ/ (voiceless): think, thanks, thunder, thirsty, thumb, throw, theory, throat, bath.

Some words that use /ð/ (voiced): this, they, father, weather, bother, bathe.

As is often the case in English orthography, there is to my knowledge no way to determine the sound from the spelling of the word. However, now that you know the IPA for each sound, you'll at least be able to tell from the pronunciation guides in dictionaries.

Writing BMP Images from Scratch

2020-03-28T00:00:00

Many of my programming projects revolve around making pretty pictures or turning them into websites. Recently, however, it occurred to me that I've never worked with a raster graphics file directly. At the lowest-level, I've always just manipulated an RGB array in memory, then called out to some library to handle saving my work.

This thought made me a little uncomfortable. The way I used computers was completely overturned once I came to understand the underlying text representation that makes up web pages, config files, source code, etc. What if understanding binary data representations is just as important?

Thus, I decided it was time to write a program that could produce images from scratch. This meant using a language without a runtime, that's good for manipulating bytes directly, and which I already needed to brush up on anyway: C. I went with BMP as an output format. There are a few even simpler formats, like TGA, but since I'm writing a blog post, I thought I might as well go with something viewable in a browser.

For the impatient, here's the end product. For everyone else, let's walk through the problem together.

Dissecting a BMP

Before we begin coding, let's start by looking inside an existing BMP file. Here's the one we'll be starting with:

Ok, maybe that's too hard to see. Let's scale it by 50x:

Yes, this is just a 1x1 pixel image with RGB color (239, 65, 53). I made it in GIMP, making sure to check "Do not write color space information" in the export dialogue.¹ Now, let's look inside the file with cat and see how it's made:

$ cat 1x1.bmp BM:6(#.#.5A�

Oh yeah. This is a binary file. So to see inside it, we'll need a different tool. For this, let's use the command xxd. This will show us the byte data of a file in hexadecimal format. We'll use the -g 1 flag to group the data in 1-byte groups:

$ xxd -g 1 1x1.bmp  00000000: 42 4d 3a 00 00 00 00 00 00 00 36 00 00 00 28 00
    BM:.......6...(. 00000010: 00 00 01 00 00 00 01 00 00 00 01 00 18 00 00 00
    ................ 00000020: 00 00 04 00 00 00 23 2e 00 00 23 2e 00 00 00 00
    ......#...#..... 00000030: 00 00 00 00 00 00 35 41 ef 00
    ......5A..

This is better, but how do we read it?

The most import part is in the center, starting with 42 4d… and ending with …ef 00. This is the byte-data of the file in hexadecimal format. As a reminder, hexadecimal is a base-sixteen representation of a number using a-f for the digits after 9. Some people can easily convert between hexadecimal and decimal in their heads, but for the rest of us, there's printf. Let's convert the 42 and 4d to decimal:

$ printf "%d" 0x42
    66 $ printf "%d" 0x4d
    77

These numbers are the ascii codes for 'B' and 'M', which appear at the start of every BMP file to indicate its format. You'll notice that these letters also appear on the right-hand side of the xxd output: it's just a representation of the same data in ascii. We won't need to worry about it too much, since most of our data is not in ascii format. Finally, on the left-hand side, we have 000000xx:. These are just the indices in hexadecimal. There are 16 columns in each row of bytes, so the numbering increases 0x10 in each row.

Now that we know how to read the xxd output, let's try and interpret the byte data. In principle we should be looking at the specification, but that will be boring… so lets just go to the Wikipedia article, which tells us that every BMP file starts with a 14-byte header. Let's mark that in blue:

 42 4d 3a 00 00 00 00 00 00
    00 36 00 00 00 28 00 00 00 01 00 00 00 01 00 00 00 01 00 18 00 00 00 00 00 04 00
    00 00 23 2e 00 00 23 2e 00 00 00 00 00 00 00 00 00 00 35 41 ef 00

The middle of the file is a little complicated, so for now let's skip to the last part: the pixel array. Each pixel is three bytes, one for each color. Since BMP is a Microsoft format and Microsoft likes doing things backwards, the order of the bytes is normally Blue, Green, Red, starting at the bottom-left pixel of the image. Each row of pixels gets zero-padded to a multiple of four bytes. We have one row of one pixel, so it will be three bytes padded to four. Thus, our pixel array will by the last four bytes of the file. Let's just confirm that 35 41 ef matches the colors we chose at the beginning: which were (239, 65, 53)

$ printf "%d %d %d" 0x35 0x41
    0xef 53 65 239

Great, it matches. Not coincidentally, this is the color we get if we add color: #ef4135 in CSS. Let's use it to mark the pixel array in our xxd output:

    42 4d 3a 00 00 00 00 00 00 00 36 00 00 00 28 00 00
    00 01 00 00 00 01 00 00 00 01 00 18 00 00 00 00 00 04 00 00 00 23 2e 00 00 23 2e 00 00 00 00 00
    00 00 00 00 00 35 41 ef 00

In-between the header and the pixel data, we have 40 bytes. This matches the size of a DIB header in BITMAPINFOHEADER format, so it's probably safe to assume that this is what we have. Let's mark it in green:

 42 4d 3a 00 00 00 00 00 00 00 36 00 00 00 28 00 00 00 01 00 00 00 01 00 00 00 01 00 18 00 00 00 00 00 04 00 00 00 23 2e 00 00
    23 2e 00 00 00 00 00 00 00 00 00 00 35 41 ef
    00

Great. Now that we've got a basic understanding of the format, let's lay the groundwork for our C code.

Starting with C — The BMP Header

Let's try and write a program that will output an identical 1×1 BMP file. Here's what we'll start with:

#include
     #include
     int main() {   // Make
    an array containing the B and M characters that  //
    identify the file as a BMP.  char tag[] = { 'B', 'M' };   FILE 
    fp = fopen("test.bmp", "w+"); // Open a file for
    writing  fwrite(&tag, sizeof(tag), 1, fp); // Write the tag to the file  fclose(fp); // Close the file }

If we run this now, it will output the first two bytes of the BMP header. Let's add the rest. According to Wikipedia, the rest of the header consists of:

4 bytes The size of the BMP file in bytes

4 bytes Reserved; actual value depends on the application that creates the image

4 bytes The offset, i.e. starting address, of the byte where the bitmap image data (pixel array) can be found.

We'll figure out how to calculate the size and offset later. But for now, let's just copy what we got from the xxd output.

00000000: 42 4d 3a 00 00 00 00 00 00 00 36 00 00 00 28 00 BM:.......6...(.

These are all integers, so we'll add a new int array to our C code and write it to the file. To represent a hexadecimal number in C, you put 0x before it. Note that we write 0x3a rather than 0x0000003a because the file data is stored in little-endian format, where the least-significant bit comes first, whereas in C, we write the hex numbers in big-endian format. If this is confusing, think about how dates are written differently in various parts of the world. Europeans write dates in Day-Month-Year format, where the smallest unit comes first. The Chinese, by contrast, write dates in Year-Month-Day format, where the biggest unit comes first.² The dates are the same, whether it's 03-28-2020 or 2020-28-03; the former is just in big-endian and the latter in little-endian. The same is true with hex numbers: 0x3a000000 in little endian equals 0x0000003a in big endian.

#include
     #include
     int main() {  char tag[] = { 'B', 'M' };   //
    Create an integer array for the header   int header[] = {  0x3a, // File Size
     0x00, // Unused
     0x36 // Byte offset of pixel
    data  };   FILEfp = fopen("test.bmp",
    "w+"); 
    fwrite(&tag, sizeof(tag), 1, fp); 
    fwrite(&header, sizeof(header), 1, fp); // Write the header to
    disk  fclose(fp);
    }

The DIB Header

Great. Now that we've made our way through the BMP header, we need to write the DIB header. This will specify more information needed to display the image. It can be in various formats, but we saw above that we're using the 40-byte BITMAPINFOHEADER. So again, let's check each field against our xxd output:

 42 4d 3a 00 00 00 00 00 00 00 36 00 00 00 28 00 00 00 01 00 00 00
    01 00 00 00 01 00 18
    00 00 00 00 00 04 00 00 00
    23 2e 00 00 23 2e 00 00 00 00 00
    00 00 00 00 00 35 41 ef 00

4 bytes - The size of this header, in bytes: 28 00 00 00.
- This is 40 bytes in hexadecimal. Our header will remain the same length.
4 bytes - The bitmap width in pixels: 01 00 00 00
4 bytes - The bitmap height in pixels: 01 00 00 00.
- Instead of copying directly, we should output width and height variables.
2 bytes - The number of color planes (must be 1): 01 00
2 bytes - the number of bits per pixel: 18 00
- We will combine these into a single integer so that we can store it in the same array.
4 bytes - The compression method being used: 00 00 00 00
- 0 means no compression
4 bytes - The image size (in bytes): 04 00 00 00
- This is actually ignored for images without compression, so we can just use 0.
4 bytes - The horizontal resolution of the image: 23 2e 00 00
4 bytes - The vertical resolution of the image: 23 2e 00 00
- As far as I can tell, these only matter for printing. We'll just use what Gimp gave us.
4 bytes - the number of colors in the color palette, or 0 to default to 2ⁿ: 00 00 00 00
4 bytes - the number of important colors used, or 0 when every color is important; generally ignored: 00 00 00 00

Adding all of these to our C code, we get:

#include
     #include
     int main() {   int width = 1; // Keep these in variables, since  int height = 1; // they'll change later.   char tag[] = { 'B', 'M' };  int header[] = {  0x3a, 0x00, 0x36,  0x28, // Header
    Size  width, height, // Image dimensions in pixels  0x180001, // 24 bits/pixel, 1 color
    plane  0, // BI_RGB no
    compression  0, // Pixel data size in
    bytes  0x002e23, 0x002e23, // Print resolution  0, 0, //
    No color palette  };   FILE 
    fp = fopen("test.bmp", "w+");  fwrite(&tag, sizeof(tag), 1,
    fp);  fwrite(&header, sizeof(header), 1, fp);
      fclose(fp);
    }

The Pixel Data

Finally, we need to output an array of pixels. Recall that each pixel is represented by its B, G, and R values, and each row is padded to a multiple of 4 bytes. Since we have one pixel, that means we'll be outputting an array of 4 bytes.

#include
     #include
     int main() {  int width = 1; 
     int height = 1;
     char tag[] = { 'B', 'M' };  int header[] = {  0x3a, 0x00, 0x36, 0x28, width, height,
    0x180001,   0, 0, 0x002e23, 0x002e23, 0, 0   };   //
    Store as char array, because we want each value to take up  // one
    byte.  char bitmap[] = {  0x35, // Blue
     0x41, // Green
     0xef, // Red
     0x00 // Padding
     };   FILEfp = fopen("test.bmp",
    "w+"); 
    fwrite(&tag, sizeof(tag), 1, fp); 
    fwrite(&header, sizeof(header), 1, fp);  
    fwrite(&bitmap, sizeof(bitmap), 1, fp); 
    fclose(fp); }

Alright, now let's run the program and see what we get:

Yay! Let's try and change the color:

char bitmap[] = {  0xa4, // Blue
     0x55, // Green
     0x00, // Red
     0x00 // Padding
    };

Hurrah!

Generalizing

Ok, so now we know how to output a valid BMP file. But sometime we might want to output a different image, maybe even one with more than one pixel. So let's refactor our main into a function that outputs a given RGB array to a file.

The pixel data is stored in a 1D array – this might seem counter-intuitive for a 2D image, but it's the normal way of handling pixel data in computer graphics, because it's more efficient and saves us from having to deal with pointers to arrays. Since the pixel data is 1D, in addition to passing its length as an argument (as C doesn't automatically track array lengths), we also need the width of the image so we know where each new row starts.

void write_bmp(char 
    filename, char rgb[], int length, int width)
    {   //
    Calculate the image height from its width and the array length
     int height = (length / 3) /
    width;   // The
    size of the pixel data. For now, use width + 1 to handle   // row
    padding.  int bitmap_size = 3height *
    (width + 1);   //
    The pixel data is now variable-length, so we need to use  //
    malloc.  char 
    bitmap = (char) malloc(bitmap_size * sizeof(char));
      //
    Zeroing out the data will set all the pixels to black.  for (int i = 0; i < bitmap_size; i++) bitmap[i] = 0;   char tag[] = { 'B', 'M' };  int header[] = {  0, // File size... update at the
    end.  0, 0x36, 0x28,  width, height, // Image dimensions in pixels   0x180001, 0, 0, 0x002e23, 0x002e23, 0, 0,  };  //
    Update file size: just the sum of the sizes of the arrays  // we
    write to disk.  header[0] = sizeof(tag) + sizeof(header) + bitmap_size;   FILE 
    fp = fopen(filename, "w+");  fwrite(&tag, sizeof(tag), 1,
    fp);  fwrite(&header, sizeof(header), 1,
    fp);   //
    Malloc returns a pointer, so we no longer need to get the  //
    adress of bitmap  fwrite(bitmap,
    bitmap_sizesizeof(char), 1, fp);
     fclose(fp);
       free(bitmap);
    }

Now that we've got that, let's try calling it on an RGB array. For no particular reason, let's try and output this 3×2 pixel image:

int main() {  char fr[] = {  0, 85, 164, // Bleu
     255, 255, 255, // Blanc
     239, 65, 53, // Rouge
     0, 85, 164,  255, 255, 255,  239, 65, 53,  };  write_bmp("french_flag.bmp", fr, sizeof(fr) / sizeof(char), 3); }

Run that program and we get:

Ok, so we've got the dimensions right. Now all we need to do is copy the RGB data into the bitmap array in the correct order (BGR) and with the correct padding.

//
    Function to round an int to a multiple of 4 int round4(int x) {
     return x % 4 == 0 ? x : x - x % 4 + 4; }  void write_bmp(char 
    filename, char rgb[], int length, int width)
    {  int height = (length / 3) /
    width;   // Pad
    the width of the destination to a multiple of 4  int padded_width = round4(width3);    int bitmap_size = height * padded_width * 3;  char 
    bitmap = (char) malloc(bitmap_size * sizeof(char));
     for (int i = 0; i < bitmap_size; i++) bitmap[i] = 0;   //
    For each pixel in the RGB image...  for (int row = 0; row < height; row++) {  for (int col = 0; col < width; col++) {    //
    For R, G, and B...  for (int color = 0; color < 3; color++)
    {   //
    Get the index of the destination image  int index = row * padded_width + col * 3 + color;   //
    Set the destination to the value of the src at row, col.  bitmap[index] = rgb[3
    (rowwidth + col) + (2 - color)];
     }  }  }   char tag[] = { 'B', 'M' };  int header[] = {  0, 0, 0x36, 0x28, width, height,
    0x180001,   0, 0, 0x002e23, 0x002e23, 0, 0  };  header[0] = sizeof(tag) + sizeof(header) + bitmap_size;  FILE 
    fp = fopen(filename, "w+");  fwrite(&tag, sizeof(tag), 1,
    fp);  fwrite(&header, sizeof(header), 1,
    fp);  fwrite(bitmap,
    bitmap_sizesizeof(char), 1, fp);
     fclose(fp);
     free(bitmap);
    }

Alright, that should do it. Now lets write out some flags (chosen for simplicity):

int main() {   char fr[] = {  0, 85, 164, // Bleu
     255, 255, 255, // Blanc
     239, 65, 53, // Rouge
     0, 85, 164,  255, 255, 255,  239, 65, 53,  };  write_bmp("french_flag.bmp", fr, sizeof(fr) / sizeof(char), 3);   char bgm[] = {  0, 0, 0, // Black
     253, 218, 36, // Yellow
     239, 51, 64, // Red  0, 0, 0,  253, 218, 36,  239, 51, 64,  };  write_bmp("belgian_flag.bmp", bgm, sizeof(bgm) / sizeof(char), 3);   //
    Transgender Pride Flag  char 
    trans = (char) malloc(8 * 5* sizeof(char) * 3);  for (int row = 0; row < 5; row++)
    {  for (int col = 0; col < 8; col++)
    {  if (row == 0 || row == 4) {  trans[3 * (row * 8 + col)] = 91;  trans[3 * (row * 8 + col) + 1] = 207;  trans[3 * (row * 8 + col) + 2] = 250;  } else if (row == 1 || row == 3) {
     trans[3 * (row * 8 + col)] = 245;  trans[3 * (row * 8 + col) + 1] = 171;  trans[3 * (row * 8 + col) + 2] = 185;  } else { 
    trans[3 * (row * 8 +
    col)] = 255; 
    trans[3 * (row * 8 +
    col) + 1] = 255;  trans[3 * (row * 8 + col) + 2] = 255;  }  }  }  write_bmp("trans_flag.bmp", trans, 3
    58, 8);    //
    Flag of the United Arab Emirates  char 
    uae = (char) malloc(12 * 6* sizeof(char) * 3);  for (int row = 0; row < 6; row++)
    {  for (int col = 0; col < 12; col++)
    {  if (col < 3) {
     uae[3 * (row * 12 + col)] = 255;  uae[3 * (row * 12 + col) + 1] = 0;  uae[3 * (row * 12 + col) + 2] = 0;  } else if (row < 2) {  uae[3 * (row * 12 + col)] = 0;  uae[3 * (row * 12 + col) + 1] = 116;  uae[3 * (row * 12 + col) + 2] = 33;  } else if (row < 4) {  uae[3 * (row * 12 + col)] = 255;  uae[3 * (row * 12 + col) + 1] = 255;  uae[3 * (row * 12 + col) + 2] = 255;  } else { 
    uae[3 * (row * 12 +
    col)] = 0; 
    uae[3 * (row * 12 +
    col) + 1] = 0;  uae[3 * (row * 12 + col) + 2] = 0;  }  }  }  write_bmp("uae_flag.bmp", uae, 3
    612, 12);  }

And there we have it:

Limitations

This only produces uncompressed files. This is fine for the tiny images we're making: in fact, it beats most other formats in terms of disk usage at this size because of how little metadata we use. However, as the image size increases, we start to get very large file sizes: at 512×512, the output of this program is more than 100x the size of the same image converted to a lossless PNG. Thus, you wouldn't want to use this program as much more than a toy. Nevertheless, walking through a toy program can be a great way to learn.

Actually, I didn't realize to do this until after I had gone through these steps. But it makes everything simpler, so lets pretend I did it right the first time.↩︎
Incidentally, the Chinese date format is almost always the one you want to use in computing, because its the only one where the alphabetical sort gives the dates in-order.

The US date format doesn't make much numeric sense, and thus doesn't help understanding endian-ness, because it puts the second-smallest unit first.↩︎

Meal Plan Explained

2020-02-13T00:00:00

When I first arrived at Brown, I found the meal plans confusing. However, during my four years, I've finally figured out all the details. For anyone still confused, it's actually quite simple:

Meals at campus eateries can be paid for in Bear Bucks, Meal Points, Meal Credits, cash, credit, and traveler's checks. You may combine a maximum of three payment methods, which may not include both meal points and Bear bucks, except at the Ivy Room.

One credit can be exchanged for between $7.60 and $8.20 (or less) worth of food from a campus eatery. However you cannot exchange a credit for points at the Blue Room on Saturdays or on Wednesdays after 12am and before 4pm. Furthermore, you cannot exchange credits for points at any campus eatery except the V-Dub on days that fall within the first or last two weeks of a semester or that are designated as federal holidays, but not both. When a point is exchanged for credits, those credits must be used immediately, and any remaining credits are discarded, unless you use two or more credits in one swipe. Note that a "swipe" is distinct from a "transaction."

Students on a meal plan (excluding "flex" meal plans) receive the corresponding number of credits and points every Thursday. Unlike points, credits do not carry over between weeks, but they carry over between days. However, you may not use more than three credits within a 24-hour period. Therefore, if you are on a 20 meals/week plan, you can only use carried-over points on Sundays. Note that the 24-hour period is extended to 36 hours during reading period. This is the only time during which the Sharpe Refectory serves breakfast on Sundays, however, meal plan-holders are not given an additional credit for the extra meal.

Students may choose either a weekly or a "flex" meal plan. The twenty meals/week is available to all students throughout their four years at Brown, but not to fifth-year seniors. Of the remaining weekly meal plans, the 14 meals/week plan is offered to all students except freshmen, and the 7 and 10 meals/week plans to juniors and seniors, respectively. Of the flex plans, the flex 460 plan is available to freshmen, Flex 330 to sophomores, and Flex 240 to juniors and seniors, not respectively. Graduate students are allowed purchase a meal plan, but it is considered embarrassing. To determine the number of credits, points, and guest swipes provided in a given meal plan, consult the Dining services website at brown.cafebonappetit.com or dining.brown.edu. Note: the provided figures on these websites are not guaranteed to be accurate or to match one another.

Meal plans include between 2 and 5 guest swipes per semester per year (inclusive). Unlike ordinary credits, guest swipes may be used for a person other than the student on the meal plan. Married couples count as the same person for this purpose, but they require two guest swipes to be admitted to the Sharpe Refectory or the V-Dub. Brown University recognizes marriages performed in every country except the Czech Republic.

All campus eateries except the Blue Room are closed beginning at the first day of Spring break and ending on the day two-days before classes resume (not inclusive). Meal plans are not credited between the first Thursday of Spring break and the day before classes resume (inclusive). On odd-numbered years,¹ campus eateries are open one additional day before classes resume.

The Blue Room is open from 9am to 4pm on Mondays, Wednesdays and Thursdays and from 9am to 1pm on Fridays. On Tuesdays and Sundays, it's open from 10:30am to 9pm, and it is open all day on Sunday. Additionally, the Blue Room closes every 300 days not including Federal Holidays except Christmas, unless it falls on a Sunday or Monday, starting from July 2, 1776.

The meal plans of graduating seniors are terminated at 2pm on the day of their graduation. However, in special circumstances, students may receive a dean's note to extend their meal plan at most four days, but no fewer than two.

Muslim students in good academic standing may elect to cancel their meal plan for the month of Ramadan. They will be refunded by an amount posted in the University Chaplain's office up to four days before the start of Ramadan. Note that the amount may be, but is not necessarily, dependent on whether a student is receiving financial aid. This offer is extended to students who have not recorded themselves as Muslim in Banner, however they will be refunded by the same amount as students not receiving financial aid, regardless of their own status. Note also that Sikhs and Yazidis are considered Muslim for this purpose.

Every fortnight, the President of the College and zero or more representatives from Johnson & Wales University will meet at an agreed-upon location for secret coin-flip. If the result is "heads," then the cost of fruits and snack-foods will be synchronized between Josiah's and Andrew's. Otherwise, one of the two will have prices 20 cents higher than the other on an alternating basis.

Reminder: students should use the Hebrew calendar to determine the number of the current year, excepting Francophone Studies concentrators and students of the Eastern Orthodox faith, the former of whom may optionally use the French Republican calendar and the latter of whom are required to use the Julian Calendar.↩︎

Advice for College Students (Part 1)

2020-01-31T00:00:00

Last semester, I spent time with some first-years who, upon learning that I was a senior, asked me if I had any accumulated "wisdom" to share. At first I found this funny, but I've nevertheless reflected on the question and decided to record my thoughts.

college courses are not croissants

The items are arranged roughly in order of importance. Thus, this article has more high-level, philosophical sort of advice, some of which might seem obvious. You might want to jump right to part 2 if you're interested in more specifics.

Prioritize Learning Before Grades

Unless you study outside the U.S., college is an enormous expense. It might not be worth it if all you're getting out of it is a diploma. Yes, there are some schools and fields where degrees carry a lot of economic value. However, if you're studying something like literature at a mid-tier university or if you want to go into a field where a degree isn't required, you should primarily be in college because you love learning and want to grow as a person. If you succeed in this, college will be worth it.

I experienced High School mostly as an ordeal I had to get through so that I could go to a good college. Yes, a few classes, particularly in Art and English, impacted me in a deeper way, but many contributed to my personal and intellectual development about as much as the SATs. I checked my grades at least once a day, and on a few occasions I convinced my parents to let me stay home from school to have more time to study for tests. This approach is the exact opposite of what you should do in college. Unless you're planning to go to Law/Med School, college is not a means to end. It is a rare opportunity in life to spend several years working with the end-goal of improving yourself: take advantage of it. The letters on your transcript are of secondary importance.

Understand that the optimal strategies for maximizing grades are not necessarily the most effective for learning. For instance, when I was a TA in 2D Game Engines, a lot of students would turn in projects that were not very polished or engaging as games¹ but which technically met all the requirements for an A. They were acting completely rationally from the perspective of someone trying to optimize grades: any extra time spent on sprite animation or level generation could have been used studying for midterms. However, the students who "irrationally" chose to put in the extra work came out of the class knowing how to make great games that they could proudly include in a portfolio.

Some people will try to take easy classes because they're protective of their GPA. My school tries to deter this by giving students the option to take any class pass/fail, which I think is a great idea. But even if your school makes you take every class for a grade, you should still not take classes just because they will be easy. This is not only a bad way to learn, but it might not even work: sometimes the hard classes aren't what you would expect. For instance, I took Moral Philosophy because the subject interested me, but I didn't imagine that it would be very hard. However, I didn't do as well as I expected, partly because I still had a little of this guy in me.

If you take classes below your level and forget everything after tests, you might be able to leave college with a 4.0 GPA while having learned very little, but you would only be cheating yourself.

Go to class

This should be obvious, but it's important enough to be worth emphasizing.

Yes, there might be a few courses that you can pass without attending lectures. Many of my classmates in Software Engineering skipped class because the content wasn't needed to complete assignments, which constituted almost the entire course grade. However, the students who attended got more out of the class.

Besides the direct value of course content, the routine of going to class is incredibly valuable: it motivates you to do the work you need, and it gives you feedback on how well you're understanding the material. If you skip classes, you will end up sleeping during the day and just generally being dysfunctional.

Some classes might record lectures. Do not use this as an excuse to skip class: anytime you tell yourself that you'll watch the lecture capture, there's a high chance that you won't.

Read and annotate the assigned texts

Readings are the main homework in humanities classes. Skipping a reading is like deciding not to hand in a problem-set or a coding project. Also, understand that "reading" a text is not the same as "looking at it." Even if your eyes passed over some words, your brain may not have learned anything. This will become clear on the occasions when you have to read something like this:

When we come to the concomitant question of the consciousness of the subaltern, the notion of what the work cannot say becomes important. In the semioses of the social text, elaborations of insurgency stand in the place of 'the utterance'. The sender – 'the peasant' – is marked only as a pointer to an irretrievable consciousness. As for the receiver, we must ask who is 'the real receiver' of an 'insurgency'? The historian, transforming 'insurgency' into 'text for knowledge', is only one 'receiver' of any collectively intended social act. ²

The best way to ensure that you're actually reading is to highlight and annotate the text. I resisted doing this for far too long, because I didn't like defacing books. However, many or most of the time your readings will not be given in the format of print books. More often I as given low-quality PDF scans from books. These are not well-suited to on-screen reading, So you should either print them out or annotate them on a tablet. I recommend Xournal if you're on GNU/Linux. If you don't interact with the text, especially when it's on a screen, the temptation to skim is too strong.

Sit in the front row

If you're too intimidated to sit in the front row, sit in the second row. Professors will remember and judge you better if you sit closer to them. I had one class where I sat in the seat directly in front of the professor, and as a consequence, he would individually greet me when I entered the classroom of 40+ people.

Besides making a good impression, sitting in the front will make it easier for you to ask questions, both because you'll have an easier time making yourself heard, and you'll start to find the professor less intimidating.

In the front, you'll also be less tempted to look at your phone or stare into space. You will also have an extra incentive to go to class, because your absence will be noticed.

Speak in class

Speaking in class can be intimidating. Nevertheless, learning to speak elegantly in front of a group of smart people is an important skill, and college is one of the best places to learn it. This is one of the reasons why you should do the readings: you'll won't feel confident speaking in class if you're behind.

If you identify a class where you have trouble contributing, be sure to take advantage of times when the class shifts to a topic you know more about. For instance, I had a lot of trouble following the math-heavy lectures in my Computer Graphics class, so I made sure to answer the professor's questions when we talked about art history.

Put away the laptop

I like computers. I spend most of my time in front of one. I'm even part of the small minority that reads ebooks more than paper books. Nevertheless, I recommend putting away your laptop in class.

Some professors will say that they don't mind laptops, but virtually none prefer that you use one. Taking notes by hand will give a better impression, if for no other reason than that it's certain that you're not using Facebook in class. (If you do use Facebook in class, spend some time thinking about why you're in that class—or in college generally.) If you take notes by hand, you'll be less distracted and you'll feel closer to your professor due to not having a barrier in front of you.

A lot of people like to use laptops because they think they can take more detailed notes. This is probably less important than you think. The main benefit of note-taking is that it helps you pay attention and remember what you learned: you're more likely to remember something that you wrote down by hand, even if you never review your notes. There's probably something better to review than your own notes anyway: a textbook, lecture slides, notes you get from a classmate, etc.

Even if you're the type of person who gets a lot out of typed-up notes and doesn't get distracted by a laptop, screens have a captivating effect that can distract other people in class. ³

And one last minor note: your college notes can be an opportunity to improve your handwriting. I started college with awful handwriting that I hated: now I regularly get compliments on it.

Continue working on fun stuff

When you're in college, you'll almost always have schoolwork that you "should" be doing. (If you don't, you should probably be taking more advanced classes.) This can sometimes make you feel as if you can't justify putting effort into things besides schoolwork. After all, how can you read a book for pleasure when you have three other books to read for your classes? How can you spend time learning to make a website when you have a project due this week?

Resist this type of thinking. As much as it might feel like it, you almost certainly don't spend every free minute on your schoolwork, and any time you "save" by not reading a novel is more likely to be wasted scrolling through internet feeds.

Formal education is kind of a weird way to learn. It's super useful, but the way that people naturally learn is by exploring, playing around, and trying new things. You should continue doing this even as you're in a formal learning environment: you will learn twice as much. I learned JavaScript while I "should" have been working on Syntax homework, I learned LaTeX while I "should" have been writing papers, and I wrote about half of my blog posts while I was procrastinating on another task.

Incidentally, this also goes for social relationships. When I've turned down invitations because I "have work to do," I've almost never accomplished whatever it is I wanted to do in the time I gained. In fact, I've probably lost more time wallowing in loneliness than I've ever saved from not being around other people.

In fact, even if you really did have to make academic sacrifices for your social life, that's usually going to be worth it. No one on their deathbed wishes that they had spent more time studying and less time with friends and family.

I realize that there are some people who need to hear the opposite advice: the type who see college primarily as a way to meet attractive people their own age. However, I somehow doubt that many of those people read blogs hosted on gitlab.io.

Take "artisan" classes

Artisan classes are those that are designed and taught by a single professor. These tend to be more niche subjects in which the professor is a passionate expert. It's a very good sign if the course contains information that the professor personally discovered, invented, or theorized: there's likely no better way you could learn that specific material. Sometimes, it will be slanted towards the professor's particular views on a subject. For instance, my syntax professor spent a lot of time on Categorial Grammar, which is not the most mainstream theory. However, it's better to get great coverage of one viewpoint than poor coverage of many.

Avoid "mass-produced" classes. These are ones that have many sections, are offered every semester, and have large class sizes. They are less likely to have you do meaningful work, as the grading burden will be huge. They are often taught by adjuncts or grad students who would rather be doing something else. The less your teacher cares, the less value you get from taking a class rather than just reading about the subject on your own.

(To be clear: Grad students can be great teachers — my first two French classes were both taught by grad students, and they were both excellent. But those were small, highly intimidate classes, not the type I'm talking about here.)

You might need to take this sort of class as a requirement for your major or a pre-requisite for other courses you'd like to take: that's why so many people need to take them. I recommend that you see if you can have the requirement waived or replaced by a different class. You might be surprised, and there's no harm in asking.

A "real" croissant rolled by hand will cost more than one molded from frozen dough in a factory. But college courses are not croissants: you generally pay the same for a lovingly-crafted seminar as for a detached, uninspired lecture.

Continue to Part 2

To be clear, a lackluster project didn't necessarily mean that a student wasn't learning. Some students had less experience programming and had to put in a lot of effort to meet the minimum requirements: they also learned a lot, just different things from the more experienced programmers.↩︎
Gayatri Chakravorty Spivak, Can the Subaltern Speak↩︎
Faria Sana, Tina Weston, and Nicholas J. Cepeda, "Laptop multitasking hinders classroom learning for both users and nearby peers," Computers & Education 62 (2013) p. 24-31↩︎