Past Issues

#299 11/28/2022

  • The Origins of Python
  • A gentle introduction to Domain Driven Design
  • Database optimisation, analytics and burnout

#298 11/24/2022

  • kmem_guard_t
  • Porting 58000 lines of D and C++ to jai, Part 0: Why and How
  • Migrating to a Multi-Cluster Managed Kafka with 0 Downtime

#297 11/23/2022

  • Retrofitting null-safety onto Java at Meta
  • Building the fastest Lua interpreter.. automatically
  • It's about time - Approaching Bitemporality (Part 1)

#296 11/22/2022

  • linux-insides
  • Building a BFT JSON CRDT
  • Oracle optimizer Or Expansion Transformations

#295 11/21/2022

  • Building a Dynamic VRChat World
  • How to create maintainable Lambda functions using custom C# templates
  • Reed-Solomon Error Correcting Codes from the Bottom Up

#294 11/17/2022

  • Assembly interpreter inside of TypeScript's type system
  • The one about Lisp interactivity
  • Perl is Actually Portable

#293 11/16/2022

  • Build the modular monolith first
  • More Evidence for Problems in VM Warmup
  • How PlanetScale Boost serves your SQL queries instantly

#292 11/15/2022

  • On Coordinated Omission
  • Simple Scalable Unbounded Queue
  • Why would anyone need JavaScript generator functions?

#291 11/14/2022

  • Taking off with Nix at FlightAware
  • The evolution of scalable CSS
  • Meet your new two-factor authenticator: your Commodore 64

#290 11/10/2022

  • Why Lisp
  • Introduction to Firmware Analysis of a Reolink IP Camera
  • Time is an illusion, Unix time doubly so...

#289 11/9/2022

  • Rewriting The Modern Web In Rust
  • Why Functional Programming Should Be the Future of Software Development
  • A Very Powerful Clipboard: Analysis of a Samsung in-the-wild exploit chain

#288 11/7/2022

  • Solving common problems with Kubernetes
  • Refactoring a checksum until it runs 100 times faster
  • Distribution packaging for Linux desktop applications is unsustainable

#287 11/3/2022

  • How to leverage HTTP conditional requests to build robust REST APIs
  • System Design: Domain Name System (DNS), Load Balancing & Clustering.
  • Launching an Infrastructure SaaS Product, An Example Walkthrough

#286 11/2/2022

  • Swift was always going to be part of the OS
  • Wii U Architecture
  • OKLCH in CSS: why we moved from RGB and HSL

#285 11/1/2022

  • JavaScript metaprogramming with the 2022-03 decorators API
  • That Time I Tried Porting Zig to SerenityOS
  • Can Web3 beat public cloud?

#284 10/31/2022

  • Compilers and IRs: LLVM IR, SPIR-V, and MLIR
  • Rapidly Solving Sudoku, N-Queens, Pentomino Placement, and More, With Knuth’s Algorithm X and Dancing Links.
  • One-Time Programs

#283 10/27/2022

  • RAII: Compile-Time Memory Management in C++ and Rust
  • Reducing Logging Cost by Two Orders of Magnitude using CLP
  • Stop Optimizing for Tutorials

#282 10/26/2022

  • The HTTP crash course nobody asked for
  • The RISC Deprogrammer
  • A Possible Vision for Macros in Swift

#281 10/25/2022

  • [CVE-2022-1786] A Journey To The Dawn
  • Chrome Browser Exploitation, Part 1: Introduction to V8 and JavaScript Internals
  • Attacking Very Weak RC4-Like Ciphers the Hard Way

#280 10/17/2022

  • Striped Development
  • A Few of My Favorite Things About The OpenBSD Packet Filter Tools
  • Real Life TDD Example

#279 10/13/2022

  • Ezno: a JavaScript compiler featuring checking, correctness and performance
  • Neural networks and the Unix philosophy
  • Simulating Wind on Procedural Terrain using GPU Accelerated Lattice Boltzmann Method

#278 10/12/2022

  • Virtual Threads: New Foundations for High-Scale Java Applications
  • Localizing a Qt App; Or Anything Else For That Matter
  • Hello World under the microscope

#277 10/11/2022

  • Explained from scratch: private information retrieval using homomorphic encryption
  • End-to-end Neural Coreference Resolution in spaCy
  • Non-standard containers in C++

#276 10/10/2022

  • D3Wasm: a port of id Tech 4 / Doom 3 engine to WebAssembly
  • Resiliency in Distributed Systems
  • Bitcoin and economic nihilism

#275 10/5/2022

  • Implementing truly safe semaphores in rust, and the costs we pay for safety
  • Distributed System Models in the Real World
  • China’s Phytium D2000: Building on A72?

#274 9/29/2022

  • The state of Flow-based Programming
  • 35 Million Hot Dogs: Benchmarking Caddy vs. Nginx
  • The Middle of the Square

#273 9/28/2022

  • Race Conditions Can Be Useful for Parallelism
  • goto hell;
  • Everything you want to know about the CAP theorem

#272 9/27/2022

  • Ed25519 Deep Dive Addendum
  • Trade-offs of Using Compilers for Java
  • When to use Bazel?

#271 9/26/2022

  • Wirth Language Evolution
  • Untangling Lifetimes: The Arena Allocator
  • Performance Improvements in .NET 7

#270 9/8/2022

  • Game Emulation via Neural Network
  • Improving Vulkan graphics state tracking in Mesa
  • Notes from kernel hacking in Hare, part 1

#269 9/7/2022

  • 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

#268 9/6/2022

  • 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

#267 9/5/2022

  • Understanding, Detecting and Localizing Partial Failures in Large System Software [pdf]
  • malloc() and free() are a bad API
  • Redis Explained
  • Parent links in Go ASTs

#266 8/25/2022

  • Fixed Partitions
  • The GPU Banana Stand
  • How SQLite Scales Read Concurrency

#265 8/23/2022

  • 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()

#264 8/22/2022

  • What Makes a Great Maintainer of Open Source Projects?
  • Using :has() as a CSS Parent Selector and much more
  • just-in-time code generation within webassembly
  • Exploring Shaders with Compiler Explorer

#263 8/18/2022

  • Hooking Go from Rust - Hitchhiker’s Guide to the Go-laxy
  • Clock-Bound Wait
  • Understanding transducers

#262 8/17/2022

  • JavaScript Visualized: Event Loop
  • Dynamic Exception Reporting in Haskell
  • Adventure game graphics with DALL-E 2

#261 8/16/2022

  • Adventures in Text Rendering: Kerning and Glyph Atlases
  • Spelunking the Deep: Guaranteed Queries on General Neural Implicit Surfaces via Range Analysis [pdf]
  • <article> vs. <section>: How To Choose The Right One
  • A Deep Dive Into Laravel Queues

#260 8/15/2022

  • Monad Confusion and the Blurry Line Between Data and Computation
  • Efficient Simulation through Linear Algebra
  • Certifying Interpreters in Racket

#259 8/11/2022

  • Ruby Garbage Collection Deep Dive: GC::INTERNAL_CONSTANTS
  • The quantum state of Linux kernel garbage collection CVE-2021-0920 (Part I)
  • The quick and practical "MSI" hash table

#258 8/10/2022

  • 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

#257 8/9/2022

  • Understanding Garbage Collection in JavaScriptCore From Scratch
  • “Who Should Write the Terraform?”
  • On Turing machines

#256 8/8/2022

  • 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

#255 7/14/2022

  • When rustc explodes
  • PostgreSQL 14 Internals
  • The Problem with RISC-V V Mask Bits

#254 7/13/2022

  • My business card runs Linux, yours can too
  • Rust PNG writer from scratch
  • Plan B for UUIDs: double AES-128

#253 7/12/2022

  • Slower Memory Zeroing Through Parallelism
  • Cell-Based Architecture
  • Visualizing Delaunay Triangulation

#252 7/11/2022

  • 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]

#251 7/7/2022

  • 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

#250 7/6/2022

  • 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

#249 7/5/2022

  • 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?
  • Reverse Engineering Dark Souls 3 Networking (#1 - Connection)

#248 7/4/2022

  • Porting Doom to Helios
  • Single Element Loaders: Going 3D!
  • Visualizing Nelder-Mead Optimization

#247 6/30/2022

  • Tutorial: Preparing libraries for CMake FetchContent
  • MitM at the Edge: Abusing Cloudflare Workers
  • X-ray reverse-engineering a hybrid module from 1960s Apollo test equipment

#246 6/29/2022

  • Transaction anomalies with SELECT FOR UPDATE
  • The Rust borrow checker just got (a little bit) smarter
  • SQLite or PostgreSQL? It's Complicated!

#245 6/28/2022

  • tolower() in bulk at speed
  • Hyperstreams – Nesting in Lucid
  • Steven Pinker and I debate AI scaling!

#244 6/27/2022

  • unordered_multiset’s API affects its big-O
  • A (Slightly) Improved Approximation Algorithm for Metric TSP [pdf]
  • Separate code from data
  • Bringing WireGuard to Genode

#243 6/23/2022

  • Test-induced design damage in Clojure
  • A look at search engines with their own indexes
  • Maintaining Software Correctness

#242 6/22/2022

  • Don’t Mock What You Don’t Own in 5 Minutes
  • The Grug Brained Developer
  • Pulling MikroTik into the Limelight

#241 6/21/2022

  • Matrix notes
  • Attempting to create an aesthetic global line breaking algorithm
  • defragmentation

#240 6/20/2022

  • Synthesizing Object State Transformers for Dynamic Software Updates [pdf]
  • Keywords 101: Difficulty, Volume, and Segmentation
  • Using web streams on Node.js
  • Understanding the Law of Demeter

#239 6/16/2022

  • (Re) Introducing Jasper as a Command Bus
  • The Case for Use.GPU
  • Some ways to use ZK-SNARKs for privacy

#238 6/15/2022

  • Dialogs and shadow DOM: can we make it accessible?
  • Uniqueness Types and In-Place Updates
  • The race condition that led to Flexcoin bankruptcy

#237 6/14/2022

  • The strange relationship between objects, functions, generators and coroutines
  • Advice for Engineering Managers Who Want to Climb the Ladder
  • ngrok for the wicked, or expose your ports comfortably

#236 6/13/2022

  • Creating Augmented and Virtual Reality Applications: Current Practices, Challenges, and Opportunities [pdf]
  • Caches In Rust
  • Exploration of the Dirty Pipe Vulnerability (CVE-2022-0847)
  • Xbox 360 Architecture

#235 6/9/2022

  • Cache made consistent: Meta’s cache invalidation solution
  • The perils of the “real” client IP
  • What Makes a Good Research Proposal?

#234 6/8/2022

  • What’s the best lossless image format? Comparing PNG, WebP, AVIF, and JPEG XL
  • Using Back-Door Adjustment Causal Analysis to Measure Pre-Post Effects
  • Practical Uses Of Blockchain Technology

#233 6/7/2022

  • 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

#232 6/6/2022

  • Shipping to Production
  • What Happened with FPGA Acceleration?
  • A Framework for Adversarially Robust Streaming Algorithms [pdf]
  • Reflection Means Hidden Coupling

#231 6/2/2022

  • 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

#230 6/1/2022

  • Double Debiased Machine Learning (part 1)
  • Technique: Recursive variants and boxes
  • Branch/cmove and compiler optimizations

#229 5/31/2022

  • Retrofitting Temporal Memory Safety on C++
  • Teleforking a process onto a different computer!
  • Hash, displace, and compress: Perfect hashing with Java

#228 5/30/2022

  • A decade of dotfiles
  • No, It's Not Always DNS
  • Scaling Attributed Network Embedding to Massive Graphs [pdf]
  • The Hitchhiker's Guide to Ethereum

#227 5/26/2022

  • 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

#226 5/25/2022

  • Assignment for optional<T>
  • Speeding up sort performance in Postgres 15
  • interactive analog LED wave array

#225 5/24/2022

  • css vs webgl cubes
  • What is Edge Compute? It’s kind of like knitting dog hats
  • Much Ado About Sampling

#224 5/23/2022

  • 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"

#223 5/19/2022

  • Animating Regular Expressions With Python and Graphviz
  • Implicit In-order Forests: Zooming a billion trace events at 60fps
  • Four Eras of JavaScript Frameworks

#222 5/18/2022

  • 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

#221 5/17/2022

  • Remembering Buildtool
  • Patching an Embedded OS from 1996 with Ghidra
  • An Efficient Data Structure for 3D Multi-Layer Terrain and Erosion Simulation

#220 5/16/2022

  • “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

#219 5/12/2022

  • Visualizing Performance-Critical Dependency Chains.
  • Earn $200K by fuzzing for a weekend: Part 1
  • Existential optics

#218 5/11/2022

  • Pine fun - Telephony (Roger, Roger?)
  • Breaking Down a Phishing Attempt
  • RouterPi - A Compute Module 4 Router

#217 5/10/2022

  • Making a falling sand simulator
  • Exploring how virtual DOM is implemented in React
  • Programming Style Influences

#216 5/9/2022

  • 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

#215 5/5/2022

  • Criticizing Hare language approach for generic data structures
  • Mechanical Watch
  • You (Probably) Shouldn't use a Lookup Table

#214 5/4/2022

  • A faster lexer in Go
  • Porting Zelda Classic to the Web
  • Depth Comonads

#213 5/3/2022

  • UA gotta be kidding
  • How masscan works
  • Why Train When You Can Optimize?
  • Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting [pdf]

#212 5/2/2022

  • Bringing up a new piece of hardware -- what can go wrong?
  • I won free load testing
  • Luhn algorithm using SWAR and SIMD

#211 4/29/2022

  • TailwindCSS Tips
  • Server-side vs Client-side Analytics
  • One Polynomial Approximation to Produce Correctly Rounded Results for Multiple Representations and Rounding Modes

#210 4/27/2022

  • 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

#209 4/26/2022

  • Announcing the Hare programming language
  • Why LSP?
  • How Democracies Spy on Their Citizens

#208 4/25/2022

  • Probabilistic Delta Debugging
  • Crimes with Go Generics
  • Chopping the monolith
  • Async and Async Void Event Handling in WPF

#207 4/21/2022

  • 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

#206 4/20/2022

  • Multi-GPU Programming with Standard Parallel C++, Part 1
  • Practising Programming
  • A blog that is a single executable binary

#205 4/19/2022

  • How To Build an Evil Compiler
  • Building a WebAssembly-powered serverless platform
  • Data-Driven, Descriptor Based Generative C++

#204 4/18/2022

  • 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

#203 4/14/2022

  • Errors are constructed, not discovered
  • Porting libffi to pure WebAssembly
  • How Netflix Content Engineering makes a federated graph searchable

#202 4/13/2022

  • Software Reverse Engineering: Ripping Apart Bomb Binary
  • TypeScript / How the compiler compiles
  • Building a Streaming Music Service with Phoenix and Elixir

#201 4/12/2022

  • 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"

#200 4/11/2022

  • 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

#199 4/8/2022

  • Principles of Object-Oriented Programming in TypeScript
  • Teaching optics through conspiracy theories
  • SkipList in Go

#198 4/6/2022

  • Self Modifying Code
  • A Primer on Proxies
  • How to leverage functional programming in Kotlin to write better, cleaner code

#197 4/6/2022

  • FORCEDENTRY: Sandbox Escape
  • Why Rust mutexes look like they do
  • Compressing looping animation clips

#196 4/4/2022

  • Transformers for software engineers
  • Those HTML Attributes You Never Use
  • I built a receipt printer for GitHub issues

#195 4/1/2022

  • Why APL is a language worth knowing
  • Eloquent JavaScript
  • How Go Mitigates Supply Chain Attacks

#194 3/30/2022

  • saturating_add vs. saturating_int – new function vs. new type?
  • The roads not taken
  • Make Beautifully Resilient Apps With Progressive Enhancement

#193 3/29/2022

  • 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

#192 3/29/2022

  • APISIX, an API Gateway the Apache way
  • What’s up with TimeZoneInfo on .NET 6? (Part 1)
  • Technical Solutions Poorly Solve Social Problems

#191 3/26/2022

  • Abuse Of Some Sum Types In OO Languages
  • Towards a Unified Metaverse
  • Racing against the clock -- hitting a tiny kernel race window

#190 3/24/2022

  • 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

#189 3/22/2022

  • The mirage of memory
  • Detecting pitch with the Web Audio API and autocorrelation
  • Neural Network From Scratch

#188 3/21/2022

  • Penny Wise and Cloud Foolish
  • Catenaries, parabolas, and ropes
  • DirtyMoe: Worming Modules

#187 3/17/2022

  • Party time: Injecting code into Teleparty extension
  • RPATH, or why lld doesn’t work on NixOS
  • A Deep dive into Ed25519 Signatures

#186 3/16/2022

  • A flexible, lightweight, spin-lock barrier
  • On finding the average of two unsigned integers without overflow
  • POSIX hardlink heartache

#185 3/15/2022

  • 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

#184 3/14/2022

  • Unravelling Python's classes
  • First look: adding type annotations to JavaScript
  • Racing the Hardware: 8-bit Division

#183 3/10/2022

  • 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

#182 3/9/2022

  • The perils of the “real” client IP
  • Design: #noFramework
  • ReScript on Deno: Declarative Command Line Tools

#181 3/8/2022

  • Creating a Static Web Content Project for Publishing with WebDeploy
  • procmail considered harmful
  • Implicit Bayesian Inference in Large Language Models

#180 3/7/2022

  • Request coalescing in async Rust
  • Hodor: Detecting and addressing overload in LinkedIn microservices
  • Sampling in Floating Point (1/3): The Unit Interval

#179 3/3/2022

  • C Structure Padding Initialization
  • How do primitive values get their properties?
  • Applicatives should usually implement Semigroup and Monoid

#178 3/2/2022

  • 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!

#177 3/1/2022

  • Announcing TypeScript 4.6
  • Solid.js feels like what I always wanted React to be
  • Encapsulated vs systemic complexity in protocol design

#176 2/28/2022

  • C++ header files and inter-class connections
  • Evolving your RESTful APIs, a step-by-step approach
  • piet-gpu progress: clipping

#175 2/24/2022

  • How I Shaved 187MB Off United Airline's 439mb iOS App
  • Can you get pwned with CSS?
  • Reversing Games with... Hashcat???

#174 2/23/2022

  • C++ exceptions are becoming more and more problematic
  • Architecture Patterns: Caching (Part-1)
  • Made of Bugs

#173 2/22/2022

  • 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

#172 2/21/2022

  • Internals of Go's new fuzzing system
  • DeepETA: How Uber Predicts Arrival Times Using Deep Learning
  • Implementing the FLIP algorithm

#171 2/17/2022

  • Off-The-Record Messaging part 1: the problem with PGP
  • Code specialization for the MIR lightweight JIT compiler
  • The FreeBSD Boot Process

#170 2/16/2022

  • 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)

#169 2/15/2022

  • Server-Sent Events: the alternative to WebSockets you should be using
  • Go’s Version Control History
  • Advanced TypeScript: The ultimate Tailwind typings

#168 2/14/2022

  • The First Bite on etcd Code
  • Implementing A Svelte Store In Rust
  • A decade of major cache incidents at Twitter

#167 2/10/2022

  • How Postgres Stores Rows
  • Writing my own build system: Coupling gulp concepts with modern JavaScript
  • EBNF As a Mental Model to Learn Programming Languages

#166 2/9/2022

  • React - The Missing Parts
  • Fitting Code Driven Displacement
  • Working with Strings in Embedded C++

#165 2/8/2022

  • Tricking Postgres into using an insane – but 200x faster – query plan
  • Improving Output Iterators
  • Destroy All Values: Designing Deinitialization in Programming Languages

#164 2/7/2022

  • Dumpster diving the Go garbage collector
  • Diving Deep: implied bounds and variance
  • Measuring Technical Debt

#163 2/3/2022

  • Pay attention to WebAssembly
  • Street Fighter II, Sound System internals
  • The specs behind the specs part 1

#162 2/2/2022

  • When Should You Use DESC in Indexes?
  • Building Setf
  • Simulating the IBM 360/50 mainframe from its microcode

#161 2/1/2022

  • A pipe operator for JavaScript: introduction and use cases
  • Implementing a MIME database in XXXX
  • Cost models are contracts

#160 1/31/2022

  • Writing a toy traceroute from scratch
  • The baseline for web development in 2022
  • Reasons for servers to support IPv6

#159 1/27/2022

  • Zooming in on Zero-click Exploits
  • Div divisiveness
  • Vertipaq optimization and its impact on columnstore compression

#158 1/26/2022

  • How do you visualize code?
  • UK COVID-19 dashboard built using Postgres and Citus for millions of users
  • Optimizing Content Migrations With Edge Compute

#157 1/25/2022

  • 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?

#156 1/24/2022

  • 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

#155 1/20/2022

  • NFT Gaming is snake oil
  • Provably Space-Efficient Parallel Functional Programming
  • Transformations by the Oracle Optimizer

#154 1/19/2022

  • The RISC-V experience
  • An extremely casual code review of MetaMask’s crypto
  • The probability of a hash collision

#153 1/18/2022

  • 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

#152 1/17/2022

  • One funny way to bundle assets
  • The best engineering interview question I’ve ever gotten, Part 1
  • Data lakes take on big data

#151 1/13/2022

  • 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

#150 1/12/2022

  • Solving Wordle with Z3
  • Form Validation Using JavaScript's Constraint Validation API
  • Penny Codes

#149 1/11/2022

  • How Bevy uses Rust traits for labeling
  • Erlang/OTP profiling: fprof
  • Benchmarking Non-shared Locks in Java

#148 1/10/2022

  • Desired state systems
  • The Third Web
  • Saving a Third of Our Memory by Re-ordering Go Struct Fields

#147 12/23/2021

  • 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!

#146 12/22/2021

  • Performant A/B Testing with Cloudflare Workers
  • Yes, fun browser extensions can have vulnerabilities too!
  • Ordering Movie Credits With Graph Theory

#145 12/21/2021

  • On the potential of Transformers in Reinforcement Learning
  • Upgrading a motherboard’s BIOS/UEFI (the hard way)
  • React prerendering experiments in Clojure(script) land

#144 12/20/2021

  • COLODEBUG: a simple way to improve bash script debugging
  • Implementing RSA in Python from Scratch (Part 1)
  • Async vs. Threads

#143 12/16/2021

  • Postgres HA: roles are dynamic
  • New tool: Mess with DNS!
  • A deep dive into an NSO zero-click iMessage exploit: Remote Code Execution

#142 12/15/2021

  • T* makes for a poor optional<T&>
  • The bit-twiddling magic of two's complement, explained
  • Circuit Scaling for Analog Computing

#141 12/14/2021

  • 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

#140 12/13/2021

  • Frickin' Shaders With Frickin' Laser Beams
  • A (not so) simple matter of privacy
  • Implementing TLS Encrypted Client Hello

#139 12/10/2021

  • 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

#138 12/8/2021

  • 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!)

#137 12/7/2021

  • Fast CSV processing with SIMD
  • Compiling The Machinery with Emscripten: Part 2 — Graphics
  • What is Better, Recursion or Iteration?

#136 12/6/2021

  • Scaling the Practice of Architecture, Conversationally
  • Postgres, Kafka, and the Mysterious 100 GB
  • Actegories and Lenses

#135 12/2/2021

  • How Does NTP Work?
  • Loop Fission
  • Conditional Members

#134 12/1/2021

  • Faster software through register based calling
  • Permutation-Invariant Neural Networks for Reinforcement Learning
  • Gentle Introduction to Realtime Fluid Simulation for Programmers and Technical Artists

#133 11/30/2021

  • Abstract Clojure
  • A prioritised micro-batch scheduler in rust
  • Faulty Logic

#132 11/29/2021

  • 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

#131 11/25/2021

  • 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

#130 11/24/2021

  • Je Ne Sais Quoi - Falcons over the Horizon
  • Learning Containers From The Bottom Up
  • Overengineering can kill your product

#129 11/23/2021

  • 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

#128 11/22/2021

  • The Clojure Promise
  • A Fulcio Deep Dive
  • An in-depth perspective on webpack's bundling process

#127 11/18/2021

  • 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

#126 11/17/2021

  • Moving faster
  • Etsy’s Journey to TypeScript
  • Programming with Something

#125 11/16/2021

  • Anycast in Segment Routing
  • Rust data structures with circular references
  • An Open Source Vibrotactile Haptics Platform for On-Body Applications.

#124 11/15/2021

  • Spotify Codes - Part 2
  • Joint Limits
  • It's probably time to stop recommending Clean Code

#123 11/11/2021

  • Async Cancellation I
  • Promises in JavaScript and Clojure
  • Make your monorepo feel small with Git’s sparse index

#122 11/10/2021

  • Concurrency in Julia
  • The Invisible JavaScript Backdoor
  • Music Transcription with Transformers

#121 11/9/2021

  • HuBERT: How to Apply BERT to Speech, Visually Explained
  • Lesser Known PostgreSQL Features
  • Free Software is an Abject Failure

#120 11/8/2021

  • 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?

#119 11/4/2021

  • An oral history of Bank Python
  • The tale of a single register value
  • Misspecification: The Blind Spot of Formal Verification

#118 11/3/2021

  • 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

#117 11/2/2021

  • 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

#116 11/1/2021

  • C++ Coroutines Do Not Spark Joy
  • SectorLISP Now Fits in One Sector
  • Relative relocations and RELR

#115 10/28/2021

  • The case for route attributes
  • A comprehensive guide to go generate
  • Porting Takua Renderer to 64-bit ARM- Part 1

#114 10/27/2021

  • Clock Gating
  • Sorting a Dependency Graph in Go
  • This bug doesn’t exist on x86: Exploiting an ARM-only race condition

#113 10/26/2021

  • Practical frontend philosophy
  • Borrowing Trouble: The Difficulties Of A C++ Borrow-Checker
  • Looking into convergent encryption

#112 10/25/2021

  • Moves in Returns
  • A step-by-step analysis of a new version of Darkside Ransomware (v. 2.1.2.3)
  • Fast and Elegant Clojure

#111 10/21/2021

  • PlayStation 3 Architecture
  • New HTTP standards for caching on the modern web
  • The Challenges of Fuzzing 5G Protocols

#110 10/20/2021

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

#109 10/19/2021

  • 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

#108 10/18/2021

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

#107 10/14/2021

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

#106 10/13/2021

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

#105 10/12/2021

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

#104 10/11/2021

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

#103 10/7/2021

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

#102 10/6/2021

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

#101 10/5/2021

  • 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

#100 10/4/2021

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

#99 9/30/2021

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

#98 9/29/2021

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

#97 9/28/2021

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

#96 9/27/2021

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

#95 9/23/2021

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

#94 9/22/2021

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

#93 9/21/2021

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

#92 9/20/2021

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

#91 9/16/2021

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

#90 9/15/2021

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

#89 9/14/2021

  • 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

#88 9/13/2021

  • 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

#87 9/9/2021

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

#86 9/8/2021

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

#85 9/7/2021

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

#84 9/6/2021

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

#83 9/2/2021

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

#82 9/1/2021

  • On using PSR abstractions
  • On Variance and Extensibility

#81 8/31/2021

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

#80 8/30/2021

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

#79 8/26/2021

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

#78 8/25/2021

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

#77 8/24/2021

  • C++20 modules with GCC11
  • Adventures in WebRTC: Making Phone Calls from XMPP

#76 8/23/2021

  • 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

#75 8/19/2021

  • 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

#74 8/18/2021

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

#73 8/17/2021

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

#72 8/16/2021

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

#71 4/5/2021

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

#70 2/25/2021

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

#69 2/24/2021

  • 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?

#68 2/23/2021

  • 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

#67 2/22/2021

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

#66 2/18/2021

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

#65 2/17/2021

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

#64 2/16/2021

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

#63 1/29/2021

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

#62 1/28/2021

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

#61 1/26/2021

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

#60 1/25/2021

  • 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

#59 1/21/2021

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

#58 1/19/2021

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

#57 1/18/2021

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

#56 1/13/2021

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

#55 1/11/2021

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

#54 1/5/2021

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

#53 1/4/2021

  • 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

#51 12/24/2020

  • 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

#50 12/22/2020

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

#49 12/21/2020

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

#48 12/16/2020

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

#47 12/15/2020

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

#46 12/14/2020

  • 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

#45 12/9/2020

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

#44 12/8/2020

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

#43 12/7/2020

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

#42 12/3/2020

  • 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

#41 12/2/2020

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

#40 12/1/2020

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

#39 11/30/2020

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

#38 11/26/2020

  • 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

#37 11/25/2020

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

#35 11/12/2020

  • 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?

#34 11/11/2020

  • 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?

#33 11/10/2020

  • 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

#32 11/9/2020

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

#31 11/5/2020

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

#30 11/4/2020

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

#29 11/3/2020

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

#28 11/2/2020

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

#27 10/29/2020

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

#26 10/28/2020

  • 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

#25 10/27/2020

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

#24 10/26/2020

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

#23 10/22/2020

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

#22 10/21/2020

  • 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

#21 10/20/2020

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

#20 10/19/2020

  • 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

#19 10/16/2020

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

#18 10/13/2020

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

#17 10/7/2020

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

#16 10/6/2020

  • 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()

#15 10/5/2020

  • 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

#14 10/1/2020

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

#13 9/30/2020

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

#12 9/28/2020

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

#11 9/25/2020

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

#10 9/24/2020

  • 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

#9 9/22/2020

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

#8 9/21/2020

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

#7 9/17/2020

  • 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?

#6 9/16/2020

  • TypeScript Builders: Improving your types one step at a time
  • Understanding Memory Leaks in Nodejs
  • ensemble networks

#5 9/15/2020

  • Which Parsing Approach?
  • Reinforcement learning, non-Markov environments, and memory
  • What Clojure spec is and what you can do with it (an illustrated guide)

#4 9/14/2020

  • Chaos and Randomness
  • Go linknames
  • Aligning superhuman AI with human behaviour: chess as a model system

#3 9/10/2020

  • How We Ended up with Git
  • Notes About Compilers
  • How Does a Database Load Balancer Work?

#2 9/9/2020

  • How do Routers Work, Really?
  • How CSS Perspective Works
  • Hacking Ethernet out of Fibre Channel cards

#1 9/8/2020

  • Fault tolerance through optimal workload placement
  • Attacking the Qualcomm Adreno GPU
  • Menu Reveal By Page Rotate Animation