matkladAboutLinksBlogroll
  • Aug 31, 2025

    Vibe Coding Terminal Editor

  • Aug 30, 2025

    Ads Are a Positional Good

  • Aug 23, 2025

    Retry Loop Retry

  • Aug 23, 2025

    Links

  • Aug 16, 2025

    Reserve First

  • Aug 9, 2025

    Zig's Lovely Syntax

  • Aug 8, 2025

    Partially Matching Zig Enums

  • Jul 16, 2025

    font-size-adjust Is Useful

  • Jul 7, 2025

    Inverse Triangle Inequality

  • Jun 26, 2025

    RSS Server Side Reader

  • May 20, 2025

    Open Source Can't Coordinate

  • May 19, 2025

    Profiling Challenge Results

  • May 14, 2025

    Scalar Select Anti-Pattern

  • May 6, 2025

    Performance Profile Visualization Challenge

  • Apr 22, 2025

    Against Horizontal Scroll

  • Apr 21, 2025

    A Fun Zig Program

  • Apr 19, 2025

    Things Zig comptime Won't Do

  • Apr 15, 2025

    Underusing Snapshot Testing

  • Mar 31, 2025

    Random Numbers Included

  • Mar 30, 2025

    Tariffs

  • Mar 30, 2025

    Deno Simple Server Side Rendering

  • Mar 25, 2025

    A Debugger is a REPL is a Debugger

  • Mar 21, 2025

    Use Long Options in Scripts

  • Mar 19, 2025

    Comptime Zig ORM

  • Feb 23, 2025

    MacOS for KDE Users

  • Dec 30, 2024

    What Is a dependency?

  • Dec 24, 2024

    Minimal Version Selection Revisited

  • Dec 13, 2024

    Majjit LSP

  • Nov 23, 2024

    SemVer Is Not About You

  • Oct 14, 2024

    A Missing IDE Feature

  • Oct 8, 2024

    Two Workflow Tips

  • Oct 6, 2024

    On Ousterhout's Dichotomy

  • Sep 24, 2024

    The Watermelon Operator

  • Sep 23, 2024

    What is io_uring?

  • Sep 6, 2024

    Try to Fix It One Level Deeper

  • Sep 3, 2024

    The Fundamental Law Of Software Dependencies

  • Aug 12, 2024

    STD Doesn't Have to Abstract OS IO

  • Aug 1, 2024

    Primitive Recursive Functions For A Working Programmer

  • Jul 25, 2024

    How I Use Git Worktrees

  • Jul 5, 2024

    Properly Testing Concurrent Data Structures

  • Jun 4, 2024

    Regular, Recursive, Restricted

  • Mar 22, 2024

    Basic Things

  • Mar 21, 2024

    Zig defer Patterns

  • Mar 2, 2024

    Kafka versus Nabokov

  • Feb 10, 2024

    Window: Live, Constant Time Grep

  • Jan 12, 2024

    Write Less

  • Jan 3, 2024

    Of Rats and Ratchets

  • Dec 31, 2023

    Git Things

  • Dec 31, 2023

    O(1) Build File

  • Dec 24, 2023

    CI Dream

  • Dec 21, 2023

    Retry Loop

  • Dec 10, 2023

    Non-Send Futures When?

  • Nov 16, 2023

    IronBeetle

  • Nov 15, 2023

    Push Ifs Up And Fors Down

  • Nov 7, 2023

    Data Oriented Blogging

  • Oct 23, 2023

    Unified Versus Split Diff

  • Oct 18, 2023

    Unless Explicitly Specified Otherwise, Open Source Software With Users Carries Moral Obligations

  • Oct 12, 2023

    LSP could have been better

  • Oct 11, 2023

    UNIX Structured Concurrency

  • Oct 6, 2023

    What is an Invariant?

  • Sep 13, 2023

    Comparative Analysis

  • Aug 17, 2023

    TypeScript is Surprisingly OK for Compilers

  • Aug 13, 2023

    Role Of Algorithms

  • Aug 9, 2023

    Types and the Zig Programming Language

  • Aug 6, 2023

    Fantastic Learning Resources

  • Aug 1, 2023

    On Modularity of Lexical Analysis

  • Jul 16, 2023

    Three Different Cuts

  • Jun 18, 2023

    GitHub Merge Queue

  • Jun 2, 2023

    The Worst Zig Version Manager

  • May 21, 2023

    Resilient LL Parsing Tutorial

  • May 6, 2023

    Zig Language Server And Cancellation

  • May 2, 2023

    Value Oriented Programming Needs Implicits?

  • Apr 23, 2023

    Data Oriented Parallel Value Interner

  • Apr 13, 2023

    Reasonable Bootstrap

  • Apr 9, 2023

    Can You Trust a Compiler to Optimize Your Code?

  • Apr 2, 2023

    UB Might Be a Wrong Term for Newer Languages

  • Mar 28, 2023

    Rust Is a Scalable Language

  • Mar 26, 2023

    Zig And Rust

  • Mar 8, 2023

    An Engine For An Editor

  • Feb 21, 2023

    Why SAT Is Hard

  • Feb 16, 2023

    Three-State Stability

  • Feb 12, 2023

    <3 Deno

  • Feb 10, 2023

    How a Zig IDE Could Work

  • Jan 26, 2023

    Rust's Ugly Syntax

  • Jan 25, 2023

    Next Rust Compiler

  • Jan 4, 2023

    On Random Numbers

  • Dec 31, 2022

    Ray Tracer Construction Kit

  • Nov 18, 2022

    If a Tree Falls in a Forest, Does It Overflow the Stack?

  • Nov 5, 2022

    Accessibility: px or rem?

  • Oct 28, 2022

    Elements Of a Great Markup Language

  • Oct 24, 2022

    GitHub Actions Permissions

  • Oct 19, 2022

    Why Linux Troubleshooting Advice Sucks

  • Oct 6, 2022

    Hard Mode Rust

  • Oct 3, 2022

    From Paxos to BFT

  • Jul 10, 2022

    Almost Rules

  • Jul 4, 2022

    Unit and Integration Tests

  • Jun 29, 2022

    Notes on GATs

  • Jun 11, 2022

    Caches In Rust

  • May 29, 2022

    Builder Lite

  • May 29, 2022

    Binary Privacy

  • Apr 25, 2022

    Why LSP?

  • Mar 26, 2022

    Self Modifying Code

  • Mar 14, 2022

    RPATH, or why lld doesn't work on NixOS

  • Nov 27, 2021

    Notes On Module System

  • Nov 7, 2021

    Generate All the Things

  • Sep 5, 2021

    One Hundred Thousand Lines of Rust

  • Sep 4, 2021

    Fast Rust Builds

  • Aug 22, 2021

    Large Rust Workspaces

  • Jul 30, 2021

    ; echo Shell Injection

  • Jul 10, 2021

    It's Not Always ICache

  • Jul 9, 2021

    Inline In Rust

  • May 31, 2021

    How to Test

  • May 12, 2021

    Design Pattern: Kitchen Sink

  • Apr 26, 2021

    Concurrent Expression Problem

  • Mar 22, 2021

    Async Benchmarks Index

  • Mar 12, 2021

    Goroutines Are Not Significantly Smaller Than Threads

  • Feb 27, 2021

    Delete Cargo Integration Tests

  • Feb 24, 2021

    Another Generic Dilemma

  • Feb 15, 2021

    matklad @ NEAR

  • Feb 14, 2021

    For the Love of Macros

  • Feb 10, 2021

    A Better Rust Profiler

  • Feb 6, 2021

    ARCHITECTURE.md

  • Jan 3, 2021

    Two Kinds of Code Review

  • Dec 28, 2020

    Call Site Dependency Injection

  • Dec 12, 2020

    Notes On Lock Poisoning

  • Nov 11, 2020

    Why an IDE?

  • Nov 1, 2020

    Notes on Paxos

  • Oct 15, 2020

    Study of std::io::Error

  • Oct 3, 2020

    Fast Thread Locals In Rust

  • Sep 20, 2020

    Why Not Rust?

  • Sep 13, 2020

    Your Language Sucks, It Doesn't Matter

  • Sep 12, 2020

    Rust in 2021

  • Aug 15, 2020

    Code Smell: Concrete Abstraction

  • Aug 12, 2020

    Who Builds the Builder?

  • Aug 11, 2020

    Things I Have Learned About Life

  • Jul 15, 2020

    Two Beautiful Rust Programs

  • Apr 15, 2020

    From Pratt to Dijkstra

  • Apr 13, 2020

    Simple but Powerful Pratt Parsing

  • Mar 22, 2020

    Fast and Simple Rust Interner

  • Feb 14, 2020

    Why is Rust the Most Loved Programming Language?

  • Jan 4, 2020

    Mutexes Are Faster Than Spinlocks

  • Jan 2, 2020

    Spinlocks Considered Harmful

  • Nov 16, 2019

    A Better Shell

  • Nov 13, 2019

    rust-analyzer Blog

  • Aug 23, 2019

    Join Your Threads

  • Jul 25, 2019

    Unsafe as a Human-Assisted Type System

  • Jul 16, 2019

    Perils of Constructors

  • Jun 20, 2019

    Linux Desktop Tips

  • May 19, 2019

    Rust Course Retrospective

  • May 19, 2019

    Consider Using Asciidoctor for Your Next Presentation

  • Jul 24, 2018

    Exceptions vs Structured Concurrency

  • Jun 18, 2018

    A Trick For Test Maintenance

  • Jun 6, 2018

    Modern Parser Generator

  • Jun 4, 2018

    Newtype Index Pattern

  • May 24, 2018

    Typed Key Pattern

  • May 4, 2018

    Encapsulating Lifetime of the Field

  • May 3, 2018

    Effective Pull Requests

  • Mar 3, 2018

    Stopping a Rust Worker

  • Jan 3, 2018

    Make your own make

  • Oct 21, 2017

    Dynamic types in LLDB

  • Mar 25, 2017

    NixOS Notes

  • Mar 18, 2017

    Min of Three Part 2

  • Mar 12, 2017

    Min of Three

Fix typo Subscribe Get in touch matklad