News Feed

  1. The Past

  2. Fully Vaccinated

  3. Ormolu internship

  4. Grumpy

  5. Excel Lambda

  6. Aviation Firsts

  7. Async Vision Doc Writing Sessions VI

  8. Tail Latency Might Matter More Than You Think

  9. Knurling-rs changelog #23

  10. Notes on building debugging puzzles

  11. AI Methodology

  12. The Sisyphean Task Of DNS Client Config on Linux

  13. Arrows, through a different lens

  14. Redundant against what?

  15. That Hat

  16. Async Vision Doc Writing Sessions V

  17. #03 - NixOS Weekly

  18. Ad-hoc interpreters with capability

  19. The Greatest

  20. Async Vision Doc Writing Sessions IV

  21. TinyPilot: Month 9

  22. What problems do people solve with strace?

  23. My “shiny future”

  24. Knurling-rs changelog #22

  25. Nineties Called

  26. A tool to spy on your DNS queries: dnspeep

  27. Testing an embedded application

  28. Async Vision Doc Writing Sessions III

  29. Knurling Financial Update

  30. Incubating the Haskell Foundation

  31. We’re Off

  32. Async Vision Doc Writing Sessions II

  33. Compile times, and why "the obvious" might not be so

  34. What You Can Learn From Old Hard Drive Adverts

  35. How to build hybrid Haskell and Java programs

  36. The Sun, Huh?

  37. Get better at programming by learning how things work

  38. Breathe-rs - An air quality monitor based on Knurling sessions

  39. A Trip

  40. Async Vision Doc Writing Sessions

  41. Knurling-rs changelog #21

  42. Types à la carte in Nickel

  43. March Tailscale newsletter

  44. Running hardware-in-the-loop tests on GitHub Actions

  45. We published the first knurling-session!

  46. Contributing to Pygame

  47. Here For

  48. Guidelines for Freelance Developers Working with Me

  49. Knurling-rs changelog #20

  50. Mac upgrade opened sshd to brute force password attacks

  51. Swarm

  52. netaddr.IP: a new IP address type for Go

  53. Knurling-rs changelog #19

  54. Key management characteristics of the Tailscale Control Protocol

  55. Announcing Gomod2nix

  56. TinyPilot: Month 8

  57. Things your manager might not know

  58. A Saturday waste of CPU cycles: building time_t values

  59. Battle-tested monadic OCaml: Tezos

  60. A little tool to make DNS queries

  61. Modules, monoliths, and microservices

  62. #02 - NixOS Weekly

  63. An incomplete list of complaints about real code

  64. Incident Response Isn't Enough

  65. Unfortunate things about performance reviews

  66. Derivation outputs in a content-addressed world

  67. How often should I rotate my ssh keys?

  68. linear-base makes writing Linear Haskell easy and fun

  69. I tried to fix it, and failed miserably

  70. February Tailscale newsletter

  71. Project: Recreating ShArc – Testing Linearity

  72. Push some big numbers through your system and look for bugs

  73. TinyPilot: Month 7

  74. Philosophy of Tailscale: Social proximity networks

  75. My Third Year as a Solo Developer

  76. Your nines are not my nines

  77. Sharing over Tailscale

  78. Project: EOGee – Injecting Fake Signals with FakeEyes for Frequency Analysis

  79. Firecracker: start a VM in less than a second

  80. Lurking bugs behind infrequently-executed code paths

  81. The Fundamental Mechanism of Scaling

  82. #01 - NixOS Weekly

  83. Tailscale on NixOS: A new Minecraft server in ten minutes

  84. HR is not your friend, and other things I think you should know

  85. Server-sent events: a simple way to stream events from a server

  86. Stuff your logs!

  87. Daily blog posts about my time at RC

  88. Quorum Availability

  89. TinyPilot: Month 6

  90. Docker Compose: a nice way to set up a dev environment

  91. Project: EOGee – Programming the EOGlass microcontrollers

  92. The more things change…

  93. My favorite essays of life advice

  94. Project: EOGee – Hardware Noise Analysis

  95. Looking back on 2020

  96. Project: EOGee – EOGlass Drift Reduction

  97. To listen well, get curious

  98. Rotating the compiler team leads

  99. In defense of blub studies

  100. TinyPilot: Month 5

  101. How to Make Your Code Reviewer Fall in Love with You

  102. #09 - NixOS Weekly

  103. Project: Recreating ShArc

  104. TinyPilot: Month 4

  105. 1.5x the PH bits for one more CLMUL

  106. Project: EOGee – Improving Drift via Reduced Bias Current

  107. Getting Big Things Done

  108. #08 - NixOS Weekly

  109. TinyPilot: Month 3

  110. Building a Homelab VM Server (2020 Edition)

  111. Consensus is Harder Than It Looks

  112. How to make video calls almost as good as face-to-face

  113. Reducing STM32 SPI HAL Latency

  114. TinyPilot: Month 2

  115. Focus on the Good Parts

  116. Mini Project: Monoprice 3D Printer Modification for Flexible Filament

  117. UMASH: a fast and universal enough hash

  118. How I Collected a Debt from an Unscrupulous Merchant

  119. Surprising Economics of Load-Balanced Systems

  120. TinyPilot: Month 1

  121. #07 - NixOS Weekly

  122. Tools for keeping focused

  123. Attention is your scarcest resource

  124. TinyPilot: Build a KVM Over IP for Under $100

  125. Be impatient

  126. Essays on programming I think about a lot

  127. Flatter wait-free hazard pointers

  128. What should we do about network-effect monopolies?

  129. Is It Keto: Month 13

  130. #06 - NixOS Weekly

  131. My weekly review habit

  132. Key Mime Pi: Turn Your Raspberry Pi into a Remote Keyboard

  133. #05 - NixOS Weekly

  134. My Eight-Year Quest to Digitize 45 Videotapes (Part Two)

  135. My Eight-Year Quest to Digitize 45 Videotapes (Part One)

  136. Check for borrows in bitwise operations

  137. Update: Stripe's Response Regarding User Tracking

  138. #04 - NixOS Weekly

  139. `zig cc`: a Powerful Drop-In Replacement for GCC/Clang

  140. #03 - NixOS Weekly

  141. Why I'm donating $150/month (10% of my income) to the musl libc project

  142. Using Zig to Provide Stack Traces on Kernel Panic for a Bare Bones Operating System

  143. String Matching based on Compile Time Perfect Hashing in Zig

  144. I Quit My Cushy Job at OkCupid to Live on Donations to Zig

  145. Zig: January 2018 in Review

  146. Unsafe Zig is Safer Than Unsafe Rust

  147. Zig: December 2017 in Review

  148. A Better Way to Implement Bit Fields

  149. Zig: Already More Knowable Than C