10/19 - 10/25
This week I have a mixed bag of pretty dense content, and other than the two podcasts and the first link I mostly skimmed the content, but many of these links are rich resources that you can continue to come back to. I recommend bookmarking any link you find interesting. Enjoy!
- The Island That Humans Can’t Conquer. Humans can only live in a comparatively small range of climates on the planet, and I find it interesting to see how we’ve pushed those boundaries throughout human history. If you find that interesting, too, you’ll probably like this.
- The Case for a Learned Sorting Algorithm. Sorting is one of the classic problems in computer science and this paper provides some interesting benchmarks for a new type of ML-driven sorting algorithm that significantly outperforms RadixSort on a massive (1 billion item) dataset, and that performance includes time to train the model. This is a pretty exciting result for anyone interested in sorting data at a large scale.
- Orbital Edge Computing: Nanosatellite Constellations as a New Class of Computer System. This paper is a wild ride into the world of true “edge computing” as it outlines some of the interesting approaches used by semi-autonomous micro-satellites that work together to send information to space to earth with limited bandwidth.
- Effect Runtime and Generic IOApp alternative. Alexandru Nedelcu is an excellent Scala engineer and prolific writer, and these two pieces are great foundations (with plenty of example code) for understanding how to build pure IOApps and effect runtimes using Cats and Cats-Effect. If you’re interested in pure FP for Scala, understanding this is the equivalent to a 101 course, and Alex makes it really easy to grok.
- GitHub - danluu/post-mortems: A collection of postmortems. Dan Luu is a great writer and teacher of industrial software engineering and this repo is a cool collection of postmortems published by a variety of different industries. If you work in operations at all, postmortems are an unfortunate but vital part of the job, and this cache of postmortems makes for great inspiration when it comes to designing and implementing a postmortem process.
- SEO mistakes I’ve made and how I fixed them. I’m pretty new to the blogging game but even I recognize the importance that good SEO can have on getting my posts in front of a wider audience. This article provides a great summary on low-hanging SEO fruit for your blog or website that can be tackled without making any major changes to your content production flow.
- Johns Hopkins Poker Course. I loved this link! If you’ve ever wanted to improve your poker playing skills (and, by extension, your betting abilities) through a grounding in first principles, Avi Rubin’s course provides a thorough overview of how you can do that (the only thing to really do after, of course, is practice).
- Signals and Threads: Python, OCaml, and Machine Learning and Signals and Threads: Language Design. Signals and Threads is my favorite podcast in tech right now: Ron Minsky is an engaging and enthusiastic host and he has a plethora of incredible engineering talent at Jane Street to pull information from. This weeks podcasts covered my two areas of programming interest: language design, and machine learning, and I especially enjoyed both of them.
- Why Life Can’t Be Simpler. The answer, of course, is because the “simplest” things are the things that require the least amount of assumptions, which are some of the hardest things in the world to actually find.
- This website is killing the planet. Just trust me.
10/12 - 10/18
The list is shorter this week – I was on vacation and kinda stayed away from tech and the internet in general as possible (I did, however, go on a lot of hikes, I read 2 books, and ate a bunch of good food!) There were still a few pieces that I read from the tech world, though, so I figured I’d share them :) They’re mostly about Scala and Haskell, with a few fun pieces (including Aphyr’s latest technical interview satire). Enjoy!
- 5 tips for writing great client SDK libraries. Wix has a great engineering blog, especially for Scala-related work, and I recommend this guide to anyone looking to write an open-source library in Scala and doesn’t know where to start. (I’m also writing a blog post about getting started in open-source, so stay tuned!)
- Rewriting the Technical Interview. Aphyr has written several hilarious posts about tech interviewing that are as technical and brilliant as they are entertaining. Each one is a treat to read. Here’s their newest :)
- The Pyramid Principle. I recommend this to anyone who’s looking to level up their communications game (which should be almost everyone – good communication skills are absolutely worth their weight in gold in tech). The Pyramid Principle is a tried-and-true McKinsey practice for effective communicating complex topics.
- Daniel Ek. The Observer Effect is a new site I’ve found that does longform interviews with tech leaders. I enjoyed this profile on Spotify’s Daniel Ek, I love how much Daniel empowers his team around him to make good decisions and how that empowerment frees up time for him to focus on the future (he mentions that he’s currently focused on 2025, which is crazy to think about).
- Delivering with Haskell. Sam Halliday (@fommil) is an excellent writer and very knowledgeable about FP, especially Haskell. I recommend this piece for anyone who’s looking for some guiding principles about being an effective industrial engineering team with Haskell (or for anyone who wants to be an industrial engineering team with Haskell).
- Mu-Haskell 0.4 Released. This is a bit of a biased article but I work on the mu ecosystem at 47 Degrees and my Haskell coworkers just released an excellent addition to the library. This piece is a good complement to the Sam Halliday article because it talks a lot about the practical benefits of using mu with Haskell to build a modern distributed microservice without adding too much complexity.
10/05 - 10/11
- Why is Snowflake so Valuable?. This piece makes the case that the high valuation of Snowflake is largely due to strong performance in the following 5 metrics: (1) Growth (2) Net Retention (3) Net Promoter Score (NPS) (4) Average Contract Value and (5) Net Loss. At my old company we frequently measured our success against these 5 metrics as well, as we ended up with a similar result to Snowflake where we were acquired at a valuation that about 10x’d our revenue. Our numbers weren’t as insane as Snowflake, but these metrics seem like a pretty good gold standard for a SaaS company valuation.
- Things I Was Wrong About: Types — Sympolymathesy, by Chris Krycho. I’m really into strongly-typed languages, so this piece was a fun read for me to challenge my assumption that strong typing is always a good thing for a programming languages. The major takeways from the author are that the 3 major benefits of type systems in a language are (1) type inference, (2) type soundness, and (3) sum/tagged union types.
- For a Good Time, Call. A story of two young women and growing up in Las Vegas in the early 2000s, told through stories on the party line. I’d never heard of party lines until this podcast from California Love, and now this is the second story in less than a month I’ve read about them. I missed this train as a kid, lol.
- How normal am I?. This website is an experiment from Dutch privacy researcher Tijmen Schep that tries to codify how normal your online profile is based on ~20 key demographics. It’s pretty shocking to see how much data is colected about you in the process of browsing the internet, and this piece is a sobering reminder about all the privacy many internet users willingly give up to be online. If this subject matter interests you, Schep has another site that I recommend checking out: Social Cooling.
- The Era of Visual Studio Code. I write a ton of content on VSCode (including this blog!), and it’s pretty amazing to see the dominance of this editor among developers in the last decade. VSCode is a great example of how powerful an editor can become when a powerful company focuses on the right things and aggressively innovates on them.
- I was wrong. CRDTs are the future. I’m still trying to understand this piece (and the original talk about Conflict-free replicated data types from Martin Kleppmann), but it’s exciting to see all of the breakthrough happening in distributed computing, since I’m a big believe that the future of software will continue to be distributed.
9/28 - 10/4
Some fun reads about typed languages, functional programming, software and language design, and just general culture stuff. Happy October!
- Neural Networks, Types, and Functional Programming.. Okay honestly I haven’t read this yet but I love everything in the title so just trust me on it I hope.
- Why Is Everything Sold Out Right Now? A lot has been written on how the woeful American response to the COVID-19 pandemic, but one of the areas that almost consumers can relate to is that it seems as though we have a shortage of everything when it comes to shopping online. If you, like me, are curious as how how these shortages came to be, you’ll find this piece interesting.
- The Conflict is the Point. This piece is an excellent summary of the relationship between virality and “earned audience” that comes with creating conflict online. My favorite quote: “Whether you’re an individual writer looking to boost your profile or a private-equity fueled global fast food conglomerate, everyone is being trained in the easiest of hacks. Stoke conflict. Be kind of a dick. Go at someone. If there’s no one to go at, build a strawman. Or just subtweet no one. Whatever you do, structure your communication in a conflict or the feeds won’t listen.”
- On Browser Tabs. A quick read that talks about the “seeking circuit” that many of us manufacture when we open (and save) a bunch of browser tabs.
- The Dark Secrets of Fast Compilation for Kotlin. Kotlin is a interesting language for a lot of reasons, but one of my favorite attributes about the language is that it was designed for industrial programming – meaning it’s optimized for large codebases with many users that grow over time. As a result, one of the things that it needed was an optimizing compiler so that compilation time didn’t become untenable as the codebase grew. This blog post from Jetbrains outlines many of the tradeoffs that they considered when designing Kotlin’s optimizing compiler, and is a good read for not only compiler nerds, but any engineer who has to think hard about tradeoffs.
- My Least Favorite Rust Type. A fun counterpoint to my post last week on “My Favorite Rust function”, this piece explains why Rust’s
std::ops::Range type is full of confusing features. As a language designer, it’s fascinating to think about how users will interact with programming languages and posts like this are a good reminder on the things that improve language ergonomics.
- Void Is a Smell. This is a Haskell post, but the idea that functions that return nothing (i.e. perform side-effects) are a code smell is an important idea that I think is worth considering in any language. In my opinion, side-effects are some of the easiest ways to accidentally introduce buggy code, and focusing on eradicating them intentionally from any program is a good practice.
- Jenna Wortham. I’m really digging Om Malik’s writings lately; last week I posted a piece on Brunello Cucinelli, and this week I went into the archives for a great read on Jenna Wortham, who’s NYT podcast (Still Processing) I’ve been loving during the pandemic. Non-technically, totally fun read.
- Taco Bell Quarterly Volume III. Just trust me. TBQ is the coolest, edgiest, and most accessible lit quarterly I’ve found on the internet.
- Lambda Pi. This is a really nice (haskell) tutorial by Andres Loh, Conor McBride, and Wouter Swierstra that is demonstrates minimal implementation of Lambda PI (STLC + dependent types). It’s only 30 pages but really clean and easy to read. If you like Haskell, or even just formal verification, you’ll have fun with this. The progressions goes as follows;
- introduce an implementation of STLC that uses Locally Nameless representation, bidirectional typechecking, and higher order abstract syntax
- implement the syntax, evaluator, and type checker.
- Describe the minimal edits to make it into Lambda PI
- show the changes to the syntax, evaluator, typechecker.
- add Nat base type, introducing motives and dependent type elimination
- add Vec base type.
- further discussions and comparison to Agda, Epigram, Coq, etc
- Why senior engineers get nothing done. Honestly I liked this post because it validated my experience at my previous company as a senior engineer who “couldn’t get anything done”.
- The Lifestyle Blog Voter. Fascinating on the precariousness of middle-class life through the lens of Lifestyle Blog Trump voters.
- Annoying things in Scala 2 that’ll be mostly gone in Scala 3. Scala 3 represents a massive paradigm shift for the Scala language and this post lays out some of the best new features that the latest version will introduce. Among them are:
- Underscores
- Implicits
- enums
9/21 - 9/27
Got a bunch of cool things from Github this week, various posts about parsers, and some fun meditations on removing oneself from the machine. Enjoy :)
- Side Project Marketing Checklist One of my big hobbies during the COVID-19 pandemic has been to learn more about (and spend more time working on) side projects, and I found this guide helpful. It’s a bit too thorough for the types of projects I’m currently doing, but it’s comprehensive, and I recommend it for anyone who’s interested in marketing their side projects and doesn’t know where to start.
- Holbert: A Graphical Interactive Proof Assistant Designed for Education Liam O’Connor is a programming languages researcher in London and they just released a really cool-looking theorem prover that, unlike many automated theorem provers, comes with a graphical component for the visually oriented. I recommend anyone who’s interested in theorem proving or formal verification to check it out.
- My favorite Rust function I’m working on a lot on parsers at work, so I’ve got tokenizing on the brain, and this post was a great deep dive into a great Rust function for tokenizing (a function that I learned about in Bodil Stokke’s post about writing a parser in Rust!). If you’re interested in Rust, parsers, or even just clever programming in general, you should check this post out (and Bodil’s too!)
- The 3 Tribes of Programming When researching the author of the previous post I noticed they referenced this article when it came to classifying different types of programmers. Personally, I don’t think anyone fits into a neat box when it comes to programming styles, but this article is a fun read if you enjoy pieces that make you look internally and classify yourself.
- Make Now Just Lab on Github In reading about parsers in Scala I stumbled onto this guy’s Github portfolio, which blew my mind. You owe it on yourself to check out this body of open-source work.
- Quine Codes. This is the personal website of the aforementioned Github page! Of course it’s one of the coolest personal website I’ve stumbled upon.
- Ousterhout’s dichotomy I hadn’t heard of this concept before but it’s an interesting classification of languages. Personally, I think it’s a pretty arbitrary distinction, but at least it got my thinking about how to categorize different types of programming languages.
- In the computer This is my new favorite meta-article on reasoning about program logic. Whether you’re a declarative, imperative, or functional programmer (or any composition of the 3); I imagine you’ll get value out of this piece.
- Brunello Cucinelli – On my Om I love fashion and I’ve always been into Brunello Cucinelli, but I never knew how philosophical or interesting the man was. I kinda stumbled upon this link by accident but I couldn’t stop thinking about it all day that I read it.
- TikTok and the new American capitalism - Margins by Ranjan Roy and Can Duruk My weekly Margins piece, and this one is a doozy. It focuses on the Oracle/Walmart/TikTok deal the absolutely bare-faced the crony capitalism that it entailed. I wrote about Scott Galloway’s Crony Capitalists piece a few weeks ago and it’s interesting to see that same terminology cropping up a few weeks later in a different context.
- Abstract Heresies: Tail recursion and debugging Oh god why didn’t the JVM ever care about optimizing tail recursion.
- PalanThiel: The Uncola. This week’s Scott Galloway goes after Palatir, and makes the case that Palantir is an over-valued, over-hyped government services company who’s only skill is in losing money at a more impressive rate than the US government itself.
- The Missing OS. I don’t really know much about OS design but this piece was really exciting to me because the ramifications of what’s being proposed (an operating system optimized for networked distributed systems, aka a DatacenterOS) would be incredibly impactful in modern computing, especially in open-source.
- Why it is important that software projects fail. The thesis of this piece is a bit tongue-in-cheek, but basically it comes down to “we need projects to fail so that bureaucrats can relax about their projects failing and maybe address project management with a more realistic scope instead of holding on to success at all costs”.
9/14 - 9/20
- When you browse Instagram and find former Australian Prime Minister Tony Abbott’s passport number. This is the most fun vulnerability disclosure I’ve ever read. “Alex” is hilarious and their posts are both insightful and a great read.
- A Robot Wrote this Article. I’m not worried about AGI coming for my job as an engineer just yet, but it’s still cool seeing software write an op-ed without any human input.
- Nothing to see here, folks. The West Coast of the US is extremely on fire currently and it’s incredibly hard to ignore; as of writing this my city has some of the worst air quality of all the major west coast cities. This piece makes the case that major media outlets in the US are refusing to acknowledge systemic climate change as a cause for these fires. This type of negligence makes many folks (including yours truly) pretty outraged.
- It was never enough. Fun long read from the Texas Monthly that profiles a prolific businessman / erstwhile scam artist who committed the wildest insurance fraud in the history of Texas.
- An intuition for optics. Tony Morris has written a bunch of intuitions on useful FP Algebraic Data Types over the last few weeks and I finally am getting around to reading them. I wish I’d read them earlier, honestly. If you’re keen on trying to understand some genuinely useful FP concepts and their associated algebraic jargon, start here.
- A Deep Dive Into the ‘Gentrification Font’. If, like me, you live in a neighborhood where it seems like bougie construction is cropping up everywhere, you may sometimes feel that all new development looks the same. This story sheds some light on how some aspects of new development (such as the typefaces used) are exactly as isomorphic as you may think.
- Thoughts on Haskell in 2020. This week I read a lot about the “pragmatic” Haskell, which the concept of writing Haskell code that (while maybe not as powerful or fancily-typed as possible) is readable, maintainable, and takes advantages of Haskell’s static typing and ergonomics. There’s this whole movement called Boring Haskell that’s been espousing this concept for years, (see writings from Fommil, Snoyman, and Matt Parsons), but it’s still a hard habit to break, especially for people who are drawn to Haskell because of all the type-level abstractions you get to do with it. In my opinion, this post is best-targeted at (a) someone who wants to use Haskell at work and needs some data to help their manager or director sign off on a project or (b) someone who works on an existing Haskell team that’s struggling to hire developers with the necessary pre-requisite programming skills to write complex Haskell code.
- Dependent and refinement types: why? LMAO so I know I just got off my soapbox talking about why simple Haskell is best, but that doesn’t mean it’s not worth understanding some of the strong types in Haskell so that you can take advantage of them when you code. In this post by my coworker Alejandro, he walks through the benefits of understanding rudimentary types in Haskell and how you can ultimately use dependent types to prove things to the compiler, which leads to writing code that is free of (software) bugs by definition
- Safe, Expressive Code with Refinement Types On the heels of Alejandro’s post about the theoretical benefits of refinement types is this post from Gordon Rennie at OVO Energy that goes through an example of how to use refinement types to safely and elegantly handle input validation, which is a problem that is the scourge of many a web developer but, as Rennie argues in this post, is trivial to handle if you use a language that supports refinement types like Scala.
9/7 - 9/13
- Vocational Awe. This piece discusses capitalism’s impact in devaluing essential services through the les of American libraries. I recommend it if you’re curious about how libraries work in the US and you want to get mad about how little they tend to be valued financially.
- SoftBank, Robinhood, and a Margins Singularity. The best pop-finance you’ll read all week imo. This piece attempts to explain what the hell the stock market has been up to during these last few months that’s accessible for an everyman. I recommend it to anyone who’s curious about why everyone is talking about stonks.
- Incomplete List of Mistakes in the Design of CSS. I’m into language design and it’s cool to see the CSS working group being so transparent in sharing the mistakes that were made when developing the language. CSS is also a very different language than many other programming languages so the fact that many of the mistakes appear syntactic belies the fact that they are often related to the architecture. This list is also interesting to consider if you wanted to work on developing a DSL that transpiles to CSS, for example.
- Living in Someone Else’s Portland. I’m obsessed with AHP’s Culture Study , so forgive me if I post about it a lot. But this piece resonated with me because it interviewed actual people in Portland to get their perspective on what’s happening there, which (of course), is much mellower than entertainment media wants us to believe. As a Seattleite who dealt with this same overblown crap when CHOP was happening, this piece feels vindicating.
- America Is Trapped in a Pandemic Spiral. Another awesome COVID-19 piece from Ed Yong, this one focuses on the idea of why it’s so hard to feel like you have any stability in US (largely due to systemic gaslight by the institutions meant to protect the US citizens). Good read if you’re feeling helpless and you want to assign a mental model towards the helplessness.
- Generative Language Modeling for Automated Theorem Proving. This is a potentially seminal paper from OpenAI that lays the foundation of AI-driven automated theorem proving, which goes a long way towards training AI towards writing software. The ramifications are exciting and terrifying.
- Timeline of low-temperature technology. In a world that seems to be heating up constantly, it’s interesting to reflect on all the various times where humans moved to a place, set up shop to keep things cold, and innovated.
- How can you not be romantic about programming? I love Thorsten’s writings and this blog is a great koan about how cool programming is. Say what you want about tech as an economic or social system, a lot of us got into the industry because of the pure joy of programming, and this read helped rekindle some of that love.
- Why software projects take longer than you think: a statistical model. I read this a year ago but it came up again in my work Slack today and generated a lot of buzz. I like ErikBern’s writing in general and this is one of the few pieces with a “Why X is Y” title that, instead of being a puff piece, tackles an ambiguous problem (project planning) with statistics. I recommend it for any engineer, but especially an engineering manager who’s looking to improve their metrics around project planning.
- Lucid Dreaming with Neural Nets. My buddy Jack sent me this one and it’s a great little post that showcases what remains my favorite application of Neural Nets: making trippy art in a programmic way. I’m hopeless at fine motor skills but I love that programs like this help people like me make art with nothing but computers and a little creativity.
- How to speed up the rust compiler. The last in a series of 10 posts dating back to 2016 from the principal engineer on the rust compiler. The whole list is worth reading if you’re the type of person who’s curious about compiler technical details and micro-optimizations.
- Android build and the journey to the end game. This post is also on micro-optimizations, only this time on a higher-level: it outlines how to speed up an android gradle build. I recommend it to anyone who’s familiar with Android and gradle and is looking to improve the speed of their builds through a few accessible micro-optimizations.
8/31 - 9/6
- Typing is Hard. This post outlines type checking and decidability in an accessible way. I recommend it to someone who’s familiar with the concepts of type systems and can understand the difference between statically and dynamically typed languages but wants to learn more about the subtle differences across popular statically typed langages. If you’re into compilers you’ll probably like it :)
- Against Online Tooling. The TL;DR is that online tools for things like JWT generation, diff checking, or anything else are access points for accidentally leaking sensitive data. The author encourages doing these operations locally as much as possible.
- The Bicycle Threat Model. An introduction to threat modeling via a practical example: keeping your bicycle safe in a city. I recommend for anyone who wants a practical example for threat modeling (perhaps to explain to a non-tech-y family member or friend).
- The Case of the top secret iPod. Cool read on an internal project at Apple that sheds some insights into what work at one of the most secretive companies in the US is like.
- Microcovid Calculator. Play around with your COVID-19 risk level! If you’re someone who likes extrapolating risk from incomplete data sets, you’ll probably have fun with it. This is a reminder that I am Not A Doctor.
- Lofi-Player. Creative project from Google Brain’s magenta project that creates lo-fi beeps n boops using RNNs and provides a cute pixelated UI to boot. Not quite robust enough to have running in the background during work to try and flow to, but definitely good for spending a break to play around with it.
- How NAT Traversal. Tailscale is a cool company that is tackling the challenge of building a secure network without needing to rely on sysadmins for each intersection, and their blog is generally great. I recommend this piece if you’re curious about the technical specifics of how networked devices actually connect with each other.
- An Overview on the Science of Function Length. More empirical analysis of software quality, this time trying to answer the hypothesis of whether very short functions are actually a code smell (one of my many pieces that challenges the “clean code” style of programming). I recommend it if you like reading attempted objective analysis of a relatively ambiguous subject.
- Shell Commands Rewritten in Rust. List of shell utilities (traditionally written in C) that have been re-written and improved in Rust. You’ll probably like this if you’re into system utilities or are a big Rust fan.
- Describing Microservices using Modern Haskell. This was written by my coworkers and is an example of a formal paper about industry-specific CS (in contrast with formal papers about more theoretical or abstract concepts). I recommend it if you’re curious about microservice design using purely functional architectures, and I’m also biased because I work on the Scala version of this library so I think the work is personally cool.
- Towards rigorous design of domain-specific distributed systems. So much of modern cloud computing is in distributed systems, and one of the killer apps of domain-specific modeling that many static FP languages do well is the ability to create programmatic DSLs (i.e. NOT yaml) to define complex distributed systems. This paper lays out a potential DSL design using that idea.
- Amazon Drivers Are Hanging Smartphones in Trees to Get More Work. Your weekly dose of gig economy dystopia.
- Hic Sunt Dracones. You’ll like this is you’re either (a) a doomer neolib who thinks we’re on the cusp of societal collapse (b) someone who enjoys dunking on doomer neolibs but you’re curious what sort of content they read and share. I’ll let you guess which one I am ;)
- Github Audio. When paired with mynoise.net you can attain focus bliss
- The Arc of the Covenant. I recommend this piece if you want to get some data on what the fuck is happening in international finance.
- What if Facebook is the real silent majority. “But what sticks out, when you dig in to the data, is just how dominant the Facebook right truly is. Pro-Trump political influencers have spent years building a well-oiled media machine that swarms around every major news story, creating a torrent of viral commentary that reliably drowns out both the mainstream media and the liberal opposition”.
8/24 - 8/30
8/17 - 8/23
8/10 - 8/16
8/3 - 8/9