Resources

Various resources for everything you’d want to learn about software development!

Class resources

• Operating Systems: Three Easy Pieces (OSTEP): The OS textbook, freely available online, written by Remzi and Andrea Arpaci-Dusseau, two professors at the University of Wisconsin-Madison. This website also includes the homework assignments that correspond with each chapter of the book, as well as other books they recommend.

Articles

Programming advice

• Why learning to code is so damn hard: One of the best blog posts that details the process of learning programming.
• The Best of edw519: A collection of comments by a very experienced software developer, covering a wide range of topics.
• Development is Inherently Wicked: An article talking about software development metholodogy through the lens of “Wicked Problems”.
• Reflections on a decade of coding: An interesting series of posts by a guy reflecting on his learnings after a decade of programming professionally.
• Why I find it hard to learn with AI: A blog post about how products like ChatGPT and GitHub Copilot can disrupt the natural processes of learning (especially important to consider for early-career developers).
• TigerStyle: A phenomenal document outlining the design principles and goals of TigerBeetle, a high-performance, distributed, in-memory database.
• Becoming a Better Programmer by Tightening Feedback Loops: An article detailing an approach to becoming a better developer.

Projects

• Challenging projects every programmer should try: Unsure what to build? Here’s a list of projects that will challenge you and help you grow as a developer.
• Coding Challenges: A series of backend coding challenges that test your knowledge as a developer, all of which involve recreating commonly used software tools.
• Flappy Bird Implemented in Typescript types: Seriously.
• Vanilla Todo: A github repository in which the developer details his approach to creating a Todo app (basic exercise for people learning frontend development and React) using vanilla JavaScript, HTML, and CSS. If you are interested in the engineering underlying frontend development, this will make you drool.
• JavaScript xv6: An implementation of xv6 (the operating system we hack on in CS 537) in JavaScript, which is crazy. It even has a game of 2048 built in.
• Writing a C compiler in 500 lines of Python: A blog post on someone’s approach to writing a simple C compiler in 500 lines of Python. The author holds your hand and walks you through the process of compiler development.
• Writing a NES Emulator in Rust: An in-depth series on writing an NES emulator in Rust. Not for the faint of heart.
• NES Emulator in Lisp: A github repository of someone’s NES emulator written in Common Lisp.

Useful blogs and posts

• Every Vim Binding Lucas Knows: A list of well-known and less-known Vim bindings.
• How to Optimize a CUDA Matmul Kernel for cuBLAS-like Performance: a Worklog: A very in-depth article about optimizing a matrix multiplication operatin in CUDA.
• How Lisp became God’s own programming language: A blog post describing the origins and history of Lisp and it’s lasting impact on the field of software development.
• Venture Capital and the Internet’s Impact: A 2015 blog post that talks about how AWS disrupted traditional venture capital in tech and the emergence of angel investors, Silicon Valley engineers and veterans of the startup scene. I (Rudy) believe this article is slightly outdated, considering the waves of new engineers and the 2022 tech market contractions, but it still provides an interesting look at underlying investment forces with startups.
• Computational Photography: A very detailed blog post about the evolution of computational photography and the algorithms behind modern camera system innovations.
• Socket Programming overview in Python: An overview of sockets programming with Python code snippets. Sockets are a fundamental abstraction for programs sending and receiving data across the internet using the IP protocol.
• Why Type Hinting Sucks!: An entertaining reddit post describing why Python type hinting sucks from the perspective of evolving project requirements and code maintanence over time.
• Learning about distributed systems: where to start?: A blog post about how to get more in-depth experience with distributed systems. Personally I (Rudy) think this is bad advice for early career developers, and instead I’d recommend building basic full-stack applications that have a frontend, backend, database, authentication, etc for getting more hands-on experience with distributed systems. I personally tried avoiding JavaScript as much as possible, but it is a futile effort.
• Portable EPUBs: A blog post that provides commentary on various file formats and proposes a new file format standard that takes the best of all worlds (according to the author of course).
• Rust won’t save us, but it’s ideas will: A blog post that organizes some of the commentary about the Rust programming language from a security perspective.
• A friendly introduction to machine learning compilers and optimizers: A blog post that provides an overview of machine learning compilers and optimizers. Overall a very good article, but the author included a meme about writing models in JavaScript so they can run natively on the browser, which I (Rudy) am ideologically opposed to.
• The engineering behind Figma’s vector networks: A blog post detailing the graphics math behind vector networks.
• Just paying figma 15 dollars a month because nothing else fucking works: A blog post that talks about the dilemmas of Free and Open Source Software (FOSS), and what makes Figma a world-class product.
• From 1s to 4ms: A walkthrough about how a developer managed to target and solve a huge performance bottleneck in a text editor.
• Files are fraught with peril: An article that goes into depth about how writing to files works at the system call level, and how the simple act of writing to a file can go wrong.
• How I wrote my own “proper” programming language: An interesting series of blog posts going into excruciating detail about someone’s journey of creating their own programming language and compiler for an Oxford senior thesis.

Papers

• A Unified Theory of Garbage Collection: A summary of a research paper proposing fundamental laws about garbage collection based on observations of different types of garbage collectors and trends of object allocation and object lifetimes in different programs. Understanding garbage collection can have interesting performance implications.
• Modern B-Tree Techniques: A long document that talks about B-trees and performance techniques that people use for implementing them in modern database systems.
• The NumPy array: a structure for efficient numerical computation: A paper detailing how the NumPy array works under the hood for efficient computation.
• Million.js: A Fast Compiler-Augmented Virtual DOM for the Web: A paper detailing a framework/Virtual DOM that speeds up React. Interesting note: the author wrote this in high school.

Talks

• Systems Distrubted: A conference by TigerBeetle about various programming and database/systems design techniques and considerations, by a variety of very smart and eloquent people doing cutting-edge work.
• Containers: Reflections after the first decade: An entertaining talk about some of the origins and motivations for developing containers. Good advice for any software developer.
• Richard Feldman - Why Static Typing Came Back: A talk about the history of Static vs Dynamic languages, motivations for using both types, and a glimpse into the frontier of language design.
• Richard Feldman - Outperforming Imperative with Pure Functional Languages: A talk about the development of a programming language (Roc) and how the creators managed to optimize it.
• Richard Feldman - Why isn’t functional programming the norm?: A talk abut the history of programming languages and how we ended up where we are.
• David Beazley - Python India Keynote: David Beazley writes an entire WebAssembly interpreter in a live-demo.
• David Beazley - Python Concurrency from the Ground Up: A talk on Python concurrency models.
• Ben Deane - Applicative: The Forgotten C++ Functional Pattern: A C++ (!) talk motivating the practical use of functional patterns.
• Rich Hickey - Simple Made Easy: The famous talk in which Rich Hickey defines the terms “simple” and “easy”.
• Guy Steele - Growing a Language: A programming-languages talk with an unusual constraint.
• Guy Steele - Four Solutions to a Trivial Problem: Kind of like a leetcode-solution video, but with more commentary on parallelism.
• Expert to Expert: Rich Hickey and Brian Beckman - Inside Clojure: A discussion about the novel ideas used by data structures Clojure.
• Ólafur Waage - Learning Rust the wrong way: A non-technical talk about various ideas surrounding learning.
• Scott Hanselman - It’s not what you read, it’s what you ignore: A talk about workflow-optimization as a full-time dev.
• Denise Yu - Why are distributed systems so hard?: A good overview of the challenges faced with distributed programming.
• Mike Acton - Data-oriented design and C++ (CppCon 2014): A talk
• Anthony Shaw - Why is Python so slow? (PyCon 2015)
• Kate Gregory - 10 core guidelines you need to start using right now (CppCon 2017): A talk detailing which features of C++ not to use, mostly for production-grade software but also provides a sense of relief when you realize that even the C++ experts can’t agree on which subset of C++ features to use.

Free Lecture-Series

• MIT 6.006 - Intro to Algorithms (Fall 2011): Covers most of the DSA ideas in CS 300, 400, 240, and 577, with way less nonsense and a lot of great examples and insights.
• MIT 6.001 - Structure and Interpretation of Computer Programs (SICP) (1986): The legendary lecture videos accompanying the classic (now free) textbook of the same name.
• MIT 6.5940 - TinyML and Efficient Deep Learning Computing: This course covers strategies and theory for getting efficient model inference, optimizations for transformers, and efficient model training. The official course website is here.
• David Beazley - Advanced Python Mastery: A github repository containing code exercises and slides from an Advanced Python Mastery course. If you are interested at learning about Python at an advanced level, feel free to skim the exercises in the repository and try completing some of them if they look interesting enough.
• CMU 15-721 - Advanced Database Systems (Spring 2023): CMU course about Advanced Database Systems. It covers advanced systems topics applied to databases and modern database implementation details about Google BigQuery, Databricks, DuckDB, Snowflake, Meta Velox, and AWS Redshift.

Extra

• Windows Drama: Some rumors about internal engineer vs designer beef within the Windows teams. Those who are frustrated by the directions Windows is going might be interested in how organizational drama can affect the development of a product, even one as big and widely used as Windows. There’s more.
• First version of Redis written in TCL: A copy of the code used in the first version of Redis. If you ignore the fact that nobody actually knows TCL anymore, this is an interesting read, especially for trying to guess how the code works in a language you’ve never seen before. Plus some commentary from the original author and others in the comments.
• Secret React Internals: Secret react internals. Originally brought up in this stackoverflow post and again in this github issue.