X'd by Elon, housing prices, and Nix

Greetings patrons,

It’s time for another research update. In this letter, four things:

1. X’d by Elon
2. Housing prices and debt
3. Nixing technological lock in
4. 100 supporters and counting

X’d by Elon

As you probably know, I spent much of 2023 ridiculing billionaires. So it came as a surprise when, in late November, I discovered that the world’s richest man had tweeted a link to my (old) post on the Dunning Kruger effect.

For those who don’t follow the debacle that is Twitter (sorry, ‘X’), Elon has largely trashed the platform since he bought it in late 2022. He has, however, managed to tweak the algorithm so that his tweets get massive engagement. Hence the 8.6 million views of this Dunning Kruger tweet.

Still, there is a reliable way to not see Musk’s tweets, which is to block him. And as it turns out, I’d done exactly that back in 2022. So when Musk linked to my blog, I didn’t see it on Twitter. Instead, I had to do some detective work to figure out why my blog traffic was off the charts.

Speaking of traffic, there’s an old saying that all publicity is good publicity. So while I dislike Musk’s politics, I’ll certainly take his free publicity. Still, his tweet was a good reminder that social media largely drives low-quality engagement. Sure, Musk sent about 100K people to my blog. But judging by the tiny bump in subscribers, it seems that the vast majority of these readers simply skimmed the post and then bounced.

The lesson is that ‘going viral’ is a bad strategy for building the readership of a scientific blog. Thankfully, I’m happy to trudge along in relative obscurity.

Housing prices and debt

For my family, 2023 was a special year; we finally shirked the landlord’s grip and bought a house. Of course, to do so, we had to move across the country from Toronto to Edmonton. But the move brought many fun surprises.¹

On the scientific front, the journey to Edmonton got me thinking about the political economy of house prices. And that’s not just because we bought a house. It’s mostly because the move allowed me to have lunch with Edmonton native (and generous blog supporter) Hilliard MacBeth.

As it turns out, Hilliard wrote a book about the Canadian house-price bubble. It’s called When the Bubble Bursts. In it, Hilliard channels his inner Steve Keen, arguing that housing prices are largely driven by the dynamics of private debt. It was a good reminder of something I knew, but had forgotten.

For more than a decade, Steve Keen has been making charts that connect housing prices to the creation of credit via private debt. (Here’s a post from 2012.) As a scientist, I knew about these charts. But as a long-time resident of Toronto, I’d somehow forgotten about their message. You see, in Toronto, housing prices increase reliably year after year … but no one is quite sure why. Is it immigration? Foreign buyers? To these common excuses, Hilliard MacBeth says ’no’. Rising house prices, he asserts, are driven by the flow of private debt.

Reading Hilliard’s book prompted me to do some digging of my own. In the fall, I assembled an extensive international dataset that relates housing prices to private debt. The correlation does not disappoint. It’s on my to-do list to write up the results, so stay tuned for a housing-price post in the coming months.

Nixing technological lock in

Now to some geek news. Over the last few months, I’ve been experimenting with a Linux distribution called NixOS. It is marvellous.

The selling point of NixOS is that you can stipulate your entire system from a single configuration file. The Nix package manager then determinately builds your system, with the convenient ability to roll back if anything goes wrong.

This feature is legitimately cool. But as I read more about the history of Nix, I realized that it has lessons for the more general problem of technological ’lock in’.

When you look at the history of technology, you realize that a surprising number of decisions are made with an utter lack of foresight. They are simply ‘hacks’ that get the product out the door.

The organization of the Unix operating system is a good example. Built in the 1970s, the creators of Unix were using computers with severely limited tape-drive storage. That led to some hacky decisions.

In the beginning, the developers put all of their executable binary files in a directory called bin. But then they ran out of space, so they started creating related directories — the system binary folder sbin, the user binary folder usr/bin, and so on. It was all a big hack.

But then a funny thing happened. Over the next four decades, the Unix design became the basis for most of the world’s computing. (In simple terms, every operating system except Windows is powered by a Unix-like design. Today, that’s something like 70% of all devices.) And as the Unix design spread, people kept the file structure of the original hack. In fact, that file structure got institutionalized as the Filesystem Hierarchy Standard — a standard that is maintained by the Linux foundation.

Looking at this filesystem standard in hindsight, physicist and Nix-maintainer Vanessa Alexandra Hollmeier argues that it is laughably inadequate. Most damningly, the standard layout provides no baked-in way to install different versions of the same program.

Now at first glance, this demand seems silly. Why would you want to install two different versions of Firefox? Well, as a user, you don’t want to. But as a software developer, there’s good reason to want different versions of the same program.

The reason is that few programs are completely self contained. Instead, they have what developers called ‘dependencies’ — other programs on which the software depends. For example, if I write a Python script, the script won’t run unless my computer has the Python interpreter installed. So my script has a ‘Python dependency’. But more than that, my script depends on a particular version of Python. You see, the Python language has changed over time, meaning code written for Python 2.7 won’t run in a Python 3.1 environment (and vice versa).

Now suppose that on my computer, I have a hodgepodge of different Python scripts, each one evoking a different version of Python. How do I make them all run?

This is not just a hypothetical problem. A common issue in software development is that your computer houses many pieces of software, each one demanding different version of the same dependency. Developers call this conflict ‘dependency hell’, and in the standard Unix environment, it has no good solution. The problem is simple: the designers of Unix never had dependency hell mind. They created a system designed to house a single version of each program. Then that system (accidentally) got baked into most of the world’s computers.

Enter the Nix package manager, which is today the new hotness among geek circles. The funny thing about Nix is that it’s actually over twenty years old. It is the result of a 2003 PhD dissertation written by Dutch computer scientist Eelco Dolstra.

Over the holidays, I had a chance to read Dolstra’s dissertation, and I was blown away. For one thing, the writing is exceptional. Most PhD theses are impenetrable tracts of scholarship, decipherable only experts. But Dolstra’s dissertation is surprisingly well written (especially for a non-native English speaker).

In the first few pages, Dolstra lays out the problem. The standard Unix design cannot house multiple versions of the same program. How do we solve this problem? Dolstra argues that the answer is simple: we abandon the filesystem hierarchy standard.

In its place, Dolstra proposes that all programs be housed according to a ‘hash’ — a long string of characters that uniquely identifies the contents of the program. The beauty of the hash is that it allows multiple versions of the same program to co-exist peacefully. Moreover, it means that programs can be updated independently, without fear of breaking their mutual dependencies. And it also allows convenient rollbacks if a build ever goes wrong.

Reading Dolstra’s dissertation, what was fascinating was the clear-headedness of his thinking. Also fascinating, in hindsight, was how slow these ideas would be to spread. Although clearly superior to the standard Unix design, the Nix system threw out institutionalized wisdom, making it slow to be adopted. Add the fact that maintaining standard Linux servers is big business, and you have the recipe for technological lock in.

Anyway, I’m writing this letter using a computer running NixOS. I love the system, and think that the underlying design principles are brilliant.

100 supporters and counting

Last up, a symbolic milestone. Late last year, Economics from the Top Down reached the 100 supporters mark. For me, that means the is project starting to resemble a ‘real job’.

Well, the time commitment of writing an in-depth research blog has always been full-time. But until recently, the pay was very much part-time. Now things are starting to change, and crowdfunding is making up a substantial part of my income. Of course, inflation is cutting into my income … but in that regard, I’m far from alone.

At any rate, I’m both proud and honored that 100+ people think my work is worth supporting. Here’s to the next 100 supporters!

Until next time

That’s it for this update. Thanks for supporting my work!

Cheers,

Blair