Past Issues
- Xilem: an architecture for UI in Rust
- A useful, critical taxonomy of decentralization, beyond blockchains
- GDBWave - A Post-Simulation Waveform-Based RISC-V GDB Debugging Server
- An Efficient Data Structure for 3D Multi-Layer Terrain and Erosion Simulation
- Remembering Buildtool
- Patching an Embedded OS from 1996 with Ghidra
- Escaping Groundhog Day
- A tale of a trailing dot
- “Practical Math” Preview: Collect Sensitive Survey Responses Privately
- The Generals’ Scuttlebutt: Byzantine-Resilient Gossip Protocols [pdf]
- Existential optics
- Earn $200K by fuzzing for a weekend: Part 1
- Visualizing Performance-Critical Dependency Chains.
- Pine fun - Telephony (Roger, Roger?)
- RouterPi - A Compute Module 4 Router
- Breaking Down a Phishing Attempt
- Making a falling sand simulator
- Programming Style Influences
- Exploring how virtual DOM is implemented in React
- Increasing wave coherence with ray binning
- Unix command line conventions over time
- The Two Generals Problem
- Efficient Module-Level Dynamic Analysis for Dynamic Languages with Module Recontextualization [pdf]
- Criticizing Hare language approach for generic data structures
- You (Probably) Shouldn't use a Lookup Table
- Mechanical Watch
- A faster lexer in Go
- Porting Zelda Classic to the Web
- Depth Comonads
- UA gotta be kidding
- How masscan works
- Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting [pdf]
- Why Train When You Can Optimize?
- Bringing up a new piece of hardware -- what can go wrong?
- I won free load testing
- Luhn algorithm using SWAR and SIMD
- One Polynomial Approximation to Produce Correctly Rounded Results for Multiple Representations and Rounding Modes
- TailwindCSS Tips
- Server-side vs Client-side Analytics
- The digital ranging system that measured the distance to the Apollo spacecraft
- The nuances of MySQL indexes
- Learning Docker with Docker - Toying With DinD For Fun And Profit
- Why LSP?
- Announcing the Hare programming language
- How Democracies Spy on Their Citizens
- Probabilistic Delta Debugging
- Async and Async Void Event Handling in WPF
- Chopping the monolith
- Crimes with Go Generics
- 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
- Practising Programming
- A blog that is a single executable binary
- Multi-GPU Programming with Standard Parallel C++, Part 1
- Data-Driven, Descriptor Based Generative C++
- How To Build an Evil Compiler
- Building a WebAssembly-powered serverless platform
- Zloader 2: The Silent Night
- Your pocket-sized cloud with a Raspberry Pi
- Behind the One-Way Mirror: A Deep Dive Into the Technology of Corporate Surveillance
- Porting libffi to pure WebAssembly
- Errors are constructed, not discovered
- How Netflix Content Engineering makes a federated graph searchable
- TypeScript / How the compiler compiles
- Software Reverse Engineering: Ripping Apart Bomb Binary
- Building a Streaming Music Service with Phoenix and Elixir
- 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"
- Use Git tactically
- Pointers Are Complicated III, or: Pointer-integer casts exposed
- Reverse-engineering the LM185 voltage reference chip and its bandgap reference
- The struggle of using native emoji on the web
- A System-Witch's Package Manager Murder Mystery
- SkipList in Go
- Teaching optics through conspiracy theories
- Principles of Object-Oriented Programming in TypeScript
- How to leverage functional programming in Kotlin to write better, cleaner code
- A Primer on Proxies
- Self Modifying Code
- Why Rust mutexes look like they do
- Compressing looping animation clips
- FORCEDENTRY: Sandbox Escape
- 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
- The roads not taken
- saturating_add vs. saturating_int – new function vs. new type?
- Make Beautifully Resilient Apps With Progressive Enhancement
- Interface method calls with the Go register ABI
- Overlooked facts about variables and objects in Python: it's all about pointers
- implementing ShadowRealm in WebKit
- APISIX, an API Gateway the Apache way
- What’s up with TimeZoneInfo on .NET 6? (Part 1)
- Technical Solutions Poorly Solve Social Problems
- Racing against the clock -- hitting a tiny kernel race window
- Abuse Of Some Sum Types In OO Languages
- Towards a Unified Metaverse
- Silent Duels—Constructing the Solution part 2
- How We Discovered Vulnerabilities in CI/CD Pipelines of Popular Open-Source Projects
- Implementing a toy version of TLS 1.3
- Neural Network From Scratch
- The mirage of memory
- Detecting pitch with the Web Audio API and autocorrelation
- Penny Wise and Cloud Foolish
- Catenaries, parabolas, and ropes
- DirtyMoe: Worming Modules
- A Deep dive into Ed25519 Signatures
- RPATH, or why lld doesn’t work on NixOS
- Party time: Injecting code into Teleparty extension
- POSIX hardlink heartache
- On finding the average of two unsigned integers without overflow
- A flexible, lightweight, spin-lock barrier
- Why is it so hard to buy things that work well?
- Review: Generic Parallel Functional Programming
- Accumulation of tech debt; experiments and shortcuts are core components
- Unravelling Python's classes
- First look: adding type annotations to JavaScript
- Racing the Hardware: 8-bit Division
- If it’s not a number, what is it? Demystifying NaN for the working programmer.
- The Internet Was Designed With a Narrow Waist
- 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
- Implicit Bayesian Inference in Large Language Models
- procmail considered harmful
- Hodor: Detecting and addressing overload in LinkedIn microservices
- Sampling in Floating Point (1/3): The Unit Interval
- Request coalescing in async Rust
- C Structure Padding Initialization
- How do primitive values get their properties?
- Applicatives should usually implement Semigroup and Monoid
- Don't try this at home: CSS _as_ the backend - introducing Cascading Server Sheets!
- Getting into the Guts of Berserk
- Some notes on writing parser-based interactive fiction in Python (part 1)
- 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
- piet-gpu progress: clipping
- Evolving your RESTful APIs, a step-by-step approach
- How I Shaved 187MB Off United Airline's 439mb iOS App
- Can you get pwned with CSS?
- Reversing Games with... Hashcat???
- Architecture Patterns: Caching (Part-1)
- C++ exceptions are becoming more and more problematic
- 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
- DeepETA: How Uber Predicts Arrival Times Using Deep Learning
- Internals of Go's new fuzzing system
- Implementing the FLIP algorithm
- Off-The-Record Messaging part 1: the problem with PGP
- The FreeBSD Boot Process
- Code specialization for the MIR lightweight JIT compiler
- CUPID—for joyful coding
- My thoughts on writing a Minecraft server from scratch (in Bash)
- Why You Should (or Shouldn't) Be Using JAX in 2022
- Advanced TypeScript: The ultimate Tailwind typings
- Server-Sent Events: the alternative to WebSockets you should be using
- Go’s Version Control History
- A decade of major cache incidents at Twitter
- Implementing A Svelte Store In Rust
- The First Bite on etcd Code
- EBNF As a Mental Model to Learn Programming Languages
- How Postgres Stores Rows
- Writing my own build system: Coupling gulp concepts with modern JavaScript
- Working with Strings in Embedded C++
- Fitting Code Driven Displacement
- React - The Missing Parts
- Improving Output Iterators
- Tricking Postgres into using an insane – but 200x faster – query plan
- Destroy All Values: Designing Deinitialization in Programming Languages
- Dumpster diving the Go garbage collector
- Diving Deep: implied bounds and variance
- Measuring Technical Debt
- Street Fighter II, Sound System internals
- The specs behind the specs part 1
- Pay attention to WebAssembly
- Building Setf
- When Should You Use DESC in Indexes?
- Simulating the IBM 360/50 mainframe from its microcode
- A pipe operator for JavaScript: introduction and use cases
- Cost models are contracts
- Implementing a MIME database in XXXX
- Writing a toy traceroute from scratch
- Reasons for servers to support IPv6
- The baseline for web development in 2022
- 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
- How I run my servers
- Did You Know the Fastest Way of Serializing a Java Field is not Serializing it at All?
- Review: Clowns to the Left of Me, Jokers to the Right
- What’s the diff?
- A Glimpse of the Deep: Finding a Creature in Ethereum's Dark Forest
- Accelerating Queries over Unstructured Data with ML, Part 5 (Semantic Indexes for Machine Learning-based Queries over Unstructured Data)
- 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
- Building a Neural Network in Pure Lisp without Built-in Numbers using only Atoms and Lists
- Dates, Times, Calendars— The Universal Source of Data Science Trauma
- Using EM Waves to Detect Malware
- One funny way to bundle assets
- Data lakes take on big data
- The best engineering interview question I’ve ever gotten, Part 1
- Replicated Log
- The Evolution of the PCI Express Specification: On its Sixth Generation, Third Decade and Still Going Strong
- Rust Any Part 1: Extension Maps in Rust
- Form Validation Using JavaScript's Constraint Validation API
- Solving Wordle with Z3
- Penny Codes
- How Bevy uses Rust traits for labeling
- Erlang/OTP profiling: fprof
- Benchmarking Non-shared Locks in Java
- The Third Web
- Saving a Third of Our Memory by Re-ordering Go Struct Fields
- Desired state systems
- 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
- Ordering Movie Credits With Graph Theory
- Yes, fun browser extensions can have vulnerabilities too!
- On the potential of Transformers in Reinforcement Learning
- React prerendering experiments in Clojure(script) land
- Upgrading a motherboard’s BIOS/UEFI (the hard way)
- Implementing RSA in Python from Scratch (Part 1)
- Async vs. Threads
- COLODEBUG: a simple way to improve bash script debugging
- New tool: Mess with DNS!
- Postgres HA: roles are dynamic
- A deep dive into an NSO zero-click iMessage exploit: Remote Code Execution
- The bit-twiddling magic of two's complement, explained
- Circuit Scaling for Analog Computing
- T* makes for a poor optional<T&>
- Everything You Never Wanted To Know About Linker Script
- Guide: How To Detect and Mitigate the Log4Shell Vulnerability (CVE-2021-44228)
- Little C++ Standard Library Utility: std::align
- A (not so) simple matter of privacy
- Frickin' Shaders With Frickin' Laser Beams
- 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
- Why your multiprocessing Pool is stuck (it’s full of sharks!)
- Generate All the Things
- Writing a simple 16 bit VM in less than 125 lines of C
- What is Better, Recursion or Iteration?
- Fast CSV processing with SIMD
- Compiling The Machinery with Emscripten: Part 2 — Graphics
- Actegories and Lenses
- Postgres, Kafka, and the Mysterious 100 GB
- Scaling the Practice of Architecture, Conversationally
- How Does NTP Work?
- Loop Fission
- Conditional Members
- Faster software through register based calling
- Gentle Introduction to Realtime Fluid Simulation for Programmers and Technical Artists
- Permutation-Invariant Neural Networks for Reinforcement Learning
- 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#?
- Modern Evolution Strategies for Creativity: Fitting Concrete Images and Abstract Concepts
- Constructs for Run Time Network Data Management & Analysis; a Data- Centric Approach
- Backdooring Rust crates for fun and profit
- How to Handle Exceptions With the ThreadPoolExecutor in Python
- Mononym: Type-Level Named Values in Rust - Part 1: Demo and Implementation
- Je Ne Sais Quoi - Falcons over the Horizon
- Learning Containers From The Bottom Up
- Overengineering can kill your product
- My Own Private Binary
- Finding why Pytorch Lightning made my training 4x slower
- Reverse-engineering the Yamaha DX7 synthesizer's sound chip from die photos
- An in-depth perspective on webpack's bundling process
- A Fulcio Deep Dive
- The Clojure Promise
- 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
- The Ruby Compiler Survey, Rubinius
- Programming with Something
- Moving faster
- Etsy’s Journey to TypeScript
- Rust data structures with circular references
- Anycast in Segment Routing
- An Open Source Vibrotactile Haptics Platform for On-Body Applications.
- It's probably time to stop recommending Clean Code
- Spotify Codes - Part 2
- Joint Limits
- Promises in JavaScript and Clojure
- Async Cancellation I
- 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
- Free Software is an Abject Failure
- Lesser Known PostgreSQL Features
- Exploring fff part 2 - get_ls_colors
- The Joy of Concurrent Logic Programming
- What is the new LZ4 TOAST compression in PostgreSQL 14, and how fast is it?
- An oral history of Bank Python
- Misspecification: The Blind Spot of Formal Verification
- The tale of a single register value
- How X Window Managers Work, And How To Write One (Part I)
- Rudra: Finding Memory Safety Bugs in Rust at the Ecosystem Scale
- Consolidating the user model
- How to build a Low-Tech website: Software & Hardware
- A guide to designing accessible, WCAG-compliant focus indicators
- 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
- Clock Gating
- This bug doesn’t exist on x86: Exploiting an ARM-only race condition
- Sorting a Dependency Graph in Go
- Practical frontend philosophy
- Borrowing Trouble: The Difficulties Of A C++ Borrow-Checker
- Looking into convergent encryption
- A step-by-step analysis of a new version of Darkside Ransomware (v. 2.1.2.3)
- Moves in Returns
- Fast and Elegant Clojure
- PlayStation 3 Architecture
- The Challenges of Fuzzing 5G Protocols
- New HTTP standards for caching on the modern web
- Downloading Web Pages
- Code vs Data Driven Displacement
- Why you shouldn't invoke setup.py directly
- 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
- Overhead of Returning Optional Values in Java and Rust
- Implementing Hash Tables in C
- Cracking Random Number Generators using Machine Learning – Part 1: xorshift128
- The Potential Merits of an Itemized OS
- Disassembling Hello World in Java
- Why I Still ‘Lisp’ (and You Should Too)
- How cross signing works with X509 certificates
- Interface ergonomics: automation isn't just about time saved
- IoT Hacking and Rickrolling My High School District
- Generating relocatable code for ARM processors
- Performance Optimization in React applications
- Writing a "bare metal" operating system for Raspberry Pi 4
- RenderingNG deep-dive: LayoutNG
- CI/CD/CF? — The DevOps toolchain’s “missing-link”
- Hey linker, can you spare a meg?
- Taming the Tarpit
- The Insane Innovation of TI Calculator Hobbyists
- Always-on Processor magic: How Find My works while iPhone is powered off
- 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
- Nested strict data in Haskell
- Bracket pair colorization 10,000x faster
- Working with SQL Server identity columns
- 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
- Fitting a FORTH in 512 bytes
- On bad advice
- Essential Page Cache theory
- Practical frontend architecture
- 5 RCEs in npm for $15,000
- Implementing Co, a Small Interpreted Language With Coroutines #2: The Interpreter
- Robots Must Be Ephemeralized
- There Was No Formal Methods Winter
- How I patched Python to include this great Ruby feature
- All about Procedure Linkage Table
- The elements of git
- 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
- Up and Down the Ladder of Abstraction
- Coercing deep const-ness
- Hack Pipe for Functional Programmers: How I learned to stop worrying and love the placeholder
- 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
- Dissecting Deno
- Greedy AI Agents Learn to Cooperate
- 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
- Using the Platform
- Exploring fff part 1 - main
- 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
- On using PSR abstractions
- On Variance and Extensibility
- Making Reasonable Use of Computer Resources: Part 2
- Article 2
- Async overloading
- DoomPhone
- Effective Shell
- Linux in a Pixel Shader - A RISC-V Emulator for VRChat
- 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
- Reducing System Load With Event Folding
- An Opinionated Guide to xargs
- Adventures in WebRTC: Making Phone Calls from XMPP
- C++20 modules with GCC11
- 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
- Battle-tested monadic OCaml: Tezos
- Design your own Runtime
- Stop Using Icon Fonts
- Will you pay the consistency costs?
- What I wish I had known about single page applications
- New browser-tracking hack works even when you flush caches or go incognito
- 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
- A data transformation problem in SQL and Scala: Dovetailing declarative solutions
- What would SQLite look like if written in Rust? — Part 1
- Let’s Create a Custom Audio Player
- Building a decentralized options exchange on ethereum
- Advanced Git Features You Didn’t Know You Needed
- Divisibility by any prime
- How Materialize and other databases optimize SQL subqueries
- Introduction to ARM Semihosting
- How humans write programs
- Simulating Latency with SQL / JDBC
- Persistent Data Structures - An Introduction
- 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
- How to convert between callbacks and Promises in Javascript
- TypeScript: Stop Using 'any', There's a Type For That
- New campaign targeting security researchers
- 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
- Build Your Own Text Editor
- Query Hints You Can Use to Avoid Blocking
- Don’t think, just defunctionalize
- The different types of cross-site scripting (XSS)
- Categories of Nets (Part 1)
- The State of State Machines
- The Philosophy of Svelte
- return first
- Writing Environment-Agnostic Functional Acceptance Tests
- Abusing C# For Loops For Job Security
- Go (golang) Error Handling - A Different Philosophy
- Breaking The Browser – A tale of IPC, credentials and backdoors
- Rebuilding the most popular spellchecker. Part 1
- An additional non-backtracking RegExp engine
- The confusing world of USB
- 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
- We rendered a million web pages to find out what makes the web slow
- ARM Cortex-M33 Instruction Tracing Without a Debugger
- Why I rewrote my open source virtual reality server
- Back to the '70s with Serverless
- The Adventures of OS: Making a RISC-V Operating System using Rust
- How to Test a Quantum Program?
- What happens when...
- Writing a custom iterator in modern C++
- Commits are snapshots, not diffs
- Scalability and Load Testing for VALORANT
- What I Wish Someone Had Told Me About Tensor Computation Libraries
- Defensive Programming - Friend or Foe?
- Fast AF Fourier Transform (FafFT)
- A Visual Tour of Backpropagation
- Improve Performance Using SQL Functions in Postgres
- An overview of end-to-end entity resolution for big data
- if... then... else had to be invented!
- Page Fault Injection in Virtual Machines: Accessing Swapped-Out Pages from HVMI
- 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?
- Hiding data from humans and computers in GIF files
- Why I Built My Own Shitty Static Site Generator
- 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
- Making our own ping
- Organizing Code by Feature using Verticle Slices
- The JPA and Hibernate first-level cache
- 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
- Semantic requirements in concepts
- Text layout is a loose hierarchy of segmentation
- 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
- 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
- The Surprising Impact of Medium-Size Texts on PostgreSQL Performance
- Container networking is simple
- Fun with Lambda Calculus
- JavaScript and TypeScript Hidden Gems: Decorators
- 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
- A mathematical formulation of the tax code?
- malloc as a service
- 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
- 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
- Understanding operational 5G: a first measurement study on its coverage, performance and energy consumption
- Reading and writing, part 2: files and databases
- The Single-Valued Type Pattern for TypeScript
- 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)
- How Mercado Libre optimized for Web Vitals (TBT/FID)
- The Last Vestiges Of Object Oriented Programming
- V8 release v8.6
- 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?
- ensemble networks
- TypeScript Builders: Improving your types one step at a time
- Understanding Memory Leaks in Nodejs
- 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
- How Does a Database Load Balancer Work?
- Notes About Compilers
- How CSS Perspective Works
- Hacking Ethernet out of Fibre Channel cards
- How do Routers Work, Really?
- Attacking the Qualcomm Adreno GPU
- Menu Reveal By Page Rotate Animation
- Fault tolerance through optimal workload placement
Home