The Curious Engineer

All blogs / Linux / Unix

Julia Evans

jvns.ca

Linux / UnixDev tools / editors / IDEsNetworkingWeb developmentEngineering blogs

’15’20’25
Posts
614 from 16 Dec 2012 to 27 Sep 2026
Posting
monthly (10 in the last year)
Kind
personal blog
Feed
https://jvns.ca/atom.xml

2026 10

  1. Replacing the old battery on rechargeable bike lights
  2. Some more things about Django I've been enjoying
  3. Learning a few things about running SQLite
  4. Moving away from Tailwind, and learning to structure my CSS
  5. Links to CSS colour palettes
  6. Testing Vue components in the browser
  7. Examples for the tcpdump and dig man pages
  8. Notes on clarifying man pages
  9. Some notes on starting to use Django
  10. A data model for Git (and other docs updates)

2025 7

  1. Notes on switching to Helix from vim
  2. New zine: The Secret Rules of the Terminal
  3. Using `make` to compile C programs (for non-C-programmers)
  4. Standards for ANSI escape codes
  5. How to add a directory to your PATH
  6. Some terminal frustrations
  7. What's involved in getting a "modern" terminal setup?

2024 25

  1. "Rules" that terminal programs follow
  2. Why pipes sometimes get "stuck": buffering
  3. Importing a frontend Javascript library without a build system
  4. New microblog with TILs
  5. ASCII control characters in my terminal
  6. Using less memory to look up IP addresses in Mess With DNS
  7. Some notes on upgrading Hugo
  8. Terminal colours are tricky
  9. Some Go web dev notes
  10. Reasons I still love the fish shell
  11. Migrating Mess With DNS to use PowerDNS
  12. Go structs are copied on assignment (and other things about Go I'd missed)
  13. Entering text in the terminal is complicated
  14. Reasons to use your shell's job control
  15. New zine: How Git Works!
  16. Notes on git's error messages
  17. Making crochet cacti
  18. Some Git poll results
  19. The "current branch" in git
  20. How HEAD works in git
  21. Popular git config options
  22. Dealing with diverged git branches
  23. Inside .git
  24. Do we think of git commits as diffs, snapshots, and/or histories?
  25. Some notes on NixOS

2023 34

  1. 2023: Year in review
  2. Mounting git commits as folders with NFS
  3. git branches: intuition & reality
  4. Some notes on nix flakes
  5. How git cherry-pick and revert use 3-way merge
  6. git rebase: what can go wrong?
  7. Confusing git terminology
  8. Some miscellaneous git facts
  9. New talk: Making Hard Things Easy
  10. In a git repository, where do your files live?
  11. Notes on using a single-person Mastodon server
  12. What helps people get comfortable on the command line?
  13. Some tactics for writing in public
  14. Behind "Hello World" on Linux
  15. Why is DNS still hard to learn?
  16. Lima: a nice way to run Linux VMs on Mac
  17. Open sourcing the nginx playground
  18. New zine: How Integers and Floats Work
  19. Some blogging myths
  20. New playground: memory spy
  21. Introducing "Implement DNS in a Weekend"
  22. New talk: Learning DNS in 10 years
  23. New playground: integer.exposed
  24. A list of programming playgrounds
  25. Building a custom site for zine feedback
  26. Some possible reasons for 8-bit bytes
  27. How do Nix builds work?
  28. Some notes on using nix
  29. Writing Javascript without a build system
  30. Print copies of The Pocket Guide to Debugging have arrived
  31. Why does 0.1 + 0.2 = 0.30000000000000004?
  32. Examples of problems with integers
  33. Examples of floating point problems
  34. Some business graphs for 2022

2022 29

  1. New zine: The Pocket Guide to Debugging
  2. A debugging manifesto
  3. Tips for analyzing logs
  4. A couple of Rust error messages
  5. Making a DNS query in Ruby from scratch
  6. Why do domain names sometimes end with a dot?
  7. How to send raw network packets in Python with tun/tap
  8. Some ways to get better at debugging
  9. A toy remote login server
  10. What happens when you press a key in your terminal?
  11. Monitoring tiny web services
  12. Notes on running containers with bubblewrap
  13. sqlite-utils: a nice way to import data into SQLite for analysis
  14. Pages that didn't make it into "How DNS Works"
  15. New zine: How DNS Works!
  16. A list of new(ish) command line tools
  17. Implementing a toy version of TLS 1.3
  18. Celebrate tiny learning milestones
  19. How to use undocumented web APIs
  20. Some tiny personal programs I've written
  21. Some things about getaddrinfo that surprised me
  22. Things that used to be hard and are now easy
  23. The multiple meanings of "nameserver" and "DNS resolver"
  24. A toy DNS resolver
  25. Reasons for servers to support IPv6
  26. Hosting my static sites with nginx
  27. Some ways DNS can break
  28. How to find a domain's authoritative nameservers
  29. Why might you run your own DNS server?

2021 54

  1. 2021: Year in review
  2. New tool: Mess with DNS!
  3. DNS "propagation" is actually caches expiring
  4. How to use dig
  5. Debugging a weird 'file not found' error
  6. Some notes on using esbuild
  7. How do you tell if a problem is caused by DNS?
  8. How to get useful answers to your questions
  9. Tools to explore BGP
  10. All my zines are now available in print!
  11. New tool: an nginx playground
  12. Teaching by filling in knowledge gaps
  13. Debugging by starting a REPL at a breakpoint is fun
  14. Quadratic algorithms are slow (and hashmaps are fast)
  15. Patterns in confusing explanations
  16. Write good examples by starting with real code
  17. Reasons why bugs might feel "impossible"
  18. You can now buy print version of my zines!
  19. Blog about what you've struggled with
  20. How to look at the stack with gdb
  21. The OSI model doesn't map well to TCP/IP
  22. I put all of my comics online!
  23. Notes on building debugging puzzles
  24. What problems do people solve with strace?
  25. A tool to spy on your DNS queries: dnspeep
  26. Get better at programming by learning how things work
  27. Things your manager might not know
  28. A little tool to make DNS queries
  29. Day 57: Trying to set up GitHub Actions
  30. Day 56: A little WebAssembly
  31. Day 53: a little nginx, IPv6, and wireguard
  32. Day 52: testing how many Firecracker VMs I can run
  33. Day 51: Fixed my logging and made a couple of puzzles
  34. Day 50: Building some tarballs for puzzles, and trying to make a kernel boot faster
  35. Day 49: making the VMs boot faster
  36. Day 48: Another Go program, and a little vim configuration
  37. Day 47: Using device mapper to manage Firecracker images
  38. Day 46: debugging an iptables problem
  39. Firecracker: start a VM in less than a second
  40. Day 44: Building my VMs with Docker
  41. Day 43: Building VM images
  42. Day 42: Writing a Go program to manage Firecracker VMs
  43. Day 41: Trying to understand what a bridge is
  44. Day 40: screen flickering & a talk about containers
  45. Day 39: Customizing gotty's terminal
  46. Day 38: Modifying gotty to serve many different terminal applications at once
  47. Day 37: A new laptop and a little Vue
  48. Server-sent events: a simple way to stream events from a server
  49. Day 35: Launching my VMs more reliably
  50. Daily blog posts about my time at RC
  51. Day 34: Learning about qemu
  52. Day 33: pairing is magic and beautiful git diffs
  53. Day 32: A Rails model that doesn't use the database with ActiveHash
  54. Docker Compose: a nice way to set up a dev environment

2020 48

  1. 2020: Year in review
  2. Day 24: a short talk about blogging myths, and a debugging tip
  3. Day 23: a little Rails testing
  4. Day 22: getting OAuth to work in Rails
  5. Day 21: wrangling systemd & setting up git deploys to a VM
  6. How I write useful programming comics
  7. Day 19: Clustering faces (poorly) using an autoencoder
  8. Day 20: trying to figure out how Google Cloud IAM works
  9. Day 18: an answer to an autoencoder question
  10. Day 17: trying to wrap my head around autoencoders
  11. An attempt at implementing char-rnn with PyTorch
  12. Day 13: BPTT, and debugging why a model isn't training is hard
  13. Day 11: learning about learning rates
  14. New zine: Hell Yes! CSS!
  15. Day 10: Training an RNN to count to three
  16. Day 9: Generating a lot of nonsense with an RNN
  17. Day 8: Start with something that works
  18. Day 5: drawing lots of faces with sketch-rnn
  19. How do you write simple explanations without sounding condescending?
  20. Day 3: an infinitely tall fridge
  21. Day 2: Rails associations & dragging divs around
  22. Day 1: a confusing Rails error message
  23. A new way I'm getting feedback on my zines: beta readers!
  24. I'm doing another Recurse Center batch!
  25. A few things I've learned about email marketing
  26. ninja: a simple way to do builds
  27. Wizard Zines' first print run: Help! I have a Manager!
  28. Implementing 'focus and reply' for Fastmail with JMAP
  29. Some possible future zines
  30. Some more CSS comics
  31. An attempt to make a font look more handwritten
  32. Some CSS comics
  33. When your coworker does great work, tell their manager
  34. scanimage: scan from the command line!
  35. saturday comics: a weekly mailing list of programming comics
  36. Tell candidates what to expect from your job interviews
  37. entr: rerun your build when files change
  38. A little bit of plain Javascript can do a lot
  39. What happens when you update your DNS?
  40. Questions to help people decide what to learn
  41. Metaphors in man pages
  42. Why strace doesn't work in Docker
  43. New zine: How Containers Work!
  44. When debugging, your attitude matters
  45. Getting started with shaders: signed distance functions!
  46. Questions you can ask about compensation
  47. New zine: Become a SELECT Star!
  48. PaperWM: tiled window management for GNOME

2019 29

  1. 2019: Year in review
  2. "server" is hard to define
  3. How tracking pixels work
  4. Challenge: find Twitter memes with suffix arrays
  5. Solutions to the tiny window manager challenge
  6. Challenge: Write a bouncy window manager
  7. What makes a programming exercise good?
  8. How containers work: overlayfs
  9. Some notes on vector drawing apps
  10. SQLite is really easy to compile
  11. Some research on shipping print zines
  12. Your Linux Toolbox: a box set of my free zines
  13. SQL queries don't start with SELECT
  14. Zine revenue for 2019
  15. Notes on building SQL exercises
  16. Taking a year to explain computer things
  17. New zine: HTTP: Learn your browser's language!
  18. How to put an HTML page on the internet
  19. How to write zines with simple tools
  20. git exercises: navigate a repository
  21. curl exercises
  22. Get your work recognized: write a brag document
  23. What does debugging a program look like?
  24. Why are monoidal categories interesting?
  25. New zine: Bite Size Networking!
  26. Organizing this blog into categories
  27. !!Con 2019: submit a talk!
  28. Networking tool comics!
  29. A few early marketing thoughts

2018 55

  1. Some nonparametric statistics math
  2. 2018: Year in review
  3. New talk: High Reliability Infrastructure Migrations
  4. How do you document a tech project with comics?
  5. An example of how C++ destructors are useful in Envoy
  6. Some notes on running new software in production
  7. Tailwind: style your site without writing any CSS!
  8. When does teaching with comics work well?
  9. Some Envoy basics
  10. New zine: Oh shit, git!
  11. What's a senior engineer's job?
  12. Some possible career goals
  13. Why sell zines?
  14. New zine: Help! I have a manager!
  15. Build impossible programs
  16. An awesome new Python profiler: py-spy!
  17. Editing my blog's HTTP headers with Cloudflare workers
  18. Who pays to educate developers?
  19. How to teach yourself hard things
  20. I started a corporation!
  21. A few recent podcasts
  22. New zine: Bite Size Command Line!
  23. IP addresses & routing
  24. netdev day 2: moving away from "as fast as possible" in networking code
  25. netdev day 1: IPsec!
  26. How I use Wireshark
  27. Batch editing files with ed
  28. How to get a core dump for a segfault on Linux
  29. New zine: Profiling & tracing with perf!!
  30. Talk: Building a Ruby profiler
  31. Reverse engineering the Notability file format
  32. Open source sabbatical = awesome
  33. Documentation site for rbspy!
  34. Talks I'd love to see at RustConf
  35. A few things I've learned about computer networking
  36. How does the internet work? podcast
  37. Prototyping an ltrace clone using eBPF
  38. Measuring a blog's success: focus on conversations, not page views
  39. Profiler week 6/7: more experiments, and a `report` subcommand!
  40. Working remotely, 4 years in
  41. Writing performance reviews with positive constructive feedback
  42. Profiler week 5: Mac support, experiments profiling memory allocations
  43. Writing eBPF tracing tools in Rust
  44. Spying on a Ruby process's memory allocations with eBPF
  45. Profiler week 4: callgrind support, containers, Mac progress!
  46. I think I found a Mac kernel bug?
  47. How do you spy on a program running in a container?
  48. How do you read the memory maps of a Mac process?
  49. Profiler week 3: refactoring, better testing, and an alpha release!
  50. Profiler week 2: support for 1.9.3 -> 2.5.0, and line numbers!
  51. Should I pause a Ruby process to collect its stack?
  52. Rust in 2018: it's way easier to use!
  53. Profiler adventures: resolving symbol addresses is hard!
  54. Profiler week 1: testing & profiling stripped binaries
  55. How does gdb call functions?

2017 76

  1. 2017: Year in review
  2. How I set up an automatic weekly blog digest
  3. A perf cheat sheet
  4. My first Rust macro
  5. Debugging a segfault in my Rust program
  6. Bindgen: awesome Rust tool for generating C bindings
  7. How are Ruby's headers different from Python's headers?
  8. How often do Ruby's stack struct definitions change?
  9. How do Ruby & Python profilers work?
  10. Taking a sabbatical to work on Ruby profiling tools
  11. New zine: So you want to be a wizard
  12. What's a reference in Rust?
  13. Linux comics: a small zine
  14. How do groups work on Linux?
  15. Glitch: write fun small web projects instantly
  16. Binder: an awesome tool for hosting Jupyter notebooks
  17. Operating a Kubernetes network
  18. Reasons Kubernetes is cool
  19. Profiling Go programs with pprof
  20. How to answer questions in a helpful way
  21. How I spent my time at the Recurse Center
  22. Cool vim feature: sessions!
  23. Data structure: the treap!
  24. Finding out if/why a server is dropping packets
  25. What's a network interface?
  26. Telling people what you're working on
  27. Debugging netlink requests
  28. Learning at work
  29. Figuring out how to contribute to open source
  30. How Kubernetes certificate authorities work
  31. Cherry picking commits & shell scripting in golang
  32. How does the Kubernetes scheduler work?
  33. Linux tracing zine
  34. Linux tracing systems & how they fit together
  35. Notes on BPF & eBPF
  36. a tiny whack-a-mole game
  37. 3 short screencasts (/proc, tcpdump, strace)
  38. What can developers learn from being on call?
  39. Awesome NLP tutorials by Allison Parrish
  40. Log-structured storage
  41. Iptables basics
  42. A few things I've learned about Kubernetes
  43. Async IO on Linux: select, poll, and epoll
  44. "Let's learn tcpdump" zine: now available for everyone
  45. Handwritten books
  46. A small website mystery
  47. Like zines about computers? You might love Bubblesort Zines
  48. Using the Strict-Transport-Security header
  49. New zine: let's learn tcpdump!
  50. No feigning surprise
  51. The fish shell is awesome
  52. Some good "Statistics for programmers" resources
  53. Making small culture changes
  54. netdev conference, day 3
  55. netdev conference, day 2
  56. How to filter packets super fast: XDP & eBPF!
  57. netdev conference, day 1
  58. Slow down your internet with tc
  59. Bash scripting quirks & safety tips
  60. Blogging principles I use
  61. ftrace: trace your kernel functions!
  62. Writing down my career
  63. So you want to be a wizard
  64. Swapping, memory limits, and cgroups
  65. Hiring & opportunity
  66. How do these "neural network style transfer" tools work?
  67. Weird unix thing: 'cd //'
  68. How big can a packet get?
  69. A magical machine learning art tool
  70. Dissecting an SSL certificate
  71. New zine: "Networking! ACK!"
  72. Choosing the "best software"
  73. A tiny zine about machine learning
  74. An idea for a programming book
  75. How do you make an awesome team?
  76. Rules of programming experiments

2016 90

  1. How to ask good questions
  2. Systems We Love 2016
  3. A container networking overview
  4. What's interesting about UDP?
  5. 2016: Year in review
  6. How much memory is my process using?
  7. More drawings about computers
  8. Things to learn about Linux
  9. "A Critique of the CAP Theorem"
  10. Ideas about how to use AWS
  11. Why cute drawings?
  12. A few drawings about Linux
  13. What happens when you run a rkt container?
  14. Service discovery at Stripe
  15. Running containers without Docker
  16. A few questions about open source
  17. Consistency vs availability (wat?)
  18. A litmus test for job descriptions
  19. What's devops?
  20. Operations for software developers for beginners
  21. What even is a container: namespaces and cgroups
  22. Switching to Hugo
  23. What happens when you start a process on Linux?
  24. A list of Linux container software
  25. "I just want to run a container!"
  26. Getting things done
  27. A swiss army knife of debugging tools: talk & transcript
  28. Some questions about Docker and rkt
  29. How I got a CS degree without learning what a system call is
  30. Learning systems programming with Rust
  31. New zine: Linux debugging tools you'll love
  32. Asking good questions is hard (but worth it)
  33. How (and why) I made a zine
  34. Why do UDP packets get dropped?
  35. Release it, then build it
  36. How do you decide what to work on?
  37. How does gdb work?
  38. A few sketches
  39. Benchmarking correctly is hard (and techniques for doing it better)
  40. How do HTTP requests get sent to the right place?
  41. PolyConf 2016
  42. Linux debugging tools I love
  43. Why do we use the Linux kernel's TCP stack?
  44. Using ltrace to debug a memory leak
  45. Should you be scared of Unix signals?
  46. How to spy on a Ruby program
  47. A useful new strace feature
  48. Ideas for making better conference talks & conferences
  49. Learning to like design documents
  50. Three ways to solve hard programming problems
  51. "advice" for aspiring tech bloggers
  52. Notes from my PyData Berlin keynote
  53. A few reasons to be skeptical of machine learning
  54. homu + highfive: awesome bots that make open source projects easier
  55. Investigating Erlang by reading its system calls
  56. A second try at using Rust
  57. What are SSL ciphers & session keys?
  58. A workshop on strace & tcpdump
  59. The Etsy site performance report is amazing
  60. How does knowledge get locked up in people's heads?
  61. CDNs aren't just for caching
  62. you can take the derivative of a regular expression?!
  63. Some links on Java garbage collection
  64. Java garbage collection can be really slow
  65. Looking inside machine learning black boxes
  66. Some of my favorite blogs
  67. I conquered thread pools! For today, at least.
  68. Thread pools! How do I use them?
  69. I/O matters.
  70. How do you do capacity planning?
  71. tcpdump is amazing
  72. How does perf work? (in which we read the Linux kernel source)
  73. Women-only spaces are a hack
  74. Surprises in Ruby HTTP libraries
  75. What is "the stack"?
  76. perf top: an awesome way to spy on CPU usage
  77. How to measure your CPU time: clock_gettime!
  78. Why I love log files
  79. Have high expectations for your computers
  80. TIL: clock skew exists
  81. How CPU load averages work (and using them to triage webserver performance!)
  82. Fast integer sets with Roaring Bitmaps (and, making friends with your modern CPU)
  83. Sendfile (a system call for web developers to know about!)
  84. Calling C from Rust
  85. Guessing Linux kernel registers
  86. A few notes on my CUSEC talk
  87. Why I ❤ Rust
  88. Talking about stock options = awesome
  89. Java isn't slow
  90. Winning the bias-variance tradeoff

2015 28

  1. Surviving meetings while remote
  2. Things you should know about stock options before negotiating an offer
  3. 2015: Year in review
  4. How to trick a neural network into thinking a panda is a vulture
  5. Women in Machine Learning 2015 (fun!!!)
  6. Why Ruby’s Timeout is dangerous (and Thread.raise is terrifying)
  7. How I got better at debugging
  8. Why you should understand (a little) about TCP
  9. Docker is amazing
  10. PAPERS ARE AMAZING: Profiling threaded programs with Coz
  11. A millisecond isn't fast (and how we made it 100x faster)
  12. Is machine learning safe to use?
  13. An argument for hiring junior developers
  14. Some easy statistics: Bootstrap confidence intervals
  15. AdaCamp Montreal 2015
  16. A zine about strace
  17. Learning at open source sprints (no preparation required)
  18. A few spy tools for your operating system (other than strace!)
  19. Seeing system calls with perf instead of strace
  20. Senior engineering & fantasy heroes
  21. Nancy Drew and the Case of the Slow Program
  22. You can choose who submits talks to your conference
  23. 1:1 topic ideas
  24. How the locate command works (and let's write a faster version in one minute!)
  25. How gzip uses Huffman coding
  26. How I learned to program in 10 years
  27. A/A testing
  28. Data Day Texas 2015

2014 58

  1. On reading the source code, not the docs
  2. Programming doesn't belong to men (it belongs to me)
  3. Fear makes you a worse programmer
  4. Reproducing awesomeness
  5. Diving into concurrency: trying out mutexes and atomics
  6. Spying on Hadoop with strace
  7. LD_PRELOAD is super fun. And easy!
  8. PyData NYC (I gave a machine learning talk! yay!)
  9. Fun with machine learning: logistic regression!
  10. Fun with machine learning: does your model actually work?
  11. What women in technology really think (150 of them, at least)
  12. Working remote, 8 months in (seeing humans is important!)
  13. How to set up a blog in 5 minutes
  14. How does SQLite work? Part 2: btrees! (or: disk seeks are slow don't do them!)
  15. How does SQLite work? Part 1: pages!
  16. Strange Loop 2014
  17. You can be a kernel hacker!
  18. How is a binary executable organized? Let's explore it!
  19. What happens if you write a TCP stack in Python?
  20. Pair programming is amazing! Except... when it's not.
  21. Open sourced talks!
  22. Ruby Rogues podcast: systems programming tricks!
  23. Fun with stats: How big of a sample size do I need?
  24. How I did Hacker School: ignoring things I understand and doing the impossible
  25. !!Con talks are up
  26. Machine learning isn't Kaggle competitions
  27. Asking questions is a superpower
  28. Should my conference do anonymous review?
  29. Working remote, 3 months in
  30. Anonymous talk review is amazing.
  31. Diving into HDFS
  32. I can spy on my CPU cycles with perf!
  33. Computers are *fast*!
  34. Stopping to think
  35. Don't feel guilty about not contributing to open source
  36. Debug your programs like they're closed source!
  37. ♥ PyCon
  38. Becoming a better developer (it's not just writing more programs)
  39. "Ask if you have questions" isn't enough
  40. Reports from remote-land: remote pairing works great!
  41. Recovering files using /proc (and spying, too!)
  42. My Rust OS will never be finished (and it's a success!)
  43. Writing an OS in Rust in tiny steps (Steps 1-5)
  44. Debugging shared library problems with strace
  45. Hacker School's Secret Strategy for Being Super Productive (or: Help.)
  46. Pair programming
  47. More practical uses for strace!
  48. Using strace to avoid reading Ruby code
  49. Spying on ssh with strace
  50. "How was Hacker School?"
  51. A few blogs I really like
  52. Three steps to learning GDB
  53. Sounding confident in interviews
  54. CUSEC = fun
  55. What my technical interviews have looked like
  56. You should give talks. They will be awesome. Here's why!
  57. 4 paths to being a kernel hacker
  58. Some things my kernel can't do

2013 70

  1. Questions I'm asking in interviews
  2. Coding strategies
  3. When is "guys" gender neutral? I did a survey!
  4. A pandas cookbook
  5. Understanding how killall works using strace
  6. Day 46: Never Graduate
  7. Day 45: I now have Rust code for executing executables!
  8. Day 44: qemu + gdb = so great
  9. Day 43: SOMETHING IS ERASING MY PROGRAM WHILE IT’S RUNNING (oh wait oops)
  10. Day 42: How to run a simple ELF executable, from scratch (I don't know)
  11. Day 41: Linkers are upsetting
  12. Day 39: Writing malloc wrong, for fun
  13. Day 40: 12 things I learned today about linkers.
  14. Day 40: Linkers are amazing.
  15. Day 38: After 6 days, I have problems that I can't understand at all
  16. Day 37: After 5 days, my OS doesn't crash when I press a key
  17. Day 36: On programming without malloc
  18. Day 35: Types in Rust, for beginners
  19. How to call Rust from assembly, and vice versa
  20. Videos from PyData NYC are up!
  21. What happens when you run 'Hello, world'
  22. Writing a kernel using rustboot & rust-core
  23. Day 34b: Writing curl using my TCP stack
  24. Day 34: The tiniest operating system
  25. Day 33: How to make music with ClojureScript
  26. Day 32: Magical Orchestra!!!
  27. Day 31: Binary trees with core.logic!
  28. Day 30: Making music in Clojure with Overtone. Clojure bugs with laziness! Fun!
  29. Day 29: Trying out Emacs!
  30. Day 28: Made a git workflow visualization webapp!
  31. Day 27: Automatically testing changes in state! Visualizing my Git workflow! Floats!
  32. Day 25: ACK all the things
  33. Day 26: Trying to describe the TCP state machine in a readable way. Failing.
  34. Women in Technology workshop at PyData NYC
  35. Day 24: Unit testing this TCP library
  36. Day 22: Got some TCP packets back!
  37. Day 23: Started writing a TCP stack in Python
  38. NYC Python talk
  39. Day 21: Trying to TCP
  40. Day 19: A few reasons why networking is hard
  41. Day 20: Traceroute in 15 lines of code using Scapy
  42. Day 18: ARP cache poisoning (or: In ur connection, sniffing ur packets)
  43. Day 17: How to write a buffer overflow exploit
  44. Day 16: gzip + poetry = awesome
  45. Do Rails programmers use node.js? Visualizing correlations in command usage
  46. Day 15: How a .gz file is structured, redux
  47. Day 14: When it's hard to write tests, that's when I should be testing
  48. Day 13: Off by one errors
  49. Day 12: Why Julia likes Julia
  50. Day 10: Goals. Goals? Maybe I need to be *reading* more code?
  51. Day 11: How does gzip work?
  52. Day 9: Bytecode is made of bytes! CPython isn't scary!
  53. Day 8: Julia writes Julia! And remembers that open source is hard.
  54. Day 7: An echo server in Clojure
  55. Day 6: I wrote a rootkit!
  56. Day 5: I wrote a kernel module!!!
  57. Where to find bike sharing systems' data feeds
  58. Day 4: Processes vs threads, and kernel modules!
  59. Day 3: What does the Linux kernel even do?
  60. Day 2: netcat fun!
  61. Day 1: What does a shell even do?
  62. Hacker School Day 1: Messing around with the stack in C
  63. Hacker School Day -4: unit testing in C. checkmk!
  64. Julia Serano's 'Excluded'
  65. PyData Boston 2013
  66. Open Data Exchange 2013
  67. Transit maps: 1941 vs 2011
  68. Graphing bike path data with IPython Notebook and pandas
  69. Trying out Octopress
  70. Montreal All-Girl Hack Night #2: now with cookies

2012 1

  1. Montreal All-Girl Hack Night #1: AMAZING