Dipesh

Blogs, Papers and Podcasts

2001-03-25T00:00:00+00:00

Blogs and Podcasts</h1>

CSS tutorial series(looks nice)</a></li>
Making Sense of Acquire Release Semantics</a></li>
Tech Blogs Worth Reading by Austin Henley(Lots of nice blogs mentioned)</a></li>
Steve Yegge Blogs Old Blog</a> New Blog</a></li>
ten-great-books</a></li>
ten-challenges (more good books)</a></li>
Alex Kladov blogs</a></li>
Jane Street Tech Blog</a></li>
Uber Eng Blogs</a></li>
Discord Engineering Blog</a></li>
fasterthanli.me(so good)</a></li>
Sid Kshatriya Blogs, good blog on rust and rr debuggers</a></li>
Why Programmers Should(n't) Learn Theory</a></li>
Max Bernstein blog</a></li>
GoWind blogs</a></li>
Vesa blogs</a></li>
Eventhelix</a></li>
Gankra_'s blog</a></li>
Ralf Jung's blog(lot of advanced Rust things)</a></li>
Niko Matsiakis blog(lots of Rust stuff)</a></li>
Fernando Borretti's blog(again super nice PL blogs)</a></li>
V8 blog, many memory and general optimization related things</a></li>
Neel Krishnaswami's blog</a></li>
Michael Hick's blog</a></li>
Nicholas Nethercote(lots of stuff about rust, valgrind)</a></li>
Retrofitting Temporal Memory Safety on C++(HN Discussion)</a></li>
Russ Cox blog</a></li>
Hillel Wayne Blogs</a></li>
CS6120 Blogs</a>, 2019 version blogs</a> , 2020 version blog</a></li>
Nice blogs on C++/Clang mostly</a></li>
The best refactoring you've never heard of</a></li>
The best multicore-parallelization refactoring you've never heard of</a></li>
More stuff on Delimited Continuations</a></li>
Continuation and Delimited Control</a></li>
Yield : Mainstream Delimited Continuations; "yield" from different languages compared and formalized</a></li>
Too many cool topics in this site(See especially Types, Metaprogramming and Continuation related things)</a></li>
Way too much information about C++ coroutines</a></li>
mcyoung's blog(very nice systems and rust related posts)</a> and some readings</a></li>
MeloSpace notes(has distsys paper summaries and some more cool things in blogs)</a></li>
WebAssembly and replayable functions</a>, other blogs by the author are also cool</li>
System Design Interviews Overview</a></li>
Ideas for Programmers Looking Beyond Web Development</a></li>
Good blogs by Kipply</a></li>
Brian Callahan's blog(Lots of Compiler stuff)</a></li>
Lots of articles/resources on Typescript compiler , compilers, books, web performance stuff</a></li>
Type checker + Compiler Stuff</a></li>
Martin Kleppman blog</a></li>
Aphyr blogs, lots of distsys stuff</a></li>
Jepsen tagged posts on aphyr</a></li>
FoundationDB blogs(lottt of distsys + db content, I need to read this someday)</a></li>
Ted Kaminski blog(matklad recommends to read all of this in chronological order)</a></li>
[Justin Jaffray blogs,lots of DB stuff]https://justinjaffray.com/)</li>
Stefan Marr blogs</a></li>
Jamie Brandon</a> and logs?</a></li>
Red Vice Blogs</a></li>
SillyCross blogs</a></li>
Colin James blogs, compiling lambda calculus one looks nice</a></li>
Some nice PL related blogs by @prophet cohost</a></li>
Alex Miller Blog(distsys + db)</a></li>
Adding Dependent Types to Swift(Forum Discussion for the Pitch)</a></li> </ul>
Misc blogs</h2>

How to become a hacker</a></li> </ul>
Must Listen Podcasts</h2>

Signals and Threads</a> Some episodes that I highly recommend are:

Memory management with Stephen Dolan</li>
What is an Operating System? with Anil Madhavapeddy</li>
Language Design with Leo White</li>
Compiler Optimization with Greta Yorsh</li>
Build Systems with Andrey Mokhov</li> </ul> </li>
Type Theory Forall</a> Some episodes that I highly recommend are(I haven't listened to a lot of them):

#13 C/C++, Emacs, Haskell, and Coq. The Journey</li>
#23 What is the SIGPLAN?</li> </ul> </li>
Corecursive podcast</a></li>
TheForkJoin podcast</a></li> </ul>
Papers Reading List</h2>

Retrofitting Effect Handlers onto OCaml</a></li>
Retrofitting Parallelism onto OCaml</a></li>
Bounding Data Races in space and time</a></li>
Modular Implicits</a></li>
Build systems a la carte</a></li>
Boehm GC(papers and links in the site)</a></li>
A flexible type system for fearless concurrency</a></li>
Rust as a Language for High Performance GC Implementation</a></li>
On the nature of progress</a></li>
Engineering Record And Replay For Deployability: Extended Technical Report</a></li>
AUTOMATED VERIFICATION OF PRACTICAL GARBAGE COLLECTORS</a></li>
mimalloc(refer to the repo as well as the paper)</a></li>
Compiling Swift Generics(HN link which has pdf link with nice discussion section)</a></li>
Counting immutable beans</a></li>
Adaptive Functional Programming</a></li>
Self-Adjusting Computation(Umut Acar's thesis)</a></li>
Efficient Parallel Self-Adjusting Computation</a></li>
Making Concurrent Reference Counting as Fast as Manual Safe Memory Reclamation</a></li>
Optimizing pattern matching</a></li>
Bartosz Modelski's master's thesis</a></li>
Monadic Parser Combinator (Graham Hutton)</a></li>
Some papers list,categorized as well</a></li>
Frank McSherry's blog(this guy super cool)</a></li>
Daniel Hillerström's phd dissertation(effect handlers)</a></li>
effects-bibliography(lots of papers)</a></li>
Distributed Systems Papers</a></li>
A Unified Theory of Garbage Collection</a></li>
Making the Global Interpreter Lock optional in CPython(covers quite a lot of python internals)</a></li>
Project Loom proposal Java</a></li>
PDOS distributed systems readings</a></li>
Simple and Efficient Construction of SSA Form</a></li>
Cornell Programming Languages Discussion Group(nice papers list)</a></li>
Cilk: An Efficient Multithreaded Runtime System (Rayon is based on this)</a></li>
Some papers categorized, list seems okay, might check sometimes once these other things are done lol</a></li>
Programming Language Research, papers</a></li>
Recent Topics in Compilers - Papers</a></li> </ul>
Misc Posts from Different Forums</h2>

Reddit - Andras Kovac's comment, regarding Rust,GC and Haskell</a></li>
Swift Discuss - Swift type checking is undecidable</a></li> </ul>

C++

2001-03-25T00:00:00+00:00

C++</h1>

Basics</h2>

CppCon 2020 Back to Basics</a></li>
CppCon 2019 Back to Basics</a></li>
C++ with James McNeils and Kate Gregory</a></li>
Modern C++ CMU-DB bootcamp(The topics covered seem super nice)</a></li> </ul>
CMake</h2>

An Introduction to Modern CMake</a></li>
More Modern CMake</a></li>
Cpp starter project</a> with video</a></li> </ul>
C++ Tips</h2>

Sutter's Mill</a></li>
Abseil's C++ Tips</a></li> </ul>
Books</h2>

Effective Modern C++</li>
David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor - C++ Templates The Complete Guide (2017)</li>
A tour of C++</li>
learncpp.com</a></li> </ul>
Articles</h2>

Lambda Tuple</a></li>
Resources that help you to delve into C++</a></li>
Rust and C++ Interoperability</a></li>
C++ Coroutines</a></li>
Making Sense of Acquire Release Semantics</a></li>
Some clang related blogs</a></li>
Fibers under the magnifying glass</a></li>
Way too much information about C++ coroutines</a></li>
C++ coroutines</a></li>
Categorized C++ links</a></li> </ul>
Messed up templates stuff</h2>

TMP Lisp</a></li> </ul>
Podcasts/Series</h2>

CppCast</a></li>
Jason Turner's cpp weekly</a></li> </ul>
Misc</h2>

LLVM Box,self contained fully static llvm tools(Something similar to zig)</a></li>
Using Zig as C/C++ Compiler</a></li> </ul>
C++ advanced topics</h2>

ADL(Argument Dependent Lookup)</a></li>
CRTP(Curiously recurring template patterns)</a></li>
PIMPL</a></li>
RAII</a></li>
Rule of five</a></li>
CTAD(Class Template Argument Deduction)</a></li>
Full specialization</a></li>
Partial specialization</a></li>
Concepts</a></li>
Requires</a></li>
SFINAE</a></li>
Exceptions(See TOC as well)</a></li>
Memory Model</a></li>
Memory Ordering</a></li>
Storage Duraton and Linkage</a></li>
Inline</a></li>
Modules(pretty much useless till now)</a></li>
Const/volatile</a></li>
Move constructor</a></li>
Move assignment</a></li>
Copy constructor</a></li>
Copy assingnment</a></li>
Explicitly Defaulted and Deleted functions</a></li>
Value Categories</a></li>
Initialization(see TOC as well)</a></li>
Lambdas</a></li>
Coroutines(still sort of unusable)</a></li>
Objects and Alignment</a></li>
Casting mechanism in C++</a>, bit_cast</a>, reintepret_cast v/s bit_cast</a></li>
Placement new</a></li>
Strict aliasing 1</a>, 2</a>, 3</a></li>
std::launder</a> and std::start_lifetime_as</a></li>
What Every C Programmer should know about Undefined Behaviour(3 Part series by Chris Lattner)</a></li> </ul>

Haskell

2001-03-25T00:00:00+00:00

Haskell</h1>

Type Systems re Haskell</a></li> </ul>
Videos</h2>

Functional Programming in Haskell</a></li>
Advanced Functional Programming in Haskell</a></li>
Haskell For Imperative Programmers</a></li> </ul>
Problems</h2>

99 Problems</a></li> </ul>
Monads</h2>

All About Monads</a></li>
Tackling the Awkward Squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell</a></li> </ul>
Internals</h2>

Alexis King - “Effects for Less” @ ZuriHac 2020(content is just madd)</a> , GHC proposal link</a></li>
GHC Reading List</a></li>
@lexi_lambda: The GHC optimization pipeline</a></li>
@lexi_lambda: GHC Simplifier basics</a></li>
@rae's Thoughts on Haskell(playlist with some advanced topics)</a></li>
GHC internals by Stephen Diehl(series of posts)</a></li> </ul>

HN Links

2001-03-25T00:00:00+00:00



Languages
2001-03-25T00:00:00+00:00
Languages</h1>
C</h2>


Pointers</a></li>

Beej C</a></li>
</ul>
Scheme</h2>


SICP</a></li>
</ul>
Zig</h2>


How a Zig IDE could work(HN)</a></li>

When Zig is safer and faster than Rust</a></li>
</ul>
JavaScript(Highly Recommended,State of the Art Stuff)</h2>


Riptide,Webkit's GC</a></li>

B3 Jit Compiler</a></li>

Speculation in JSC</a></li>

Concurrent JavaScript, It Can Work</a></li>

Understanding GC in JSC From Scratch</a></li>

High Performance GC for C++</a></li>

Precise Stack Scanning in C++</a></li>
</ul>
React</h3>


Understanding React Compiler</a></li>

React as a UI Runtime</a></li>
</ul>
Golang</h2>


Dmitry Vyukov — Go scheduler: Implementing language with lightweight concurrency </a></li>

Proposal: Non-cooperative goroutine preemption</a></li>

Preemption in Go: an introduction</a>, code</a></li>
</ul>
Python</h2>


Gil removal and faster CPython project</a></li>
</ul>
Swift</h2>


Swift for C++ Practitioners</a></li>
</ul>


Lobste.rs Links
2001-03-25T00:00:00+00:00

Having your compile-time cake and eating it too</a> , Lobste.rs Discussion</a></li>
What Works (and Doesn't) Selling Formal Methods</a> , Lobste.rs Discussion</a></li>
How I used o3 to find CVE-2025-37899, a remote zeroday vulnerability in the Linux kernel’s SMB implementation</a> , Lobste.rs Discussion</a></li>
Domain Theory Lecture Notes</a> , Lobste.rs Discussion</a></li>
The Illusion of Thinking</a> , Lobste.rs Discussion</a></li>
Agentic Coding Recommendations</a> , Lobste.rs Discussion</a></li>
What I talk about when I talk about IRs</a> , Lobste.rs Discussion</a></li>
Compiler Explorer Cost Transparency</a> , Lobste.rs Discussion</a></li>
Compiler Explorer and the Promise of URLs That Last Forever</a> , Lobste.rs Discussion</a></li>
Writing a Verified Postfix Calculator in Ada/SPARK</a> , Lobste.rs Discussion</a></li>
Type-based vs Value-based Reflection</a> , Lobste.rs Discussion</a></li>
Introducing facet: Reflection for Rust</a> , Lobste.rs Discussion</a></li>
jemalloc Postmortem</a> , Lobste.rs Discussion</a></li>
Raku's "core"</a> , Lobste.rs Discussion</a></li>
OxCaml, Jane Street's extension of OCaml is now open-source</a> , Lobste.rs Discussion</a></li>
Datalog in Rust</a> , Lobste.rs Discussion</a></li>
strace tips for better debugging</a> , Lobste.rs Discussion</a></li>
Implementing Logic Programming</a> , Lobste.rs Discussion</a></li>
A meta-analysis of three different notions of software complexity</a> , Lobste.rs Discussion</a></li>
StarMalloc: verified memory allocator</a> , Lobste.rs Discussion</a></li>
The Zed Debugger is Here</a> , Lobste.rs Discussion</a></li>
What Would a Kubernetes 2.0 Look Like</a> , Lobste.rs Discussion</a></li>
I wrote my PhD Thesis in Typst</a> , Lobste.rs Discussion</a></li>
Discover C++26’s compile-time reflection</a> , Lobste.rs Discussion</a></li>
Gemini CLI: your open-source AI agent</a> , Lobste.rs Discussion</a></li>
How fast are Linux pipes anyway? (2022)</a> , Lobste.rs Discussion</a></li>
Fixing Letrec (Reloaded)</a> , Lobste.rs Discussion</a></li>
To Bind and Loose a Reference (2020)</a> , Lobste.rs Discussion</a></li>
How to Grow an LSM-tree? Towards Bridging the Gap Between Theory and Practice</a> , Lobste.rs Discussion</a></li>
Subtype Inference by Example</a> , Lobste.rs Discussion</a></li>
Interfacing MCP with Combinatorial, Convex, and SMT Solvers</a> , Lobste.rs Discussion</a></li>
Zero-Cost 'Tagless Final' in Rust with GADT-style Enums</a> , Lobste.rs Discussion</a></li>
What's higher-order about so-called higher-order references?</a> , Lobste.rs Discussion</a></li>
Uniqueness for Behavioural Types</a> , Lobste.rs Discussion</a></li>
Handling bidirectional control flow</a> , Lobste.rs Discussion</a></li>
How Compiler Explorer Works in 2025</a> , Lobste.rs Discussion</a></li>
AI Changes Everything</a> , Lobste.rs Discussion</a></li>
I Think I’m Done Thinking About genAI For Now</a> , Lobste.rs Discussion</a></li>
AI is a gamechanger for TLA+ users</a> , Lobste.rs Discussion</a></li>
A programming system</a> , Lobste.rs Discussion</a></li>
In which I have Opinions about parsing and grammars</a> , Lobste.rs Discussion</a></li>
Linearity and uniqueness</a> , Lobste.rs Discussion</a></li>
APLearn: machine learning library</a> , Lobste.rs Discussion</a></li>
Jepsen: TigerBeetle 0.16.11</a> , Lobste.rs Discussion</a></li>
Just fucking code</a> , Lobste.rs Discussion</a></li>
How can one write blazing fast yet useful compilers (for lazy pure functional languages)?</a> , Lobste.rs Discussion</a></li>
I Read All Of Cloudflare's Claude-Generated Commits</a> , Lobste.rs Discussion</a></li>
How I program with Agents</a> , Lobste.rs Discussion</a></li>
The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity</a> , Lobste.rs Discussion</a></li>
Patterns for failure-free, bounded-space, and bounded-time programming</a> , Lobste.rs Discussion</a></li>
Zig-style generics are not well-suited for most languages (2022)</a> , Lobste.rs Discussion</a></li>
Why doesn’t Rust care more about compiler performance?</a> , Lobste.rs Discussion</a></li>
GenAI Criticism and Moral Quandaries</a> , Lobste.rs Discussion</a></li>
container: tool for creating and running Linux containers using lightweight virtual machines on a Mac</a> , Lobste.rs Discussion</a></li>
WebAssembly Troubles part 4: Microwasm (2019)</a> , Lobste.rs Discussion</a></li>
Memory Safe Languages: Reducing Vulnerabilities in Modern Software Development</a> , Lobste.rs Discussion</a></li>
"Why is the Rust compiler so slow?"</a> , Lobste.rs Discussion</a></li>
Box combinators</a> , Lobste.rs Discussion</a></li>
Weird expressions in rust</a> , Lobste.rs Discussion</a></li>
Notes on type inference and polymorphism</a> , Lobste.rs Discussion</a></li>
How much code does that proc macro generate?</a> , Lobste.rs Discussion</a></li>
Reflecting JSON into C++ Objects at compile time</a> , Lobste.rs Discussion</a></li>
Solving UK Passport Application</code> with Haskell</a> , Lobste.rs Discussion</a></li>
Inequality Union Finds: Baby Steps to Refinement E-graphs</a> , Lobste.rs Discussion</a></li>
Programming as Theory Building</a> , Lobste.rs Discussion</a></li>
Tree-Structured Concurrency II: Replacing Background Tasks With Actors</a> , Lobste.rs Discussion</a></li>
Parsing Layout, or: Haskell's Syntax is a Mess</a> , Lobste.rs Discussion</a></li>
Awesome Emacs on macOS</a> , Lobste.rs Discussion</a></li>
Just make it scale: An Aurora DSQL story</a> , Lobste.rs Discussion</a></li>
MCP explained without hype or fluff</a> , Lobste.rs Discussion</a></li>
Async Traits Can Be Directly Backed By Manual Future Impls</a> , Lobste.rs Discussion</a></li>
Type-level Bounded Recursion in Rust</a> , Lobste.rs Discussion</a></li>
Large Language Models can run tools in your terminal with LLM 0.26</a> , Lobste.rs Discussion</a></li>
A break from programming languages</a> , Lobste.rs Discussion</a></li>
Systems Correctness Practices at Amazon Web Services</a> , Lobste.rs Discussion</a></li>
I am disappointed in the AI discourse</a> , Lobste.rs Discussion</a></li>
parking_lot: ffffffffffffffff</a> , Lobste.rs Discussion</a></li>
Tools built on tree-sitter's concrete syntax trees</a> , Lobste.rs Discussion</a></li>
Types of Types: Common to Exotic</a> , Lobste.rs Discussion</a></li>
Reflections on Haskell and Rust</a> , Lobste.rs Discussion</a></li>
Tools: Code Is All You Need</a> , Lobste.rs Discussion</a></li>
The scary and surprisingly deep rabbit hole of Rust's temporaries</a> , Lobste.rs Discussion</a></li>
The Tree Borrows paper is finally published</a> , Lobste.rs Discussion</a></li>
WebAssembly: Yes, but for What?</a> , Lobste.rs Discussion</a></li>
Oregon Programming Languages Summer School (OPLSS) 2025: Types, Logic, and Formal Methods</a> , Lobste.rs Discussion</a></li>
The case against which-key: a polemic</a> , Lobste.rs Discussion</a></li>
Deterministic Simulation Testing in Rust: A Theater Of State Machines</a> , Lobste.rs Discussion</a></li>
“Bad Apple!!” But It’s 3288 Lean Tactics Spamming VSCode</a> , Lobste.rs Discussion</a></li>
Unified Memory Management</a> , Lobste.rs Discussion</a></li>
Variadic Generics ideas that won’t work for Rust</a> , Lobste.rs Discussion</a></li>
MicroHs, a tiny Haskell Compiler</a> , Lobste.rs Discussion</a></li>
(Quite) A Few Words About Async</a> , Lobste.rs Discussion</a></li>
Programming Language Theory has a public relations problem</a> , Lobste.rs Discussion</a></li>
Zig's New Async I/O</a> , Lobste.rs Discussion</a></li>
detour: A detour through the Linux dynamic linker</a> , Lobste.rs Discussion</a></li>
constrained languages are easier to optimize</a> , Lobste.rs Discussion</a></li>
Hacking coroutines into C</a> , Lobste.rs Discussion</a></li>
Store tags after payloads</a> , Lobste.rs Discussion</a></li>
Row Polymorphic Programming</a> , Lobste.rs Discussion</a></li>
Binding Application in Idris</a> , Lobste.rs Discussion</a></li>
Automerge 3.0</a> , Lobste.rs Discussion</a></li>
A distributed systems reliability glossary</a> , Lobste.rs Discussion</a></li>
"Bypassing" specialization in Rust or How I Learned to Stop Worrying and Love Function Pointers</a> , Lobste.rs Discussion</a></li>
A Rust shaped hole</a> , Lobste.rs Discussion</a></li>
Designing Kotlin Beyond Type Inference</a> , Lobste.rs Discussion</a></li>
My favorite use-case for AI is writing logs</a> , Lobste.rs Discussion</a></li>
How bad are search results? Let's compare Google, Bing, Marginalia, Kagi, Mwmbl, and ChatGPT</a> , Lobste.rs Discussion</a></li>
Some notes on using nix</a> , Lobste.rs Discussion</a></li>
What are temporal and spatial memory safety?</a> , Lobste.rs Discussion</a></li>
Demystifying monads in Rust through property-based testing</a> , Lobste.rs Discussion</a></li>
Typst 0.13 is out now: Experimental HTML export, semantic paragraphs, and more</a> , Lobste.rs Discussion</a></li>
Five Kinds of Nondeterminism</a> , Lobste.rs Discussion</a></li>
Towards A Simple and Expressive Query Language</a> , Lobste.rs Discussion</a></li>
Neut Programming Language</a> , Lobste.rs Discussion</a></li>
My go-to C++ code for asynchronous work processing on a separate thread</a> , Lobste.rs Discussion</a></li>
Carbon Copy Newsletter No.5</a> , Lobste.rs Discussion</a></li>
Garbage Collected Smart Pointers in Rust via Concurrent Cycle Collection</a> , Lobste.rs Discussion</a></li>
Firefox has surpassed Chrome on Speedometer</a> , Lobste.rs Discussion</a></li>
So you want to be a proof engineer?</a> , Lobste.rs Discussion</a></li>
The E-graph extraction problem is NP-complete</a> , Lobste.rs Discussion</a></li>
CCDetect-lsp: Language-agnostic real-time duplicate code detection LSP server</a> , Lobste.rs Discussion</a></li>
The Hunt for the Missing Data Type</a> , Lobste.rs Discussion</a></li>
JVM/Java: Null-Restricted and Nullable Types</a> , Lobste.rs Discussion</a></li>
What conferences are you all looking forward to?</a> , Lobste.rs Discussion</a></li>
The gen auto-trait problem</a> , Lobste.rs Discussion</a></li>
Vine: A programming language based on Interaction Nets</a> , Lobste.rs Discussion</a></li>
Investigating a Strange Out-of-Memory Error</a> , Lobste.rs Discussion</a></li>
Fenwick Trees are Awesome</a> , Lobste.rs Discussion</a></li>
Why Checked Exceptions Failed</a> , Lobste.rs Discussion</a></li>
Mapping High Level Constructs to LLVM IR</a> , Lobste.rs Discussion</a></li>
So You Want To Build A Browser Engine</a> , Lobste.rs Discussion</a></li>
Fun Friday: what got you into programming?</a> , Lobste.rs Discussion</a></li>
Lamport clocks</a> , Lobste.rs Discussion</a></li>
Semgrep: a static analysis journey</a> , Lobste.rs Discussion</a></li>
Generalized Autoref-Based Specialization (2019)</a> , Lobste.rs Discussion</a></li>
Whither CockroachDB?</a> , Lobste.rs Discussion</a></li>
Beyond Ctrl-C: The dark corners of Unix signal handling</a> , Lobste.rs Discussion</a></li>
Shell History Is Your Best Productivity Tool</a> , Lobste.rs Discussion</a></li>
More Software Projects need Defenses of Design</a> , Lobste.rs Discussion</a></li>
A quick look at destination-driven code generation</a> , Lobste.rs Discussion</a></li>
Why Split Lexing and Parsing Into Two Separate Phases?</a> , Lobste.rs Discussion</a></li>
Small VMs & Coroutines</a> , Lobste.rs Discussion</a></li>
Ownership</a> , Lobste.rs Discussion</a></li>
Fish 4.0: The Fish Of Theseus</a> , Lobste.rs Discussion</a></li>
How Multi-User Dungeons Taught Me To Code</a> , Lobste.rs Discussion</a></li>
requiem for a stringref</a> , Lobste.rs Discussion</a></li>
Thinking about functional programming</a> , Lobste.rs Discussion</a></li>
Stuff I learnt in 2022</a> , Lobste.rs Discussion</a></li>
Debugging a rustc segfault on illumos</a> , Lobste.rs Discussion</a></li>
Bytecode VMs in surprising places</a> , Lobste.rs Discussion</a></li>
Cheating is All You Need</a> , Lobste.rs Discussion</a></li>
I made a multi-language programmable linter</a> , Lobste.rs Discussion</a></li>
Async Rust Is A Bad Language</a> , Lobste.rs Discussion</a></li>
What Goes Around Comes Around... And Around</a> , Lobste.rs Discussion</a></li>
Contributing to OCaml: Collective maintenance</a> , Lobste.rs Discussion</a></li>
Properly Testing Concurrent Data Structures</a> , Lobste.rs Discussion</a></li>
Will it block?</a> , Lobste.rs Discussion</a></li>
Distributed Systems Programming Has Stalled</a> , Lobste.rs Discussion</a></li>
Building Query Compilers</a> , Lobste.rs Discussion</a></li>
A Mechanically Verified Garbage Collector for OCaml</a> , Lobste.rs Discussion</a></li>
Our optimizers need a rethink</a> , Lobste.rs Discussion</a></li>
What’s in an e-graph?</a> , Lobste.rs Discussion</a></li>
A Distributed Systems Reading List</a> , Lobste.rs Discussion</a></li>
Making OCaml Safe for Performance Engineering</a> , Lobste.rs Discussion</a></li>
Designing a Distributed SQL Engine: Challenges and Decisions</a> , Lobste.rs Discussion</a></li>
Formal Methods: Just Good Engineering Practice?</a> , Lobste.rs Discussion</a></li>
Fast LLM Inference From Scratch</a> , Lobste.rs Discussion</a></li>
Memory Order in C++ (2022)</a> , Lobste.rs Discussion</a></li>
My spiciest take on tech hiring</a> , Lobste.rs Discussion</a></li>
Data Replication Design Spectrum</a> , Lobste.rs Discussion</a></li>
The algebra (and calculus!) of algebraic data types</a> , Lobste.rs Discussion</a></li>
Types comparison: Rust -> Zig</a> , Lobste.rs Discussion</a></li>
The World's Simplest Lock-Free Hash Table (2013)</a> , Lobste.rs Discussion</a></li>
Kalyn: a self-hosting compiler for x86-64</a> , Lobste.rs Discussion</a></li>
Pinned places</a> , Lobste.rs Discussion</a></li>
On "Safe" C++</a> , Lobste.rs Discussion</a></li>
Pin</a> , Lobste.rs Discussion</a></li>
Address Sanitizer Internals</a> , Lobste.rs Discussion</a></li>
Copy Hunting</a> , Lobste.rs Discussion</a></li>
What's the big deal about Deterministic Simulation Testing?</a> , Lobste.rs Discussion</a></li>
Why choose async/await over threads?</a> , Lobste.rs Discussion</a></li>
On Recursion, Continuations and Trampolines</a> , Lobste.rs Discussion</a></li>
In 2024, please switch to Firefox</a> , Lobste.rs Discussion</a></li>
Challenging projects every programmer should try (2019)</a> , Lobste.rs Discussion</a></li>
Why Test?</a> , Lobste.rs Discussion</a></li>
Type system of the React compiler</a> , Lobste.rs Discussion</a></li>
The looming demise of the 10x developer</a> , Lobste.rs Discussion</a></li>
The path to implementing a programming language</a> , Lobste.rs Discussion</a></li>
Big Datatype: why code tools like to be written with fancy types</a> , Lobste.rs Discussion</a></li>
A Fascinating Diversion into Compression</a> , Lobste.rs Discussion</a></li>
Encoding ML-style modules in Rust</a> , Lobste.rs Discussion</a></li>
Async/Await Is Real And Can Hurt You</a> , Lobste.rs Discussion</a></li>
Memory Safe C++</a> , Lobste.rs Discussion</a></li>
An opinion on what's a good general-purpose programming language</a> , Lobste.rs Discussion</a></li>
Database Fundamentals</a> , Lobste.rs Discussion</a></li>
How Capabilities Work in Austral</a> , Lobste.rs Discussion</a></li>
Java is becoming more like Rust, and I am here for it</a> , Lobste.rs Discussion</a></li>
Nix is a build system</a> , Lobste.rs Discussion</a></li>
Implementing Raft: Part 5 - Exactly-once delivery</a> , Lobste.rs Discussion</a></li>
Turing Machines</a> , Lobste.rs Discussion</a></li>
Building Bridges to C++</a> , Lobste.rs Discussion</a></li>
A close encounter with false sharing</a> , Lobste.rs Discussion</a></li>
You Could Have Invented Normalization-by-Evaluation</a> , Lobste.rs Discussion</a></li>
Rust's Most Subtle Syntax</a> , Lobste.rs Discussion</a></li>
C++ programmer′s guide to undefined behavior: part 8 of 11</a> , Lobste.rs Discussion</a></li>
MinPin: yet another pin proposal</a> , Lobste.rs Discussion</a></li>
Principles of Dependent Type Theory</a> , Lobste.rs Discussion</a></li>
Why I love Rust for tokenising and parsing</a> , Lobste.rs Discussion</a></li>
How We Built a Self-Healing System to Survive a Terrifying Concurrency Bug At Netflix</a> , Lobste.rs Discussion</a></li>
determination: Rust typecheckers for System F and System F-omega</a> , Lobste.rs Discussion</a></li>
Functors to Monads: A Story of Shapes</a> , Lobste.rs Discussion</a></li>
Non-Send Futures When?</a> , Lobste.rs Discussion</a></li>
Some tricks from the Scrapscript compiler</a> , Lobste.rs Discussion</a></li>
Maybe Everything Is a Coroutine</a> , Lobste.rs Discussion</a></li>
What is a Query Optimizer for?</a> , Lobste.rs Discussion</a></li>
An intuition for distributed consensus in OLTP systems</a> , Lobste.rs Discussion</a></li>
Towards zero-downtime upgrades of stateful systems</a> , Lobste.rs Discussion</a></li>
The e-graph data structure: a gradual introduction</a> , Lobste.rs Discussion</a></li>
Async Rust can be a pleasure to work with (without Send + Sync + 'static</code>)</a> , Lobste.rs Discussion</a></li>
C and C++ Prioritize Performance over Correctness</a> , Lobste.rs Discussion</a></li>
What are your favourite pieces of software?</a> , Lobste.rs Discussion</a></li>
A Grand Unified Theory of the AI Hype Cycle</a> , Lobste.rs Discussion</a></li>
What is the reason for the /a /b prefixes of git diff?</a> , Lobste.rs Discussion</a></li>
What is the best pointer tagging method?</a> , Lobste.rs Discussion</a></li>
A CAP tradeoff in the wild</a> , Lobste.rs Discussion</a></li>
Emacs From Scratch, Part 1: Foundations</a> , Lobste.rs Discussion</a></li>
Threads with WebAssembly</a> , Lobste.rs Discussion</a></li>
2025: The Year of 1,000 DataFusion-Based Systems</a> , Lobste.rs Discussion</a></li>
Postgres sequences can commit out-of-order</a> , Lobste.rs Discussion</a></li>
What’s so hard about constexpr allocation?</a> , Lobste.rs Discussion</a></li>
Elixir type system updates moving from research into development</a> , Lobste.rs Discussion</a></li>
More thoughts on claiming</a> , Lobste.rs Discussion</a></li>
More use of Rust is inevitable in open source software</a> , Lobste.rs Discussion</a></li>
Build faster with Buck2: Our open source build system</a> , Lobste.rs Discussion</a></li>
The Inside Story of ClickHouse (9): How to Perform Aggregation</a> , Lobste.rs Discussion</a></li>
Some notes on Rust, mutable aliasing and formal verification</a> , Lobste.rs Discussion</a></li>
Go's concurrency in a dynamic language Rye</a> , Lobste.rs Discussion</a></li>
Techniques for Safe Garbage Collection in Rust</a> , Lobste.rs Discussion</a></li>
How Cache Memory Works</a> , Lobste.rs Discussion</a></li>
Trustfall</a> , Lobste.rs Discussion</a></li>
Why Trees Without Branches Grow Faster: The Case for Reducing Branches in Code</a> , Lobste.rs Discussion</a></li>
Parametric Subtyping for Structural Parametric Polymorphism</a> , Lobste.rs Discussion</a></li>
Pointers Are Complicated II, or: We need better language specs (2020)</a> , Lobste.rs Discussion</a></li>
How Jane Street accidentally built a better build system for OCaml</a> , Lobste.rs Discussion</a></li>
Preview crates</a> , Lobste.rs Discussion</a></li>
Adding garbage collection to our Rust-based interpreters with MMTk</a> , Lobste.rs Discussion</a></li>
Introducing Werk</a> , Lobste.rs Discussion</a></li>
Perf is not enough</a> , Lobste.rs Discussion</a></li>
Abstract interpretation in the Toy Optimizer</a> , Lobste.rs Discussion</a></li>
Compiler Development: Rust or OCaml?</a> , Lobste.rs Discussion</a></li>
What is your Mac OS Setup?</a> , Lobste.rs Discussion</a></li>
Compare the Assembly Generated for Static vs Dynamic Dispatch in Rust</a> , Lobste.rs Discussion</a></li>
Damas-Hindley-Milner inference two ways</a> , Lobste.rs Discussion</a></li>
Safety in Programming Languages is a Means to an End</a> , Lobste.rs Discussion</a></li>
What software do you dream about, but do not have time to code yourself?</a> , Lobste.rs Discussion</a></li>
Notes on Type Layouts and ABIs in Rust (2018)</a> , Lobste.rs Discussion</a></li>
Pinning Down "Future Is Not Send" Errors</a> , Lobste.rs Discussion</a></li>
clr: Checker for Lifetimes and other Refinement types</a> , Lobste.rs Discussion</a></li>
A compiler IR for Scrapscript</a> , Lobste.rs Discussion</a></li>
Decorator JITs - Python as a DSL</a> , Lobste.rs Discussion</a></li>
Cooperative multitasking in Rust</a> , Lobste.rs Discussion</a></li>
Zig's Comptime is Bonkers Good</a> , Lobste.rs Discussion</a></li>
The Three Projections of Doctor Futamura (2009)</a> , Lobste.rs Discussion</a></li>
The inevitability of the borrow checker</a> , Lobste.rs Discussion</a></li>
baffled by generational garbage collection</a> , Lobste.rs Discussion</a></li>
Carbon is not a programming language (sort of)</a> , Lobste.rs Discussion</a></li>
LRGrep: Selecting Error Messages for LR parsers</a> , Lobste.rs Discussion</a></li>
LocalStorage vs. IndexedDB vs. Cookies vs. OPFS vs. WASM-SQLite</a> , Lobste.rs Discussion</a></li>
So you're writing a programming language</a> , Lobste.rs Discussion</a></li>
They all use it</a> , Lobste.rs Discussion</a></li>
How I run my servers</a> , Lobste.rs Discussion</a></li>
bfs 3.0: the fastest find yet</a> , Lobste.rs Discussion</a></li>
The Seamstress Event Loop In Zig</a> , Lobste.rs Discussion</a></li>
Crossing the Impossible FFI Boundary, and My Gradual Descent Into Madness</a> , Lobste.rs Discussion</a></li>
whippet: towards a new local maximum</a> , Lobste.rs Discussion</a></li>
Place expressions and value expressions in Rust</a> , Lobste.rs Discussion</a></li>
Enabling seamless interop between Rust and other languages</a> , Lobste.rs Discussion</a></li>
C++/Rust Interoperability Problem Statement</a> , Lobste.rs Discussion</a></li>
The legend of "x86 CPUs decode instructions into RISC form internally"</a> , Lobste.rs Discussion</a></li>
Ergonomic Self-Referential Types for Rust</a> , Lobste.rs Discussion</a></li>
So you think you want to write a deterministic hypervisor?</a> , Lobste.rs Discussion</a></li>
Land ahoy: leaving the Sea of Nodes</a> , Lobste.rs Discussion</a></li>
Bringing Record and Replay everywhere</a> , Lobste.rs Discussion</a></li>
Typst as a Language</a> , Lobste.rs Discussion</a></li>
Tree Calculus</a> , Lobste.rs Discussion</a></li>
What are your favorite non-standard CLI utilities/applications</a> , Lobste.rs Discussion</a></li>
Weak references and garbage collectors</a> , Lobste.rs Discussion</a></li>
Zig May Pass Anything By Reference</a> , Lobste.rs Discussion</a></li>
Faster compilation with the parallel front-end in nightly</a> , Lobste.rs Discussion</a></li>
What is the type of Type?</a> , Lobste.rs Discussion</a></li>
Thinking like a compiler: places and values in Rust</a> , Lobste.rs Discussion</a></li>
Composable SQL</a> , Lobste.rs Discussion</a></li>
How fast is your shell?</a> , Lobste.rs Discussion</a></li>
A 2024 Discussion Whether To Convert The Linux Kernel From C To Modern C++</a> , Lobste.rs Discussion</a></li>
Typst 0.12 is just ... better</a> , Lobste.rs Discussion</a></li>
First-Class Modules and Modular Implicits in OCaml (2017)</a> , Lobste.rs Discussion</a></li>
Lezer</a> , Lobste.rs Discussion</a></li>
Rust needs an official specification</a> , Lobste.rs Discussion</a></li>
Analyzing the codebase of Caffeine: a high performance caching library</a> , Lobste.rs Discussion</a></li>
SICP in Emacs</a> , Lobste.rs Discussion</a></li>
breakelse: When Compiler Developers Get Bored</a> , Lobste.rs Discussion</a></li>
"Where have all the hackers gone?" + a way to discuss programming languages</a> , Lobste.rs Discussion</a></li>
The life and times of an Abstract Syntax Tree</a> , Lobste.rs Discussion</a></li>
Rust std fs slower than Python!? No, it's hardware</a> , Lobste.rs Discussion</a></li>
How conditional breakpoints work</a> , Lobste.rs Discussion</a></li>
How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More</a> , Lobste.rs Discussion</a></li>
A response to 'A decade of developing a programming language'</a> , Lobste.rs Discussion</a></li>
Functional Semantics in Imperative Clothing</a> , Lobste.rs Discussion</a></li>
Compilation of JavaScript to Wasm, part 3: Partial evaluation</a> , Lobste.rs Discussion</a></li>
RustRover Is Released and Includes a Free Non-Commercial Option</a> , Lobste.rs Discussion</a></li>
Who Killed the Network Switch? A Hubris Bug Story</a> , Lobste.rs Discussion</a></li>
Usb-C and its overengineered history</a> , Lobste.rs Discussion</a></li>
BTrees, Inverted Indices, and a Model for Full Text Search</a> , Lobste.rs Discussion</a></li>
Async from scratch 1: What's in a Future, anyway?</a> , Lobste.rs Discussion</a></li>
facet: Rust reflection, serialization, deserialization — know the shape of your types</a> , Lobste.rs Discussion</a></li>
Why is Snapshot Isolation not enough?</a> , Lobste.rs Discussion</a></li>
How to Sync Anything</a> , Lobste.rs Discussion</a></li>
React for Two Computers</a> , Lobste.rs Discussion</a></li>
"Verified" "Compilation" of "Python" with Knuckledragger, GCC, and Ghidra</a> , Lobste.rs Discussion</a></li>
Erlang’s not about lightweight processes and message passing…</a> , Lobste.rs Discussion</a></li>
FuturesUnordered and the order of futures</a> , Lobste.rs Discussion</a></li>
Flambda2 Ep. 2: Loopifying Tail-Recursive Functions</a> , Lobste.rs Discussion</a></li>
A decade of developing a programming language</a> , Lobste.rs Discussion</a></li>
We have proved "BB(5) = 47,176,870"</a> , Lobste.rs Discussion</a></li>
What I Learned Building a CLI App in Rust</a> , Lobste.rs Discussion</a></li>
NP-Complete isn't (always) Hard</a> , Lobste.rs Discussion</a></li>
A curiously recurring lifetime issue</a> , Lobste.rs Discussion</a></li>
Good theory books you would recommend?</a> , Lobste.rs Discussion</a></li>
Flambda2 Ep. 3: Speculative Inlining</a> , Lobste.rs Discussion</a></li>
The missing tier for query compilers</a> , Lobste.rs Discussion</a></li>
Derivative grammars: a symbolic approach to parsing with derivatives</a> , Lobste.rs Discussion</a></li>
Async Rust</a> , Lobste.rs Discussion</a></li>
On Learning Compilers and Creating Programming Languages</a> , Lobste.rs Discussion</a></li>
Haskell: A Great Procedural Language</a> , Lobste.rs Discussion</a></li>
Why Swift's type checker is slow</a> , Lobste.rs Discussion</a></li>
An Intro to DeepSeek's Distributed File System</a> , Lobste.rs Discussion</a></li>
Two Years of Rust</a> , Lobste.rs Discussion</a></li>
Atomicless Concurrency (2023)</a> , Lobste.rs Discussion</a></li>
Flambda2 Ep. 4: How to write a purely functional compiler</a> , Lobste.rs Discussion</a></li>
Async from scratch 2: Wake me maybe</a> , Lobste.rs Discussion</a></li>
Decomposing Transactional Systems</a> , Lobste.rs Discussion</a></li>
15,000 lines of verified cryptography now in Python</a> , Lobste.rs Discussion</a></li>
falsify: Hypothesis-inspired shrinking for Haskell</a> , Lobste.rs Discussion</a></li>
A Survey Of System Languages (2024)</a> , Lobste.rs Discussion</a></li>
All my favorite tracing tools: eBPF, QEMU, Perfetto, new ones I built and more</a> , Lobste.rs Discussion</a></li>
Async Rust is about concurrency, not (just) performance</a> , Lobste.rs Discussion</a></li>
How decentralized is Bluesky really?</a> , Lobste.rs Discussion</a></li>
How Designing Carbon C++ Interop Taught me About C++ Variadics & Bound Members</a> , Lobste.rs Discussion</a></li>
Why is std::pin::Pin so weird?</a> , Lobste.rs Discussion</a></li>
Improving the approachability of data-race safety</a> , Lobste.rs Discussion</a></li>
The most elegant search data structure | (a,b)-trees</a> , Lobste.rs Discussion</a></li>
Visions of the future: formal verification in Rust</a> , Lobste.rs Discussion</a></li>
Too dangerous for C++</a> , Lobste.rs Discussion</a></li>
The last 5 years of V8's garbage collector</a> , Lobste.rs Discussion</a></li>
Compiling higher order functions with GADTs</a> , Lobste.rs Discussion</a></li>
My Kind of REPL</a> , Lobste.rs Discussion</a></li>
How do databases execute expressions?</a> , Lobste.rs Discussion</a></li>
What is PID 0?</a> , Lobste.rs Discussion</a></li>
Effects, capabilities, and boxes: from scope-based reasoning to type-based reasoning and back (2022)</a> , Lobste.rs Discussion</a></li>
Introducing: Zero to Nix</a> , Lobste.rs Discussion</a></li>
My thoughts on OCaml</a> , Lobste.rs Discussion</a></li>
On Tech Debt: My Rust Library is now a CDO</a> , Lobste.rs Discussion</a></li>
LSP: the good, the bad, and the ugly</a> , Lobste.rs Discussion</a></li>
Things Zig comptime Won't Do</a> , Lobste.rs Discussion</a></li>
Exploiting Undefined Behavior in C/C++ Programs for Optimization: A Study on the Performance Impact</a> , Lobste.rs Discussion</a></li>
Zed Decoded: Linux when?</a> , Lobste.rs Discussion</a></li>
Okay, fine, I'm using a static site generator now</a> , Lobste.rs Discussion</a></li>
Was Rust Worth It For Us?</a> , Lobste.rs Discussion</a></li>
TigerBeetle Architecture</a> , Lobste.rs Discussion</a></li>
Generics and Typeclasses in Knuckledragger</a> , Lobste.rs Discussion</a></li>
Claiming, auto and otherwise</a> , Lobste.rs Discussion</a></li>
Modular Borrowing Without Ownership or Linear Types</a> , Lobste.rs Discussion</a></li>
Adding row polymorphism to Damas-Hindley-Milner</a> , Lobste.rs Discussion</a></li>
Unsafe Rust Is Harder Than C</a> , Lobste.rs Discussion</a></li>
Generators with UnpinCell</a> , Lobste.rs Discussion</a></li>
The most ugly trick in Rust language</a> , Lobste.rs Discussion</a></li>
HYTRADBOI 2025 postmortem</a> , Lobste.rs Discussion</a></li>
Answer Set Programming 01 | Just the Facts</a> , Lobste.rs Discussion</a></li>
Algebraic effects are a functional approach to manage side effects</a> , Lobste.rs Discussion</a></li>
Distributed Systems without Raft (part 1)</a> , Lobste.rs Discussion</a></li>
Systems Correctness Practices at AWS: Leveraging Formal and Semi-formal Methods</a> , Lobste.rs Discussion</a></li>
Bit-Stealing Made Legal: Compilation for Custom Memory Representations Of Algebraic Data Types</a> , Lobste.rs Discussion</a></li>
Career advice for young system programmers</a> , Lobste.rs Discussion</a></li>
Some Programming Language Ideas</a> , Lobste.rs Discussion</a></li>
TigerBeetle on The Primeagen</a> , Lobste.rs Discussion</a></li>
Dada, an experiement by the creators of Rust</a> , Lobste.rs Discussion</a></li>
An alternative idea for a typed language living alongside/inside JavaScript</a> , Lobste.rs Discussion</a></li>
An epic treatise on error models for systems programming languages</a> , Lobste.rs Discussion</a></li>
Databases are not Compilers</a> , Lobste.rs Discussion</a></li>
Fixing the Next 10,000 Aliasing Bugs</a> , Lobste.rs Discussion</a></li>
Garbage Collection for Systems Programmers</a> , Lobste.rs Discussion</a></li>
Native Implementation of Mutable Value Semantics</a> , Lobste.rs Discussion</a></li>
Losing the Faith on Testing</a> , Lobste.rs Discussion</a></li>
Rust in 2025: Targeting foundational software</a> , Lobste.rs Discussion</a></li>
Functional vs Data-Driven development: a Case-Study in Clojure & OCaml</a> , Lobste.rs Discussion</a></li>
FIFO queues are all you need for cache eviction</a> , Lobste.rs Discussion</a></li>
A few programming language features I’d like to see</a> , Lobste.rs Discussion</a></li>
ARC: A Self-Tuning, Low Overhead Replacement Cache</a> , Lobste.rs Discussion</a></li>
Perspectives from the Technical University of Munich</a> , Lobste.rs Discussion</a></li>
The Art of Formatting Code</a> , Lobste.rs Discussion</a></li>
Representing type lattices compactly</a> , Lobste.rs Discussion</a></li>
Inspecting rustc LLVM optimization remarks using cargo-remark</a> , Lobste.rs Discussion</a></li>
An Introduction to TLA+ and Its Use in Parties</a> , Lobste.rs Discussion</a></li>
MDN Curriculum</a> , Lobste.rs Discussion</a></li>
The seven programming ur-languages</a> , Lobste.rs Discussion</a></li>
Faster virtual machines: Speeding up programming language execution</a> , Lobste.rs Discussion</a></li>
Verifying Selection Sort: an Introduction to Program Verification in Dafny</a> , Lobste.rs Discussion</a></li>
Go internals: invariance and memory layout of slices (2021)</a> , Lobste.rs Discussion</a></li>
Demystifying Pratt Parsers</a> , Lobste.rs Discussion</a></li>
did u ever read so hard u accidentally wrote?</a> , Lobste.rs Discussion</a></li>
snmalloc: Message passing based allocator</a> , Lobste.rs Discussion</a></li>
Hacking on PostgreSQL is really hard</a> , Lobste.rs Discussion</a></li>
Language interop and the extensible compiler</a> , Lobste.rs Discussion</a></li>
Does unsafe undermine Rust's guarantees?</a> , Lobste.rs Discussion</a></li>
Faster interpreters in Go: Catching up with C++</a> , Lobste.rs Discussion</a></li>
Why is Prettier rock solid?</a> , Lobste.rs Discussion</a></li>
Semantics and Scheduling for Machine Knitting Compilers</a> , Lobste.rs Discussion</a></li>
I'm a programmer and I'm stupid</a> , Lobste.rs Discussion</a></li>
Hasochism: The Pleasure and Pain of Dependently Typed Haskell Programming</a> , Lobste.rs Discussion</a></li>
Type Inference in Rust and C++</a> , Lobste.rs Discussion</a></li>
ACTORS: A Model of Concurrent Computation in Distributed Systems (1985)</a> , Lobste.rs Discussion</a></li>
CakeML</a> , Lobste.rs Discussion</a></li>
Squeezing a Little More Performance Out of Bytecode Interpreters</a> , Lobste.rs Discussion</a></li>
The CAP Theorem is Irrelevant for Cloud Systems</a> , Lobste.rs Discussion</a></li>
Verse Language Reference</a> , Lobste.rs Discussion</a></li>
Link-time optimisation (LTO)</a> , Lobste.rs Discussion</a></li>
Asynchronous clean-up [in Rust]</a> , Lobste.rs Discussion</a></li>
A Lambda Calculus With Coroutines and Heapless, Directly-Called Closures</a> , Lobste.rs Discussion</a></li>
The Structure of a Programming Language Revolution (2012)</a> , Lobste.rs Discussion</a></li>
Type Tailoring</a> , Lobste.rs Discussion</a></li>
A Mathematical Model of Package Management Systems</a> , Lobste.rs Discussion</a></li>
When static types make your code shorter</a> , Lobste.rs Discussion</a></li>
Improving Your Zig Language Server Experience</a> , Lobste.rs Discussion</a></li>
How to stop Linux threads cleanly</a> , Lobste.rs Discussion</a></li>
Threads and Goroutines</a> , Lobste.rs Discussion</a></li>
Coroutines and effects</a> , Lobste.rs Discussion</a></li>
Somehow AutoHotKey is kinda good now</a> , Lobste.rs Discussion</a></li>
The Wizardry Frontier </a> , Lobste.rs Discussion</a></li>
Building a search engine from scratch, in Rust: part 1</a> , Lobste.rs Discussion</a></li>
Learn CSS Layout The Pedantic Way</a> , Lobste.rs Discussion</a></li>
Data demand some damn respect</a> , Lobste.rs Discussion</a></li>
Things that go wrong with disk IO</a> , Lobste.rs Discussion</a></li>
Pile of Eternal Rejections: The Cost of Garbage Collection for State Machine Replication – Aleksey Charapko</a> , Lobste.rs Discussion</a></li>
Simple Datalog engine in Rust (2018)</a> , Lobste.rs Discussion</a></li>
Rust Any part 3: Finally we have upcasts</a> , Lobste.rs Discussion</a></li>
Single Ownership and Memory Safety without Borrow Checking, Reference Counting, or Garbage Collection</a> , Lobste.rs Discussion</a></li>
CPS Representation and Foundational Design Decisions in Flambda2</a> , Lobste.rs Discussion</a></li>
Rust to Assembly: Understanding the Inner Workings of Rust</a> , Lobste.rs Discussion</a></li>
Semantics of Programming (video lectures that go with the "Concrete Semantics" book)</a> , Lobste.rs Discussion</a></li>
When is inlining useful?</a> , Lobste.rs Discussion</a></li>
Writing down (and searching through) every UUID</a> , Lobste.rs Discussion</a></li>
Precedence-aware pretty printing</a> , Lobste.rs Discussion</a></li>
Thoughts on Zig</a> , Lobste.rs Discussion</a></li>
Interaction nets</a> , Lobste.rs Discussion</a></li>
Warren's Abstract Machine: A Tutorial Reconstruction (1999)</a> , Lobste.rs Discussion</a></li>
Giving up the dylib dream</a> , Lobste.rs Discussion</a></li>
Intuiting TLS</a> , Lobste.rs Discussion</a></li>
3110 Coq Tactics Cheatsheet</a> , Lobste.rs Discussion</a></li>
The Best Refactoring You've Never Heard Of</a> , Lobste.rs Discussion</a></li>
How We Got the Generics We Have: (Or, how I learned to stop worrying and love erasure)</a> , Lobste.rs Discussion</a></li>
Deadlock-free Mutexes and Directed Acyclic Graphs (2022)</a> , Lobste.rs Discussion</a></li>
Rust Temporary Lifetimes and "Super Let"</a> , Lobste.rs Discussion</a></li>
Baby's second wasm compiler</a> , Lobste.rs Discussion</a></li>
Logic and Proof</a> , Lobste.rs Discussion</a></li>
A Gentle Introduction to LLVM IR</a> , Lobste.rs Discussion</a></li>
You could have invented denotational semantics</a> , Lobste.rs Discussion</a></li>
The Design & Implementation of the CPython Virtual Machine</a> , Lobste.rs Discussion</a></li>
Learning about debuggers</a> , Lobste.rs Discussion</a></li>
Compilers: Incrementally and Extensibly</a> , Lobste.rs Discussion</a></li>
A rough survey of compilation, recompilation, and compile-time evaluation</a> , Lobste.rs Discussion</a></li>
The road to hell is paved with good intentions and C++ modules</a> , Lobste.rs Discussion</a></li>
What's the big deal about embedded key-value databases like RocksDB?</a> , Lobste.rs Discussion</a></li>
Nix Based C++ Workflow From Scratch (2021)</a> , Lobste.rs Discussion</a></li>
Simple fast value semantics</a> , Lobste.rs Discussion</a></li>
Streams, Calculational Proofs and Dafny</a> , Lobste.rs Discussion</a></li>
Parallel property-based testing with a deterministic thread scheduler</a> , Lobste.rs Discussion</a></li>
Why some of us like "interdiff" code review systems (not GitHub)</a> , Lobste.rs Discussion</a></li>
Oleg's Programming Site</a> , Lobste.rs Discussion</a></li>
The Juggler's Curse</a> , Lobste.rs Discussion</a></li>
Use Monoids for Construction</a> , Lobste.rs Discussion</a></li>
Macros and optimizations: it's just a phase</a> , Lobste.rs Discussion</a></li>
Durable Incrementality</a> , Lobste.rs Discussion</a></li>
pgdog: Horizontal scaling for PostgreSQL with automatic sharding</a> , Lobste.rs Discussion</a></li>
Blindsided by Rust's Subtyping and Variance</a> , Lobste.rs Discussion</a></li>
It Takes Two to Contract</a> , Lobste.rs Discussion</a></li>
Interaction Nets, Combinators, and Calculus</a> , Lobste.rs Discussion</a></li>
Simplifying Expressions Bottom-Up</a> , Lobste.rs Discussion</a></li>
Fantastic Learning Resources</a> , Lobste.rs Discussion</a></li>
What Austral Proves</a> , Lobste.rs Discussion</a></li>
Why SQLite Uses Bytecode</a> , Lobste.rs Discussion</a></li>
UI for sums must remember products</a> , Lobste.rs Discussion</a></li>
How bad is LLVM really?</a> , Lobste.rs Discussion</a></li>
Jepsen: RavenDB 6.0.2</a> , Lobste.rs Discussion</a></li>
I Have No Constructor, and I Must Initialize</a> , Lobste.rs Discussion</a></li>
Queueing - an interactive study of queueing strategies</a> , Lobste.rs Discussion</a></li>
Coding as Craft: Going Back to the Old Gym</a> , Lobste.rs Discussion</a></li>
What If We Could Rebuild Kafka From Scratch?</a> , Lobste.rs Discussion</a></li>
How Discord Indexes Trillions of Messages</a> , Lobste.rs Discussion</a></li>
Differential Coverage for Debugging</a> , Lobste.rs Discussion</a></li>
DataFusion - The Database Building Toolkit</a> , Lobste.rs Discussion</a></li>
How should I read type system notation?</a> , Lobste.rs Discussion</a></li>
Why You Should Write Your Own Static Site Generator</a> , Lobste.rs Discussion</a></li>
Learning modern compilers?</a> , Lobste.rs Discussion</a></li>
A Very Subtle Bug (2010)</a> , Lobste.rs Discussion</a></li>
Async Rust Complexity </a> , Lobste.rs Discussion</a></li>
Typestate - the new Design Pattern in Swift 5.9</a> , Lobste.rs Discussion</a></li>
Linear-time parser combinators</a> , Lobste.rs Discussion</a></li>
Swift almost</em> does a really cool thing I want</a> , Lobste.rs Discussion</a></li>
References are like jumps</a> , Lobste.rs Discussion</a></li>
Resilient LL Parsing Tutorial</a> , Lobste.rs Discussion</a></li>
What a good debugger can do</a> , Lobste.rs Discussion</a></li>
Strange Loop's greatest hits</a> , Lobste.rs Discussion</a></li>
Compiling ML models to C for fun</a> , Lobste.rs Discussion</a></li>
Let's write a setjmp</a> , Lobste.rs Discussion</a></li>
Cosmopolitan Third Edition</a> , Lobste.rs Discussion</a></li>
Testing Distributed Systems for Linearizability (2017)</a> , Lobste.rs Discussion</a></li>
swift-evolution/0382: Expression Macros</a> , Lobste.rs Discussion</a></li>
Is something bugging you?</a> , Lobste.rs Discussion</a></li>
Traits are a Local Maximum</a> , Lobste.rs Discussion</a></li>
Story-time: C++, bounds checking, performance, and compilers</a> , Lobste.rs Discussion</a></li>
Ghosts of Departed Proofs (2018)</a> , Lobste.rs Discussion</a></li>
I'm betting on Call-by-Push-Value</a> , Lobste.rs Discussion</a></li>
A Dependently Typed Assembly Language</a> , Lobste.rs Discussion</a></li>
Syntactic musings on match expressions</a> , Lobste.rs Discussion</a></li>
Asynchronous IO: the next billion-dollar mistake?</a> , Lobste.rs Discussion</a></li>
conservative gc can be faster than precise gc</a> , Lobste.rs Discussion</a></li>
The State of Full-Stack OCaml</a> , Lobste.rs Discussion</a></li>
Extending Rust's Effect System</a> , Lobste.rs Discussion</a></li>
New Go garbage collector</a> , Lobste.rs Discussion</a></li>
Functional HTML</a> , Lobste.rs Discussion</a></li>
modern-latex: A short guide to LaTeX that avoids legacy cruft</a> , Lobste.rs Discussion</a></li>
An Interactive Debugger for Rust Trait Errors</a> , Lobste.rs Discussion</a></li>
The Curse of Knowing How, or; Fixing Everything</a> , Lobste.rs Discussion</a></li>
Implement your language twice</a> , Lobste.rs Discussion</a></li>
Newtyped Indices are Proofs</a> , Lobste.rs Discussion</a></li>
Memory Safety Features in Zig</a> , Lobste.rs Discussion</a></li>
Algebraic Effects: Another mistake carried through to perfection?</a> , Lobste.rs Discussion</a></li>
Rust Dependencies scare Me</a> , Lobste.rs Discussion</a></li>
Functional programming languages should be so much better at mutation than they are</a> , Lobste.rs Discussion</a></li>
The Hitchhiker's Guide to Logical Verification</a> , Lobste.rs Discussion</a></li>
Java FFI vs JNI for Meta's RocksDB Java API</a> , Lobste.rs Discussion</a></li>
So You Want to Optimize Your Code? (also, a disordered, confusing and absolutely incomplete oral history of Firefox performance)</a> , Lobste.rs Discussion</a></li>
How I think about Zig and Rust</a> , Lobste.rs Discussion</a></li>
Scheduling Internals</a> , Lobste.rs Discussion</a></li>
A Twist on Wadler's Printer</a> , Lobste.rs Discussion</a></li>
Jepsen: jetcd 0.8.2</a> , Lobste.rs Discussion</a></li>
Time is not a synchronization primitive</a> , Lobste.rs Discussion</a></li>
How RocksDB works</a> , Lobste.rs Discussion</a></li>
Programming Languages Going Above and Beyond</a> , Lobste.rs Discussion</a></li>
Second-Class References</a> , Lobste.rs Discussion</a></li>
Reconstructing TypeScript, part 0: intro and background</a> , Lobste.rs Discussion</a></li>
The sad state of property-based testing libraries</a> , Lobste.rs Discussion</a></li>
Writing that changed how I think about PL</a> , Lobste.rs Discussion</a></li>
Lock-Free Rust: How to Build a Rollercoaster While It’s on Fire</a> , Lobste.rs Discussion</a></li>
Hyper-Typing</a> , Lobste.rs Discussion</a></li>
The penultimate conditional syntax</a> , Lobste.rs Discussion</a></li>
Divorce from LLVM</a> , Lobste.rs Discussion</a></li>
Async Rust Challenges in Iroh</a> , Lobste.rs Discussion</a></li>
smol_world: Compact garbage-collected heap and JSON-like object model</a> , Lobste.rs Discussion</a></li>
Use GNU Emacs</a> , Lobste.rs Discussion</a></li>
Implementing MVCC and major SQL transaction isolation levels</a> , Lobste.rs Discussion</a></li>
The Heart of a Language Server</a> , Lobste.rs Discussion</a></li>
Why Static Languages Suffer From Complexity (and type-safe printf implementation without macros)</a> , Lobste.rs Discussion</a></li>
The Rust I Wanted Had No Future</a> , Lobste.rs Discussion</a></li>
Formal verification makes RSA faster — and faster to deploy</a> , Lobste.rs Discussion</a></li>
Do we fear the serializable isolation level more than we fear subtle bugs?</a> , Lobste.rs Discussion</a></li>
Stop Making Me Memorize The Borrow Checker</a> , Lobste.rs Discussion</a></li>
A rustc soundness bug in the wild</a> , Lobste.rs Discussion</a></li>
Implementing Type Systems as Macros</a> , Lobste.rs Discussion</a></li>
Zig Reproduced Without Binaries</a> , Lobste.rs Discussion</a></li>
Structured Editing and Incremental Parsing</a> , Lobste.rs Discussion</a></li>
Dependent Types and the Art of HTTP Headers</a> , Lobste.rs Discussion</a></li>
A love letter to make</a> , Lobste.rs Discussion</a></li>
All about LeakSanitizer</a> , Lobste.rs Discussion</a></li>
Timeouts and cancellation for humans (2018)</a> , Lobste.rs Discussion</a></li>
How Discord Stores Trillions of Messages</a> , Lobste.rs Discussion</a></li>
Memory Safety is a Red Herring</a> , Lobste.rs Discussion</a></li>
missing the point of webassembly</a> , Lobste.rs Discussion</a></li>
Jepsen: Datomic Pro 1.0.7075</a> , Lobste.rs Discussion</a></li>
Emacs From Scratch Part Two: Projects and Keybindings</a> , Lobste.rs Discussion</a></li>
Readings in Database Systems, 5th Edition</a> , Lobste.rs Discussion</a></li>
What if everybody did everything right?</a> , Lobste.rs Discussion</a></li>
Unsafe : on Rust still being helpful even with a lot of unsafe</code></a> , Lobste.rs Discussion</a></li>
How I Use Git Worktrees</a> , Lobste.rs Discussion</a></li>
Investigating an Event Queue Hang: The Code Works Correctly</a> , Lobste.rs Discussion</a></li>
The State of Async Rust</a> , Lobste.rs Discussion</a></li>
Logic and Computation Intertwined</a> , Lobste.rs Discussion</a></li>
Debugging by querying a database of all program state</a> , Lobste.rs Discussion</a></li>
Compilers for free with weval</a> , Lobste.rs Discussion</a></li>
rsc-regexp: Translations of a simple C program to Rust</a> , Lobste.rs Discussion</a></li>
How Austral’s Linear Type Checker Works</a> , Lobste.rs Discussion</a></li>
You should be reading academic computer science papers (2022)</a> , Lobste.rs Discussion</a></li>
Refined Input, Degraded Output: The Counterintuitive World of Compiler Behavior</a> , Lobste.rs Discussion</a></li>
Does Your Test Suite Account For Weak Transaction Isolation?</a> , Lobste.rs Discussion</a></li>
A tour of the LLVM backend</a> , Lobste.rs Discussion</a></li>
Implementing #embed for C and C++</a> , Lobste.rs Discussion</a></li>
Faking Algebraic Effects and Handlers With Traits: A Rust Design Pattern</a> , Lobste.rs Discussion</a></li>
Maglev - V8’s Fastest Optimizing JIT</a> , Lobste.rs Discussion</a></li>
The State Of Garnet in 2025</a> , Lobste.rs Discussion</a></li>
Understanding React Compiler</a> , Lobste.rs Discussion</a></li>
Less-technical introductions to type checking?</a> , Lobste.rs Discussion</a></li>
MLIR For Beginners</a> , Lobste.rs Discussion</a></li>
Functional Data Structures and Algorithms. A Proof Assistant Approach</a> , Lobste.rs Discussion</a></li>
Borrow checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches</a> , Lobste.rs Discussion</a></li>
On Modularity of Lexical Analysis</a> , Lobste.rs Discussion</a></li>
Yo, I heard you like decorators</a> , Lobste.rs Discussion</a></li>
Reasons I still love the fish shell</a> , Lobste.rs Discussion</a></li>
How Swift Achieved Dynamic Linking Where Rust Couldn't (2019)</a> , Lobste.rs Discussion</a></li>
Tiny challenges for learning WebAssembly</a> , Lobste.rs Discussion</a></li>
Programming and computing bloggers: How do you decide what to write about?</a> , Lobste.rs Discussion</a></li>
A catalog of ways to generate SSA</a> , Lobste.rs Discussion</a></li>
Write more "useless" software</a> , Lobste.rs Discussion</a></li>
Storing data in pointers</a> , Lobste.rs Discussion</a></li>
TypeScript is Surprisingly OK for Compilers</a> , Lobste.rs Discussion</a></li>
Moving Beyond Type Systems</a> , Lobste.rs Discussion</a></li>
Introducing the Determinate Nix Installer</a> , Lobste.rs Discussion</a></li>
'Modules Matter' Most for the Masses</a> , Lobste.rs Discussion</a></li>
Delimited Generators - A more natural API for JS generators</a> , Lobste.rs Discussion</a></li>
Zig, Rust, and other languages</a> , Lobste.rs Discussion</a></li>
Bril: An Intermediate Language for Teaching Compilers</a> , Lobste.rs Discussion</a></li>
Visitor Pattern Considered Pointless - Use Pattern Switches Instead (2021)</a> , Lobste.rs Discussion</a></li>
Into CPS, never to return</a> , Lobste.rs Discussion</a></li>
Use of Time in Distributed Databases (part 2): Use of logical clocks in databases</a> , Lobste.rs Discussion</a></li>
Stuff I learnt in 2024</a> , Lobste.rs Discussion</a></li>
Reference Counting: Harder than it Sounds (2015)</a> , Lobste.rs Discussion</a></li>
How does a Linux machine connect to the internet, really?</a> , Lobste.rs Discussion</a></li>
Do you use a debugger?</a> , Lobste.rs Discussion</a></li>
A survey of every iterator variant</a> , Lobste.rs Discussion</a></li>
Iteration in one language, then all the others (2016)</a> , Lobste.rs Discussion</a></li>
Debugging in the Multiverse</a> , Lobste.rs Discussion</a></li>
Many explanations of JOIN are wrong, and people get confused</a> , Lobste.rs Discussion</a></li>
Why am I writing a JavaScript toolchain in Zig?</a> , Lobste.rs Discussion</a></li>
How do modern compilers choose which variables to put in registers?</a> , Lobste.rs Discussion</a></li>
Algebraic effects are a functional approach to manage side effects</a> , Lobste.rs Discussion</a></li>
TeX and Typst: Layout Models</a> , Lobste.rs Discussion</a></li>
Type Erasure: The Implementation Details</a> , Lobste.rs Discussion</a></li>
aya-dev: A proof assistant and a dependently-typed language</a> , Lobste.rs Discussion</a></li>
Building Type Search for Unison</a> , Lobste.rs Discussion</a></li>
Cranelift: Correctness in Register Allocation</a> , Lobste.rs Discussion</a></li>
What I've Learned About Formal Methods In Half a Year</a> , Lobste.rs Discussion</a></li>
Type safe variadic printf, without macros</a> , Lobste.rs Discussion</a></li>
Why I'm Writing a Scheme Implementation in 2025 (The Answer is Async Rust)</a> , Lobste.rs Discussion</a></li>
Code Style Sheets: CSS for Code</a> , Lobste.rs Discussion</a></li>
How I implement SSA form</a> , Lobste.rs Discussion</a></li>
The worst bug we faced at Antithesis</a> , Lobste.rs Discussion</a></li>
Unwind considered harmful?</a> , Lobste.rs Discussion</a></li>
Compiling typed Python</a> , Lobste.rs Discussion</a></li>
Tasks are the wrong abstraction</a> , Lobste.rs Discussion</a></li>
Hardest Problem in Computer Science: Centering Things</a> , Lobste.rs Discussion</a></li>
Types and the Zig Programming Language</a> , Lobste.rs Discussion</a></li>
Let futures be futures</a> , Lobste.rs Discussion</a></li>
Proof Pearl: Magic Wand as Frame</a> , Lobste.rs Discussion</a></li>
Transaction Isolation in Postgres, explained</a> , Lobste.rs Discussion</a></li>
Optimizing a parser/compiler with data-oriented design: a case study</a> , Lobste.rs Discussion</a></li>
A Python frozenset interpretation of Dependent Type Theory</a> , Lobste.rs Discussion</a></li>
How the jax.jit() JIT compiler works in jax-js</a> , Lobste.rs Discussion</a></li>
Zenbleed</a> , Lobste.rs Discussion</a></li>
You probably wrote half a monad by accident</a> , Lobste.rs Discussion</a></li>
Building a baseline JIT for Lua automatically</a> , Lobste.rs Discussion</a></li>
The Cloud Computer / Oxide</a> , Lobste.rs Discussion</a></li>
Go evolves in the wrong direction</a> , Lobste.rs Discussion</a></li>
Don’t Implement Unification by Recursion</a> , Lobste.rs Discussion</a></li>
Bergamot: Exploring Programming Language Inference Rules</a> , Lobste.rs Discussion</a></li>
Testing Distributed Systems w/ Deterministic Simulation (2014)</a> , Lobste.rs Discussion</a></li>
The Windows Subsystem for Linux is now open source</a> , Lobste.rs Discussion</a></li>
The Lisp in the Cellar: Dependent Types that Live Upstairs</a> , Lobste.rs Discussion</a></li>
Why Algebraic Effects?</a> , Lobste.rs Discussion</a></li>
Async from scratch 3: Pinned against the wall</a> , Lobste.rs Discussion</a></li>
</ul>


Miscellaneous CS
2001-03-25T00:00:00+00:00
Misc</h1>


Advanced Topics in Computer Systems</a></li>

Computer Organization</a></li>

Beej Networking</a></li>

What Every Programmer Should Know About Memory</a></li>

Nand2Tetris</a></li>

David Wetherall Computer Networking</a></li>

ILP, DLP, TLP</a></li>

Paradigms of Artificial Intelligence Programming (Peter Norvig)</a></li>

SQLite Internals HN post,(fly.io has more articles about sqlite)</a></li>

Intro to Databases</a></li>

Advanced Databases(Focus on OLAP systems only)</a></li>

Advanced Databases(Focus on OLTP(and transactions) and OLAP)</a></li>

Distributed Systems MIT(Robert Morris)</a>
, More recent version is here</a> ,
Some interesting papers mentioned
here</a></li>

Performance Engineering of Software Systems</a></li>

Operating Systems Engineering</a></li>

Computer System Engineering(Looks like a very good course, covers a lot of concepts)</a></li>

Software Construction(Covers a lot of cool concepts)</a></li>

Missing Semester</a>A</li>

Fly io Distsys</a></li>

Fantastic Bugs and where to find them</a></li>

Algorithmica(must translate from Russian to English)</a></li>

Cp Algorithms</a></li>

Algorithms for Modern Hardware(looks super useful to learn about intricate details about performance)</a></li>

Agner Fog(see optimization manual, apparently very good)</a></li>

Dmitry Vyukov, lockfree algorithms is a goldmine</a></li>

Parallel and Concurrent Algorithms, Carnegie Mellon University</a></li>

perf-book</a></li>

perf-ninja</a>,
YT-playlist</a></li>

Has a lot of cool design patterns(found this page while looking for Event Sourcing Pattern)</a></li>

Series of articles on The internals of PostgreSQL</a></li>

Distsys-class by aphyr(good overview of many things and a good way to learn terminologies)</a></li>

Getting started with Database development(reddit post)</a></li>

Linux Internals gitbook</a></li>

Phil Eaton's An intuition for distributed consensus in OLTP systems</a></li>

Distributed Programming Book(good content)</a></li>

Building a Transactional Key-Value Database</a></li>

TiDB Dev guide(Has some DB internals stuff)</a></li>

TiKV Deep Dive, has very interesting TOC</a></li>

[What every systems programmer should know about concurrency by Matt Kline
](What every systems programmer should know about concurrency by Matt Kline
) , GitHub</a></li>
</ul>


Miscellaneous Tools
2001-03-25T00:00:00+00:00
Misc Tools</h1>


 Zero to Nix </a> HN</a></li>

Vim Cool Tricks </a></li>

Vim guide for advanced users</a></li>

Hermit, Deterministic Linux, by Facebook(in rust, has another cool thing they're using to intercept syscalls called reverie)</a></li>

Twenty years of valgrind</a></li>

What rr does</a></li>

The state of debugging in 2022(rr)</a></li>

Sqlite is not a toy database</a></li>

What a good debugger can do</a></li>

Perf Examples(perf is super powerful and supports so many things)</a></li>

Linux Performance(many links, by the same author of above article)</a></li>

Valgrind Intro</a></li>

Callgrind Intro</a></li>

GDB reference card</a></li>
</ul>


Miscellaneous Saved Links
2001-03-25T00:00:00+00:00
Miscellaneous Saved Links</h1>
Articles and Blog Posts</h2>

Profiling code with LLVM</a></li>
Code Character</a></li>
LLVM Passes</a></li>
More on LLVM Passes</a></li>
LLVM</a></li>
More on LLVM Passes</a></li>
Pre-commit tips</a></li>
Interior Mutability Series</a></li>
Compile-time Codegen</a></li>
CRTP Interface</a></li>
The Evolution of the QEMU Translator</a></li>
Go Garbage Collector</a></li>
Ruby Garbage Collection</a></li>
NAN Boxing</a></li>
What Every Programmer Should Know About Compiler Optimizations, Part 2</a></li>
Modern JavaScript Tutorial</a></li>
Simplify with Dependency Injection with Uber FX</a></li>
Data Race Patterns in Go</a></li>
Using Apache Kafka to Process 1 Trillion Messages</a></li>
Scheduling in Go, Part 1</a></li>
Event-Driven Topic Design Using Kafka</a></li>
The Laws of Reflection in Go</a></li>
Uber Go Style Guide</a></li>
How We Halved Go Monorepo CI Build Time</a></li>
Recursion Schemes in Rust</a></li>
Dockerfile Best Practices</a></li>
Redis Architecture Notes</a></li>
Apache Server: Use mod_evasive to Refute DoS Attack</a></li>
A Guide to Porting C to Rust: Memory Allocation</a></li>
Setting Apache2 ulimit for Maximum Prefork Performance</a></li>
TCP/IP Packets Introduction: Manually Create and Send Raw TCP/IP Packets</a></li>
A Complete Guide to NodeJS Process Management with PM2</a></li>
How io_uring and eBPF Will Revolutionize Programming in Linux</a></li>
How io_uring and eBPF Will Revolutionize Programming in Linux (ScyllaDB)</a></li>
Apache Stability on a Very High-Traffic Server</a></li>
Speed Up Apache</a></li>
Monitoring Apache Web Server Performance</a></li>
Containers: Learning Docker with Docker</a></li>
Sapling: A Scalable, User-Friendly Source Control System</a></li>
Workbox</a></li>
Language Server Protocol in Monaco Editor</a></li>
mujs-uiuctf</a></li>
albatross-redpwnctf</a></li>
Awaitable Timers</a></li>
Why I Love Databases</a></li>
PhD Dissertation Background</a></li>
GCC Under the Hood</a></li>
Rich Programmer Food</a></li>
Intel Zero-Opt</a></li>
My Thoughts on OCaml vs Haskell/Rust (2023)</a></li>
Coherence and Errors</a></li>
PL Resources</a></li>
Algorithms for Modern Hardware</a></li>
EventHelix System Design</a></li>
Bartosz Milewski's Master Thesis</a></li>
Compiling with Continuations</a></li>
Faultlore</a></li>
Ralf Jung's Blog</a></li>
Love Types</a></li>
Making a Language</a></li>
GHC Reading List</a></li>
Performance Optimisation ~ Writing an Essay</a></li>
All You Need Is Call/CC</a></li>
dancres.github.io</a></li>
nnethercote.github.io</a></li>
Hillel Wayne's Blog</a></li>
New Garbage Collector for LuaJIT</a></li>
Trail of Bits Blog</a></li>
Melody's Notes</a></li>
Assembly Tutorial 3</a></li>
BlazingMQ</a></li>
Too Many Web Servers</a></li>
WASM Replayable Functions</a></li>
Past Webdev</a></li>
System Design Interviews</a></li>
Fast Pipes</a></li>
Pin and Unpin in Rust</a></li>
Brian Callahan's Blog</a></li>
c9x.me/compile</a></li>
Tree-structured Concurrency</a></li>
Demystifying Database Transactions</a></li>
Software Resources</a></li>
Java Development Practices: Using Thread Pools and Thread Variables Properly</a></li>
Java Multithreading</a></li>
Memcached Interview</a></li>
Optimizing await</code></a></li>
A Hack to Implement Efficient TLS (Thread Local Storage)</a></li>
Linux Insides</a></li>
Server-Side Sandboxing: Containers and Seccomp</a></li>
Ankit Sultana's Reading List</a></li>
dancres.github.io</a></li>
Marc Brooker's Blog</a></li>
Types and Zig</a></li>
Scattered Thoughts</a></li>
Zack's Blog</a></li>
The Part of PostgreSQL We Hate the Most</a></li>
Our Journey Adopting SPIFFE/SPIRE at Uber</a></li>
Postgres Internals</a></li>
NilAway: Practical Nil Panic Detection for Go</a></li>
Undefined Behavior Deserves a Better Reputation</a></li>
How to Execute an Object File: Part 4</a></li>
GoWind's Blog</a></li>
PPrint Documentation</a></li>
Mulligan: A Statically-Typed Lisp-like Language</a></li>
Storing Data in Pointers</a></li>
Sillycross's Archives</a></li>
Daniel J. Harvey's Blog</a></li>
Signaling from Within: How eBPF Interacts with Signals</a></li>
Wingolog</a></li>
Upgrading GitHub.com to MySQL 8.0</a></li>
Twitter's Manhattan Database</a></li>
Goodbye, C++</a></li>
Solving the Structured Control Flow Problem Once and for All</a></li>
Software Transactional Memory</a></li>
Why is Idris 2 so much faster than Idris 1?</a></li>
TiDB Dev Guide</a></li>
Some of the things I've learned about building compilers</a></li>
Consistency</a></li>
Just Write the Parser</a></li>
The Deadlock Empire</a></li>
An Overview of Distributed PostgreSQL Architectures</a></li>
Dan Luu's Blog on Culture</a></li>
Distributed Systems Theory for the Distributed Systems Engineer</a></li>
Linux Kernel Memory Barriers</a></li>
Stuff I Learnt in 2021</a></li>
Stuff I Learnt in 2022</a></li>
Transactional Blog</a></li>
Deep Dive TiKV</a></li>
Log-Structured Merge-Trees</a></li>
Are Databases a Thing of the Past?</a></li>
Eklitzke's Blog</a></li>
Distributed Transactions in TiDB</a></li>
Rufflewind's Blog</a></li>
How RocksDB Works</a></li>
Data-Oriented Design</a></li>
Job Hernandez's Blog</a></li>
How to Learn Compilers: LLVM Edition</a></li>
The Copenhagen Book</a></li>
Borrow Checking Without Lifetimes</a></li>
Pause and Resume a JavaScript Function</a></li>
Polytypic Blog</a></li>
Verified Compiler</a></li>
Linear DP</a></li>
Doisinkidney's Blog</a></li>
Type Theory Stuff in Blog</a></li>
Notes on Compiler IRs</a></li>
Rust Runtime Design</a></li>
Swift for C++ Peeps</a></li>
Understanding the React Compiler</a></li>
Java Annotation Processing Tool - AbstractProcessor</a></li>
Thume's Archive</a></li>
Getting Started with Category Theory</a></li>
Pin and Suffering</a></li>
Database Ruins All Good Ideas</a></li>
SIGPLAN Blog</a></li>
A Beginner's Guide to PL Academia</a></li>
PRL @ Northeastern Blog</a></li>
Taming Null Dereferences with Pluggable Type Systems (Part I)</a></li>
Recent PL Research</a></li>
How to Build an Agent - Amp</a></li>
Kubernetes Problems</a></li>
Log Proof Localisation</a></li>
Patterns in FP</a></li>
</ul>
Courses and Educational Resources</h2>

LeetCode Problem List</a></li>
Advanced Compilers 2015</a></li>
LLVM & Clang Study Notes</a></li>
Topic List</a></li>
IU Compiler Course</a></li>
Compilers in Haskell</a></li>
UCSD Compilers OCaml Course</a></li>
UPenn Compilers Course (OCaml)</a></li>
MIT 6.005</a></li>
NEU CS4410</a></li>
MIT 6.005 Archive</a></li>
Matt Might's Articles</a></li>
UPenn CIS341 2020</a></li>
Dinosaur Book (YACC)</a></li>
Lua 5.3 Manual</a></li>
TypeScript Gitbook</a></li>
Stanford CS242</a></li>
Labuladong's Algo Book</a></li>
IU Compiler Course (Again)</a></li>
Google Code Source</a></li>
VSCode Language Server Extension Guide</a></li>
Jongy's Website</a></li>
Steve Yegge's Blog Rants</a></li>
ITPL</a></li>
Static Program Analysis Course</a></li>
Static Program Analysis Videos</a></li>
SRE Book</a></li>
LaTeX Tutorial</a></li>
TheNumbat's Lists</a></li>
TheNumb.at</a></li>
GoWind's GitHub</a></li>
Ralf Jung's Research</a></li>
UCSD Compilers S23</a></li>
How to Become a Hacker</a></li>
Distributed Systems: 6.824</a></li>
Kleppmann's Distributed Systems Course</a></li>
CMU DB Systems</a></li>
Discrete Mathematics by László Lovász</a></li>
Security: 6.858</a></li>
Theoretical CS: 6.080</a></li>
Modern Algorithmic Toolbox</a></li>
Algorithms for Modern Hardware</a></li>
Performance Engineering of Software Systems: 6.172</a></li>
Berkeley CS262</a></li>
Programming Language Research</a></li>
CMU Course Reviews</a></li>
Learning About Distributed Systems</a></li>
How Query Engines Work</a></li>
Let's Build a Simple Database</a></li>
PingCAP Talent Plan</a></li>
Mini-LSM</a></li>
Bustub Course Projects</a></li>
Linux Kernel Labs</a></li>
Cornell CS4110</a></li>
Cambridge Advanced Functional Programming</a></li>
Cambridge Distributed Systems</a></li>
Proofs</a></li>
OCaml Memgraph</a></li>
Cambridge Advanced Functional Programming (2017-18)</a></li>
Simon's Website</a></li>
Type Systems</a></li>
MCIR</a></li>
Zig Documentation</a></li>
PLDG at Cornell</a></li>
Mini Key-Value DB</a></li>
Lean4 Type Checking</a></li>
GSOC '24 Ideas</a></li>
Lean Publications</a></li>
Total Parser Combinator</a></li>
Terminating Parser Combinators</a></li>
Michael Young's Syllabus</a></li>
Type Theory and Formal Proof</a></li>
Semantics Course</a></li>
Xavier Leroy's Courses</a></li>
Logic and Computation Course</a></li>
Lean Course Tactics</a></li>
NBE Four Ways</a></li>
Higher-Order Abstract Syntax</a></li>
Normalization by Evaluation</a></li>
ECE750T29: Advanced Topics in Software Engineering</a></li>
APV: Automated Program Verification</a></li>
CIS700: Topics in Programming Languages & Compilers</a></li>
RTC: Research Topics in Compilers</a></li>
Logical Verification</a></li>
How to Implement Dependent Type Theory I</a></li>
CSCI1710: Logic for Systems</a></li>
Program Logics a la Carte</a></li>
Normalization by Evaluation Tutorial</a></li>
CPSC539B: Dependently-Typed Programming</a></li>
CPSC539B: Advanced Functional Programming</a></li>
Refinement Calculus</a></li>
The G-Machine in Detail</a></li>
The Semantics of Evaluation & Continuations</a></li>
Impredicative Polymorphism</a></li>
Amulet's New Type Checker</a></li>
Dependent Types</a></li>
A Proof of Correctness for the Compiler of a Verified Ecosystem</a></li>
New Computation Model for Dune</a></li>
How We Accidentally Built a Better Build System for OCaml</a></li>
Exploring Lean4</a></li>
FIX: A Library for Fixpoints</a></li>
Curry-Howard Correspondence</a></li>
Proofs and Types</a></li>
Type Theory and Formal Proof: An Introduction</a></li>
Structural Operational Semantics</a></li>
Lean Reference</a></li>
Metaprogramming in Lean4</a></li>
Typechecking in Lean4</a></li>
Calculus of Inductive Constructions</a></li>
Learn Lean</a></li>
Mathlib4 API Reference</a></li>
Substructural Polymorphism</a></li>
Incremental Computation</a></li>
Checker Framework New Contributor Projects</a></li>
1ML - Core and Modules United</a></li>
Fundamental Concepts in Programming Languages</a></li>
PyTorch Internals</a></li>
Skipping the Binder Bureaucracy with Mixed Embeddings in a Semantics Course (Functional Pearl)</a></li>
Redex</a></li>
Testing Distributed Systems</a></li>
Poisson Chat</a></li>
Reciprog Slides</a></li>
Parametricity and Coinduction</a></li>
Coinductive Datatypes</a></li>
Structural Recursion and Co-recursion</a></li>
Composable Data Systems: Lessons from Apache Calcite's Success</a></li>
Type Theory for All</a></li>
Better Data Types à la Carte</a></li>
Lean4 Documentation</a></li>
</ul>
Discussions and Forums</h2>

Stack Overflow: Why does GCC push rbx</code> at the beginning of main</code>?</a></li>
Stack Overflow: Confusion about StateT</code>, State</code>, and MonadState</code></a></li>
Stack Overflow: How does garbage collection work in languages which are natively compiled?</a></li>
Reddit: Which OSS codebases out there are so beautiful they bring a tear to your eye?</a></li>
Reddit: No good overview of how languages are implemented?</a></li>
Hacker News: The Dirty Pipe Vulnerability</a></li>
Reddit: Advent of Code 2022 Day 5</a></li>
Reddit: Thoughts on proof assistants?</a></li>
Reddit: Programmable Type Systems</a></li>
Reddit: Recent PL Research</a></li>
Lobste.rs: Tree-structured Concurrency</a></li>
Hacker News: Discussion on a blog post</a></li>
Hacker News: Discussion on a blog post</a></li>
Hacker News: Discussion on a blog post</a></li>
Hacker News: Discussion on a blog post</a></li>
Hacker News: Discussion on a blog post</a></li>
Stack Overflow: volatile</code> keyword in C++</a></li>
Stack Overflow: git rebase --onto</code></a></li>
Software Engineering Stack Exchange: What is the single most influential book every programmer should read?</a></li>
Stack Overflow: What is open recursion?</a></li>
Stack Overflow: Is it safe to clean docker/overlay2?</a></li>
Stack Overflow: The Value Restriction</a></li>
Stack Overflow: What is the volatile</code> keyword useful for?</a></li>
Stack Exchange: What is coinduction?</a></li>
Proof Assistants Stack Exchange: Comparison between proof assistants for coinductive structures and proofs</a></li>
Hacker News: Discussion on a blog post</a></li>
Reddit: Firefox address bar suggestions going up instead of down</a></li>
Swift Forums: Swift Type Checking is Undecidable</a></li>
Reddit: Local LLM</a></li>
Reddit: Programming Languages</a></li>
Reddit: Programming Languages</a></li>
Hacker News: Discussion on a blog post</a></li>
Lobste.rs: Database Ruins All Good Ideas</a></li>
Coq Discourse: What is the difference between Gallina and Ltac?</a></li>
OCaml Discourse: Dependent types in the purest form</a></li>
Swift Forums: Pitch: Dependent Types & Universes (Stage 1 of Proof-Driven Development)</a></li>
OCaml Discourse: Multicore blog post: a deep dive into multicore OCaml garbage collector</a></li>
Reddit: Programmable Type Systems</a></li>
Reddit: Recent PL Research</a></li>
Math Stack Exchange: Online reference/book for implementing concepts in type theory</a></li>
LangDev Stack Exchange: What does it mean for a type system or language to be sound?</a></li>
Proof Assistants Stack Exchange: How much of trouble is Lean's failure of normalization given that logical consistency is guaranteed?</a></li>
Proof Assistants Stack Exchange: Is there something special about weak head normal form used with proof assistants?</a></li>
CS Theory Stack Exchange: What exactly is large elimination?</a></li>
CS Stack Exchange: Relation between type checking decidability, typability decidability and strong normalization</a></li>
OCaml Discourse: Dependent types in the purest form</a></li>
OCaml Discourse: Best approach for implementing open recursion over extensible types</a></li>
Reddit: Nepal</a></li>
</ul>
Miscellaneous</h2>

Interactive Runner</a></li>
[inxi command](inxi --admin --verbosity=7 --filter --no-host --width)</li>
koona</a></li>
charly-vm</a></li>
oakc</a></li>
ssr.nvim</a></li>
TheNumbat/Lists</a></li>
GoWind.github.io</a></li>
OCaml Pull Request #12193</a></li>
llvm-expected</a></li>
programming-language-research</a></li>
CS410-18</a></li>
tomprimozic/type-systems</a></li>
were/mcir</a></li>
ocsigen/js_of_ocaml Pull Request #1503</a></li>
brandonspark/mulligan</a></li>
Yiling-J/theine-go Issue #29</a></li>
erikgrinaker/readings</a></li>
polytypic/blog</a></li>
etcd Issue #741</a></li>
nuprl/10PL</a></li>
digama0/lean-type-theory</a></li>
Elewyth/type-search</a></li>
flux-rs/flux Issue #549</a></li>
bufbuild/protovalidate-java</a></li>
aripiprazole/lura</a></li>
aripiprazole/soft</a></li>
moby/moby Issue #1905</a></li>
Fewbytes/rubber-docker</a></li>
wasp-lang/haskell-handbook</a></li>
lura</a></li>
soft</a></li>
The Dirty Pipe Vulnerability</a></li>
Modern JavaScript Tutorial</a></li>
ECOOP Test of Time Award</a></li>
NUS – Beyond PhD</a></li>
Lean4 Documentation</a></li>
Lean Reference</a></li>
From Parametricity to Conservation Laws</a></li>
How to Build an Agent - Amp</a></li>
ECOOP Test of Time Award</a></li>
NUS – Beyond PhD</a></li>
Lean4 Documentation</a></li>
Lean Reference</a></li>
From Parametricity to Conservation Laws</a></li>
</ul>


OCaml
2001-03-25T00:00:00+00:00
Ocaml</h1>


CS3110 Ocaml Cornell</a></li>

Real World OCaml</a></li>

OCaml Internals(GC chapter very good)</a></li>

OCaml 5.0 multicore is out (HN Discussion)</a></li>

OCaml Videos</a></li>

More Typeclasses in OCaml</a></li>

Implementing typeclasses as OCaml modules</a></li>

Modules Matter Most for the masses</a></li>

Oxidizing OCaml: Locality</a></li>

Oxidizing OCaml: Rust-Style Ownership</a></li>

Oxidizing OCaml: Data Race Freedom</a></li>

How does a language like OCaml implement pattern matching?</a></li>

Ocaml Profiling(Can follow technqiues/tools used here in general too)</a></li>

Petrol: embedding a type-safe SQL API in OCaml using GADTs</a></li>

How I wrote an Activitypub Server in OCaml: Lessons Learnt, Weekends Lost</a></li>

Memtrace overview</a> , internals</a></li>

Spacetime</a></li>

Discuss discussion on OCaml Compiler Design and Development</a></li>

Making OCaml5 succeed for developers and organisations(has lots of links that can be studied)</a></li>

PR for Compaction in OCaml5</a></li>

Profiling in OCaml</a></li>

kcas 1/2</a></li>

kcas 2/2</a></li>

 Are OCaml modules basically compile-time records? </a></li>

Oxidizing OCaml with Modal Memory Management</a></li>

OCaml Discuss - [Multicore] [Blog post] A deep dive into Multicore OCaml garbage collector</a></li>
</ul>


OS
2001-03-25T00:00:00+00:00
Operating Systems</h1>


OSTEP</a></li>

OS Notes(Topics coverage is nice and seems to have extra stuff not present in OSTEP)</a></li>

Parallel And Distributed Computing</a></li>

Operating Systems Engineering</a></li>

Systems Programming</a></li>

Computer Systems A Programmers Perspective</a></li>

Beej IPC</a></li>

Writing A Linux Debugger</a></li>

Is Parallel Programming Hard, And, If So, What Can You Do About It?</a></li>

Little Book of Semaphores</a></li>

Linux</a></li>

How a CPU works: Bare metal C on my RISC-V toy CPU(HN Discussion link)</a></li>

Linux: What can you epoll? </a></li>

liburing</a></li>

Efficient IO in linux with io_uring</a></li>

LockFree Algorithms 2010</a></li>

Linux Kernel exploration + theory sort of(I'm never going to see this but the effort seems insane on this)</a></li>

linux-insides(again great effort, synchronization topics look good might see someday)</a></li>
</ul>
Some Cool Stuff</h2>


The Deadlock Empire! Slay dragons, master concurrency!</a></li>

Some stuff on Memory barries from Linux Kernel Documentation</a></li>
</ul>


Programming Languages
2001-03-25T00:00:00+00:00
Programming Languages/Compilers/Interpreters</h1>

Heavily inspired from
here</a></p>
</blockquote>
Theory</h2>


Theory of Computation by Michael Sipser</a></li>

Types and Programming Languages</a></li>

Classical Papers in PL, recommendations</a></li>

PL-Compilers-Resources</a></li>

All you need is call/cc</a></li>

Racket evaluation model(has a bit of stuff on continuation)</a></li>

Racket continuations</a></li>

Type System for Memory Safety(another banger by borretti)</a></li>

Programming Languages Research (many papers and links consolidated here)</a></li>

How to read inference rules</a></li>

How to implement effect handlers</a></li>

How should I read type system notation?(by lexilambda)</a></li>

ACM India summer School on PL and optimizations</a></li>

ACM India Summer School on Programming Languages(Thing of more interest is Program Semantics lectures(done in F*))</a></li>

ACM Summer School on Compiler Design and construction(uses some llvm)</a></li>

PL Semantics by Graham Hutton</a></li>

Getting Started with Category Theory</a></li>

NUPRL - 10 papers that all PhD students in programming languages ought to know, for some value of 10</a></li>

What does it mean for a type system or language to be "sound"?</a></li>

Normalization by Evaluation Four Ways: Reconstructing NbE Designs from First Principles</a></li>

Parametric Higher-Order Abstract Syntax</a> , HOAS</a></li>

The precise definition of Normalization By Evaluation?</a></li>

Normalization by Evaluation, Agda</a></li>

Normalisation by Evaluation in the
Compilation of Typed Functional
Programming Languages - Sam Lindley Thesis</a></li>

Zulip Chat Archive - Subject Reduction</a></li>

Zulip Chat Archive - What is the subject reduction debate?</a></li>

Subject reduction in Lean</a></li>

How much of trouble is Lean's failure of normalization, given that logical consistency is not obviously broken?</a></li>
</ul>
Overview</h2>


Crafting Interpreter</a></li>

An Incremental Approach to Compiler Construction</a></li>

Let's Learn X86-64 Assembly</a></li>
</ul>
Compiler Architecture</h2>


How the TypeScript Compiler Compiles - understanding the compiler internal</a></li>

Anders Hejlsberg on Modern Compiler Construction</a></li>

AOSA book: LLVM</a></li>
</ul>
Parsing</h2>


Simple but Powerful Pratt Parsing</a></li>
</ul>
JIT</h2>


Adventures in JIT Compilation</a></li>

Rhizome - a JIT for Ruby, implemented in pure Ruby</a></li>

Kipply's blog(lots of content relating to JIT)</a></li>
</ul>
Functional Languages</h2>


The Implementation of Functional Programming Languages</a> -
by Simon Peyton Jones</li>

Compiling Functional Languages to LLVM, a series(Lots of other cool articles as well in blog about typeclasses)</a></li>
</ul>
GC</h2>


Baby's First Garbage Collector</a></li>

The Garbage Collection Handbook</a></li>

Oilshell "Pictures of a working garbage collector"(Goldmine for garbage collector stuff, see the whole blog)</a></li>

Modern Garbage Collection(HN Discussion)
Part 1</a>
Part 2</a></li>

Boehm-Demers-Weiser Garbage Collector(Has papers linked in the GitHub repo)</a></li>

Understanding GC in JSC From Scratch</a></li>

Riptide,Webkit's GC</a></li>

High Performance GC for C++</a></li>

Precise Stack Scanning in C++</a></li>

GC Resources, Thorsten Ball</a></li>

Whippet, towards a new local maximum(more posts about GC present in the site)</a></li>

Deep Dive into ZGC, a modern garbage collector</a></li>

Memory Allocation Strategies</a></li>

LuaJIT quad color GC</a></li>
</ul>
Compiler Optimizations</h2>


CS 6120: Advanced Compilers: The Self-Guided Online Course</a></li>
</ul>
Educational Projects</h2>


chibcc by Rui Ueyama </a></li>

Multi-Language Programmable Linter</a></li>

NEAL(Language agnostic code analysis tool)</a></li>

AST Grep tool</a></li>

Comby, Tool for searching and changing code structure</a></li>

Parser Parser Combinators(Talk about Comby)</a></li>

Making a Language(information about typechecker, looks good)</a></li>

GCC Translation Validation(uses smt with gcc)</a></li>

Not exactly educational, but FStar wiki seems very comprehensive(I want to read all of this sooo badly)</a></li>

Hackett by lexilambda</a></li>

labrys</a></li>

llvm-tutor</a></li>

lura(IDE focused programming language study)</a></li>

Soft(Lisp that compiles to LLVM)</a></li>

Wasm reference interpreter in OCaml</a></li>

Mukul Rathi's Bolt(has a series of blog posts explaining implementation)</a></li>

Carbon Design Documents</a></li>

Trustfall(super cool thing)</a></li>

Extensive tutorial of Hindley Milner</a></li>

Write your own tiny programming system(s) (Hindley-Milner, OOP, Prolog,etc implementation)</a></li>

Type systems in ocaml</a></li>
</ul>
Virtual Machine</h2>


How to Build a Virtual Machine</a></li>

Small VMs and coroutines
HN</a>
Lobsters</a></li>

Faster Virtual Machines
Lobsters</a></li>

Interesting things about the Lua Interpreter(HN post link)</a></li>

Writing Interpreters in Rust</a></li>
</ul>
Misc Compilers</h2>


Cranelift Stuff(Reg Alloc, Instruction Selector etc, a series of blogs)</a></li>

Let's write a setjmp(HN Discussion)</a></li>

Design of Austral Compiler(See other articles as well to see more about typechecker)</a></li>

What Austral Proves(Lobsters discussion and link)</a></li>

Fibers, Oh My!</a></li>

Dmitry Vyukov — Go scheduler: Implementing language with lightweight concurrency</a></li>

Phil Eaton's Favourite Compiler and Interpreter Resources</a></li>

JVM Internals by Aleksey Shipilev</a></li>

Max Bernstein(tekknolagi) pl resources</a></li>

A lisp compiler and interpreter writing series by tekknolagi</a></li>

How to compile with continutations</a></li>

Design roadmap about YSH(by oilshell guy)</a></li>

Tao programming language(has so many cool features,see how they're implemented)</a></li>

Alexis King - “Effects for Less” @ ZuriHac 2020(content is just madd)</a>
,
GHC proposal link</a></li>

Blog for Kalyn(Compiled Typed Haskell like Lisp)</a></li>

Alexis King - "Delimited Continuations, Demystified"</a>,
same talk ZuriHac 2023</a></li>

GHC Reading List</a></li>

Mapping High level constructs to LLVM IR</a></li>

Program Analysis Resources(very comprehensive)</a></li>

Learning Resources for Clang libraries</a></li>

Compiler Optimizations</a></li>

Algebraic Effects for the Rest of Us</a></li>
</ul>
Linkers</h2>


Mold(README has a lot of information)</a></li>

How to execute an object file</a></li>
</ul>
Courses and Assignments</h2>


CIS 341 - Compilers(Has very nice assignments) </a></li>

CSE 131 - Compiler Construction(Haskell) </a></li>

CSE 131 - Compiler Construction(Ocaml) </a></li>

CSE 131/231- Compiler Construction(Rust)</a></li>

CMU Compilers Course by Jan Hoffman</a></li>

Essentials of Compilation Course and Book</a></li>

Course on VMs and Managed Runtimes</a></li>

(Book)Design and semantics of PL, in Scala</a></li>

Programs and Proofs</a></li>

Software Foundations(Course Cornell)</a></li>

Software Foundations Books</a></li>

An introduction to creating a C compiler for those who want to know the lower layers(In Japanese, so have to translate)</a></li>

PL Class by Edward Z Yangz</a>,
materials link( i think )</a></li>

Advanced Functional Programming(in Agda with videos)</a></li>

Programming languages(follows TAPL and content looks great)</a></li>

Xavier Leroy - Program logics: reasoning principles for high-assurance software</a></li>

Xavier Leroy - Mechanized semantics: when machines reason about their languages</a></li>

Xavier Leroy - Programming = proving? The Curry-Howard correspondence today</a></li>

Xavier Leroy - Control structures</a></li>
</ul>
Theorem Provers</h2>


Logic and Proofs in Lean(3?)</a></li>

Theorem Proving in Lean4</a></li>

Mathematics in Lean</a></li>

Mechanics of Proofs</a></li>

What is the difference between Gallina and Ltac?</a></li>

Coq <-> Lean4 Tactics Cheat Sheet</a></li>

Lean Tactic Reference</a></li>

Logic and Computation Course, uses Lean 4</a></li>

Lean 3 Type theory</a></li>

Typechecking in Lean4</a></li>

Lean4Lean</a></li>

Semantics Course in Coq/Rocq - Saarland University </a></li>

A Logical Approach to Type Soundness</a></li>

Iris Tutorial</a> , Iris Lecture Notes</a></li>

PulseCore: A Dependently Typed Stratified Separation Logic</a></li>

Hitchhiker's Guide to Logical Verification - Lean4</a></li>
</ul>
Some Cool stuff I've found</h2>


How does this work??? (Mulligan)</a></li>

Garbage collection with zero cost at non-GC time</a></li>

Why is Idris 2 much faster than Idris 1?</a></li>

Making more out of traits(Rust)</a>  and many other discussion about Rust language design</a></li>

New research programming languages thread Reddit</a></li>
</ul>
Dependent Types</h2>


A tutorial implementation of a dependently typed lambda calculus (LambdaPi)</a></li>

OCaml Discuss - Dependent Types in the Purest Form</a></li>

Swift Discuss - [Pitch] Dependent Types & Universes (Stage 1 of Proof-Driven Development?)</a></li>

Dependent Theory of Types</a></li>

Online reference book for implementing</em> concepts in type theory, Answererd by Andras Kovacs</a></li>
</ul>
Automated Verification</h2>


Automated Program Verification - Waterloo</a></li>

Automated Program Verification - Kartik Nagar</a></li>

Modern Symbolic AI and Automated Reasoning</a></li>
</ul>


Learning Resources(README)
2001-03-25T00:00:00+00:00
Learning Resources</h1>
A list of learning resources that I would like to refer back later or intent to
study.</p>
Learning Resources</h1>
A list of learning resources that I would like to refer back later or intent to
study.</p>
Other great place to find Learning resources is</p>

Lesley Lai's learning</code> repository</a></li>
Max Slater(Works in jane street compiler backend team right out of undergrad from cmu, living my dream🥲) useful links</a></li>
My Notion Reading List which I'm pretty sure I'll actually never read</a></li>
Lots of useful and cool things here</a></li>
</ul>
Computer Science and Software Engineering</h2>


Languages</p>

C++</a></li>
Rust</a></li>
Haskell</a></li>
Other Languages</a></li>
</ul>
</li>

 Operating Systems </a></p>
</li>

 Programming Languages and Compilers</a></p>
</li>

 Misc CS </a></p>
</li>
</ul>


Rust
2001-03-25T00:00:00+00:00
Rust</h1>
Books</h2>


Rust Book (Haven't fully read)</a></li>

Nomicon</a></li>

Learn Rust With Entirely Too Many Linked Lists</a></li>

Rustc Dev Guide</a></li>

Rust Atomics and Locks</a></li>

Rust for Rustaceans</a></li>

The Rust Performance Book</a></li>

The little book of Rust Macros</a></li>

Learning async rust with entirely too many web servers</a></li>
</ul>
Videos</h2>


CS 110L: Safety in Systems Programming</a></li>

John Gjengset</a></li>

Ryan Levick</a></li>
</ul>
Educational repos</h2>


mini-redis</a></li>

Educational Executor</a></li>

Type exercise in Rust</a></li>
</ul>
Blogs</h2>


HN Discussion on "Thoughts on what a next Rust compiler would do" by Alex Kladov</a></li>

Rust and C++ Interoperability</a></li>

Explain GATs like I'm 5 years old</a></li>

Pin, Unpin and why Rust needs them</a></li>

How Rust optimizes async/await</a></li>

Rust Runtime Design and Implementation, series(https://github.com/bytedance/monoio)</a></li>

Pin and suffering</a></li>
</ul>
Internals and Design/Architecture docs of compiler</h2>


Chalk(Chalk is a library that implements the Rust trait system, based on Prolog-ish logic rules.)</a></li>

Rust Analyzer Dev Docs</a></li>

Rustc Dev Guide</a></li>

Salsa documentations(used by rustc(ig cuz niko has videos on salsa) and rust-analyzer)</a></li>
</ul>

Dipesh

Blogs, Papers and Podcasts

C++

C++</h1>

C++ Tips</h2> Sutter's Mill</a></li> Abseil's C++ Tips</a></li> </ul> Books</h2> Effective Modern C++</li> David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor - C++ Templates The Complete Guide (2017)</li> A tour of C++</li>

Books</h2> Effective Modern C++</li> David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor - C++ Templates The Complete Guide (2017)</li> A tour of C++</li>

Haskell

HN Links

Languages

Languages</h1>

Lobste.rs Links

Miscellaneous CS

Miscellaneous Tools

Miscellaneous Saved Links

Miscellaneous Saved Links</h1>

OCaml

OS

Programming Languages

Learning Resources(README)

Learning Resources</h1> A list of learning resources that I would like to refer back later or intent to study.</p>

Learning Resources</h1> A list of learning resources that I would like to refer back later or intent to study.</p> Other great place to find Learning resources is</p>

Computer Science and Software Engineering</h2> Languages</p>

Rust

Rust</h1>

Learning Resources</h1>
A list of learning resources that I would like to refer back later or intent to study.</p>

Computer Science and Software Engineering</h2>

Languages</p>

C++</a></li>
Rust</a></li>
Haskell</a></li>
Other Languages</a></li> </ul> </li>

Operating Systems </a></p> </li>

Programming Languages and Compilers</a></p> </li>

Misc CS </a></p> </li> </ul>