Past Issues

• Code vs Data Driven Displacement
• Why you shouldn't invoke setup.py directly
• Downloading Web Pages

• Printf("%s %s", dependency, injection).
• DbContextExtensions: An approach to managing the EF Core DbContext
• Where does all the effort go? Looking at Python core developer activity

• Cracking Random Number Generators using Machine Learning – Part 1: xorshift128
• Overhead of Returning Optional Values in Java and Rust
• Implementing Hash Tables in C

• The Potential Merits of an Itemized OS
• Disassembling Hello World in Java
• Why I Still ‘Lisp’ (and You Should Too)

• IoT Hacking and Rickrolling My High School District
• How cross signing works with X509 certificates
• Interface ergonomics: automation isn't just about time saved

• Generating relocatable code for ARM processors
• Performance Optimization in React applications
• Writing a "bare metal" operating system for Raspberry Pi 4

• CI/CD/CF? — The DevOps toolchain’s “missing-link”
• Hey linker, can you spare a meg?
• RenderingNG deep-dive: LayoutNG

• The Insane Innovation of TI Calculator Hobbyists
• Always-on Processor magic: How Find My works while iPhone is powered off
• Taming the Tarpit

• Revenge of Lisp (Part 1⁄2)
• 100% CPU: My Fault?
• Under the Hood of Macros in Elixir

• Rewriting Go source code with AST tooling
• What is yield and how does it work in C#?
• Implicit Overflow Considered Harmful (and how to fix it)

• Making a Game in Janet, Part 1: Psst, hey kid, wanna try some Janet?
• Are Dockerfiles good enough?
• Polymorphism without objects via multimethods

• Working with SQL Server identity columns
• Nested strict data in Haskell
• Bracket pair colorization 10,000x faster

• Interactive introduction to [OpenVSCode Server]
• C++20 Coroutine Iterators
• Implementer's Guide to WebSockets

• A Bonding Exercise
• Finding Number Related Memory Corruption Vulns
• RTC (Real-Time Communication) at scale

• A terminal case of Linux
• Category Theory Illustrated
• The Speed of Time

• Essential Page Cache theory
• Fitting a FORTH in 512 bytes
• On bad advice

• Implementing Co, a Small Interpreted Language With Coroutines #2: The Interpreter
• 5 RCEs in npm for $15,000
• Practical frontend architecture

• Robots Must Be Ephemeralized
• How I patched Python to include this great Ruby feature
• There Was No Formal Methods Winter

• The elements of git
• All about Procedure Linkage Table
• Fixing Time.deltaTime in Unity 2020.2 for smoother gameplay: What did it take?

• Reconstructing TypeScript, part 1: bidirectional type checking
• An Intro to JavaScript Proxy
• Turing Oversold

• Go'ing Insane Part One: Endless Error Handling
• Shulman’s Practical Type Theory for Symmetric Monoidal Categories
• Ship / Show / Ask

• Coercing deep const-ness
• Hack Pipe for Functional Programmers: How I learned to stop worrying and love the placeholder
• Up and Down the Ladder of Abstraction

• Resource efficient Thread Pools with Zig
• Introducing Coalton: How to Have Our (Typed) Cake and (Safely) Eat It Too, in Common Lisp
• Ray casting in 2D game engines

• Greedy AI Agents Learn to Cooperate
• Dissecting Deno
• Laziness: Clojure vs Haskell

• Approaches for Building Real-Time ML Systems
• Heterogenous Maps and Dynamic Case Classes in Scala 3
• How Materialize and other databases optimize SQL subqueries

• Clojure Zippers
• How to Eliminate Render-Blocking Resources: a Deep Dive
• Ballerina Concurrency Model and Non-Blocking I/O

• Exploring fff part 1 - main
• Using the Platform
• One Hundred Thousand Lines of Rust

• Let’s build an LC-3 Virtual Machine
• File IO improvements in .NET 6
• Proving 50-Year-Old Sorting Networks Optimal: Part 1

• Reflective Towers of Interpreters
• On Variance and Extensibility
• On using PSR abstractions

• Making Reasonable Use of Computer Resources: Part 2
• Article 2
• Async overloading

• DoomPhone
• Linux in a Pixel Shader - A RISC-V Emulator for VRChat
• Effective Shell

• Ode to a Streaming ByteString
• HTTP/2 in infrastructure: Ambry network stack refactoring
• Understanding Network Access in Windows AppContainers

• Crypto Markets Recover Amid COVID-19 Fears
• An Opinionated Guide to xargs
• Reducing System Load With Event Folding

• C++20 modules with GCC11
• Adventures in WebRTC: Making Phone Calls from XMPP
• Speeding up atan2f by 50x

• I figured out how DMARC works, and it almost broke me
• A Record Type Representation Trick
• Integer Overflow to RCE — ManageEngine Asset Explorer Agent (CVE-2021–20082)

• Should the browser use all available memory?
• Let's write a compiler, part 1: Introduction, selecting a language, and doing some planning
• Structuring Authorization Architecture

• How We (Don’t) Reason About Code
• Stephen Wiesner
• Modern web apps without JavaScript bundling or transpiling

• Climbing Mount Effect
• Two counterintuitive results
• Code memory safety and efficiency by example

• C++ exceptions under the hood
• TLDs -- Putting the 'Fun' in the top of the DNS
• Namespaced De Bruijn indices

• A look under the hood: how branches work in Git
• C++ coroutines: The mental model for coroutine promises
• Preemptive Pluralization is (Probably) Not Evil

• Design your own Runtime
• Battle-tested monadic OCaml: Tezos
• Stop Using Icon Fonts

• New browser-tracking hack works even when you flush caches or go incognito
• What I wish I had known about single page applications
• Will you pay the consistency costs?

• The usefulness of currying
• Booting the IBM 1401: How a 1959 punch-card computer loads a program
• Reverse Engineering a Gameboy Advance game: Let’s Stretch the Bridge! — Part 1

• What would SQLite look like if written in Rust? — Part 1
• A data transformation problem in SQL and Scala: Dovetailing declarative solutions
• Getting Deep into Shadows

• Let’s Create a Custom Audio Player
• Building a decentralized options exchange on ethereum
• Advanced Git Features You Didn’t Know You Needed

• Introduction to ARM Semihosting
• Divisibility by any prime
• How Materialize and other databases optimize SQL subqueries

• Simulating Latency with SQL / JDBC
• Persistent Data Structures - An Introduction
• How humans write programs

• A Look at iMessage in iOS 14
• Inheritance Without Pointers
• Blinkenlights

• Experimenting with remote debugging: Node.js runtime code injection
• DBA in training: SQL Server under the hood
• Progressive Rendering for Better Web App Performance

• TypeScript: Stop Using 'any', There's a Type For That
• How to convert between callbacks and Promises in Javascript
• New campaign targeting security researchers

• Building a social media platform without going bankruptPart I–Laying the numbers
• Let’s Build a Quasiquoter
• Build Your Own Container Using Less than 100 Lines of Go

• Don’t think, just defunctionalize
• Query Hints You Can Use to Avoid Blocking
• Build Your Own Text Editor

• The State of State Machines
• The different types of cross-site scripting (XSS)
• Categories of Nets (Part 1)

• return first
• Writing Environment-Agnostic Functional Acceptance Tests
• The Philosophy of Svelte

• Breaking The Browser – A tale of IPC, credentials and backdoors
• Abusing C# For Loops For Job Security
• Go (golang) Error Handling - A Different Philosophy

• Rebuilding the most popular spellchecker. Part 1
• The confusing world of USB
• An additional non-backtracking RegExp engine

• Patterns of Distributed Systems
• Geometric effects of certain system design choices
• Chain loading, not preloading: the dynamic linker as a virtualization vector

• Post #0: In Which I Set Out to Write a Terrible Compiler for a Useless Language
• C++ and passing by value
• How Not to Teach Recursion

• ARM Cortex-M33 Instruction Tracing Without a Debugger
• Why I rewrote my open source virtual reality server
• We rendered a million web pages to find out what makes the web slow

• The Adventures of OS: Making a RISC-V Operating System using Rust
• How to Test a Quantum Program?
• Back to the '70s with Serverless

• Writing a custom iterator in modern C++
• What happens when...
• Commits are snapshots, not diffs

• Defensive Programming - Friend or Foe?
• What I Wish Someone Had Told Me About Tensor Computation Libraries
• Scalability and Load Testing for VALORANT

• A Visual Tour of Backpropagation
• Improve Performance Using SQL Functions in Postgres
• Fast AF Fourier Transform (FafFT)

• Page Fault Injection in Virtual Machines: Accessing Swapped-Out Pages from HVMI
• An overview of end-to-end entity resolution for big data
• if... then... else had to be invented!

• Good-bye ESNI, hello ECH!s
• Contracts, Preconditions & Invariants
• Does reducing numerical precision affect real world datasets?

• Why nullable types?
• Logical layout enhancements with flow-relative shorthands
• Combinators and the Story of Computation

• Nvidia Ampere vs. AMD RDNA 2: Battle of the Architectures
• The Subtle Hazards of Real-World Cryptography
• Command Line Interface Guidelines

• Inheritance vs Composition: Which is Better for Your JavaScript Project?
• Three Classes of Problems Found by Mutation Testing
• Using Bloom filters to efficiently synchronise hash graphs

• Feature Casualties of Large Databases
• What machines can and can't do
• Protein folding & The AI 'Solution' : A primer for non-scientists

• Gamedev from scratch 0: Groundwork
• Objects in Functional Languages
• Component-Oriented Programming

• 2Q Cache Management Algorithm
• Seeing is believing: a client-centric specification of database isolation
• ARM and Lock-Free Programming

• My list of magic numbers for your turkey day enjoyment
• Modern storage is plenty fast. It is the APIs that are bad.
• Karen on Python mocks: threading.Timer

• What is a Programming Paradigm?
• Why I Built My Own Shitty Static Site Generator
• Hiding data from humans and computers in GIF files

• How we designed Dropbox’s ATF - an async task framework
• What is shader occupancy and why do we care about it?
• Chasing a Performance Regression with Erlang/OTP 22

• Making Mass Effect not require administrator rights, or maybe how to not write a boolean check
• Uncovering Online Delivery Menu Best Practices with Machine Learning
• Fun with Concepts: Do You Even Lift, Bool?

• How Netflix Scales its API with GraphQL Federation (Part 1)
• DBA in training: Backups, SLAs, and restore strategies
• Low Hanging Fruits in Frontend Performance Optimization

• Stop checking for NULL pointers!
• Problem Solving
• [OpenGL and Vulkan Interoperability on Linux] Part 2: Using OpenGL to draw on Vulkan textures.

• Understanding JavaScript IIFEs Like a Boss
• Exception safety in Rust: using transient droppers to prevent memory leaks
• Frequency Domain Image Compression and Filtering

• Demystifying a very simple TrustZone enabled program on ARM Cortex-M33
• Ensuring Clean Code: A Look at Python, Parameterized
• Java Concurrency: Deadlock

• Math keeps changing
• Keeping Netflix Reliable Using Prioritized Load Shedding
• Linear Algebra Shenanigans: Gizmo Repair

• Names are not type safety
• Helios: hyperscale indexing for the cloud & edge (part II)
• What Does It Take To Resolve A Hostname

• The JPA and Hibernate first-level cache
• Making our own ping
• Organizing Code by Feature using Verticle Slices

• What all Developers need to know about: Reverse Tabnabbing
• Program in Arm6 assembly language on a Raspberry Pi
• The Grand Unified Theory of Software Architecture

• Pi from High School Maths
• Text layout is a loose hierarchy of segmentation
• Semantic requirements in concepts

• Reading and writing, part 1: locations and locks
• Transport-Oriented Growth and Procedural Trees
• Helios: hyperscale indexing for the cloud & edge – part 1

• Generating Rock Climbing Route Descriptions with ML (GPT-2)
• Hot Swapping Production Tables for Safe Database Backfills
• More and More Utilities in C++20

• Leveraging LD_AUDIT to Beat the Traditional Linux Library Preloading Technique
• The Surprising Impact of Medium-Size Texts on PostgreSQL Performance
• What every programmer should know about memory, Part 1
• Get me off Your Fucking Mailing List

• Fun with Lambda Calculus
• JavaScript and TypeScript Hidden Gems: Decorators
• Container networking is simple

• Floating Point in the Browser, Part 3: When x+y=x
• Abstract Classes vs. Interfaces in C# - What You Know is Probably Wrong
• The case for a learned sorting algorithm

• How to Conditionally Add Attributes to Objects
• Video processing with WebCodecs
• Classic Path.DirectorySeparatorChar gotchas when moving from .NET Core on Windows to Linux

• Creating a JavaScript promise from scratch, Part 4: Promise.resolve() and Promise.reject()
• A mathematical formulation of the tax code?
• malloc as a service

• Look Ma, No Data Structures!
• Compiling a Lisp: If
• Local File Inclusions, explained

• Bidirectional text
• Creating a JavaScript promise from scratch, Part 3: then(), catch(), and finally()
• Scrollable Grid with Just-in-Time Data Loading – Part 5: Hooking up the Database

• The Single-Valued Type Pattern for TypeScript
• Understanding operational 5G: a first measurement study on its coverage, performance and energy consumption
• Reading and writing, part 2: files and databases

• 5 TILs about Node.js Fundamentals from the Node.js Design Patterns Book
• Reflection for aggregates
• Comparing Load Balancers for PostgreSQL

• Common Table Expressions
• The M140i project post - Part 10
• Exploring Node.js Async Hooks

• The User Wizard Scenario
• Generalizing 'jq' and Traversal Systems using optics and standard monads
• Design Considerations for Secure GraphQL APIs

• std::exchange Patterns: Fast, Safe, Expressive, and Probably Underused
• Slack Tracking in V8
• The Fresh Smell of ransomed coffee

• Why it is important to apply static analysis for open libraries that you add to your project
• Leveraging Declarative Programming to Create Maintainable Web Apps
• A Gentle Introduction to Using a Docker Container as a Dev Environment

• Accessible Web Animation: The WCAG on Animation Explained
• Creating a JavaScript promise from scratch, Part 1: Constructor
• Content delivery networks (CDNs)

• The Last Vestiges Of Object Oriented Programming
• How Mercado Libre optimized for Web Vitals (TBT/FID)
• V8 release v8.6