Past Issues
- Trade-offs of Using Compilers for Java
- Ed25519 Deep Dive Addendum
- When to use Bazel?
- Wirth Language Evolution
- Untangling Lifetimes: The Arena Allocator
- Performance Improvements in .NET 7
- Improving Vulkan graphics state tracking in Mesa
- Notes from kernel hacking in Hare, part 1
- Game Emulation via Neural Network
- Write-ahead logging and the ARIES crash recovery algorithm
- Developing Error Handling Strategies for Asynchronous Messaging
- Building a Panel out of e-ink Electronic Shelf Labels
- Branch predictor: How many "if"s are too many? Including x86 and M1 benchmarks!
- Git’s database internals I: packed object store
- Bootkitting Windows Sandbox
- Understanding, Detecting and Localizing Partial Failures in Large System Software [pdf]
- Parent links in Go ASTs
- malloc() and free() are a bad API
- Redis Explained
- The GPU Banana Stand
- How SQLite Scales Read Concurrency
- Fixed Partitions
- How to deal with money in software
- Technology Deep Dive: Building a Faster ORAM Layer for Enclaves
- A General Overview of What Happens Before main()
- What Makes a Great Maintainer of Open Source Projects?
- Exploring Shaders with Compiler Explorer
- just-in-time code generation within webassembly
- Using :has() as a CSS Parent Selector and much more
- Clock-Bound Wait
- Understanding transducers
- Hooking Go from Rust - Hitchhiker’s Guide to the Go-laxy
- JavaScript Visualized: Event Loop
- Dynamic Exception Reporting in Haskell
- Adventure game graphics with DALL-E 2
- Adventures in Text Rendering: Kerning and Glyph Atlases
- <article> vs. <section>: How To Choose The Right One
- Spelunking the Deep: Guaranteed Queries on General Neural Implicit Surfaces via Range Analysis [pdf]
- A Deep Dive Into Laravel Queues
- Certifying Interpreters in Racket
- Efficient Simulation through Linear Algebra
- Monad Confusion and the Blurry Line Between Data and Computation
- Ruby Garbage Collection Deep Dive: GC::INTERNAL_CONSTANTS
- The quick and practical "MSI" hash table
- The quantum state of Linux kernel garbage collection CVE-2021-0920 (Part I)
- What happens when you press a key in your terminal?
- How Kubernetes Reinvented Virtual Machines (in a good sense)
- Improving MBA Deobfuscation using Equality Saturation
- “Who Should Write the Terraform?”
- On Turing machines
- Understanding Garbage Collection in JavaScriptCore From Scratch
- CLIPasso: Semantically-Aware Object Sketching [pdf]
- What's the Most Portable Way to Include Binary Blobs in an Executable?
- How and why to do link-time symbol wrapping (or not?)
- Use One Big Server
- When rustc explodes
- PostgreSQL 14 Internals
- The Problem with RISC-V V Mask Bits
- My business card runs Linux, yours can too
- Rust PNG writer from scratch
- Plan B for UUIDs: double AES-128
- Slower Memory Zeroing Through Parallelism
- Cell-Based Architecture
- Visualizing Delaunay Triangulation
- Working in the software industry, circa 1989
- My favorite Erlang Container
- An Overview of Kandria's Development with Lisp
- ZooKeeper: Wait-free coordination for Internet-scale systems [pdf]
- Creating an Aimbot: Reverse Engineering & Source SDK (2/4)
- The difficult problem of managing Java dependencies
- Scaling Causal's Spreadsheet Engine from Thousands to Billions of Cells: From Maps to Arrays
- Order independent transparency, part 1
- An Ubuntu kernel bug causes container crashes
- No, We Don't Have to Choose Batch Sizes As Powers Of 2
- Reverse Engineering Dark Souls 3 Networking (#1 - Connection)
- Semantic Bug Seeding: A Learning-Based Approach for Creating Realistic Bugs
- Beigels, software, and why you should control queues instead of cycle times
- No really, why can't we have raw UDP in JavaScript?
- Porting Doom to Helios
- Single Element Loaders: Going 3D!
- Visualizing Nelder-Mead Optimization
- Tutorial: Preparing libraries for CMake FetchContent
- X-ray reverse-engineering a hybrid module from 1960s Apollo test equipment
- MitM at the Edge: Abusing Cloudflare Workers
- The Rust borrow checker just got (a little bit) smarter
- Transaction anomalies with SELECT FOR UPDATE
- SQLite or PostgreSQL? It's Complicated!
- Hyperstreams – Nesting in Lucid
- tolower() in bulk at speed
- Steven Pinker and I debate AI scaling!
- Bringing WireGuard to Genode
- unordered_multiset’s API affects its big-O
- A (Slightly) Improved Approximation Algorithm for Metric TSP [pdf]
- Separate code from data
- Test-induced design damage in Clojure
- A look at search engines with their own indexes
- Maintaining Software Correctness
- The Grug Brained Developer
- Pulling MikroTik into the Limelight
- Don’t Mock What You Don’t Own in 5 Minutes
- Matrix notes
- defragmentation
- Attempting to create an aesthetic global line breaking algorithm
- Synthesizing Object State Transformers for Dynamic Software Updates [pdf]
- Keywords 101: Difficulty, Volume, and Segmentation
- Understanding the Law of Demeter
- Using web streams on Node.js
- (Re) Introducing Jasper as a Command Bus
- The Case for Use.GPU
- Some ways to use ZK-SNARKs for privacy
- Uniqueness Types and In-Place Updates
- The race condition that led to Flexcoin bankruptcy
- Dialogs and shadow DOM: can we make it accessible?
- The strange relationship between objects, functions, generators and coroutines
- ngrok for the wicked, or expose your ports comfortably
- Advice for Engineering Managers Who Want to Climb the Ladder
- Creating Augmented and Virtual Reality Applications: Current Practices, Challenges, and Opportunities [pdf]
- Xbox 360 Architecture
- Caches In Rust
- Exploration of the Dirty Pipe Vulnerability (CVE-2022-0847)
- Cache made consistent: Meta’s cache invalidation solution
- The perils of the “real” client IP
- What Makes a Good Research Proposal?
- Using Back-Door Adjustment Causal Analysis to Measure Pre-Post Effects
- What’s the best lossless image format? Comparing PNG, WebP, AVIF, and JPEG XL
- Practical Uses Of Blockchain Technology
- TypoSquatting, RepoJacking, and Domain Takeover – The Story of the Recent Attacks
- A layered approach to content blocking
- Formal-Methods-Based Bugfinding for LLVM’s AArch64 Backend
- Reflection Means Hidden Coupling
- What Happened with FPGA Acceleration?
- Shipping to Production
- A Framework for Adversarially Robust Streaming Algorithms [pdf]
- The curse of strong typing
- Things to keep in mind when working with POSIX signals
- Code execution 0-day in Windows has been under active exploit for 7 weeks
- Technique: Recursive variants and boxes
- Double Debiased Machine Learning (part 1)
- Branch/cmove and compiler optimizations
- Retrofitting Temporal Memory Safety on C++
- Teleforking a process onto a different computer!
- Hash, displace, and compress: Perfect hashing with Java
- A decade of dotfiles
- No, It's Not Always DNS
- Scaling Attributed Network Embedding to Massive Graphs [pdf]
- The Hitchhiker's Guide to Ethereum
- Think Like Git
- Sometimes, it is a compiler bug
- Exploit Development: No Code Execution? No Problem! Living The Age of VBS, HVCI, and Kernel CFG
- Assignment for optional<T>
- Speeding up sort performance in Postgres 15
- interactive analog LED wave array
- css vs webgl cubes
- Much Ado About Sampling
- What is Edge Compute? It’s kind of like knitting dog hats
- Tasks, lists, and promises
- AutoGRD: Model Recommendation Through Graphical Dataset Representation [pdf]
- Postgres Query Optimization: LEFT JOIN vs UNION ALL
- My take on "where's all the code"
- Animating Regular Expressions With Python and Graphviz
- Implicit In-order Forests: Zooming a billion trace events at 60fps
- Four Eras of JavaScript Frameworks
- Xilem: an architecture for UI in Rust
- GDBWave - A Post-Simulation Waveform-Based RISC-V GDB Debugging Server
- A useful, critical taxonomy of decentralization, beyond blockchains
- Remembering Buildtool
- Patching an Embedded OS from 1996 with Ghidra
- An Efficient Data Structure for 3D Multi-Layer Terrain and Erosion Simulation
- “Practical Math” Preview: Collect Sensitive Survey Responses Privately
- A tale of a trailing dot
- The Generals’ Scuttlebutt: Byzantine-Resilient Gossip Protocols [pdf]
- Escaping Groundhog Day
- Visualizing Performance-Critical Dependency Chains.
- Earn $200K by fuzzing for a weekend: Part 1
- Existential optics
- Pine fun - Telephony (Roger, Roger?)
- Breaking Down a Phishing Attempt
- RouterPi - A Compute Module 4 Router
- Making a falling sand simulator
- Exploring how virtual DOM is implemented in React
- Programming Style Influences
- Efficient Module-Level Dynamic Analysis for Dynamic Languages with Module Recontextualization [pdf]
- The Two Generals Problem
- Unix command line conventions over time
- Increasing wave coherence with ray binning
- Criticizing Hare language approach for generic data structures
- Mechanical Watch
- You (Probably) Shouldn't use a Lookup Table
- A faster lexer in Go
- Porting Zelda Classic to the Web
- Depth Comonads
- UA gotta be kidding
- How masscan works
- Why Train When You Can Optimize?
- Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting [pdf]
- Bringing up a new piece of hardware -- what can go wrong?
- I won free load testing
- Luhn algorithm using SWAR and SIMD
- TailwindCSS Tips
- Server-side vs Client-side Analytics
- One Polynomial Approximation to Produce Correctly Rounded Results for Multiple Representations and Rounding Modes
- Learning Docker with Docker - Toying With DinD For Fun And Profit
- The digital ranging system that measured the distance to the Apollo spacecraft
- The nuances of MySQL indexes
- Announcing the Hare programming language
- Why LSP?
- How Democracies Spy on Their Citizens
- Probabilistic Delta Debugging
- Crimes with Go Generics
- Chopping the monolith
- Async and Async Void Event Handling in WPF
- Changing std::sort at Google’s Scale and Beyond
- That is not a number, that is a freed object
- Faster initialization of instances with new class features
- Multi-GPU Programming with Standard Parallel C++, Part 1
- Practising Programming
- A blog that is a single executable binary
- How To Build an Evil Compiler
- Building a WebAssembly-powered serverless platform
- Data-Driven, Descriptor Based Generative C++
- Your pocket-sized cloud with a Raspberry Pi
- Behind the One-Way Mirror: A Deep Dive Into the Technology of Corporate Surveillance
- Zloader 2: The Silent Night
- Errors are constructed, not discovered
- Porting libffi to pure WebAssembly
- How Netflix Content Engineering makes a federated graph searchable
- Software Reverse Engineering: Ripping Apart Bomb Binary
- TypeScript / How the compiler compiles
- Building a Streaming Music Service with Phoenix and Elixir
- Use Git tactically
- Pointers Are Complicated III, or: Pointer-integer casts exposed
- Getting web proxys and certificates working on Linux or "if it's all the same to you, I'd rather take a thousand years of the Sarlacc pit, thankyouverymuch"
- The struggle of using native emoji on the web
- Reverse-engineering the LM185 voltage reference chip and its bandgap reference
- A System-Witch's Package Manager Murder Mystery
- Principles of Object-Oriented Programming in TypeScript
- Teaching optics through conspiracy theories
- SkipList in Go
- Self Modifying Code
- A Primer on Proxies
- How to leverage functional programming in Kotlin to write better, cleaner code
- FORCEDENTRY: Sandbox Escape
- Why Rust mutexes look like they do
- Compressing looping animation clips
- Transformers for software engineers
- Those HTML Attributes You Never Use
- I built a receipt printer for GitHub issues
- Why APL is a language worth knowing
- Eloquent JavaScript
- How Go Mitigates Supply Chain Attacks
- saturating_add vs. saturating_int – new function vs. new type?
- The roads not taken
- Make Beautifully Resilient Apps With Progressive Enhancement
- implementing ShadowRealm in WebKit
- Overlooked facts about variables and objects in Python: it's all about pointers
- Interface method calls with the Go register ABI
- APISIX, an API Gateway the Apache way
- What’s up with TimeZoneInfo on .NET 6? (Part 1)
- Technical Solutions Poorly Solve Social Problems
- Abuse Of Some Sum Types In OO Languages
- Towards a Unified Metaverse
- Racing against the clock -- hitting a tiny kernel race window
- Implementing a toy version of TLS 1.3
- How We Discovered Vulnerabilities in CI/CD Pipelines of Popular Open-Source Projects
- Silent Duels—Constructing the Solution part 2
- The mirage of memory
- Detecting pitch with the Web Audio API and autocorrelation
- Neural Network From Scratch
- Penny Wise and Cloud Foolish
- Catenaries, parabolas, and ropes
- DirtyMoe: Worming Modules
- Party time: Injecting code into Teleparty extension
- RPATH, or why lld doesn’t work on NixOS
- A Deep dive into Ed25519 Signatures
- A flexible, lightweight, spin-lock barrier
- On finding the average of two unsigned integers without overflow
- POSIX hardlink heartache
- Why is it so hard to buy things that work well?
- Accumulation of tech debt; experiments and shortcuts are core components
- Review: Generic Parallel Functional Programming
- Unravelling Python's classes
- First look: adding type annotations to JavaScript
- Racing the Hardware: 8-bit Division
- The Internet Was Designed With a Narrow Waist
- If it’s not a number, what is it? Demystifying NaN for the working programmer.
- Finding an Authorization Bypass on my Own Website
- The perils of the “real” client IP
- Design: #noFramework
- ReScript on Deno: Declarative Command Line Tools
- Creating a Static Web Content Project for Publishing with WebDeploy
- procmail considered harmful
- Implicit Bayesian Inference in Large Language Models
- Request coalescing in async Rust
- Hodor: Detecting and addressing overload in LinkedIn microservices
- Sampling in Floating Point (1/3): The Unit Interval
- C Structure Padding Initialization
- How do primitive values get their properties?
- Applicatives should usually implement Semigroup and Monoid
- Some notes on writing parser-based interactive fiction in Python (part 1)
- Getting into the Guts of Berserk
- Don't try this at home: CSS _as_ the backend - introducing Cascading Server Sheets!
- Announcing TypeScript 4.6
- Solid.js feels like what I always wanted React to be
- Encapsulated vs systemic complexity in protocol design
- C++ header files and inter-class connections
- Evolving your RESTful APIs, a step-by-step approach
- piet-gpu progress: clipping
- How I Shaved 187MB Off United Airline's 439mb iOS App
- Can you get pwned with CSS?
- Reversing Games with... Hashcat???
- C++ exceptions are becoming more and more problematic
- Architecture Patterns: Caching (Part-1)
- Made of Bugs
- The wild west of Windows command line parsing
- Making A Cross Platform Mobile & Desktop App with Qt 6.2
- Diagnosing an ASP.NET Core hard crash
- Internals of Go's new fuzzing system
- DeepETA: How Uber Predicts Arrival Times Using Deep Learning
- Implementing the FLIP algorithm
- Off-The-Record Messaging part 1: the problem with PGP
- Code specialization for the MIR lightweight JIT compiler
- The FreeBSD Boot Process
- CUPID—for joyful coding
- Why You Should (or Shouldn't) Be Using JAX in 2022
- My thoughts on writing a Minecraft server from scratch (in Bash)
- Server-Sent Events: the alternative to WebSockets you should be using
- Go’s Version Control History
- Advanced TypeScript: The ultimate Tailwind typings
- The First Bite on etcd Code
- Implementing A Svelte Store In Rust
- A decade of major cache incidents at Twitter
- How Postgres Stores Rows
- Writing my own build system: Coupling gulp concepts with modern JavaScript
- EBNF As a Mental Model to Learn Programming Languages
- React - The Missing Parts
- Fitting Code Driven Displacement
- Working with Strings in Embedded C++
- Tricking Postgres into using an insane – but 200x faster – query plan
- Improving Output Iterators
- Destroy All Values: Designing Deinitialization in Programming Languages
- Dumpster diving the Go garbage collector
- Diving Deep: implied bounds and variance
- Measuring Technical Debt
- Pay attention to WebAssembly
- Street Fighter II, Sound System internals
- The specs behind the specs part 1
- When Should You Use DESC in Indexes?
- Building Setf
- Simulating the IBM 360/50 mainframe from its microcode
- A pipe operator for JavaScript: introduction and use cases
- Implementing a MIME database in XXXX
- Cost models are contracts
- Writing a toy traceroute from scratch
- The baseline for web development in 2022
- Reasons for servers to support IPv6
- Zooming in on Zero-click Exploits
- Div divisiveness
- Vertipaq optimization and its impact on columnstore compression
- How do you visualize code?
- UK COVID-19 dashboard built using Postgres and Citus for millions of users
- Optimizing Content Migrations With Edge Compute
- Review: Clowns to the Left of Me, Jokers to the Right
- How I run my servers
- Did You Know the Fastest Way of Serializing a Java Field is not Serializing it at All?
- What’s the diff?
- Accelerating Queries over Unstructured Data with ML, Part 5 (Semantic Indexes for Machine Learning-based Queries over Unstructured Data)
- A Glimpse of the Deep: Finding a Creature in Ethereum's Dark Forest
- NFT Gaming is snake oil
- Provably Space-Efficient Parallel Functional Programming
- Transformations by the Oracle Optimizer
- The RISC-V experience
- An extremely casual code review of MetaMask’s crypto
- The probability of a hash collision
- Dates, Times, Calendars— The Universal Source of Data Science Trauma
- Building a Neural Network in Pure Lisp without Built-in Numbers using only Atoms and Lists
- Using EM Waves to Detect Malware
- One funny way to bundle assets
- The best engineering interview question I’ve ever gotten, Part 1
- Data lakes take on big data
- Rust Any Part 1: Extension Maps in Rust
- Replicated Log
- The Evolution of the PCI Express Specification: On its Sixth Generation, Third Decade and Still Going Strong
- Solving Wordle with Z3
- Form Validation Using JavaScript's Constraint Validation API
- Penny Codes
- How Bevy uses Rust traits for labeling
- Erlang/OTP profiling: fprof
- Benchmarking Non-shared Locks in Java
- Desired state systems
- The Third Web
- Saving a Third of Our Memory by Re-ordering Go Struct Fields
- Contexts and capabilities in Rust
- Containers 101: attach vs. exec - what's the difference?
- A challenger to the throne of vector graphics. SVG is dead, long live TinyVG!
- Performant A/B Testing with Cloudflare Workers
- Yes, fun browser extensions can have vulnerabilities too!
- Ordering Movie Credits With Graph Theory
- On the potential of Transformers in Reinforcement Learning
- Upgrading a motherboard’s BIOS/UEFI (the hard way)
- React prerendering experiments in Clojure(script) land
- COLODEBUG: a simple way to improve bash script debugging
- Implementing RSA in Python from Scratch (Part 1)
- Async vs. Threads
- Postgres HA: roles are dynamic
- New tool: Mess with DNS!
- A deep dive into an NSO zero-click iMessage exploit: Remote Code Execution
- T* makes for a poor optional<T&>
- The bit-twiddling magic of two's complement, explained
- Circuit Scaling for Analog Computing
- Little C++ Standard Library Utility: std::align
- Guide: How To Detect and Mitigate the Log4Shell Vulnerability (CVE-2021-44228)
- Everything You Never Wanted To Know About Linker Script
- Frickin' Shaders With Frickin' Laser Beams
- A (not so) simple matter of privacy
- Implementing TLS Encrypted Client Hello
- Why General Inheritance is Flawed and How to Finally Fix it
- Creating and morphing Lego faces with neural networks
- Cache the directionality of the HTML element
- Writing a simple 16 bit VM in less than 125 lines of C
- Generate All the Things
- Why your multiprocessing Pool is stuck (it’s full of sharks!)
- Fast CSV processing with SIMD
- Compiling The Machinery with Emscripten: Part 2 — Graphics
- What is Better, Recursion or Iteration?
- Scaling the Practice of Architecture, Conversationally
- Postgres, Kafka, and the Mysterious 100 GB
- Actegories and Lenses
- How Does NTP Work?
- Loop Fission
- Conditional Members
- Faster software through register based calling
- Permutation-Invariant Neural Networks for Reinforcement Learning
- Gentle Introduction to Realtime Fluid Simulation for Programmers and Technical Artists
- Abstract Clojure
- A prioritised micro-batch scheduler in rust
- Faulty Logic
- 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
- Mononym: Type-Level Named Values in Rust - Part 1: Demo and Implementation
- Backdooring Rust crates for fun and profit
- Je Ne Sais Quoi - Falcons over the Horizon
- Learning Containers From The Bottom Up
- Overengineering can kill your product
- Reverse-engineering the Yamaha DX7 synthesizer's sound chip from die photos
- My Own Private Binary
- Finding why Pytorch Lightning made my training 4x slower
- The Clojure Promise
- A Fulcio Deep Dive
- An in-depth perspective on webpack's bundling process
- The Ruby Compiler Survey, Rubinius
- The inside story of the outside investigation of SoftRAM 95
- Stack Exchange is a good place to explain initial and terminal objects in the category of sets
- Moving faster
- Etsy’s Journey to TypeScript
- Programming with Something
- Anycast in Segment Routing
- Rust data structures with circular references
- An Open Source Vibrotactile Haptics Platform for On-Body Applications.
- Spotify Codes - Part 2
- Joint Limits
- It's probably time to stop recommending Clean Code
- Async Cancellation I
- Promises in JavaScript and Clojure
- Make your monorepo feel small with Git’s sparse index
- Concurrency in Julia
- The Invisible JavaScript Backdoor
- Music Transcription with Transformers
- HuBERT: How to Apply BERT to Speech, Visually Explained
- Lesser Known PostgreSQL Features
- Free Software is an Abject Failure
- 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
- How X Window Managers Work, And How To Write One (Part I)
- Consolidating the user model
- Rudra: Finding Memory Safety Bugs in Rust at the Ecosystem Scale
- How to build a Low-Tech website: Software & Hardware
- IPv4 addresses are silly, inet_aton(3) doubly so.
- A guide to designing accessible, WCAG-compliant focus indicators
- C++ Coroutines Do Not Spark Joy
- SectorLISP Now Fits in One Sector
- Relative relocations and RELR
- The case for route attributes
- A comprehensive guide to go generate
- Porting Takua Renderer to 64-bit ARM- Part 1
- Clock Gating
- Sorting a Dependency Graph in Go
- This bug doesn’t exist on x86: Exploiting an ARM-only race condition
- Practical frontend philosophy
- Borrowing Trouble: The Difficulties Of A C++ Borrow-Checker
- Looking into convergent encryption
- Moves in Returns
- A step-by-step analysis of a new version of Darkside Ransomware (v. 2.1.2.3)
- Fast and Elegant Clojure
- PlayStation 3 Architecture
- New HTTP standards for caching on the modern web
- The Challenges of Fuzzing 5G Protocols
- Why you shouldn't invoke setup.py directly
- Code vs Data Driven Displacement
- Downloading Web Pages
- Printf("%s %s", dependency, injection).
- Where does all the effort go? Looking at Python core developer activity
- DbContextExtensions: An approach to managing the EF Core DbContext
- Implementing Hash Tables in C
- Overhead of Returning Optional Values in Java and Rust
- Cracking Random Number Generators using Machine Learning – Part 1: xorshift128
- Why I Still ‘Lisp’ (and You Should Too)
- The Potential Merits of an Itemized OS
- Disassembling Hello World in Java
- IoT Hacking and Rickrolling My High School District
- How cross signing works with X509 certificates
- Interface ergonomics: automation isn't just about time saved
- Writing a "bare metal" operating system for Raspberry Pi 4
- Performance Optimization in React applications
- Generating relocatable code for ARM processors
- CI/CD/CF? — The DevOps toolchain’s “missing-link”
- Hey linker, can you spare a meg?
- RenderingNG deep-dive: LayoutNG
- Taming the Tarpit
- Always-on Processor magic: How Find My works while iPhone is powered off
- The Insane Innovation of TI Calculator Hobbyists
- 100% CPU: My Fault?
- Revenge of Lisp (Part 1⁄2)
- Under the Hood of Macros in Elixir
- What is yield and how does it work in C#?
- Implicit Overflow Considered Harmful (and how to fix it)
- Rewriting Go source code with AST tooling
- Polymorphism without objects via multimethods
- Making a Game in Janet, Part 1: Psst, hey kid, wanna try some Janet?
- Are Dockerfiles good enough?
- Working with SQL Server identity columns
- Nested strict data in Haskell
- Bracket pair colorization 10,000x faster
- Implementer's Guide to WebSockets
- Interactive introduction to [OpenVSCode Server]
- C++20 Coroutine Iterators
- Finding Number Related Memory Corruption Vulns
- A Bonding Exercise
- RTC (Real-Time Communication) at scale
- The Speed of Time
- Category Theory Illustrated
- A terminal case of Linux
- On bad advice
- Essential Page Cache theory
- Fitting a FORTH in 512 bytes
- 5 RCEs in npm for $15,000
- Implementing Co, a Small Interpreted Language With Coroutines #2: The Interpreter
- Practical frontend architecture
- There Was No Formal Methods Winter
- Robots Must Be Ephemeralized
- How I patched Python to include this great Ruby feature
- Fixing Time.deltaTime in Unity 2020.2 for smoother gameplay: What did it take?
- All about Procedure Linkage Table
- The elements of git
- An Intro to JavaScript Proxy
- Turing Oversold
- Reconstructing TypeScript, part 1: bidirectional type checking
- Go'ing Insane Part One: Endless Error Handling
- Ship / Show / Ask
- Shulman’s Practical Type Theory for Symmetric Monoidal Categories
- Up and Down the Ladder of Abstraction
- Hack Pipe for Functional Programmers: How I learned to stop worrying and love the placeholder
- Coercing deep const-ness
- Ray casting in 2D game engines
- Resource efficient Thread Pools with Zig
- Introducing Coalton: How to Have Our (Typed) Cake and (Safely) Eat It Too, in Common Lisp
- Dissecting Deno
- Greedy AI Agents Learn to Cooperate
- Laziness: Clojure vs Haskell
- How Materialize and other databases optimize SQL subqueries
- Approaches for Building Real-Time ML Systems
- Heterogenous Maps and Dynamic Case Classes in Scala 3
- Clojure Zippers
- Ballerina Concurrency Model and Non-Blocking I/O
- How to Eliminate Render-Blocking Resources: a Deep Dive
- Using the Platform
- Exploring fff part 1 - main
- One Hundred Thousand Lines of Rust
- Let’s build an LC-3 Virtual Machine
- Proving 50-Year-Old Sorting Networks Optimal: Part 1
- File IO improvements in .NET 6
- On using PSR abstractions
- On Variance and Extensibility
- Async overloading
- Making Reasonable Use of Computer Resources: Part 2
- Article 2
- DoomPhone
- Effective Shell
- Linux in a Pixel Shader - A RISC-V Emulator for VRChat
- HTTP/2 in infrastructure: Ambry network stack refactoring
- Understanding Network Access in Windows AppContainers
- Ode to a Streaming ByteString
- An Opinionated Guide to xargs
- Reducing System Load With Event Folding
- Crypto Markets Recover Amid COVID-19 Fears
- C++20 modules with GCC11
- Adventures in WebRTC: Making Phone Calls from XMPP
- Integer Overflow to RCE — ManageEngine Asset Explorer Agent (CVE-2021–20082)
- I figured out how DMARC works, and it almost broke me
- A Record Type Representation Trick
- Should the browser use all available memory?
- Structuring Authorization Architecture
- Let's write a compiler, part 1: Introduction, selecting a language, and doing some planning
- How We (Don’t) Reason About Code
- Modern web apps without JavaScript bundling or transpiling
- Stephen Wiesner
- Climbing Mount Effect
- Two counterintuitive results
- Code memory safety and efficiency by example
- TLDs -- Putting the 'Fun' in the top of the DNS
- C++ exceptions under the hood
- Namespaced De Bruijn indices
- C++ coroutines: The mental model for coroutine promises
- Preemptive Pluralization is (Probably) Not Evil
- A look under the hood: how branches work in Git
- Battle-tested monadic OCaml: Tezos
- Design your own Runtime
- Stop Using Icon Fonts
- What I wish I had known about single page applications
- New browser-tracking hack works even when you flush caches or go incognito
- Will you pay the consistency costs?
- Reverse Engineering a Gameboy Advance game: Let’s Stretch the Bridge! — Part 1
- The usefulness of currying
- Booting the IBM 1401: How a 1959 punch-card computer loads a program
- What would SQLite look like if written in Rust? — Part 1
- A data transformation problem in SQL and Scala: Dovetailing declarative solutions
- Advanced Git Features You Didn’t Know You Needed
- Building a decentralized options exchange on ethereum
- Let’s Create a Custom Audio Player
- 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
- Progressive Rendering for Better Web App Performance
- DBA in training: SQL Server under the hood
- Experimenting with remote debugging: Node.js runtime code injection
- TypeScript: Stop Using 'any', There's a Type For That
- New campaign targeting security researchers
- How to convert between callbacks and Promises in Javascript
- Build Your Own Container Using Less than 100 Lines of Go
- Building a social media platform without going bankruptPart I–Laying the numbers
- Let’s Build a Quasiquoter
- 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
- The Philosophy of Svelte
- Writing Environment-Agnostic Functional Acceptance Tests
- Abusing C# For Loops For Job Security
- Breaking The Browser – A tale of IPC, credentials and backdoors
- Go (golang) Error Handling - A Different Philosophy
- The confusing world of USB
- Rebuilding the most popular spellchecker. Part 1
- An additional non-backtracking RegExp engine
- Geometric effects of certain system design choices
- Patterns of Distributed Systems
- Chain loading, not preloading: the dynamic linker as a virtualization vector
- How Not to Teach Recursion
- C++ and passing by value
- Post #0: In Which I Set Out to Write a Terrible Compiler for a Useless Language
- Why I rewrote my open source virtual reality server
- ARM Cortex-M33 Instruction Tracing Without a Debugger
- 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
- Back to the '70s with Serverless
- How to Test a Quantum Program?
- Commits are snapshots, not diffs
- What happens when...
- Writing a custom iterator in modern C++
- What I Wish Someone Had Told Me About Tensor Computation Libraries
- Defensive Programming - Friend or Foe?
- Scalability and Load Testing for VALORANT
- Fast AF Fourier Transform (FafFT)
- A Visual Tour of Backpropagation
- Improve Performance Using SQL Functions in Postgres
- if... then... else had to be invented!
- An overview of end-to-end entity resolution for big data
- Page Fault Injection in Virtual Machines: Accessing Swapped-Out Pages from HVMI
- Does reducing numerical precision affect real world datasets?
- Contracts, Preconditions & Invariants
- Good-bye ESNI, hello ECH!s
- Combinators and the Story of Computation
- Why nullable types?
- Logical layout enhancements with flow-relative shorthands
- The Subtle Hazards of Real-World Cryptography
- Command Line Interface Guidelines
- Nvidia Ampere vs. AMD RDNA 2: Battle of the Architectures
- 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
- Protein folding & The AI 'Solution' : A primer for non-scientists
- What machines can and can't do
- Feature Casualties of Large Databases
- Objects in Functional Languages
- Component-Oriented Programming
- Gamedev from scratch 0: Groundwork
- Seeing is believing: a client-centric specification of database isolation
- 2Q Cache Management Algorithm
- 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
- Hiding data from humans and computers in GIF files
- Why I Built My Own Shitty Static Site Generator
- What is a Programming Paradigm?
- How we designed Dropbox’s ATF - an async task framework
- Chasing a Performance Regression with Erlang/OTP 22
- What is shader occupancy and why do we care about it?
- Uncovering Online Delivery Menu Best Practices with Machine Learning
- Making Mass Effect not require administrator rights, or maybe how to not write a boolean check
- Fun with Concepts: Do You Even Lift, Bool?
- Low Hanging Fruits in Frontend Performance Optimization
- How Netflix Scales its API with GraphQL Federation (Part 1)
- DBA in training: Backups, SLAs, and restore strategies
- Problem Solving
- Stop checking for NULL pointers!
- [OpenGL and Vulkan Interoperability on Linux] Part 2: Using OpenGL to draw on Vulkan textures.
- Understanding JavaScript IIFEs Like a Boss
- Frequency Domain Image Compression and Filtering
- Exception safety in Rust: using transient droppers to prevent memory leaks
- Demystifying a very simple TrustZone enabled program on ARM Cortex-M33
- Java Concurrency: Deadlock
- Ensuring Clean Code: A Look at Python, Parameterized
- Linear Algebra Shenanigans: Gizmo Repair
- Keeping Netflix Reliable Using Prioritized Load Shedding
- Math keeps changing
- What Does It Take To Resolve A Hostname
- Helios: hyperscale indexing for the cloud & edge (part II)
- Names are not type safety
- 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
- The Grand Unified Theory of Software Architecture
- Program in Arm6 assembly language on a Raspberry Pi
- Semantic requirements in concepts
- Text layout is a loose hierarchy of segmentation
- Pi from High School Maths
- Transport-Oriented Growth and Procedural Trees
- Reading and writing, part 1: locations and locks
- Helios: hyperscale indexing for the cloud & edge – part 1
- Generating Rock Climbing Route Descriptions with ML (GPT-2)
- More and More Utilities in C++20
- Hot Swapping Production Tables for Safe Database Backfills
- The Surprising Impact of Medium-Size Texts on PostgreSQL Performance
- Get me off Your Fucking Mailing List
- What every programmer should know about memory, Part 1
- Leveraging LD_AUDIT to Beat the Traditional Linux Library Preloading Technique
- JavaScript and TypeScript Hidden Gems: Decorators
- Fun with Lambda Calculus
- Container networking is simple
- Floating Point in the Browser, Part 3: When x+y=x
- The case for a learned sorting algorithm
- Abstract Classes vs. Interfaces in C# - What You Know is Probably Wrong
- Video processing with WebCodecs
- How to Conditionally Add Attributes to Objects
- Classic Path.DirectorySeparatorChar gotchas when moving from .NET Core on Windows to Linux
- malloc as a service
- A mathematical formulation of the tax code?
- Creating a JavaScript promise from scratch, Part 4: Promise.resolve() and Promise.reject()
- Look Ma, No Data Structures!
- Compiling a Lisp: If
- Local File Inclusions, explained
- Scrollable Grid with Just-in-Time Data Loading – Part 5: Hooking up the Database
- Bidirectional text
- Creating a JavaScript promise from scratch, Part 3: then(), catch(), and finally()
- 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
- Reflection for aggregates
- 5 TILs about Node.js Fundamentals from the Node.js Design Patterns Book
- Comparing Load Balancers for PostgreSQL
- The M140i project post - Part 10
- Common Table Expressions
- Exploring Node.js Async Hooks
- Design Considerations for Secure GraphQL APIs
- The User Wizard Scenario
- Generalizing 'jq' and Traversal Systems using optics and standard monads
- The Fresh Smell of ransomed coffee
- Slack Tracking in V8
- std::exchange Patterns: Fast, Safe, Expressive, and Probably Underused
- A Gentle Introduction to Using a Docker Container as a Dev Environment
- Leveraging Declarative Programming to Create Maintainable Web Apps
- Why it is important to apply static analysis for open libraries that you add to your project
- Accessible Web Animation: The WCAG on Animation Explained
- Content delivery networks (CDNs)
- Creating a JavaScript promise from scratch, Part 1: Constructor
- The Last Vestiges Of Object Oriented Programming
- V8 release v8.6
- How Mercado Libre optimized for Web Vitals (TBT/FID)
- std::span in C++20: Bounds-Safe Views for Sequences of Objects
- CQRS and MediatR in ASP.NET Core
- What is blocking and how would you troubleshoot it?
- TypeScript Builders: Improving your types one step at a time
- Understanding Memory Leaks in Nodejs
- ensemble networks
- Which Parsing Approach?
- Reinforcement learning, non-Markov environments, and memory
- What Clojure spec is and what you can do with it (an illustrated guide)
- Chaos and Randomness
- Go linknames
- Aligning superhuman AI with human behaviour: chess as a model system
- How We Ended up with Git
- Notes About Compilers
- How Does a Database Load Balancer Work?
- How do Routers Work, Really?
- How CSS Perspective Works
- Hacking Ethernet out of Fibre Channel cards
- Fault tolerance through optimal workload placement
- Attacking the Qualcomm Adreno GPU
- Menu Reveal By Page Rotate Animation