Past Issues
- Conditional Members
- Loop Fission
- How Does NTP Work?
- Permutation-Invariant Neural Networks for Reinforcement Learning
- Gentle Introduction to Realtime Fluid Simulation for Programmers and Technical Artists
- Faster software through register based calling
- Abstract Clojure
- Faulty Logic
- A prioritised micro-batch scheduler in rust
- Why does Go not need a fancy expensive garbage collector like Java and C#?
- Constructs for Run Time Network Data Management & Analysis; a Data- Centric Approach
- Modern Evolution Strategies for Creativity: Fitting Concrete Images and Abstract Concepts
- How to Handle Exceptions With the ThreadPoolExecutor in Python
- Backdooring Rust crates for fun and profit
- Mononym: Type-Level Named Values in Rust - Part 1: Demo and Implementation
- Learning Containers From The Bottom Up
- Je Ne Sais Quoi - Falcons over the Horizon
- Overengineering can kill your product
- Reverse-engineering the Yamaha DX7 synthesizer's sound chip from die photos
- Finding why Pytorch Lightning made my training 4x slower
- My Own Private Binary
- An in-depth perspective on webpack's bundling process
- The Clojure Promise
- A Fulcio Deep Dive
- Stack Exchange is a good place to explain initial and terminal objects in the category of sets
- The Ruby Compiler Survey, Rubinius
- The inside story of the outside investigation of SoftRAM 95
- Programming with Something
- Etsy’s Journey to TypeScript
- Moving faster
- Rust data structures with circular references
- An Open Source Vibrotactile Haptics Platform for On-Body Applications.
- Anycast in Segment Routing
- Spotify Codes - Part 2
- It's probably time to stop recommending Clean Code
- Joint Limits
- Promises in JavaScript and Clojure
- Async Cancellation I
- Make your monorepo feel small with Git’s sparse index
- The Invisible JavaScript Backdoor
- Music Transcription with Transformers
- Concurrency in Julia
- HuBERT: How to Apply BERT to Speech, Visually Explained
- Free Software is an Abject Failure
- Lesser Known PostgreSQL Features
- The Joy of Concurrent Logic Programming
- Exploring fff part 2 - get_ls_colors
- What is the new LZ4 TOAST compression in PostgreSQL 14, and how fast is it?
- An oral history of Bank Python
- The tale of a single register value
- Misspecification: The Blind Spot of Formal Verification
- Rudra: Finding Memory Safety Bugs in Rust at the Ecosystem Scale
- How X Window Managers Work, And How To Write One (Part I)
- Consolidating the user model
- A guide to designing accessible, WCAG-compliant focus indicators
- How to build a Low-Tech website: Software & Hardware
- IPv4 addresses are silly, inet_aton(3) doubly so.
- SectorLISP Now Fits in One Sector
- C++ Coroutines Do Not Spark Joy
- Relative relocations and RELR
- Porting Takua Renderer to 64-bit ARM- Part 1
- The case for route attributes
- A comprehensive guide to go generate
- Sorting a Dependency Graph in Go
- This bug doesn’t exist on x86: Exploiting an ARM-only race condition
- Clock Gating
- Practical frontend philosophy
- Looking into convergent encryption
- Borrowing Trouble: The Difficulties Of A C++ Borrow-Checker
- Moves in Returns
- A step-by-step analysis of a new version of Darkside Ransomware (v. 2.1.2.3)
- Fast and Elegant Clojure
- The Challenges of Fuzzing 5G Protocols
- PlayStation 3 Architecture
- New HTTP standards for caching on the modern web
- 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
Home