Weekly Links from Davis Haupt

Weekly Links #31: Crossing the Chasm

Sun, 01 Mar 2026 17:00:00 GMT

LLM-assisted programming has crossed the chasm. Across the IndieWeb I see skeptics either being won over or at least acknowledging the changes to our shared craft. Adam Levanthal calls the feeling Deep Blue. There’s little doubt that programming is undergoing an industrial revolution. Where we go from here is more up for debate.

You Are Here (Marc Brooker)

On the first road we can see this as the end to a craft we have loved. The slow end of programming as an economic discipline, as weaving, ploughing, and coopering went before. It is reasonable and rational to feel a sense of loss, and a sense of uncertainty. With the loss of the craft comes the loss of the economic moment where that craft was valued beyond nearly any other. Perhaps any other in history. It is irrational to feel denial. You are here.

I Started Programming When I Was 7. I’m 50 Now, and the Thing I Loved Has Changed (James Randall)

The feedback loop has changed. The intimacy has gone. The thing that kept me up at night for decades — the puzzle, the chase, the moment where you finally understand why something isn’t working — that’s been compressed into a prompt and a response. And I’m watching people with a fraction of my experience produce superficially similar output. The craft distinction is real, but it’s harder to see from the outside. Harder to value.

A programmer’s loss of a social identity (Dave Gauer)

Do I sound like a machine code programmer in the 1950s refusing to learn structured programming and compiled languages? I reject that comparison. I love a beautiful abstraction just as much as I love a good low-level trick.

If the problem is that we’ve painted our development environments into a corner that requires tons of boilerplate, then that is the problem. We should have been chopping the cruft away and replacing it with deterministic abstractions like we’ve always done. That’s what that Larry Wall quote about good programmers being lazy was about. It did not mean that we would be okay with pulling a damn slot machine lever a couple times to generate the boilerplate.

Code has always been the easy part (Kellan Elliott-McCrea)

We’ve always had this tension. We’ve always fetishized the act of writing code, the quality of the code, the code as the primary artifact and IP. And on the other hand successful teams have always known that the value is the system, the value is human-technology hybrid that allows a product to be delivered, meet customer needs, evolve to provide more value over time, meet the spoken and unspoken needs of the problem domain, etc. This confusion in our thinking has laid at the heart of why, for example, technical hiring was such a disaster for so long.

Travel agents took 10 years to collapse. Developers are 3 years in. (Martin Alderson)

The real value now lies in domain knowledge: understanding how systems connect, knowing which data exists where, and grasping what the business actually needs. I’ve had outrageously good results taking my knowledge of internal and external data sources and getting LLM agents to synthesise it all together. That kind of work isn’t going away: if anything, improvements in agentic coding mean you can do what would have required a team of 10 in what seems like a few afternoons.

Weekly Links #30

Mon, 22 Dec 2025 17:00:00 GMT

Another batch of links, coming your way! While I’m a little sad this weekly didn’t follow on the heels of #29, I can’t complain too much. I spent some time working on a new side project!

I’m working on my own little algorithmic newsfeed prioritized by what I think is most important. I subscribe to a ton of RSS feeds that all publish on different frequencies. I want to make sure that infrequent publishers are never drowned out by more frequent posters. Whenver I check the feed, I want posts from weekly authors for this week to show up alongside posts from monthly authors for this month before any content from daily newsletters. At this point I’ve set up a lot of the infrastructure to ingest RSS feeds and spit out a ranked version. Next is actually working on a good algorithm!

Anyways, I’ve still got a lot of thoughts on articles I’ve read over the past few weeks. Time to get to it!

Engineering Management

Seeing like a software company (Sean Goedecke): I’ve often thought about why large organizations are so ineffecient. In the past I’ve chalked it up to the coordination overhead between any two people that scales exponetnionally in larger networks. But Sean Goedecke makes a stronger claim that efficienty is intentionally sacrificed for legibility and steerability.

I’ve only recently stumbled upon Goedecke’s writing, but his experience inside GitHub (which itself is inside the much-larger Microsoft) offers an interesting perspective that isn’t often present on the indie blogosphere.
Transparent Leadership Beats Servant Leadership (Christoffer Stjernlöf): This post really struck a chord with me and in many ways has helped me set a new north star for my career. Christoffer presents a view of management as coaching and facilitation over top-down decision making.

After your team is more-or-less autonomous, what then? “The manager should turn into a high-powered spare worker, rather than a paper-shuffler.” Managers often have a birds-eye view that can give insight into what tasks can be particularly high-leverage at any given moment. The manager-as-spare-worker lets the team stay focused while they jump in and let themselves be redirected more aggressively.
Why I Ignore The Spoltight as a Staff Engineer (Lalit Maganti): I feel like a lot of ink has been spilled refuting Sean Goedecke’s various posts over the past few months. All these takes complement the opinion they’re refuting invalidate them. Lalit’s post is a great counter-narrative about how to dive deep within an organization.

I appreciated that Lalit called out that “The foundational reason for our diverging paths is that Sean and I operate in entirely different worlds with different laws governing them.” Product engineering and infrastructure have different incentives, and Sean doesn’t have to be “wrong” for Lalit to be “right”. Different experience can lead us to different conclusions, and that’s okay!

Tech and Society

Software Engineers Are Not Politicians (Alex Wennerberg): Another Goedeke repsonse piece that I enjoyed. The part on “delivering value” was an expecially interesting read. Sticking to what’s valuable, and having an understanding of value beyond the price tag or revenue number, is paramount to actually building something that can last.
The Resonant Computing Manifesto: Another piece on the topic of value in technology. There’s been a lot of talk about AI as a force for enshittification. But the inflection point that we’re at could point in another direction: “we can now build technology that adaptively shapes itself in service of our individual and collective aspirations. We can build resonant environments that bring out the best in every human who inhabits them.”

I support the idea wholeheartedly — I’ve thought a bit of what LLM-enhanced Programmable Ink would look like. But it seems like the economic energy is already moving towards passive consumption platforms that Sora has shown us a preview of.

Programmers and technoligists have for a long time championed computing as a means of creation even as computers have been used by most of the public as a means of consumption. Revealed preference is a stronger force than stated preference, unfortunately, and I’m not sure what we can do about that.
Ghostty Is Now Non-Profit (Mitchell Hashimoto): Nothing much to add here. Just excited to see Mitchell continuing to do the right thing with Ghostty!

Actual Software

Thoughts on Go vs. Rust vs. Zig (Sinclair Target): PL comparisons are one of the most emotional and least productive sub-genres of technical writing. This was the most thoughtful and first-principles-driven language comparison I’d read on the topic in a while. Explaining when each language is useful in its own context was a great addition that I wish more people took into account when comparing programming languages.
We are in the “gentleman scientist” era of AI research (Sean Goedecke): This was an interesting thought for me. There’s a capability overhang with existing LLMs and also an engineering overhang in how to most effectively train a transformer model that the barrier to entry is not particularly high for novel research. Who knows when that door will close, but it hasn’t happened yet!
The CRDT Dictionary (Ian Duncan): This was an amazing resource to encounter! A single page is pretty limiting, though. I really wish there was better browse-ability and categorization among all these different kinds of CRDTs. The interactive demos were also enlightening.
I Tried Glean for Advent of Code, and I Get the Hype (Oscar Molnar): I got a chuckle out of how much of this article boiled down to standard library functions derived from OCaml rather than anything unique about Glean as a language.

Weekly Links #29

Sat, 29 Nov 2025 17:00:00 GMT

Welcome to Weekly 29, six days after Weekly 28! Crazy how that works. I’m back in the Pinboarding habit, which means we have a full and fresh newsletter this week!

Distributed Systems

Why Strong Consistency? (Marc Brooker): Distributed systems engineers often talk about the how and skim over the why. I appreciated Marc’s explanation of why strong consistency is a useful property of a database as a user even if it might be difficult to maintain.

AI

Compressed Filesystems á la Language Models (Rohan Gupta): This post blew my mind. Everyone normally thinks LLM inference as text generation rather than the more fundamental probability distribution that these models can produce. I’d heard about arithmetic coding before, but seeing it used in practice to turn a probability distribution into compression was really awesome.
Val Town 2023-2025 Retrospective (Tom MacWright): Tons of startups were pressured by their investors over the past few years to integrate AI into their offerings. This is a wider retrospective (and some sneaky content marketing for open job positions), but I found it particularly interesting how Tom talks about Townie, Val Town’s AI coding assistant. Townie was a huge driver of user growth, but is also expensive to run. Moving it to a premium feature made it pay for itself, but then it’s no longer as much of a growth driver. Cutting through the hype bubble, it was a small window into the realities of building a VC-funded startup that hasn’t gone all-in on an AI pivot in the current era.

Organizations

How good engineers write bad code at big companies (Sean Goedecke): Understanding organizations of almost any size is all about understanding incentives. Sean provides an in-depth explanation of how larger tech companies can push engineers towards mediocrity.
What They Don’t Tell You About Maintaining an Open Source Project (Andrej Acevski): This was the most positive view of open source authorship and contribution that I’ve read in a while. It can be easy to get intimidated by the mountain of work that ineveitably piles up as an open source maintainer, but Andrej gets motivated rather than intimidated by the users that are attracted to a good service. More power to him! I hope he’s able to monetize it at some point, though — open source maintainer-ship is a fulltime job, and it shouldn’t have to be your second one!
Size Matters (Alex Kladov): I’m skeptical of organizations that just grab Google’s style guide without thinking hard about why style matters. Alex zooms in on file/module size here, articulating some deep-held intuitions.

Weekly Links #28

Sun, 23 Nov 2025 17:00:00 GMT

Colder weather means November’s the first month with two newsletters in a long while. Let’s hope I can keep up the pace as we head into the holiday season!

Comment on “Thinking about Thinking with LLMs” (Simon Willison): When I submitted my most recent blog post to Lobsters I was not expecting Simon Willison to say he “couldn’t agree more”, but it was certainly a high point of my blogging career so far! His comment mentioned Brad Fitzpatrick’s chapter in Coders at Work, which has also had an impact on me since I read it over the holidays in 2022. I thought his take at the end was a great addendum to the post:

There’s so much low-level stuff that [LLMs] can help me understand way faster than if I was to try and dig out the details myself. Just this morning I was poking at WebAssembly compiled binaries and learned a decent amount about how that format works. Curiosity engines!
Towards interplanetary QUIC traffic (Adolfo Ochagravía): I love outer space, I love technical blog posts, so this was a slam-dunk for me. I didn’t know much about QUIC but it was an interesting exercise to see how the requirements of the Deep Space Network can be translated into a protocol designed for terrestrial usecases.
More Than DNS: The 14 hour AWS us-east-1 outage (Jonathon Belotti): Jonathon shows a deep sense of software systems as a part of larger human systems. I’ve been working in the industry for almost half a decade but I still haven’t truly developed this skill yet. Amidst an outage can be a difficult time to zoom out and reflect on organizations and culture, but it’s often the most important time to do so.
A Very Early History of Algebraic Data Types (Hillel Wayne): Another great piece of digital archaeology from Hillel. This is history as a discipline as much as anything I’ve seen in the computer science field: his sources here aren’t perfect, and Hillel artfully fills in the gaps to create a convincing and informative narrative.
I use Typst now (Chris Biscardi): While I haven’t had to write any LaTeX since undergrad, Typst has caught my eye a while back as an interesting typesetting alternative with a lot of potential for more than just academic papers. They recently added HTML output, making it possible to integrate easily into a SSG blog.

I’ve long been trying to figure out how to write talk slides in text files and also cross-post as blog posts with speaker notes. Markdown isn’t expressive enough to do this well, and Typst has a great export story for PDFs, so I’m somewhat interested in trying this out. I’m not sure if I really want to add another file format to this blog just yet, but I’ll certainly be keeping an eye on this space!

Weekly Links #27

Sun, 09 Nov 2025 17:00:00 GMT

Happy November! I spent the weekend visiting friends in Cambridge, MA and am on an Amtrak train back to New York. We’re a bit past peak fall-foliage season, but I’m hoping for a good view over the water between Providence and New Haven.

Data Infrastructure

TernFS — An Exabyte Scale, Multi-Region Distributed Filesystem (XTX Markets): It’s not often we get a comprehensive peek into distributed systems of this scale. My main takeaway: avoid single points of coordination as much as possible, and make sure any coordination across multiple hosts is only required for low-throughput operations.
Small Data (Stanislav Kozlovski): Even as machine learning eats up more and more CPU cores, GPUs and hard drives, this post proves that most other data needs firmly do not fit into that bucket. Small data can get away without distributed systems, but they certainly still benefit from improvements and technologies developed to support big data.

Software Engineering

Be Simple: Much ink has been spilled over premature optimization, but premature generalization can be just as bad of an instinct. I liked the narrative structure of this post and also definitely agree with the takeaways. Optimize code for readability over writeability, and make sure errors are legible and actionable to whoever’s on call.
How to Fix Any Bug (Dan Abramov): A well-written post demonstrating how good software engineering practices — in this case, spending time automating a reproduction of a bug — still matter in the age of LLM assistance.
Vibing a Non-Trivial Ghostty Feature (Mitchell Hashimoto): Vibecoding still requires a lot of manual work and understanding to make something truly production-ready. My main takeaway came from Mitchell’s description of the time he spent structuring the view model for this feature. I wholeheartedly second this advice: if you spend time defining your protocol types well it’s a lot harder for an LLM to go off the rails.
Use the saw, fear the saw (Steph Ango): Dangerous tools are powerful tools, and powerful tools are dangerous tools, too. I’ve always appreciated the programming-as-woodworking analogy and Steph’s extension of to LLMs and power saws clicked for me. So many technologies are “dual use” and it’s important to think about both edges to the blade.

Weekly Links #26

Thu, 04 Sep 2025 17:00:00 GMT

Welcome to The Weekly, back from summer vacation! While I did miss posting I’m still not beating myself up about getting out of the routine.

I’m currently on a flight back from the VLDB conference in London. I had a really great time! The papers were interesting, I got to catch up with a a handful of former coworkers, and I even gave a talk in our sponsor slot on what I’ve been working on at my day job! More than anything, though, it was awesome getting to pick the brains of a lot of academics and practitioners that spend their day thinking about the same problems that I do. There’s a lot we can all learn from each other.

The Weekly will be a bit different over the next few installments. I did a much better job than last year of collecting links that were interesting to me during my writing hiatus. Each post will have a few entries from the summer in addition to anything new I read that week.

Without further ado, on to the links!

Databases

Making Postgres distributed with FoundationDB (Fabian Lindfors): I realized recently that the OLTP query engines are a lot like browser engines. Writing a good one from scratch can take years because it requires handling a ton of edge cases (rewrite rules for query engines, vagaries of the HTML/CSS specs for browsers) and painstaking performance optimization. The easier path when building a product is to integrate the industry standard and focus on your actual value proposition.

Browser engines have Chrome; query engines have Postgres. So many systems either build directly on top of it (Neon, Aurora, Yugabyte) or try to emulate it as closely as possible (CockroachDB). I found this project to be a pretty cool experiment, and as the article says, “a testament to just how extensible Postgres is.”
Dynamo, DynamoDB, and Aurora DSQL (Marc Brooker): Compared to web developement or even programming languages theory and implementation, there’s not that much written online from folks deep in the guts of database systems. Marc’s blog is an absolute joy to read, and I learn more than a few new things from every one of his posts.

I’d read the Dynamo paper a few years ago and never even realized that DynamoDB was a completely different system than the one that was described. The evolution of distributed OLTP databases at Amazon over the past 15 years was fascinating. Marc’s humility that back in 2010 nobody really knew how to build systems in the way we do now was also refreshing. It’s okay to not get something “right” on the first try; Innovation is all about iteration.

Tech and Society

Advice for Tech Non-Profits (Mitchell Hashimoto): It felt like this advice boils down to the fact that folks in software often forget that so many things in life are all about interpersonal relationships, which fundamentally don’t scale in the same way that software does. In some ways, quite a simple takeaway, but it’s an important reminder that we could all keep in mind.
The evasive evitability of enshittification (Avery Pennarun): An overview of enshittification, and what founders can do to avoid it. Product growth almost always slows. It’s up to founders — if they stay in control — to choose to run the business sustainably without compromising the core product or user experience.

Avery presents a much healthier and even-keeled description of “founder mode” without mentioning Brian Chesky, Paul Graham, or the term itself. Founders have the clearest view of the kinds of things a company did (and didn’t do) in order to earn the trust of users and customers and get to the place that it did. Building a product is riddled with Chesterson’s fences that often knocked down if (and when) optimizing next quarter’s profits becomes the priority over long-term user trust and satisfaction.
Subscribe to my sponsors-only monthly newsletter (Simon Willison): I’ve long been interested in open-source business models. In addition to being an open-source maintainer, Simon has also become one of the more important and prolific journalistic voices in AI over the past few years. It’s exciting to see him take a somewhat innovative tach in letting people pay him to send them less content than his famous link-blog firehose.

Software Engineering

TODOs aren’t for doing (Sophie Alpert): At my current job this is very much our philosophy around TODOs in code: either you handle something “soon” somewhere in the stack of current PRs, or you’ll handle it “someday”, whenever you or someone else gets around to tidying up that area of the codebase. Tying absolutely everything to a ticket in JIRA can often be counterproductive.
Why Was Apache Kafka Created? (Stanislav Kozlovski): I love these mini-histories into open-source technology. I didn’t learn anything profound, but it’s always interesting reading about how a given piece of technology came to be and why it’s shaped in the way that it is.

Weekly Links #25

Sun, 18 May 2025 17:00:00 GMT

Welcome to this month’s Weekly! I’ve been putting in some work on other parts of this site. I launched my book review section that I mentioned last time and seeded it with some books I’ve read this year. I’ve also freshened up the site design a bit sprinkling in some more sans-serif.

I’m starting to think about writing up the last installment in my nix-on-mac series, covering nix modules and splitting out a flake into mulitiple files. I’ve had a draft of this for over a year now and I’m thinking it’s time to put pen to paper and ship it!

Anyways, on to the links:

Whimsy

It is as if you were on your phone (Pippin Barr): This was just delightful — a scrolling simulator that runs on your phone, minus all the doom.
Unparalleled Misalignments (Ricki Heiklen): This page is a list of “pairs of non-synonymous phrases where the words in one phrase are each synonyms of the words in the other”. Rather than explain more what that means, I’ll just let you click the link and check it out — this tickled a very particular part of my brain.

Software

Compiler Reminders (Jeroen Engels): I’ve thought for a while that LLMs should do exceedingly well at this kind of compiler-driven development, and it seems like some of the models and agent frameworks like Claude Code and Cursor are doing pretty well here. I feel like if I were to go and get a PhD, I’d want to focus at this intersection of coding models and strong typing.
Write the most clever code you possibly can (Hillel Wayne): Stretching your ability for the sake of learning — the title of this post is a bit clickbaity, but the sentiment boils down to “it’s worth it to write code that you’ll never commit”.

Miscellaneous

Burn your title (Phil Eaton): Another post to join Tom MacWright’s in the “what you spend 8 hours doing every day can be positive sum” genre. I generally think of “agency” and “ownership” are bland, corporate-speak-y words that don’t inspire much excitement, and this post reframes the conceps in a way that puts the worker front-and-center. It’s my experience that there are always niches to fill if you go looking for them.
Reflections on 25 years of Interconnected (Matt Webb): I really enjoy Interconnected but had no idea that it’s been around for so long! Matt’s recap of the different iterations of his blog over the course of the past quarter-century was a fun and relatively short ride through the history of the modern internet told through his personal perspective.

Weekly Links #24

Fri, 18 Apr 2025 17:00:00 GMT

It’s once again been another month since my last update. I hope you find some interesting reads in this issue, though!

I’m trying to read more this year, and I’ve been working on a new section of the website for small book reviews inspired by Tom MacWright’s Reading section and Arne Bahlo’s Library. Building it has been my first real forray into “vibe coding” with Cursor. The experience has been pretty great, and I was able to get a setup I’m pretty happy with in about an hour.

Anyways, on to the links!

The Best Programmers I Know (Matthias Endler): There’s a lot of good advice in this post, but I think the over-arching takeaway among all the points is Don’t be afraid to get your hands dirty. Taking existing abstractions for granted will force you to miss a lot of the details that could make the difference between building an acceptable system and an outstanding one.
Why we ditched Next.js and never looked back (Will Stewart, Tom Snelling): “Build versus buy” is a big discussion at larger companies, but startups that supposedly shouldn’t focus engineering effort outside of their core competency can also benefit from taking a deeper look at what benefits they’re actually reaping from dependencies.

NextJS is an extremely powerful framework with a lot of features. This is great when prototyping a product that you don’t yet know the final shape of, but can actually work against you if you don’t actually need all those features. In line with the post above, getting your hands dirty and just writing the 200 lines to implement React SSR can pay dividends in latency and engineering effort that would otherwise go towards fighting with the framework.
JSX Over The Wire (Dan Abramov): I’d say an appropriate subtitle for this post could be “React Server Components from First Principles”. I first wrote about data fetching and full stack web frameworks four and a half years ago and really enjoyed the in-depth look at how Facebook and the React team arrived at Server Components.
The Post-Developer Era (Josh Comeau): An important gut-check that even as AI assistants are much more useful than they were two years ago, the must bullish predictions for where we’d be in 2025 haven’t proved themselves out. I appreciated the analogy to cruise control: while AI coding tools can take away a lot of the mental labor of writing code, you’ll end up drifting out of the lane if you stop paying close attention. Josh didn’t go this far, but I think the analogy can be extended all the way to self-driving cars: agentic, automated software engineers are probably in our future, but getting from 90% effectiveness to 99.9% effectiveness could take much longer than optimists expect.
Making any integer with four 2s (Eli Bendersky): This post explained a real ogre of a math problem. The progression of how you can “level up” your answer with more advanced and abstract math, all the way to a general answer, was fun to read.

Weekly Links #23

Sat, 22 Mar 2025 17:00:00 GMT

I hope everyone’s had a good month! I might need to figure out another time to write these posts if my weekends start getting busy again. I watched Severance S2E10 last night, and my I’ll keep my spoiler free review to just numbers: 9.5/10.

From the Webring

The Secret Ingredient? (Alex Kaplan): I’d bet most of us drink coffee every day without thinking much about what goes into a cup. I learned a ton from this post and really enjoyed the different threads Alex followed along the way.

What I’m Watching

Severance S2E10: Cold Harbor (Dan Erickson, Ben Stiller): My numbers-only, spoiler-free review is 9.5/10. I really love the “protagonists are figuring out the rules of this world along with the viewers” type of show, but LOST and Westworld are examples of how these shows can jump the shark and start taking themselves too seriously. I’m glad that Severance delivered a season finale that delivered on the show’s themes, answering some questions while avoiding the impulse to subvert everyone’s expectations at every turn.

The Rest of It

Upgrading Semgrep from OCaml 4 to OCaml 5: Major version upgrades are hard. Maintainers often think every regression feels like the complaint in xkcd 1172: Workflow, but it’s important to communicate tradeoffs and work to make upgrades as seamless as possible.
Decorator JITs - Python as a DSL (Eli Bendersky): Abstract syntax trees get me more excited than a cup of coffee, and this was a great read with illustrative examples about how Python’s flexibility can make some things feel like magic.
TeX and Typst: Layout Models (Laurenz Mädje): Knuth’s TeX has stood the test of time, but Typst is an ambitious and exciting project to reinvent the one of the “wheels” of applied computer science for the 21st century. I learned a lot reading about the different tradeoffs and design decisions Laurenz made in designing Typst.

I know this isn’t the first use-case, but I’m interested in how Typst can evolve to replace Markdown for my own use. I’d love to have a lightweight but still expressive typesetting language that I could use on my blog and in presentations.

MAKE-ing

Building a smartwatch from scratch (Andrew Childs): Ten years after I built my own digital watch, I still love reading about other people’s watch builds.

Weekly Links #22

Sat, 22 Feb 2025 17:00:00 GMT

I hope everyone’s been having a good February! This week’s Weekly is more of a Monthly, but I hope you enjoy the articles all the same. I had a lot to say about these, so it’s quality of commentary over quantity of posts this time around.

My LLM codegen workflow atm (Harper Reed): I’m still trying to figure out where LLMs fit in my workflow. The post emphasizes how fast-moving this stuff is: its guidance “probably will not work in 2 weeks, or it will work twice as well. ¯\_(ツ)_/¯”

Call me boring, but I’d bet that we end up somewhere between the doomers, haters and hypebeasts. On one hand, these models are clearly a step change in software development similar to how online search engines and StackOverflow changed development back at the turn of the millennium. Reasoning models like o1 and o3 are able to be more independent, but on the other hand I’m still skeptical of how generative models that are best at pushing out code will fit into the design and development of more complex systems. I spend less than 40% of my engineering time heads-down writing code and tests. The rest of my day-to-day is reacting to how that code reacts to different load patterns from users and changing conditions of our underlying system dependencies.

On the other, other hand, I’m thinking about the shape of arguments that those more skeptical of AI systems are making feel similar to Gell-Mann Amnesia — it’s easy for me to say that while LLMs are excelling at full-stack development they’ll never be able to build distributed systems, since I feel like my own experience is important in my day-to-day work. But who knows? Maybe systems engineers will be the next subdiscipline to be blindsided by some new model.
Querying Parquet with Millisecond Latency (Raphael Taylor-Davies and Andrew Lamb): The Apache Parquet format is used through a lot of OSS “big data” infrastructure since it compresses extremely well. Once data is in a place, though, people often have the gall to want to query it out in a reasonable amount of time. This post was a great introduction to the nitty-gritty details of the Parquet format along with a walk-through of read-time optimizations, some of which are still not implemented in the mainline Parquet reader implementations like Arrow three years later.
Are Efficiency and Horizontal Scalability at odds? (Hillel Wayne): As always, a thought-provoking post from Hillel. From my own experience trawling through some large OSS codebases for distributed systems, it’s often surprising how obviously inneffecient some parts of the system are that are considered to be off of the hot path for the modal use-case.

I agree with Hillel’s point at the end of this newsletter that this is probably cultural to an extent. Similarly to what I wrote about Parquet above, systems built for scale often explicitly trade off interactive latencies as a matter of allocating limited development resources even if there isn’t a strict technical tradeoff in every case.

This is maybe an interesting place for LLM assisted development! Working with a model to optimize some local hot loop in a distributed system reduces the development overhead for parts of the system that are more easily unit-testable.

Weekly Links #21

Sun, 26 Jan 2025 17:00:00 GMT

I can’t believe I’m relishing the weather today when it’s just above 40 degrees. But that’s how it goes deep in the heart of winter in New York. Weeks like these make me think of this xkcd and how the weather extremes here in the summer and winter are pretty close to the worst of both worlds. Oh, well! The buildings look pretty at night at least.

This is a short Weekly this week. Let’s get on to it!

An explosion of transitive dependencies (Phil Eaton): I feel like pushing languages to have comprehensive standard libraries is admirable, but I did disagree with Phil on some of the details here — specifically that Parquet support should be part of a standard library alongside JSON and CSV. Parquet might be an emerging standard, but it’s a binary format with lots of small features an edge cases. Its own reference implementations in Java and C++ don’t always agree on how to populate some of its metadata and statistics.

Including functionality in a standard library tends to stifle competition outside of the stdlib. A stagnating Parquet implementation would be pretty dangerous for language.
The Mythical IO-bound Rails App (Jean Boussier): An interesting rebuttal to the use of Ruby and Python in web development that spells out how “the database is the bottleneck” can hide some important details.

Weekly Links #20

Sun, 19 Jan 2025 17:00:00 GMT

Hello again! I realized I messed up my automated email schedule up a bit and last week’s newsletter was sent out this evening, a full week late. Sorry for that! As an apology to my O(10) newsletter subscribers, you’ll see two posts in 24 hours — going forward the newsletter will get sent out Monday mornings rather than Sunday evenings to account for any late editions.

What I’m listening to

Normally I write this post in a coffee shop where I try to enjoy the barista’s playlist rather than put my own music on, but this week I’m writing from home while a few inches of snow come down outside. I’m listening to Lawrence , Couch, Ripe and other similar bands on a Spotify mix.

Miscellaneous reading

You should get a blog (Hugh Rundle): “Motivational meta-posts” might be over-saturated on newsletter now, but I do always enjoy reading these.
On the Gracchi, Part I: Tiberius Gracchus (Bret Devereaux): This was a great essay about how the Gracchi’s norm breaking behavior shaped the century-long fall of the Roman Republic.
Why is Git Autocorrect too fast for Formula One drivers? (Scott Chacon): Some really fun programming archaeology here. I hadn’t learned about deciseconds before and it was fun to hear another way text-based config languages can bite you.

AI

An “oh fuck” moment in time (Geoffrey Huntley): A similar realization to my blurb about Cursor last week. Data wall or not, it’s going to be an exciting few years while we all figure out where LLMs fit into productivity workflows.
AI’s Uneven Arrival (Ben Thompson): From one angle, it’s a restatement of Christiansen’s disruption theory. From another angle it’s another piece by Thompson that helps frame current events in tech in a historical context.

Weekly Links #19

Sun, 12 Jan 2025 17:00:00 GMT

It’s an edition coming in right at the buzzer this week! I had a really fulfilling day today — went to the first session for a new book club this morning and hosted friendly low buy-in poker with some friends in the afternoon. I’m feeling good about the time I’m spending with people I care about so far in 2025; I hope to continue it through the rest of the month!

Cursor: I tried out the Cursor editor for a bit this weekend and it kind of blew my mind. Building on top of VSCode is a huge advantage: I was able to get it to match my existing editor setup exactly within 30 seconds of launching the app for the first time. It’s really cool easy it is to move compiler errors and failed terminal commands into an LLM chat with a single keypress and get back some explanation along with diffs to apply to your existing code to fix the error.

I can see how non-thoughtful use of tools like Cursor can lead to code slop, though. Applying a few AI diffs to a personal project was super easy, but I felt so unmotivated to proofread or refactor code that I didn’t write. If I was to integrate Cursor more into my daily workflow, I’d need to be more comfortable spending most of my day reviewing code rather than writing it.
The Linkfest (Clive Thompson): I found another curation newsletter! I’ve only read the most recent issue but I appreciated the variety of different types of content that Clive included. Two weeks is also an interesting cadence — I’m interested to see how this newsletter fits into my reading routine.
The State of Garnet 2025: An interesting read about programming language implementation.
How I run a coffee club (Phil Eaton): It’s always good to remember how a little bit of effort can help maintain a really valuable thing like an in-person tech meetup. I’ve been meaning to go to this specific one, and I enjoyed reading about how Phil keeps it running.

Weekly Links #18

Sat, 04 Jan 2025 17:00:00 GMT

Happy new year! I just posted my 2024 year-in-review post over on the other part of this site. It was fun to sum up the year, and I’m excited to see where 2025 takes me! On to the links:

From the webring

Tips for New Open Source Maintainers (Robert Lord): A post written in 2014 by a former coworker that found its way to the lobste.rs front page this past week. Like Daniel Doubrovkine’s post I shared last week, I really wish I had read this a few years ago.

Programming

Collection of insane and fun facts about SQLite (v): I learned a lot of things about how SQLite is made — it’s definitely not the “standard” profitability path for tech.
Django in 2024 (Timo Zimmermann): I’ll always have a soft spot in my heart for Django. I enjoyed reading about Timo’s best practices, and will definitely take a deeper look at Django Ninja sometime.
Should Programming Languages be Safe or Powerful? (Ashton Wiersdorf): The article is certainly Lisp-pilled, but had some interesting insight about how “power” in PL can be along different dimensions (manipulating memory, modeling state) and how expressiveness relates to power and safety. It would have been interesting to show an example of a language that the author didn’t consider powerful as a counterexample.

AI

Things we learned about LLMs in 2024 (Simon Willison): Simon’s coverage of the development of LLMs over the past few years has struck the balance of optimisim and technical depth without ever diving into the hype/grifter industrial complex. This was a long but great summary of LLM developments over the past year.

Weekly Links #17

Sat, 28 Dec 2024 17:00:00 GMT

Is it even worth talking about what weather is and isn’t “unseasonable” anymore?

Turing Machines (Sam Rose): Gödel, Escher, Bach is one of my favorite books and I’m fascinated by computability theory. Sam’s Turing machine simulator was characteristically amazing, but I wish there was a bit more of a look into complexity theory and the progression from regular expressions to Turing machines rather than diving straight into the deep end. I was left wondering from an off-hand comment in the middle of the piece — why should “Turing complete” not always be the goal? I may be a bit biased by my interest in type systems on this one but I think it’s a fun question to consider.
Do Not Fix Bugs Reported in Your Open Source Projects (Daniel Doubrovkine): The title kind of says it all. As someone who burned out from an OSS project, I wish I had read this years ago. Just putting something out there in the world for free is a huge lift to do and you’re not obligated to make it work for everyone.
Narrative jailbreaking for fun and profit (Matt Webb): I enjoyed how reminiscent these “jailbreaking” sessions were of text-based adventure games.
Ephemerality in User Interfaces (Fernando Boretti): A discussion of how Web 2.0’s full-page refreshes had a bunch of positive externalities for the web that many sites have lost over the past decade.
Career Advice for New Tech Workers in 2025 (Mathew Duggan): The focus of this piece is less on the tech and more on the work environment:

One of the biggest mistakes newcomers make in tech is believing that technical decisions are what truly matter. Spoiler: they’re not.

Projects don’t succeed or fail because of technical issues, and teams don’t thrive or collapse based on coding prowess alone. The reality is this: human relationships are the most critical factor in determining your success. Everything else is just noise that can (usually) be worked around or fixed.
Journalism Requires Owners Committed to the Cause (John Gruber): The Washington Post has been in the partisan political discourse recently, but John’s post dives past that to talk about what good journalism is actually about and how it should be best supported anywhere on the political spectrum.

Weekly Links #16

Sat, 21 Dec 2024 17:00:00 GMT

It was the first snow of the season in New York City last night! Today the sun is shining, so we’ll see how long it actually sticks around for.

I’ve got fewer articles than normal this week in the newsletter — I spent more time than normal reading actual, gosh-darned novels! Taking even more inspriation from Arne Bahlo I might start writing up longer reviews of books I read.

Books

A Deepness in the Sky (Vernor Vinge): This was a classic space opera that tackled some interesting political and moral themes. Vinge was a computer science professor, and one of my favorite parts of the book was the description of “programmer-archaeologist”: thousands of years after the death of Moore’s Law, all software for all tasks has already been written by someone, somewhere — the job of a programmer is mostly to decode and tweak old software rather than create new things.
Tomorrow, and Tomorrow, and Tomorrow (Gabrielle Zevin): It’s a novel about love, life, and video games. The descriptions of how the technical and creative process intersect with the human and interpersonal story of the main characters was really great. I think this will take the cake for my favorite book of 2024.

Blogs

The Secret Inside One Million Checkboxes (Nolen Royalty): After discovering Nolen’s blog a few weeks ago I’ve devoured all his entries. This story stood out to me as showcasing the Internet at its best.
I’ve had a change of heart regarding employee metrics (Rachel by the Bay): Flipping the script on productivity metrics really clicked with me. I can’t say it better than the article itself:

It’s the job of a manager to know what their reports are up to, and whether they’re doing a good job of it, and are generally effective. If they can’t do that, then they themselves are ineffective, and *that* is the sort of thing that is the responsibility of THEIR manager, and so on up the line.

From this vantage point, the logical conclusion of the belief that productivity can be reduced to commit frequency or lines of code written is that people management itself should be automated away.
The Best Emacs Microfeature (Fernando Boretti): fill-paragraph a small thing, but one way to describe Emacs is just a collection of tiny building blocks that all can work together.
Advent of Code in Zig (Loris Cro): A tour of Zig through the lens of Advent of Code. I doubt this is acutal content marketing, but if it was, I’d say this is some of the most effective content marketing you can do.
“Rules” that terminal programs follow (Julia Evans): From one perspective UX is the collection of conventions we carry around with us as we interact with the digital and physical worlds.

Weekly Links #15

Sat, 07 Dec 2024 17:00:00 GMT

I took a vacation this week, so I’m writing this weekly with more of a laid-back attitude.

Product Design

Sometimes the product innovation is the distribution (Matt Webb): An interesting story about how Moleskine “hacked” into bookshop distribution and what it can mean for tech businesses in general.
Ink & Switch: This independent research lab / design studio has put together some really thought-provoking proofs of concept.

Just plain fun

Every UUID Dot Com: This gave me a chuckle. The writeup of how this got made is also worth a read.

Databases

DSQL Vignette: Reads and Compute (Marc Brooker): Calling the SQL engine the “easy half of a database system” is certainly a choice, but this was an interesting look into a new database offering from AWS. I found this entry via Simon Willison, but it looks like the whole series is already posted on Marc’s blog. It seems like much of the secret sauce is in how “adjudicator” instances coordinate with each other, which unfortuantely isn’t discussed in the series.
DELETEs are difficult (Radim Marek): The title kind of says it all. This was a deep dive into how row deletions are processed in Postgres and why they’re expensive.
Turning Your Root URL Into a DuckDB Remote Database (Drew Breunig): A fun reminder that there’s other ways to experience the internet than in a Web browser. If I wasn’t running this blog as a static site on Netlify, this would be a fun thing to try out. Even so I might try embedding a SQLite database somewhere around here.

Weekly Links #14

Sat, 30 Nov 2024 17:00:00 GMT

Happy Saturday! After sending off last week’s installment I finally finished up and published part 3 of my Nix-on-macOS series. This was sitting in my drafts folder for a long while and I’m happy to have gotten it out there. I have some more ideas for posts in the series to write, but I also want to start thinking about other series and topics I can explore.

Writing on writing

Always. Be. Blogging. (Nate Silver): Always interesting to learn about the process of someone who you’ve followed for a long time. I think the advice here can apply to any kind of self-guided work.

Programming Languages

The algebra (and calculus!) of algebraic data types (Joel Burget): This post draws parallels between the cardinality of different basic functional data types and laws of arithmetic, algebra and differentiation. On first blush, it seems absolutely mind-blowing. The author is ready to admit towards the end that the analogy is still incomplete. I don’t have a deep enough mathematical background to be able to judge whether this correspondence is coincidence, trivial, or profound, but there’s enough links out to academic papers and other posts on the subject to dig deeper and read more.

I’m reminded of when I learned about e in pre-calc class in high school. At first I was almost convinced that the recurrence of this number in everything from compound interest to radioactive decay was evidence of divine intervention. After a few more classes it all seemed a lot more pedestrian: if all exponential functions are transformations of each other, there needs to be one with unit coeffecients — and e falls right out of that — it’s why it’s the base of the “natural” log.

That whole thought process was a good lesson in how abstractions can feel like magic if you don’t have a deep understanding of how they work.
Haskell: A Great Procedural Language (Chris, Entropic Thoughts): I feel like every week I’m posting a new article that looks at monads in a new way, but somehow I still find them interesting.
Swift for C++ Practitioners, Part 11: Domain-Specific Languages with Result Binders (Doug Gregor): I’ve really enjoyed this series and this installment was no exception. I’m surprised that a special protocol is required. The equivalent functionality in Kotlin just falls out of trailing lambdas.

Software in the real world

Shrinking a Postgres Table (John Nunemaker): A story mostly about how AI chatbots can help with a squishy, real-world problem. I sensed some echoes of my post on ChatGPT from a few years back.
Storing times for human events (Simon Willison): I’m a big fan of this sub-genre of the indie technical blog sub-genre: thorough writeups of hard-won knowledge from years of experience in the industry.

Weekly Links #13

Sun, 24 Nov 2024 17:00:00 GMT

Hey there! I hope everyone has had a great past six months. Life comes at you fast and when the weather got warm I found it harder to keep the routine of writing every week. It’s getting cold again, I’m back in my coffee shop, and will still be aspirationally calling this series “weekly” to try and keep myself motivated to write.

Anyways, I’ve got less than I expected saved up in my Pinboard, but it’s enough for a Weekly, so let’s get to it!

Learning in Software

Doing is normally distributed, learning is log-normal (Andrew Quinn): An attempt to answer “why is estimation so hard in software engineering”? The insight that any substantial task probably requires some time to stop and learn something new made a lot of sense to me.
Confusion is a muse (Phil Eaton): Be curious! This feels kind of like a corrolary to the Andrew’s post. Stopping to learn might slow you down in finishing a task, but it’s going to pay dividends for the rest of your career.

Programming Languages

You probably wrote half a monad by accident (Andy G): I’ve been wanting to write a post for a while about how monads really are more common and less weird than the programming community often gives them credit for. Andy mostly beat me to it!
A Dictionary of Single-Letter Variable Names (Jack Kelly): This was a fun tour of common conventions in everyone’s favorite write-only programming language.

Scaling Systems

The Practical Guide to Scaling Django: I couldn’t agree more with the framing of this article — “Real scaling isn’t about handling hypothetical millions of users - it’s about systematically eliminating bottlenecks as you grow.” I’ve spent my fair share of time scaling Django, and this blog post would have been invaluable. While its examples are Django-based, its lessons really apply to most database-backed web apps.
Heroku on two standard dynos? (Brandur): Discussions around effeciency among different programming languages often gets reduced to raw speed of code execution, but your runtime bottlenecks will often lay in the I/O operations you have to do. This post was a good reminder of how important memory efficiency and concurrency support can be in determining your system requirements.

Weekly Links #12

Sat, 04 May 2024 17:00:00 GMT

May the Fourth be with you! It’s been a while again, but I’m here with some more links, and also a bit of a longer reflection to start off the Weekly today.

Coffee in Mexico City

I spent a week in Mexico City last month. In the morning I would walk around Roma Norte, the neighborhood I was staying in, looking for an espresso to start my day. At one point I found a coffee shop that just really spoke to me: I walked in, smiled, and was excited to order. Stepping back and looking around, I could only think of this snippet from Ezra Klein’s interview with Kyle Chayka that I linked to back in January:

Kyle Chayka: The generic coffee shop has become my Moby Dick. It was just this strange, uncanny experience I was having that as I traveled around the world doing these freelance magazine assignments, I would land in a particular city, whether that was Tokyo or L.A. or Berlin or Beijing, and I always managed to find a particular style of coffee shop. It was this minimalist box of a cafe with white subway tiles on the walls and midcentury Scandinavian furniture and handmade ceramic mugs with nice cappuccinos in them. And this was not the work of a parent company. It wasn’t a Starbucks. It wasn’t a global chain. Instead, it was all of these completely independent coffee shops, baristas, entrepreneurs, who had decided to mold themselves into the same aesthetic. So I started wondering what connected them all together…

Chayka: They were authentically connected to something, but it wasn’t to the geography of the place. It wasn’t to the realities of Mexico City or the aesthetics of Chinese culture in Beijing. What they were really connected to was our culture that we’ve developed on the internet. So we feel this authentic connection. We feel they’re connected to our identities and our preferences. But I think the preferences that they connect to are the ones that we have developed online that come through platforms like Instagram or Yelp or Google Maps.

Klein: That ability to have much more familiarity as a traveler going around the world — it can be kind of wonderful, but it makes it much more difficult to find that confrontation with new experience that helps you discover new things that you like.

Actually experiencing this phenomenon that I’d listened to a conversation about a few months before was disorienting. There’s nothing wrong with finding a place that I like, resonate with, and which feels comfortable, but part of travel is also getting out of your comfort zone, and I’m happy I was able to be mindful of that tension.

Technology and Society

MKBHDs for Everything (Ben Thompson): Somehow this is the first time I’m linking to Ben Thompson even though he’s one of my favorite bloggers and podcasters out there. A great post from Ben about how AI has the potential to shift the balance of power in other industries in a similar way to how the Internet has transformed media over the past two decades.
Losing My Hands (Jason Liu): A powerful reflection on purpose and work ethic in America post-pandemic. I really enjoyed the asides with philosophy and book recommendations throughout Jason’s personal narrative.
Being quitely radicalised by being on holiday (Matt Webb): Travel can open our eyes to different perspectives and ways of living. I don’t agree that it would be easy to “just… take the essentials out of the for-profit bit of the economy”, but I do think that as automation continues to improve the productivity of individual workers society should be re-evaluating whether higher productivity should be the goal in and of itself.

Programming Languages

Swift for C++ Practitioners (Doug Gregor): A fantasic series currently with seven parts introducing Swift from a member of the Swift core team. I find Swift to be a really interesting language, and learning about it through the lens of someone who also has a lot of respect for C++ was an interesting perspective when most proponents of more modern languages tend to view C++ with derision.
Zed Decoded: Async Rust (Thorsten Ball and Antonio Scandurra): I haven’t worked with Async Rust, but showing how the runtime can be integrated so deep into macOS was a very interesting read.

Miscellaneous

What makes a great technical blog: As someone who writes a technical blog, I enjoyed the food for thought here.
Memo on Celestial Time: The sci-fi geek in me really enjoyed this: dealing with timezones in computer systems is tough enough on Earth — just wait until folks have to make sure things work properly on the Moon too!

Weekly Links #11

Sat, 06 Apr 2024 17:00:00 GMT

Happy Saturday! It’s April, I just finished doing my taxes, and I’m excited to share some links with you all this week :)

Memory managegment madness

To add on to the Algoilia article about malloc_trim from the last newsletter, I have two more to share:

Garbage Collection for Systems Programmers (Matt Kline): I’ve been learning the lessons in this article the hard way over the past few weeks at work, and Matt sums it all up amazingly succinctly. Modern garbage collectors may increase latency due to GC pauses but don’t really reduce raw throughput in terms of operations per second — whether or not that tradeoff is worth it is up to your specific use case.
Underrust: What does vec![0u8; 1024] really do? (Graham King): One of those extremely narrow and deep dives down a line of code most programmers don’t think much about, but whose performance characteristics can make a huge difference in systems. I’d love to start writing deep dives like this someday.

Human-computer Interfaces

Type Inference Was a Mistake (Fernando Boretti): I love strong type systems, and yet my least favorite languages are not Python and JavaScript, but C++ and Java(8), where specifying types over and over again is almost always mandatory. Fernando has an interesting perspective in this post which focuses on Hindley-Milner type inference in OCaml. An interesting point from the end of the post: “I don’t want to infer types from my code. I’d rather infer the code from the types.”
llm cmd undo last git commit (Simon Willison): It’s still so early in figuring out the right paradigms for interacting with generative AI for productive work, and experimentation in this space is exciting to see. This “prompt, confirm, execute” loop feels promising to me.

Computing and society

This Video Has 71,650,121 Views (Tom Scott): An introduction to what an API is for a less technical audience, and also a powerful meditation on the fragility of the modern Web.
Universities have a Computer Science problem (Ian Bogost): I’ve long thought that universities have been too slow to adapt to how much computing and the Internet have permeated our enire economy — academic computer science programs are overcrowded and are not actually teaching what most undergraduate students who enroll in them are looking for. This was a great summary of the state of affairs with some perspectives about where to go from here.
Will AI Break the Internet? Or Save It? (Nilay Patel on The Ezra Klien Show): Ezra and Nilay are good friends from Ezra’s days at Vox and their raport helps carry this insightful podcast episode focused on how our society and economy will need to adapt from the changes that generative AI is bringing to the culture and media landscapes.

Weekly Links #10

Sat, 23 Mar 2024 17:00:00 GMT

Hello again! It’s been too long since I’ve published a newsletter. Routines are hard to build, but I do still want to try to make writing a weekly habit of mine.

Luckily I haven’t been publishing because I’ve been keeping busy offline, so I can’t complain too much. But anyways, on to the weekly!

From the webring

September, 2022 (Aryav Pal): Some poetry to start off this weekend: I find Aryav’s writing somehow both vivid and vague in a way that lets you fill in the space between the lines with your own imagery and memories.

Programming for its own sake

Programming Jigs (Hillel Wayne): As someone who hasn’t used a table saw since high school, I still often feel drawn to the woodworking/programming analogy. Another great essay from Hillel on the craft of programming and what we can learn from other disciplines.
Fifty Things you can do with a Software Defined Radio: I’d heard of SDR before but I never really considered how many different broadcasts are traveling through the air all the time, all around us.

Databases

DuckDB as the New jq (Paul Gross): SQL might not be the most beautiful language but its ubiquity lends itself to versatililty. Sometimes fluency in a technology is reason enough to make larger use of it, especially for building jigs like Hilel wrote about above.

Systems

When allocators are hoarding your prescious memory (Algolia Engineering): I ran into this issue at work this week, and it kind of melted my brain learning that free() doesn’t actually free memory back to the kernel, at least with the default implementation of malloc/free on Linux. I might try to write my own blog post about this if I can figure out how to make a minimal reproduction.
Latency Numbers Every Programmer Should Know (Sam Rose): Computers are fast, but not infinitely so. Caring about these kinds of bottlenecks and numbers is, for me, one of the things that separates programming from software engineering.

Weekly Links #9

Tue, 27 Feb 2024 17:00:00 GMT

Apologies for the delayed weekly this week — it may be Tuesday, but it’s still the same content you’ve come to appreciate and expect!

Personal updates

I’ve got a new homepage! I’ve been wanting to start over with my homepage for a while and I’m very happy with how it turned out. I took inspiration from a few new places around the web, but it still feels like my own.
I posted the second installment in my Nix on macOS series last weekend too. Someone left a really encouraging comment on Lobsters. I’ve still got a lot of posts planned for this series, so stay tuned!

From the webring

Left foot, right foot (Aryav Pal): Aryav’s a great writer, and I really enjoyed this article and its message.

Programming Languages

Query optimization works because sql is declarative (Jamie Brandon): SQL is weird, and this was a cool look into how part of its weirdness may contribute to its effectiveness and staying power.

Fun hacks

htmz (Lean Rada): htmx has been interesting to learn about, and I was pretty blown away by this little project, and how much could be done with so little code.
Happy New Year: GPT in 500 lines of SQL: Just kind of crazy that this works?
Quicksort with Jenkins for Fun and No Profit (Susam Pal): Turing completeness keeps bearing fruit year after year.

Tech? Politics? You decide

AI Stole Our Jobs (Kevin Cox): How tech affects the rest of our society is something we all should be thinking about, and how Kevin articulates the example with coal plants versus cheap solar was really illuminating.

Weekly Links #8

Sat, 17 Feb 2024 17:00:00 GMT

It’s a snowy day in New York City! Nice day to post up in a warm and cozy café to watch it all go by.

Open Source

Paying people to work on open source is good actually (Jacob Kaplan-Moss): Anyone who believes that American capitalism properly rewards people for even just the economic value they provide to society should take some time learning about open source software. How to sustainably fund open source contributors is undoubtedly a Hard Problem with no Easy Answer. What is easy on the internet is letting idealism blind one to pragmatic, incremental solutions — Jacob steers clear of that with a great piece on how we should celebrate anyone who can make a living working on open source regardless of ideological purity.
Ghostty Devlog 006 (Mitchell Hashimoto): I’ve learned something from each of the Ghostty dev logs, and it’s inspiring seeing Mitchell pump out high-quality software year after year.
Numderline (Tristan Hume): Anyone who stares at benchmarks or log lines in their terminal will appreciate this font hack.

From the webring

Half My Life (Peyton Walters): A powerful reflection on motivation, craft and finding joy in what we do.

Technical Reference

Popular git config options (Julia Evans): A great list that I’ll be pulling into own config.
How to Center a Div (Josh Comeau): A common, simple question with complex answers broken down into easily understandable bits. A post that I’m sure to turn back to lots for a long time.

The kitchen sink

New York ACTUALLY HAS 12 SEASONS (Devon Peticolas): This website brings a meme alive with a little bit of programming to make it feel real and tangible.
Why Software Engineers like Woodworking (Zain Rizvi): I haven’t done any woodworking since woodshop in high school, but this post still resonated.
A bird’s eye view of Polars: Query optimization isn’t just for databases! This was a cool look into other places that query engines can be useful outside of strict database systems.

Weekly Links #7

Sat, 10 Feb 2024 17:00:00 GMT

I spent some time over the past week tweaking and improving this site. Not all the changes are live yet, but every post now has an OpenGraph preview image to go along with it. I got a lot of guidance from Arne Bahlo’s post on how to generate SVGs in Astro and a lot of inspiration from Jacob Kaplan-Moss’s preview images.

I find frontend development to be a creative outlet where I can still write code without feeling like I’m doing something too similar to my day job. I’ve had fun thinking critically about my design inspirations and trying to build something that feels like an authentic expression of how I want to present myself on the Internet.

Without further ado, on to the links!

Software history

Typewriters and WordPerfect (Mat Duggan): A trip down memory lane for some, a history lesson for me, and a window into the ways that the methods of distributing software can feed back on how that software is developed.

Lessons learned

(Almost) Every infrastructure decision I endorse or regret after 4 years running infrastructure at a startup (Jack Lindamood): As someone who isn’t in the infrastructure/DevOps space, this was an insightful read that gave me a more balanced perspective on AWS than the screeds against vendor lock-in that can bubble to the top in internet discussions.

Programming languages

Rye: A Vision Continued (Armin Ronacher): The more batteries included software systems, the merrier! I might try to set up Rye with my next Python project.
Kinds and Higher-Kinded Types in Haskell (Gints Dreimanis): I wanted to gain a deeper understanding of what exactly higher-kinded types actually were, and this article was a great introduction. I’ve felt for a while that monads are way more ubiquitous than commonly understood — async/await is a monad that almost all programmers in 2024 are familiar with! Something that isn’t ubiquitous, though, is the support in the type system for describing a generic monad — that requires higher-kinded types. I do wonder if it’s strictly necessary, though — OCaml doesn’t support higher-kinded types but still has generic syntax support for monads. This is definitely something I’d like to think about some more, and maybe turn into a blog post!
Physical Properties #2 (Justin Jaffray): This series has been an approachable introduction to Cascades. People are often down on dynamic programming, and while I don’t think it’s a great way to get good signal out of technical interviews, it is a useful technique in real algorithms. Cascades has been my favorite example of this for a while: Justin doesn’t use the term directly but the “optimal substructure” critical to the definition of DP problems is heavily implied when he talks about the “Principle of Optimiality”.

Weekly Links #6

Sun, 04 Feb 2024 17:00:00 GMT

Happy February! I had a high school teacher of mine call month #2 the F-month: a month so terrible it wasn’t even worth naming. While February does tend to be the coldest month here in New York, there’s still plenty to take advantage of — It’s always easier to find tables at my favorite bars when the weather’s bad outside :)

Software

jj init (Chris Krycho): A great deep dive into jujitsu and how its mental model draws on and differs from current-gen version control systems. I’ve felt fow a while that Git+GitHub has some major shortcomings when it comes to collaboration, and I’m excited to see how new tools like jujitsu and Graphite start to change the status quo.
Long Term Refactors (Max Chernyak): Technical challenges are often unseparable from their related organizational challenges. This post was an interesting breakdown on how to adress both sides of the coin.
Stanchion: Stanchion is a SQLite extension that adds column-oriented tables to SQLite. It’s cool to see how someone was able to tack on column-oriented data structures to row-oriented SQLite. I’d be interested to see what performance benefits they’re able to get on analytic queries, though.

Career and Culture

Work hard and take everything seriously (Tom Macwright): This post articulated really well something I’d been thinking about for a while: Working hard for the sake of “the grind” is almost never worth it: it’s important to make sure that you’re personally getting something out of the work you put in. It was also another reminder of the ways in which life can be far from zero-sum. The whole post is worth reading (like everything in this weekly), but I wanted to quote the last two paragraphs:

You can burn out by going too fast, or your flame can dim because you don’t let yourself spend silly amounts of time on silly projects to satisfy your intellectual curiosity. Beware of both outcomes: cultivate your enthusiasm for the things you want to hang onto.

It isn’t a revolutionary idea that people who are excellent in their fields often get there by trying really hard. If you can figure out the difference between busy-work that only benefits your employer, and the kind of work that makes you as a person feel like you’re making progress and becoming more skilled, then you’re ready to learn.

From the archives

Was Javascript really made in 10 days? (Hillel Wayne): A look into the history behind what is probably one of the most common truisms in software. I learned a lot about JavaScript specifically and the environment at Netscape at the time — I had no clue that there was an actual deal with Sun to make the language more “Java-like,” for one.

Weekly Links #5

Sun, 28 Jan 2024 17:00:00 GMT

I have Lobsters and Hacker News blocked on my devices because I’m way to prone to refreshing those constantly. I rely on my RSS feed that I’ve curated over the past few years which also includes some other curators like Simon Willison and John Gruber. I’m thinking about how I can still discover new authors without scrolling on autopilot, especially on Lobsters, where I find the submissions to be really high-quality.

Maybe these weekly links posts can be part of a prompt to an LLM that can trawl through all the submissions and help find a sample that I’ll be most interested in? Rather than filtering out any posts, it could just rank them from “most likely to be interesting” to least likely. I’m still trying to rely less on algorithms, but I’m curious how I could incorporate an algorithm that I control into my own curation.

Anyways, on to the links.

Tech, science, and society

The Open Source Sustainability Crisis (Chad Whitacre): The question of how we as a society can make sure we’re compensating folks that create value that’s distributed at no marginal cost on the Internet, whether they’re making software, music, or art, is that we could all spend some time thinking about.
The Most Dangerous Rock in the World (Welch Labs on Youtube): A look into the collaboration and competition across Europe throughout the early 20th century that ultimately led to the development of the atomic bomb. This was a great counterpoint to the singular focus on individual “great man” scientists prevalent in pop culture, showing how scientific breakthroughs are often the result of decades of incremental and collaborative work among the whole community.

Nix and code

How to Learn Nix, Part 48: Installing (single-user) Nix on macOS (Ian Henry): I find Ian’s written voice one of the most entertaining I’ve encountered in the indie tech blogosphere, and this post into a more bespoke Nix setup was interesting as I’ve gotten into Nix more recently.
Nix from the bottom up (Chris Warbo): I’ve been learning Nix more from the “top-down”, thinking about what configuration I’d like to centralize and figuring out how Nix can help me out. This article helped fill in some of my conceptual gaps in how Nix works under the hood.
Ruby (3.3) on Rails (1.0) (Vasily Ermolovich): Working on database systems, I’ve spent a lot of time thinking about both backwards and forwards compatibility. This was a cool dive into digital archaeology that also shows how challenging cross-version compatibility can be.

From the archives

Inside New Query Engine of MongoDB (Nikita Lapkov): Nikita and I overlapped on the Query team at MongoDB, and this deep dive that he wrote after leaving was a great overview for anyone interested in high-performance interpreters, query engines, or programming language implementation in general.

Weekly Links #4

Sun, 21 Jan 2024 17:00:00 GMT

Happy Sunday! It was a short week this week, and I didn’t do as much reading as I would’ve liked. I did, however, finally start getting content I enjoy out of my YouTube recommendation algorithm: who could’ve known the Like button was useful for something?

From the webring

Teaching is DAG-building (Peyton Walters): Teaching is hard. It’s also difficult to pin down exactly what separates exceptional teachers from the rest. Peyton has some really great food for thought here on a mental model for teaching rooted in empathy with students.

Music

Stick Season (Live on SNL) (Noah Kahan): Stick Season is not a happy song, but this performance from SNL last month transforms it into a triumphant one. You can feel the “holy shit, we’re playing SNL” energy through the screen, and it’s infectious. This song really launched Noah Kahan to popularity, and this performance drills home how good things can often sprout from painful experiences. This also sent me down a rabbit hole of Kahan’s most recent album which I think is pretty amazing all-around.

Out of the archives

Memory Allocation (Sam Rose): A succinct and clear explanation of how memory allocation works under the hood. The visualizations interspersed throughout the piece are wonderful — I hope I can move towards this style of article some day.
TypeScript is Suprisingly OK for Compilers (Alex Kladov): I don’t know if this was quite the intention of this post, but it was a great soft introduction to programming language implementation made even more accessible using a language that most developers already know.

Weekly Links #3

Sun, 14 Jan 2024 17:00:00 GMT

Why limit myself to recommending blog posts? It’s a multimedia weekly this week!

How to Discover Your Own Taste: The Ezra Klein Show is a staple of my podcast rotation, and I thought this was a really thought-provoking episode that was a good one to listen to as the 2024 kicks into full gear. This newsletter is already part of my starting to cultivate my own taste more consciously — independent curation is how we fight back against the algorithms!
Redeployment Part One: brr.fyi has probably been my favorite blog of the past year. I love reading science fiction, and learning about what it’s like living at South Pole Station in Antarctica scratches that same itch for me as some of my favorite book series.
New in Fedora Asahi Remix: I maintain that the Asahi Linux development blog produces one of the best techincal release notes on the internet. Lots of interesting tidbits about Mac hardware and the internals of MacOS.
Is htmx Just Another JavaScript Framework?: A great article that also proves wrong Betteridge’s law of headlines. It’s great reading not just thoughts about the tools we make and use, but also thoughts about how to think about them.
What We Got Right, What We Got Wrong: Go is not my favorite programming language. Over time though, I’ve developed way more of an appreciation for why they made some of the design choices that I’ve disagreed with. This talk was another interesting piece of the puzzle.

From the Archives

Dennis Ritchie on & | vs. ==: Backwards compatibility is an issue that comes up all the time in database systems, and it was cool reading about how insurmountable it can feel, no matter the scale you’re dealing with. “Success” is always relative.

Two well-written deep dives into indie game development on the web this week to round out the Archives:

Weekly Links #2

Sat, 06 Jan 2024 17:00:00 GMT

I hope everyone had a good first week of 2024! I set some New Year’s resolutions this year (like I have in the past). We’ll see how they stick — I’ve tried to make them vague enough that they’ll be difficult to objectively “fail” at, but only time will tell. Anyways, on to the links:

Flakes aren’t real and cannot hurt you: This was one of the best technical posts I’ve read in a while. I mentioned in my post that Flakes were the first thing to really make Nix stick for me. This post gave me a lot deeper of an understanding of their tradeoffs and how they fit into the wider Nix ecosystem.
9 years of Apple text editor solo dev: This article was a great mix of technical and business learnings.
Fixing Macs Door to Door: I can best describe this blog post as a virtual page-turner. Similar to the post above, the secret sauce was how it mixed technical content with less technical subject matter. The post was a really interesting peek into socioeconomics around the Great Recession¹.
A CAP tradeoff in the wild: It’s always cool seeing how theory rears its head in practice, especially in a project as big as Kubernetes. It’s interesting how someone had an issue, and it’s only in the follow-up where it’s recognized as a manifestation of the CAP theorem.

From the vault

An Engine For An Editor: Emacs is super interesting. Not much more needs to be say. Alex Kladov has a great blog, and this post is no exception.

If it sounds like I’m talking about a historical event here, I was, well, 10 years old at the time. I did happen to graduate during the subsequent economic crisis of 2020, though, so it was interesting drawing parallels. ↩

Weekly Links #1

Sat, 30 Dec 2023 17:00:00 GMT

I find a lot of cool articles around the internet, and inspired by some other weekly links collections I’ve come across recently, I thought I’d start my own little bloglet.

This week

You don’t need analytics on your blog: A good reminder for indie bloggers out there to remember why you’re writing — chasing higher audience numbers can be demotivating and futile if you’re writing for your own enjoyment.
Emacs From Scratch, Part 1: Foundations: I really am loving how this series is introducing Emacs concepts in a slow drip. I’ve used Doom Emacs whenever I’ve dipped my toes in, but this series might give me the confidence to make a go of it on my own.
NixOS & Flakes Book: One of the first things you’ll learn about Nix is that the documentation is byzantine, to say the least. This book/website is refreshingly straightforward: explaining concepts like Flakes in-depth which the official docs don’t even touch on. I run Nix on my macOS systems and haven’t touched NixOS yet, but the book has still been full of great insights and tips.
Sam Altman’s Knack for Dodging Bullets: I was more than a little intrigued by the OpenAI drama a few weeks back, and I’m interested to see how those few days in November are unpacked and reported on more and more over the next few months.

From the vault

Eventually the Weekly will just be links from the current week, but while I’m getting started I’ll also include some links “from the vault”.

The Rust I Wanted Had No Future: Graydon Hoare describes the direction he would have taken Rust if he had truly been the BDFL for the language. In a lot of ways it is not what I would expect given where Rust has ended up.

What stuck with me the most was Graydon’s objections to how library-defined iterators interact with the generics system and led in part to Rust’s infamously slow compile times. It gave me more respect and understanding for Go’s built-in container types and reluctance to release generics.