Bookmarks
2026-09-013
2026-08-3110
- Unexplanations: relational algebra is math
- Efficient instance resolution for Agda
- Formalization of Polynomial Functors in Lean 4
- Typechecker Zoo
- Optimizing a Layer Normalization Kernel with CUDA: a Worklog
- What is cuTile BASIC?
- Parser generators vs. handwritten parsers: surveying major language implementations in 2021
- Every byte matters
- Permacomputing 101
- The category design pattern
2026-08-24
2026-07-1611
- Formal or not formal? That is the question in AI for theorem proving.
- Things unlearned
- A defense of boring languages
- Rewriting type theory
- A bidirectional typechecking puzzle
- Dissecting a Shader Quine
- Using Perlin Noise to Generate 2D Terrain and Water
- A first look at programming in Poly
- Glaive-Research
- Sequents for sequence II: Balancing the strangeness budget
- Sequents for sequence
2026-06-19
2026-05-285
2026-05-068
2026-04-18
2026-04-16
2026-04-102
2026-03-26
2026-03-235
2026-03-18
2026-03-172
2026-03-032
2026-02-27
2026-02-06
2026-02-05
2026-02-04
2026-01-26
2026-01-165
- Why Philosophers Should Care About Computational Complexity
- How (and why) to Build an Automated Theorem Prover: De-mystifying Logical Inference
- Computational Complexity and Explanations in Physics–Scott Aaronson (University of Texas at Austin)
- Program verification is not all-or-nothing
- Broken proofs and broken provers
2026-01-12
2026-01-092
2026-01-02
2025-12-257
- Emily Riehl, A New Paradigm for Mathematical Proof? | Natural Philosophy Symposium 2025
- Lecture 22 - Kolmogorov Complexity + Halting Problem + Godel Incompleteness
- The Past, Present and Future of Programming Languages - Kevlin Henney - ACCU 2025
- Bourbaki vs. Category Theory: What is Mathematics About?
- RISC-V Oral History Panel
- Lecture 88: TinyTPU
- Malloc tutorial
2025-12-192
2025-12-136
2025-12-09
2025-12-083
2025-12-022
2025-11-24
2025-11-172
2025-11-072
2025-11-062
2025-11-05
2025-11-04
2025-10-27
2025-10-262
2025-10-15
2025-10-13
2025-10-0612
- They Rebuilt this Whole Game in UE5
- Oxidize Conference: How Rust makes Oxide possible
- Big Data and AI at the CERN LHC by Dr. Thea Klaeboe Aarrestad
- Sam H. Smith – Parsing without ASTs and Optimizing with Sea of Nodes – BSC 2025
- How far can I broadcast LoRa packets WITHOUT a radio? - LoLRa
- Speedrunning 30yrs of lithography technology
- Bidirectional Type Checking
- Beyond Sequential Consistency - Leveraging Atomics for Fun & Profit - Christopher Fretz C++Now 2025
- Avi's Permanent Impact on Me - Scott Aaronson
- Professor Avi Wigderson on the "P vs. NP" problem
- "A Theoretical Computer Science Lens on Consciousness" by Lenore Blum, Manuel Blum, and Avrim Blum
- The ULTIMATE Deadlock Movement Guide – Master Every Trick (Beginner to Advanced)
2025-09-15
2025-09-02
2025-09-013
2025-08-29
2025-08-198
- What Alan T. did for his PhD
- Lecture 3: Gödel, Turing, and Friends
- Solomonoff induction still works if the universe is uncomputable, and its usefulness doesn't require knowing Occam's razor
- How to Think About GPUs
- PyTorch is dead. Long live JAX.
- Affine Dialect and OpenMP
- Program Synthesis: The λ in the Machine
- Dependent types in Haskell - Sort of
2025-08-182
2025-08-052
2025-07-305
2025-07-29
2025-07-25
2025-07-2473
- 3D Gaussian Splatting
- Keynote: Linus Torvalds, Creator of Linux & Git, in Conversation with Dirk Hohndel
- Our video editor is actually kinda useable
- ThePrimeagen On Running Linux
- Jonathan Blow on computer science curriculum
- Zig in Depth: Vectors and SIMD
- Hacking Raylib
- 3D in TypeScript using Ray Casting
- A simple socket example in Ziglang. No Talking Asmr Coding.
- 03 CUDA Fundamental Optimization Part 1
- Who needs malloc anyways?
- zig on the client, wasm on the server, what am i doing
- Everything you need to know about FFI in Gleam
- Computer Architecture Explained With MINECRAFT
- Linux Signals. I Spent 2 Years to Understand This Part.
- Yabai - Tiling Window Manager for macOS - A First Look - Effective Remote Work
- My Retro 3D Engine is Ready
- ARM Assembly: Lesson 1 (MOV, Exit Syscall)
- The most important talk on programming by Jonathan Blow
- Zig Roadmap 2023 - Andrew Kelley
- 100+ Linux Things you Need to Know
- I Designed A CPU (And So Can You)
- 2022 - Non-Euclidean Doom: what happens to a game when pi is not 3.14159…
- Elite: "The game that couldn't be written"
- How a Clever 1960s Memory Trick Changed Computing
- The Most Complicated Algorithm I've Ever Written: SQLite B-Tree Balancing
- Procedural Generation using Constraint Satisfaction
- DragonflyDB Architecture Overview, Internals, and Trade-offs - hitting 6.43 million ops/sec
- Advanced C: The UB and optimizations that trick good programmers.
- I made a Compiler in 25 Days - Here is what I learned
- CRAFTING A CPU TO RUN PROGRAMS
- Failure & Change: Principles of Reliable Systems • Mark Hibberd • YOW! 2018
- Rendering and texturing a rotating rectangle in software
- APL vs BQN vs Uiua
- 4 Months of Game Programming With My Own Engine
- Proficient Parallel Programming - King Butcher - Software You Can Love VC 2023
- ATTACK of the KILLER FEATURES - Martin Wickham - Software You Can Love Vancouver 2023
- Casey Muratori | Smart-Pointers, RAII, ZII? Becoming an N+2 programmer
- Exploring Verse, Haskell, Language Design and Teaching (with Simon Peyton Jones)
- Jonathan Blow on the Design of Jai
- Zig Master: Let's Create a Trie!
- Jonathan Blow - The Gauntlet
- Improving Learn OpenGL's Text Rendering Example | Adventures in Coding
- Adding File Manager to My Text Editor
- A* Search: How Your Map Applications Find Shortest Routes
- Simple Code, High Performance
- Zig in Production - Jens Goldberg
- Refterm Lecture Part 5 - Parsing with SIMD
- Lightning Talk: Your Favorite Undefined Behavior in C++ - JF Bastien - CppNow 2023
- Data Oriented Programming in Java 21 by Nicolai Parlog
- Visualizing memory layout of Rust's data types
- How rust forces you to respect memory
- Understanding Compiler Optimization - Chandler Carruth - Opening Keynote Meeting C++ 2015
- Making a simple Dynamic Memory Allocator (malloc)
- CppCon 2016: Timur Doumler “Want fast C++? Know your hardware!"
- Simple Artificial Neural Network entirely in assembly language
- Casey Muratori on his work experience
- Microservices are Technical Debt
- Database Scalability
- C++ cache locality and branch predictability
- OSI and TCP IP Models - Best Explanation
- Zen 5 And AI Doom w/ Casey Muratori
- Day 26 of Building An Operating System | Programming every day day 100
- Stephen Wolfram - Where the Computational Paradigm Leads (in Physics, Tech, AI, Biology, Math, ...)
- Episode 048: Why TigerBeetle Is So Slow, With Tobi!
- Jacob Pratt: "Compiler-Driven Development: Making Rust Work for You" | RustConf 2024
- The Tech Poutine #23: AMD's Moving to 2nm
- 484 - All About Dat Compiler + Some Chill Browsing (TempleOS | Livestream) [2016]
- Why GPU Programming Is Chaotic
- What Is an Interactive Theorem Prover? | Kevin Buzzard
- What P vs NP is actually about
- On The Unusual Effectiveness Of Logic In Computer Science
- Custom Floating-Point Formats
2025-07-22236
- Understanding B-Trees: The Data Structure Behind Modern Databases
- Go isn’t secure?!? feat. Low Level Learning | 053
- "Boundaries of Language Design" with Andrew Kelley & Ginger Bill
- Halting Problem & Quantum Entanglement 2020 Breakthrough result [MIP*=RE]
- 04 CUDA Fundamental Optimization Part 2
- Making Systems Programming Accessible by Andrew Kelley
- Jonathan Blow on how an operating system should work
- Writing a Compiler and Interpreter in Rust - Part 1
- Migrating from Zig to Jai
- Rope Datastructure
- What is a Lexer (No BS explanation)
- HOW TRANSISTORS REMEMBER DATA
- Bezier curve editor from scratch in 1 hour and 46 minutes
- Introduction | GPU Programming | Episode 0
- WTF is Build.Zig? by Ed Yu
- [PLDI24] Descend: A Safe GPU Systems Programming Language
- Zig 0.13.0 - Overview and Updates
- Zig Bytes 0x00: Getting Started
- Building A Programming Language From Its Core (with Peter Saxton)
- Dynamic Programming isn't too hard. You just don't know what it is.
- C++26 Preview - Jeffrey Garland - C++Now 2024
- Enter The Arena: Simplifying Memory Management (2023)
- CppCon 2018: Stoyan Nikolov “OOP Is Dead, Long Live Data-oriented Design”
- Know your Java? by Venkat Subramaniam
- You CAN do error payloads in zig
- CppCon 2018: Jonathan Boccara “105 STL Algorithms in Less Than an Hour”
- Tony Hawk's Pro Strcpy
- C3 with Christoffer Lerno -- His career and how he brought us the C3 language -- Conversation #6
- Linking can be fast (if you cheat): Roc's Surgical Linker - Brendan Hansknecht
- CppCon 2017: Carl Cook “When a Microsecond Is an Eternity: High Performance Trading Systems in C++”
- How 1 Software Engineer Outperforms 138 - Lichess Case Study
- Writing a Software Renderer from scratch in C - Part 1
- A Crash Course in Category Theory - Bartosz Milewski
- Category Theory, The essence of interface-based design - Erik Meijer
- Expert Talk: Zig Programming Language & Linters • Andrew Kelley & Jeroen Engels • GOTO 2022
- "Categories for the Working Hacker" by Philip Wadler
- CppCon 2018: Alan Talbot “Moving Faster: Everyday efficiency in modern C++”
- Type Theory for the Working Rustacean - Dan Pittman
- A Type System From Scratch – Robert Widmann
- Category Theory for the Working Hacker by Philip Wadler
- Dylan Patel - Inference Math, Simulation, and AI Megaclusters - Stanford CS 229S - Autumn 2024
- Nicholas Matsakis (Co-Lead, Rust Design Team): "Rust Roadmap 2.0” | KEYNOTE | RustConf 2024
- Miguel Ojeda (Rust for Linux): KEYNOTE | RustConf 2024
- Programming with Categories - Lecture 0
- C++ Memory Model: from C++11 to C++23 - Alex Dathskovsky
- Why algebraic data types are important - Bartosz Milewski - code::dive 2018
- Mini Project: How to program a GPU? | CUDA C/C++
- Joshua Liebow-Feeser: "Safety in an Unsafe World" | RustConf 2024
- Joshua Liebow-Feeser: "Safety in an Unsafe World" | RustConf 2024
- Coding Game of Life in C from Scratch | Graphics | Ep. 1
- 34. "Course Recap" 2024 Fall ECE344 Section 1 (University of Toronto)
- The Clean Code Debacle and Rhetoric Tricks - Casey Muratori vs Mr "Uncle Bob" Martin
- You Don't Know Network Programming
- The Impact of Memory Allocators on Performance: A Deep Dive - Arthur Pastel | EuroRust 2024
- What did category theory ever do for us (functional programmers)?
- Coding a Bouncy Ball Simulation in C
- No, I Made The Hardest Game Ever
- CppCon 2017: Matt Godbolt “What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid”
- Why OCaml
- Bret Victor The Future of Programming
- Category Theory for Programmers: Chapter 5 - Products and Coproducts
- Building a UI Framework with Ty Overby
- C++Now 2019: Ben Deane “Identifying Monoids: Exploiting Compositional Structure in Code”
- Modern CPUs Assign Registers To Speed Up Your Code - Computerphile
- Odin experience report, 1 year into a work project
- January 2025 Q&A
- Introducing Clay - High Performance UI Layout in C
- RollerCoaster Tycoon was the last of its kind.
- Lambda World 2019 - A categorical view of computational effects - Emily Riehl
- François Chollet on OpenAI o-models and ARC
- Debuggers and programming from scratch with Ryan Fleury!
- How a Computer Works - from silicon to apps
- Use Arc Instead of Vec
- Jim Keller: Moore’s Law is Not Dead
- Jon Gjengset - Towards Impeccable Rust
- Jonathan Blow on his programming language jai!
- Tips for C Programming
- Limits of Logic: The Gödel Legacy
- Building Machine Learning Systems for a Trillion Trillion Floating Point Operations
- System Jitter and Where to Find It: A Whack-a-Mole Experience
- 2024 LLVM Developers' Meeting - Rust ❤️ LLVM
- Making a Better Particle Simulation in C++ (Part 2)
- Designing Distributed Systems with TLA+ • Hillel Wayne • YOW! 2019
- VULKAN: From 2D to 3D // C++ 3D Multiplayer Game From Scratch // LIVE TUTORIAL
- I made Soft Body Physics from Scratch
- Trading at light speed: designing low latency systems in C++ - David Gross - Meeting C++ 2022
- (Ep.73) DeepSeek CEO interview in English.
- Arena Allocator, Stack Allocator, Free-list Allocator, Pool Allocator Visualized
- How CPU Memory & Caches Work - Computerphile
- How I Take Notes With Neovim (as a highschool student)
- BLAZINGLY FAST C++ Optimizations
- raylib author on library internals and C programming language!
- uv: An Extremely Fast Python Package Manager
- The ARC Prize 2024 Winning Algorithm
- Endgame: Big Tech Bytes the Dust - Jim Keller, Tenstorrent, Tesla, Apple, AMD, Intel #261
- Designing in 2023: 10 Problems to Solve w/ Jim Keller
- [#39] DVUI - David Vanderson
- Let's code math | Lean4 | Theorem prover
- Hierarchical Tiling to speed up my Matrix Multiplication
- I Recreated Shazam's Algorithm from Scratch because no one is hiring jnr devs
- What Jim Keller Sees that Others Miss – DemystifySci #326
- One System, Eight Tenstorrent Wormholes
- 61DAC Keynote: Jim Keller, CEO, Tenstorrent
- Jim Keller on RISC-V Cores and Chiplets
- RISC-V Day '23 Summer The Future of RISC-V and RISC-V AI (Jim Keller | CEO, Tenstorrent)
- Rust is the New C
- Code walkthrough of my game written in x64 assembly
- I can prove I’ve solved this Sudoku without revealing it
- RISC-V Technology Conference: Day 1 Keynotes | Nerds Talking to Nerds About RISC V
- The Genius of RISC-V Microprocessors - Erik Engheim - ACCU 2022
- Jim Keller's Initial Confidence in Tenstorrent
- Tenstorrent: Relegating the Important Stuff to the Compiler
- The critical threshold in programming: 5 thousand lines of code | ThePrimeagen and Lex Fridman
- Keynote: Development Environments Shape Programming Solutions - Stephanie Brenham - ACCU 2023
- Not Your Grandparent's C++ - The Evolution of Cpp - Phil Nash - ACCU Cambridge
- Live at NVIDIA GTC with Acquired
- TSMC founder Morris Chang on the evolution of the semiconductor industry
- Past, Present & Future of AI Compute (Panel) | Beyond CUDA Summit 2025
- AI Coding: Compute Shaders vs CUDA vs openCL - Dr. Fuhua (Frank) Cheng
- NVIDIA Doesn't Care About GPUs
- The Exact Moment AMD Beat Intel
- What Every Programmer Should Know about How CPUs Work • Matt Godbolt • GOTO 2024
- The Beauty of Simplicity - Making Your Own Technology • Yan Chernikov • YOW! 2024
- Richard S. Sutton, Turing Award Winner | Approximately Correct
- Amateurs Solve a Famous Computer Science Problem On Discord
- The Past, Present & Future of Programming Languages • Kevlin Henney • GOTO 2024
- Getting Started with Multi-GPU Scaling: Distributed Libraries | NVIDIA GTC 2025
- How to write a fast Softmax kernel
- Physicist Dr. David Deutsch-Quantum Computing, Turing Machines, & Multiverses (THE SAAD TRUTH_1742)
- Scott Aaronson | How Much Math Is Knowable?
- Zeroes and Ones: Into the Depths of Computation | Jim Keller | EP 272
- TPU V4 and Trends in Accelerator Hardware - Mike Hutton
- "Propositions as Types" by Philip Wadler
- But what is quantum computing? (Grover's Algorithm)
- Fujitsu’s New ARM Chip: Focused, Fast, and Unlike Anything Else
- Grammars, parsing, and recursive descent
- Intro to TT-Forge
- System Design for Next-Gen Frontier Models — Dylan Patel, SemiAnalysis
- The State of Silicon and the GPU Poors - with Dylan Patel of SemiAnalysis
- Stephen Wolfram | Computational Foundations of Everything
- Lecture 55: Modular’s unified device accelerator language
- Building a Debugger • Sy Brand & Tim Misiak • GOTO 2025
- Developer Productivity, v2 with ThePrimeagen | Preview
- Formalizing a proof in Lean using Github copilot and canonical
- How the heck do you make a PCB?
- Mojo meets AMD MI300X: Modular GPU Kernel Hackathon Highlights 🔥
- Formalizing a proof in Lean using Claude and o4
- How the Rust Compiler Works, a Deep Dive
- How I FOUND the Nsa's backdoor inside your Intel Cpu
- Must Know Technique in GPU Computing | Episode 4: Tiled Matrix Multiplication in CUDA C
- Watch: Writing a new programming language from scratch! (How hard can it be?)
- A Hundred PyTorch Backends: Mark Saroufim at the Modular GPU Kernel Hackathon
- Jonathan Blow on pattern matching and Option type
- How BAD Is Test Driven Development? - The Standup #6
- How 1999 Quake 3 Teaches Elite Software Engineering
- Turning Portal 2 into a Web Server
- Dylan Patel (SemiAnalysis) on Multi-Datacenter Training @ Decentralized AI Day 2025
- Oxidise Your Command Line (2025 Edition)
- Ultimate NixOS Guide | Flakes | Home-manager
- What is PLUS times PLUS?
- GTC 2022 - How CUDA Programming Works - Stephen Jones, CUDA Architect, NVIDIA
- Intro to CUDA (part 4): Indexing Threads within Grids and Blocks
- Nix explained from the ground up
- CUDA Mode Keynote | Andrej Karpathy | Eureka Labs
- Why Use C for UI Library? | Nic Barker
- Agentic Engineering in Action with Mitchell Hashimoto
- Inside a Real High-Frequency Trading System | HFT Architecture
- RISC-V and the CPU Revolution, Yunsup Lee, Samsung Forum
- Typst is pretty neat
- Building precision machines is simple, until it isn't.
- Coding Adventure: Simulating Fluids
- Scaling Computing Performance Beyond the End of Moore’s Law: Song Han
- EXO 2
- GOSIM CHINA 2024 - Nicholas Nethercote: Rust Compiler Overview
- Gordon Moore: Behind the Ubiquitous Microchip
- Declarative C++ - Ankur Satle - C++Online 2025
- Writing an own Terminal from Scratch in C
- Dylan Patel: GPT4.5's Flop, Grok 4, Meta's Poaching Spree, Apple's Failure, and Super Intelligence
- How I Simulate Over a Million Persistent NPCs For My Procedural City
- Weathering Software Winter
- Jonathan Blow - Jai Demo and Design Explanation (KEYNOTE) - Updated
- Type Theory in Computer Science, Linguistics, Logic
- Developing an application from scratch (Haskell Unfolder #46)
- BRYCE ADELSTEIN LELBACH - The C++ Execution Model
- FPGA in HFT Systems Explained | Why Reconfigurable Hardware Beats CPUs
- Luminal - Search-Based Deep Learning Compilers
- "An approach to computing and sustainability inspired from permaculture" by Devine Lu Linvega
- #22 Dylan Patel: China’s Robotics Dominance; AI Infrastructure Breakdown
- An Introduction to Functional Imperative Programming in Flix • Magnus Madsen • GOTO 2023
- The Death of Monads? Direct Style Algebraic Effects
- Algebraic Effects from Scratch by Kit Langton
- Intel’s Reign of Terror
- The Birth, Boom and Bust of the Hard Disk Drive
- Why the Soviet Computer Failed
- AT&T’s UNIX PC Failure
- Casey Muratori – The Big OOPs: Anatomy of a Thirty-five-year Mistake – BSC 2025
- Eiríkr Åsheim: Uxn: Permacomputing & Roguelikes
- Dennis Gustafsson – Parallelizing the physics solver – BSC 2025
- Lambda Calculus vs. Turing Machines (Theory of Computation)
- A Flock of Functions: Lambda Calculus and Combinatory Logic in JavaScript | Gabriel Lebec @ DevTalks
- Stephen Wolfram visits RWRI 20 (The Real World Risk Summer School, 2025)
- OpenAI's Stable Code 3B: A Game-Changer for Coding & Programming Tasks
- The World's First Microprocessor: F-14 Central Air Data Computer
- How do hardware timers work?
- Quantum Computing - Hype vs. reality | Field Notes
- Donald Knuth: Algorithms, Complexity, and The Art of Computer Programming | Lex Fridman Podcast #62
- Using Apple Vision Pro: What It’s Actually Like!
- The Map of Quantum Computing - Quantum Computing Explained
- Quantum Computing for Computer Scientists
- Hardware and software [2024 edition]
- Watch kernel developer do Linux kernel development ;-)
- Memristors for Analog AI Chips
- Grounded II: Making The Last of Us Part II
- Marc Raibert: Boston Dynamics and the Future of Robotics | Lex Fridman Podcast #412
- How AI Discovered a Faster Matrix Multiplication Algorithm
- Jeff Dean (Google): Exciting Trends in Machine Learning
- Let's build the GPT Tokenizer
- 1.2 - Racing Down the Slopes of Moore’s Law (Bram Nauta)
- The hidden beauty of the A* algorithm
- How does Groq LPU work? (w/ Head of Silicon Igor Arsovski!)
- Fine-tune LLMs - Line by line code example
- Intel's Crazy Plan for AI Chips IS WORKING! (Supercut)
- How Particle Life emerges from simplicity
- WHY IS THE HEAP SO SLOW?
- Is this the Future of Programming Languages?
- George Hotz | Programming | rewriting linearizer (tinygrad) | Day In The Life Of A Software Engineer
- How do CPUs read machine code? — 6502 part 2
- Busy Beaver Turing Machines - Computerphile
- Anthropic's Meta Prompt: A Must-try!
- Building a Scripting Language in C - Floats
- Tmux has forever changed the way I write code.
- Turn VIM into a full featured IDE with only one command
- The perfect Neovim setup for Python
- Edsger W. Dijkstra - The Power of Counting Arguments
- Hardware SPI Continued - IO from Scratch - Part 7
- Learn how to design your own custom computer chips!
2025-07-18
2025-07-16
2025-07-156
2025-07-14
2025-07-096
2025-07-05
2025-07-01
2025-06-276
2025-06-269
- How we built our multi-agent research system
- An MLIR Dialect for Distributed Heterogeneous Computing
- Why Resonate
- TPU Deep Dive
- Tiger Style
- LazyLog: A New Shared Log Abstraction for Low-Latency Applications
- Consistency Models
- Are You Sure You Want To Use Mmap In Your Database Management System?
- Convex is the open-source reactive database for app developers.
2025-05-29
2025-05-163
2025-05-032
2025-04-242
2025-04-224
2025-04-198
- tt-metal/tech_reports/memory/allocator.md at main · tenstorrent/tt-metal
- What Modern NVMe Storage Can Do, And How To Exploit It: High-Performance I/O for High-Performance Storage Engines
- Memory on Tenstorrent
- Subnanosecond flash memory enabled by 2D-enhanced hot-carrier injection
- Andrew_S._Tanenbaum_-_Structured_Computer_Organization
- A Gentle Introduction to Lambda Calculus - Part 1: Syntax
- Getting Started
- curry-howard.dvi
2025-04-103
2025-04-05
2025-04-01
2025-03-297
2025-03-283
2025-03-27
2025-03-252
2025-03-242
2025-03-22
2025-03-184
2025-03-175
- The Making of Python
- tt-metal/METALIUM_GUIDE.md at main · tenstorrent/tt-metal · GitHub
- Scoping out the Tenstorrent Wormhole
- What’s the (floating) Point of all these data types? A (not so) brief overview of the history and usage of datatypes within the wide world of computation
- Tenstorrent first thoughts
2025-03-07
2025-03-063
2025-02-28
2025-02-26
2025-02-253
2025-02-17
2025-02-15
2025-01-27
2025-01-253
2025-01-23
2025-01-19
2025-01-15
2025-01-12
2025-01-09
2025-01-02
2024-12-27
2024-12-232
2024-12-222
2024-12-19
2024-12-174
2024-12-168
- Proofs and Types
- What is the "question" that programming language theory is trying to answer?
- Introducing Limbo: A complete rewrite of SQLite in Rust
- TLA+ is hard to learn
- How hard is constraint programming?
- Advanced programming languages
- ugh.book
- GitHub - avinassh/py-caskdb: (educational) build your own disk based KV store
2024-12-13
2024-12-11
2024-12-10
2024-12-09
2024-12-07
2024-12-034
2024-12-02
2024-11-293
2024-11-25
2024-11-19
2024-11-183
2024-11-177
2024-11-12
2024-11-09
2024-10-31
2024-10-272
2024-10-15
2024-10-01
2024-09-304
2024-09-23
2024-09-132
2024-09-09
2024-08-27
2024-08-246
2024-08-152
2024-08-143
2024-08-092
2024-08-062
2024-08-042
2024-08-032
2024-08-02
2024-08-012
2024-07-30
2024-07-2920
- Efficient n-states on x86 systems
- Program tuning as a resource allocation problem
- How web bloat impacts users with slow connections
- Files are hard
- Ringing in a new asynchronous I/O API
- applicative-mental-models
- Optimizing subroutines in assembly language
- Demystifying programs that create programs, part 1: A disassembler
- QBE vs LLVM
- Recent presentations and papers
- How long does it take to make a context switch?
- Ghostty Devlog 001
- Tiled Matrix Multiplication
- Rust Atomics and Locks
- Compiler Backend
- Vale's Memory Safety Strategy: Generational References and Regions
- Introduction
- Cache-Oblivious Algorithms
- A Memory Allocator
- 1024cores
2024-07-2812
- Implementing interactive languages
- Pointers Are Complicated, or: What's in a Byte?
- Three Architectures for a Responsive IDE
- How a Zig IDE Could Work Feb 10, 2023
- Properly Testing Concurrent Data Structures Jul 5, 2024
- Parse, don’t validate
- Too Fast, Too Megamorphic: what influences method call performance in Java?
- The Black Magic of (Java) Method Dispatch
- Why null sucks, even if it's checked
- Unnamed Document
- Resources for Building Programming Languages
- Little 'Big Ideas' in Programming Language Design
2024-07-279
- Computer Networking: A Top-Down Approach
- Using Uninitialized Memory for Fun and Profit Posted on Friday, March 14, 2008.
- Zip Files All The Way Down
- Minimal Boolean Formulas
- Hacking the OS X Kernel for Fun and Profiles Posted on Tuesday, August 13, 2013.
- How To Build a User-Level CPU Profiler Posted on Thursday, August 8, 2013.
- An Encoded Tree Traversal
- Our Software Dependency Problem
- Running the “Reflections on Trusting Trust” Compiler Posted on Wednesday, October 25, 2023.
2024-07-263
2024-07-254
2024-07-238
- Updating the Go Memory Model
- Programming Language Memory Models (Memory Models, Part 2) Posted on Tuesday, July 6, 2021. PDF
- Hardware Memory Models (Memory Models, Part 1) Posted on Tuesday, June 29, 2021. PDF
- Baby Steps to a C Compiler
- Kernel Programming Guide
- Tiny Tapeout
- Why Pascal is Not My Favorite Programming Language
- What Color is Your Function?
2024-07-222
2024-07-21
2024-07-202
2024-07-18
2024-07-1711
- Your Starting Point!
- Zig Interfaces for the Uninitiated, an update
- Zig Interfaces for the Uninitiated
- Exploring Compile-Time Interfaces in Zig
- Aro - a C compiler
- Database Systems
- Discovering and exploring mmap using Go
- But how, exactly, databases use mmap?
- reHow memory mapped files, filesystems and cloud storage works
- Implementing a file pager in Zig
- Criticizing Hare language approach for generic data structures
2024-07-162
2024-07-154
2024-07-14
2024-07-13
2024-07-126
2024-07-114
2024-07-106
2024-07-096
2024-07-0811
- Compiling tree transforms to operate on packed representations
- Pipelines Support Vectorized, Point-Free, and Imperative Style
- Entering text in the terminal is complicated
- What happens when you start a process on Linux?
- Debug your programs like they're closed source!
- How I got better at debugging
- Media Page Under Construction
- Infographics: Operation Costs in CPU Clock Cycles
- Handles are the better pointers
- You're Not Sick of Programming
- Zig Bare Metal Programming on STM32F103 — Booting up
2024-07-073
2024-07-062
2024-07-059
- Learning LLVM (Part-1) - Writing a simple LLVM pass
- Some Were Meant for C
- Xv6, a simple Unix-like teaching operating system
- C Is Not a Low-level Language
- Should you learn C to "learn how the computer works"?
- A Guide to Undefined Behavior in C and C++, Part 1
- When Network is Faster than Cache
- John Carmack on Functional Programming in C++
- Zig-style generics are not well-suited for most languages
2024-07-044
2024-07-038
- A Freestanding Rust Binary
- Manually linking Rust binaries to support out-of-tree LLVM passes
- The Rust Reference
- Rust Compiler Development Guide
- How to speed up the Rust compiler one last time
- How to speed up the Rust compiler in March 2024
- Zig Bits 0x4: Building an HTTP client/server from scratch
- Do We Really Need A Link Step?
2024-07-027
- jamiebuilds/the-super-tiny-compiler: :snowman: Possibly the smallest compiler ever
- 5 Days to Virtualization: A Series on Hypervisor Development
- In-depth analysis on Valorant’s Guarded Regions
- Exploit Development: No Code Execution? No Problem! Living The Age of VBS, HVCI, and Kernel CFG
- Reader
- CheerpX versus WebContainers
- Creating a Rootkit to Learn C
2024-07-0110
- Picsart-AI-Research/LIVE-Layerwise-Image-Vectorization: [CVPR 2022 Oral] Towards Layer-wise Image Vectorization
- Udacity CS344: Intro to Parallel Programming
- CS 361: Systems Programming
- Resolving Rust Symbols
- When FFI Function Calls Beat Native C
- Cap'n Proto, FlatBuffers, and SBE
- A Database Without Dynamic Memory Allocation
- Wizard Zines Collection!
- Aggregating Millions of Groups Fast in Apache Arrow DataFusion 28.0.0
- Problems of C, and how Zig addresses them
2024-06-302
2024-06-28
2024-06-272
2024-06-25
2024-06-2417
- The Graphics Codex
- Notes on partial borrows
- Dioxus Labs + “High-level Rust”
- Compile-Time Configuration For Zig Libraries
- Generics
- Zig's HashMap - Part 1
- Zig Parser
- Causal ordering
- Assorted thoughts on zig (and rust)
- Columnar kernels in go?
- An opinionated map of incremental and streaming systems
- Internal consistency in streaming systems
- Pain we forgot
- Have you tried rubbing a database on it?
- The shape of data
- Prospecting for Hash Functions
- The Missing Zig Polymorphism / Runtime Dispatch Reference
2024-06-23
2024-06-20
2024-06-1914
- Text Buffer Reimplementation
- What Is The Minimal Set Of Optimizations Needed For Zero-Cost Abstraction?
- Using ASCII waveforms to test hardware designs
- Rust 2019 and beyond: limits to (some) growth.
- Your ABI is Probably Wrong
- GitHub - sirupsen/napkin-math: Techniques and numbers for estimating system's performance from first-principles
- Don't write bugs
- technicalities: "not rocket science" (the story of monotone and bors)
- Why is Python slow
- Design duality and the expression problem
- Random Thoughts On Rust: crates.io And IDEs
- John Carmack on Inlined Code
- A Few Billion Lines of Code Later: Using Static Analysis to Find Bugs in the Real World
- What is Systems Programming, Really?
2024-06-173
2024-06-16
2024-06-143
2024-06-133
2024-06-125
2024-06-113
2024-06-092
2024-06-08
2024-06-064
2024-06-056
2024-05-313
2024-05-282
2024-05-276
2024-05-252
2024-04-30
2024-04-07
2024-03-062
2024-03-052
2024-03-032
2024-02-272
2024-02-08
2024-02-05
2024-02-032
2024-01-26
2024-01-16
2024-01-08
2024-01-072
2024-01-03
Subcategories
- algorithms (2)
- computer_architecture (139)
- computer_graphics (29)
- courses (5)
- cryptography (6)
- databases (12)
- distributed_systems (10)
- game_development (27)
- hardware_engineering (13)
- history (25)
- networking (5)
- parallel_computing (30)
- programming_languages (150)
- signal_processing (3)
- software_architecture (2)
- software_development (273)
- systems_programming (141)
- theory (339)
- tools (5)
- web_technologies (1)