|
|
|
Some blogging myths
|
|
|
|
New playground: memory spy
|
|
|
|
Introducing "Implement DNS in a Weekend"
|
|
|
|
New talk: Learning DNS in 10 years
|
|
|
|
New playground: integer.exposed
|
|
|
|
A list of programming playgrounds
|
|
|
|
Building a custom site for zine feedback
|
|
|
|
Some possible reasons for 8-bit bytes
|
|
|
|
How do Nix builds work?
|
|
|
|
Some notes on using nix
|
|
|
|
Writing Javascript without a build system
|
|
|
|
Print copies of The Pocket Guide to Debugging have arrived
|
|
|
|
Why does 0.1 + 0.2 = 0.30000000000000004?
|
|
|
|
Examples of problems with integers
|
|
|
|
Examples of floating point problems
|
|
|
|
Some business graphs for 2022
|
|
|
|
New zine: The Pocket Guide to Debugging
|
|
|
|
A debugging manifesto
|
|
|
|
Tips for analyzing logs
|
|
|
|
A couple of Rust error messages
|
|
|
|
Making a DNS query in Ruby from scratch
|
|
|
|
Why do domain names sometimes end with a dot?
|
|
|
|
How to send raw network packets in Python with tun/tap
|
|
|
|
Some ways to get better at debugging
|
|
|
|
A toy remote login server
|
|
|
|
What happens when you press a key in your terminal?
|
|
|
|
Monitoring tiny web services
|
|
|
|
Notes on running containers with bubblewrap
|
|
|
|
sqlite-utils: a nice way to import data into SQLite for analysis
|
|
|
|
Pages that didn't make it into "How DNS Works"
|
|
|
|
New zine: How DNS Works!
|
|
|
|
A list of new(ish) command line tools
|
|
|
|
Implementing a toy version of TLS 1.3
|
|
|
|
Celebrate tiny learning milestones
|
|
|
|
How to use undocumented web APIs
|
|
|
|
Some tiny personal programs I've written
|
|
|
|
Some things about getaddrinfo that surprised me
|
|
|
|
Things that used to be hard and are now easy
|
|
|
|
The multiple meanings of "nameserver" and "DNS resolver"
|
|
|
|
A toy DNS resolver
|
|
|
|
Reasons for servers to support IPv6
|
|
|
|
Hosting my static sites with nginx
|
|
|
|
Some ways DNS can break
|
|
|
|
How to find a domain's authoritative nameservers
|
|
|
|
Why might you run your own DNS server?
|
|
|
|
2021: Year in review
|
|
|
|
New tool: Mess with DNS!
|
|
|
|
DNS "propagation" is actually caches expiring
|
|
|
|
How to use dig
|
|
|
|
Debugging a weird 'file not found' error
|
|
|
|
Some notes on using esbuild
|
|
|
|
How do you tell if a problem is caused by DNS?
|
|
|
|
How to get useful answers to your questions
|
|
|
|
Tools to explore BGP
|
|
|
|
All my zines are now available in print!
|
|
|
|
New tool: an nginx playground
|
|
|
|
Teaching by filling in knowledge gaps
|
|
|
|
Debugging by starting a REPL at a breakpoint is fun
|
|
|
|
Quadratic algorithms are slow (and hashmaps are fast)
|
|
|
|
Patterns in confusing explanations
|
|
|
|
Write good examples by starting with real code
|
|
|
|
Reasons why bugs might feel "impossible"
|
|
|
|
You can now buy print version of my zines!
|
|
|
|
Blog about what you've struggled with
|
|
|
|
How to look at the stack with gdb
|
|
|
|
The OSI model doesn't map well to TCP/IP
|
|
|
|
I put all of my comics online!
|
|
|
|
Notes on building debugging puzzles
|
|
|
|
What problems do people solve with strace?
|
|
|
|
A tool to spy on your DNS queries: dnspeep
|
|
|
|
Get better at programming by learning how things work
|
|
|
|
Things your manager might not know
|
|
|
|
A little tool to make DNS queries
|
|
|
|
Day 57: Trying to set up GitHub Actions
|
|
|
|
Day 56: A little WebAssembly
|
|
|
|
Day 53: a little nginx, IPv6, and wireguard
|
|
|
|
Day 52: testing how many Firecracker VMs I can run
|
|
|
|
Day 51: Fixed my logging and made a couple of puzzles
|
|
|
|
Day 50: Building some tarballs for puzzles, and trying to make a kernel boot faster
|
|
|
|
Day 49: making the VMs boot faster
|
|
|
|
Day 48: Another Go program, and a little vim configuration
|
|
|
|
Day 47: Using device mapper to manage Firecracker images
|
|
|
|
Day 46: debugging an iptables problem
|
|
|
|
Firecracker: start a VM in less than a second
|
|
|
|
Day 44: Building my VMs with Docker
|
|
|
|
Day 43: Building VM images
|
|
|
|
Day 42: Writing a Go program to manage Firecracker VMs
|
|
|
|
Day 41: Trying to understand what a bridge is
|
|
|
|
Day 40: screen flickering & a talk about containers
|
|
|
|
Day 39: Customizing gotty's terminal
|
|
|
|
Day 38: Modifying gotty to serve many different terminal applications at once
|
|
|
|
Day 37: A new laptop and a little Vue
|
|
|
|
Server-sent events: a simple way to stream events from a server
|
|
|
|
Day 35: Launching my VMs more reliably
|
|
|
|
Daily blog posts about my time at RC
|
|
|
|
Day 34: Learning about qemu
|
|
|
|
Day 33: pairing is magic and beautiful git diffs
|
|
|
|
Day 32: A Rails model that doesn't use the database with ActiveHash
|
|
|
|
Docker Compose: a nice way to set up a dev environment
|
|
|
|
2020: Year in review
|
|
|
|
Day 24: a short talk about blogging myths, and a debugging tip
|
|
|
|
Day 23: a little Rails testing
|
|
|
|
Day 22: getting OAuth to work in Rails
|
|
|
|
Day 21: wrangling systemd & setting up git deploys to a VM
|
|
|
|
Day 19: Clustering faces (poorly) using an autoencoder
|
|
|
|
How I write useful programming comics
|
|
|
|
Day 20: trying to figure out how Google Cloud IAM works
|
|
|
|
Day 18: an answer to an autoencoder question
|
|
|
|
Day 17: trying to wrap my head around autoencoders
|
|
|
|
An attempt at implementing char-rnn with PyTorch
|
|
|
|
Day 13: BPTT, and debugging why a model isn't training is hard
|
|
|
|
Day 11: learning about learning rates
|
|
|
|
New zine: Hell Yes! CSS!
|
|
|
|
Day 10: Training an RNN to count to three
|
|
|
|
Day 9: Generating a lot of nonsense with an RNN
|
|
|
|
Day 8: Start with something that works
|
|
|
|
Day 5: drawing lots of faces with sketch-rnn
|
|
|
|
How do you write simple explanations without sounding condescending?
|
|
|
|
Day 3: an infinitely tall fridge
|
|
|
|
Day 2: Rails associations & dragging divs around
|
|
|
|
Day 1: a confusing Rails error message
|
|
|
|
A new way I'm getting feedback on my zines: beta readers!
|
|
|
|
I'm doing another Recurse Center batch!
|
|
|
|
A few things I've learned about email marketing
|
|
|
|
ninja: a simple way to do builds
|
|
|
|
Wizard Zines' first print run: Help! I have a Manager!
|
|
|
|
Implementing 'focus and reply' for Fastmail with JMAP
|
|
|
|
Some possible future zines
|
|
|
|
Some more CSS comics
|
|
|
|
An attempt to make a font look more handwritten
|
|
|
|
Some CSS comics
|
|
|
|
When your coworker does great work, tell their manager
|
|
|
|
scanimage: scan from the command line!
|
|
|
|
Twitter summary from 2020 so far
|
|
|
|
saturday comics: a weekly mailing list of programming comics
|
|
|
|
Tell candidates what to expect from your job interviews
|
|
|
|
entr: rerun your build when files change
|
|
|
|
A little bit of plain Javascript can do a lot
|
|
|
|
What happens when you update your DNS?
|
|
|
|
Questions to help people decide what to learn
|
|
|
|
Metaphors in man pages
|
|
|
|
Why strace doesn't work in Docker
|
|
|
|
New zine: How Containers Work!
|
|
|
|
When debugging, your attitude matters
|
|
|
|
Getting started with shaders: signed distance functions!
|
|
|
|
Questions you can ask about compensation
|
|
|
|
New zine: Become a SELECT Star!
|
|
|
|
PaperWM: tiled window management for GNOME
|
|
|
|
2019: Year in review
|
|
|
|
"server" is hard to define
|
|
|
|
How tracking pixels work
|
|
|
|
Challenge: find Twitter memes with suffix arrays
|
|
|
|
Solutions to the tiny window manager challenge
|
|
|
|
Challenge: Write a bouncy window manager
|
|
|
|
What makes a programming exercise good?
|
|
|
|
How containers work: overlayfs
|
|
|
|
Some notes on vector drawing apps
|
|
|
|
Some research on shipping print zines
|
|
|
|
SQLite is really easy to compile
|
|
|
|
Your Linux Toolbox: a box set of my free zines
|
|
|
|
SQL queries don't start with SELECT
|
|
|
|
Zine revenue for 2019
|
|
|
|
Notes on building SQL exercises
|
|
|
|
Taking a year to explain computer things
|
|
|
|
New zine: HTTP: Learn your browser's language!
|
|
|
|
How to put an HTML page on the internet
|
|
|
|
How to write zines with simple tools
|
|
|
|
git exercises: navigate a repository
|
|
|
|
curl exercises
|
|
|
|
Get your work recognized: write a brag document
|
|
|
|
What does debugging a program look like?
|
|
|
|
Why are monoidal categories interesting?
|
|
|
|
New zine: Bite Size Networking!
|
|
|
|
Organizing this blog into categories
|
|
|
|
!!Con 2019: submit a talk!
|
|
|
|
Networking tool comics!
|
|
|
|
A few early marketing thoughts
|
|
|
|
Some nonparametric statistics math
|
|
|
|
2018: Year in review
|
|
|
|
New talk: High Reliability Infrastructure Migrations
|
|
|
|
How do you document a tech project with comics?
|
|
|
|
An example of how C++ destructors are useful in Envoy
|
|
|
|
Some notes on running new software in production
|
|
|
|
Tailwind: style your site without writing any CSS!
|
|
|
|
When does teaching with comics work well?
|
|
|
|
New zine: Oh shit, git!
|
|
|
|
Some Envoy basics
|
|
|
|
What's a senior engineer's job?
|
|
|
|
Some possible career goals
|
|
|
|
Why sell zines?
|
|
|
|
New zine: Help! I have a manager!
|
|
|
|
Build impossible programs
|
|
|
|
An awesome new Python profiler: py-spy!
|
|
|
|
Editing my blog's HTTP headers with Cloudflare workers
|
|
|
|
Who pays to educate developers?
|
|
|
|
How to teach yourself hard things
|
|
|
|
I started a corporation!
|
|
|
|
A few recent podcasts
|
|
|
|
New zine: Bite Size Command Line!
|
|
|
|
IP addresses & routing
|
|
|
|
netdev day 2: moving away from "as fast as possible" in networking code
|
|
|
|
netdev day 1: IPsec!
|
|
|
|
How I use Wireshark
|
|
|
|
Batch editing files with ed
|
|
|
|
How to get a core dump for a segfault on Linux
|
|
|
|
New zine: Profiling & tracing with perf!!
|
|
|
|
Talk: Building a Ruby profiler
|
|
|
|
Reverse engineering the Notability file format
|
|
|
|
Open source sabbatical = awesome
|
|
|
|
Documentation site for rbspy!
|
|
|
|
Talks I'd love to see at RustConf
|
|
|
|
A few things I've learned about computer networking
|
|
|
|
How does the internet work? podcast
|
|
|
|
Prototyping an ltrace clone using eBPF
|
|
|
|
Measuring a blog's success: focus on conversations, not page views
|
|
|
|
Profiler week 6/7: more experiments, and a `report` subcommand!
|
|
|
|
Working remotely, 4 years in
|
|
|
|
Writing performance reviews with positive constructive feedback
|
|
|
|
Profiler week 5: Mac support, experiments profiling memory allocations
|
|
|
|
Writing eBPF tracing tools in Rust
|
|
|
|
Spying on a Ruby process's memory allocations with eBPF
|
|
|
|
Profiler week 4: callgrind support, containers, Mac progress!
|
|
|
|
I think I found a Mac kernel bug?
|
|
|
|
How do you spy on a program running in a container?
|
|
|
|
How do you read the memory maps of a Mac process?
|
|
|
|
Profiler week 3: refactoring, better testing, and an alpha release!
|
|
|
|
Profiler week 2: support for 1.9.3 -> 2.5.0, and line numbers!
|
|
|
|
Should I pause a Ruby process to collect its stack?
|
|
|
|
Rust in 2018: it's way easier to use!
|
|
|
|
Profiler adventures: resolving symbol addresses is hard!
|
|
|
|
Profiler week 1: testing & profiling stripped binaries
|
|
|
|
How does gdb call functions?
|
|
|
|
2017: Year in review
|
|
|
|
How I set up an automatic weekly blog digest
|
|
|
|
A perf cheat sheet
|
|
|
|
My first Rust macro
|
|
|
|
Debugging a segfault in my Rust program
|
|
|
|
Bindgen: awesome Rust tool for generating C bindings
|
|
|
|
How are Ruby's headers different from Python's headers?
|
|
|
|
How often do Ruby's stack struct definitions change?
|
|
|
|
How do Ruby & Python profilers work?
|
|
|
|
Taking a sabbatical to work on Ruby profiling tools
|
|
|
|
New zine: So you want to be a wizard
|
|
|
|
What's a reference in Rust?
|
|
|
|
Linux comics: a small zine
|
|
|
|
How do groups work on Linux?
|
|
|
|
Glitch: write fun small web projects instantly
|
|
|
|
Binder: an awesome tool for hosting Jupyter notebooks
|
|
|
|
Operating a Kubernetes network
|
|
|
|
Reasons Kubernetes is cool
|
|
|
|
How to teach technical concepts with cartoons
|
|
|
|
Profiling Go programs with pprof
|
|
|
|
How to answer questions in a helpful way
|
|
|
|
How I spent my time at the Recurse Center
|
|
|
|
Cool vim feature: sessions!
|
|
|
|
Data structure: the treap!
|
|
|
|
Finding out if/why a server is dropping packets
|
|
|
|
Debugging netlink requests
|
|
|
|
What's a network interface?
|
|
|
|
Telling people what you're working on
|
|
|
|
Learning at work
|
|
|
|
Figuring out how to contribute to open source
|
|
|
|
How Kubernetes certificate authorities work
|
|
|
|
Cherry picking commits & shell scripting in golang
|
|
|
|
How does the Kubernetes scheduler work?
|
|
|
|
Linux tracing zine
|
|
|
|
Linux tracing systems & how they fit together
|
|
|
|
Notes on BPF & eBPF
|
|
|
|
3 short screencasts (/proc, tcpdump, strace)
|
|
|
|
a tiny whack-a-mole game
|
|
|
|
What can developers learn from being on call?
|
|
|
|
Awesome NLP tutorials by Allison Parrish
|
|
|
|
Log-structured storage
|
|
|
|
Iptables basics
|
|
|
|
A few things I've learned about Kubernetes
|
|
|
|
Async IO on Linux: select, poll, and epoll
|
|
|
|
Handwritten books
|
|
|
|
"Let's learn tcpdump" zine: now available for everyone
|
|
|
|
A small website mystery
|
|
|
|
Like zines about computers? You might love Bubblesort Zines
|
|
|
|
Using the Strict-Transport-Security header
|
|
|
|
New zine: let's learn tcpdump!
|
|
|
|
No feigning surprise
|
|
|
|
The fish shell is awesome
|
|
|
|
Some good "Statistics for programmers" resources
|
|
|
|
Making small culture changes
|
|
|
|
netdev conference, day 3
|
|
|
|
netdev conference, day 2
|
|
|
|
How to filter packets super fast: XDP & eBPF!
|
|
|
|
netdev conference, day 1
|
|
|
|
Slow down your internet with tc
|
|
|
|
Bash scripting quirks & safety tips
|
|
|
|
Blogging principles I use
|
|
|
|
ftrace: trace your kernel functions!
|
|
|
|
Writing down my career
|
|
|
|
So you want to be a wizard
|
|
|
|
Swapping, memory limits, and cgroups
|
|
|
|
Hiring & opportunity
|
|
|
|
How do these "neural network style transfer" tools work?
|
|
|
|
Weird unix thing: 'cd //'
|
|
|
|
How big can a packet get?
|
|
|
|
A magical machine learning art tool
|
|
|
|
Dissecting an SSL certificate
|
|
|
|
New zine: "Networking! ACK!"
|
|
|
|
Choosing the "best software"
|
|
|
|
A tiny zine about machine learning
|
|
|
|
An idea for a programming book
|
|
|
|
How do you make an awesome team?
|
|
|
|
Rules of programming experiments
|
|
|
|
How to ask good questions
|
|
|
|
Systems We Love 2016
|
|
|
|
A container networking overview
|
|
|
|
2016: Year in review
|
|
|
|
What's interesting about UDP?
|
|
|
|
How much memory is my process using?
|
|
|
|
More drawings about computers
|
|
|
|
Things to learn about Linux
|
|
|
|
"A Critique of the CAP Theorem"
|
|
|
|
Ideas about how to use AWS
|
|
|
|
Why cute drawings?
|
|
|
|
A few drawings about Linux
|
|
|
|
What happens when you run a rkt container?
|
|
|
|
Service discovery at Stripe
|
|
|
|
A few questions about open source
|
|
|
|
Running containers without Docker
|
|
|
|
A litmus test for job descriptions
|
|
|
|
Consistency vs availability (wat?)
|
|
|
|
What's devops?
|
|
|
|
Operations for software developers for beginners
|
|
|
|
What even is a container: namespaces and cgroups
|
|
|
|
Switching to Hugo
|
|
|
★
|
What happens when you start a process on Linux?
|
|
|
|
A list of Linux container software
|
|
|
|
"I just want to run a container!"
|
|
|
★
|
Getting things done
|
|
|
|
A swiss army knife of debugging tools: talk & transcript
|
|
|
|
Some questions about Docker and rkt
|
|
|
|
How I got a CS degree without learning what a system call is
|
|
|
★
|
Learning systems programming with Rust
|
|
|
|
New zine: Linux debugging tools you'll love
|
|
|
|
Asking good questions is hard (but worth it)
|
|
|
|
How (and why) I made a zine
|
|
|
|
Why do UDP packets get dropped?
|
|
|
|
Release it, then build it
|
|
|
★
|
How do you decide what to work on?
|
|
|
|
How does gdb work?
|
|
|
|
A few sketches
|
|
|
|
Benchmarking correctly is hard (and techniques for doing it better)
|
|
|
|
How do HTTP requests get sent to the right place?
|
|
|
★
|
Linux debugging tools I love
|
|
|
|
PolyConf 2016
|
|
|
★
|
Why do we use the Linux kernel's TCP stack?
|
|
|
|
Using ltrace to debug a memory leak
|
|
|
|
Should you be scared of Unix signals?
|
|
|
★
|
How to spy on a Ruby program
|
|
|
|
A useful new strace feature
|
|
|
|
Ideas for making better conference talks & conferences
|
|
|
|
Learning to like design documents
|
|
|
|
Three ways to solve hard programming problems
|
|
|
|
"advice" for aspiring tech bloggers
|
|
|
|
Notes from my PyData Berlin keynote
|
|
|
|
A few reasons to be skeptical of machine learning
|
|
|
|
Investigating Erlang by reading its system calls
|
|
|
|
homu + highfive: awesome bots that make open source projects easier
|
|
|
|
A second try at using Rust
|
|
|
|
A workshop on strace & tcpdump
|
|
|
|
What are SSL ciphers & session keys?
|
|
|
|
The Etsy site performance report is amazing
|
|
|
|
How does knowledge get locked up in people's heads?
|
|
|
|
CDNs aren't just for caching
|
|
|
|
you can take the derivative of a regular expression?!
|
|
|
|
Some links on Java garbage collection
|
|
|
|
Java garbage collection can be really slow
|
|
|
|
Looking inside machine learning black boxes
|
|
|
|
Some of my favorite blogs
|
|
|
|
I conquered thread pools! For today, at least.
|
|
|
|
Thread pools! How do I use them?
|
|
|
|
I/O matters.
|
|
|
|
How do you do capacity planning?
|
|
|
|
tcpdump is amazing
|
|
|
|
How does perf work? (in which we read the Linux kernel source)
|
|
|
|
Women-only spaces are a hack
|
|
|
|
Surprises in Ruby HTTP libraries
|
|
|
|
What is "the stack"?
|
|
|
|
perf top: an awesome way to spy on CPU usage
|
|
|
|
How to measure your CPU time: clock_gettime!
|
|
|
|
Why I love log files
|
|
|
|
Have high expectations for your computers
|
|
|
★
|
TIL: clock skew exists
|
|
|
|
How CPU load averages work (and using them to triage webserver performance!)
|
|
|
|
Fast integer sets with Roaring Bitmaps (and, making friends with your modern CPU)
|
|
|
|
Sendfile (a system call for web developers to know about!)
|
|
|
|
Guessing Linux kernel registers
|
|
|
|
Calling C from Rust
|
|
|
|
A few notes on my CUSEC talk
|
|
|
★
|
Why I ❤ Rust
|
|
|
|
Talking about stock options = awesome
|
|
|
|
Java isn't slow
|
|
|
|
Winning the bias-variance tradeoff
|
|
|
|
Surviving meetings while remote
|
|
|
★
|
Things you should know about stock options before negotiating an offer
|
|
|
|
2015: Year in review
|
|
|
★
|
How to trick a neural network into thinking a panda is a vulture
|
|
|
|
Women in Machine Learning 2015 (fun!!!)
|
|
|
|
Why Ruby’s Timeout is dangerous (and Thread.raise is terrifying)
|
|
|
★
|
How I got better at debugging
|
|
|
★
|
Why you should understand (a little) about TCP
|
|
|
|
Docker is amazing
|
|
|
|
PAPERS ARE AMAZING: Profiling threaded programs with Coz
|
|
|
★
|
A millisecond isn't fast (and how we made it 100x faster)
|
|
|
|
Is machine learning safe to use?
|
|
|
|
An argument for hiring junior developers
|
|
|
|
Some easy statistics: Bootstrap confidence intervals
|
|
|
|
AdaCamp Montreal 2015
|
|
|
|
A zine about strace
|
|
|
|
Learning at open source sprints (no preparation required)
|
|
|
|
A few spy tools for your operating system (other than strace!)
|
|
|
|
Seeing system calls with perf instead of strace
|
|
|
|
Senior engineering & fantasy heroes
|
|
|
|
Nancy Drew and the Case of the Slow Program
|
|
|
|
1:1 topic ideas
|
|
|
|
You can choose who submits talks to your conference
|
|
|
|
How the locate command works (and let's write a faster version in one minute!)
|
|
|
★
|
How gzip uses Huffman coding
|
|
|
★
|
How I learned to program in 10 years
|
|
|
|
A/A testing
|
|
|
|
Why a C++ programmer might say "I could never write Python"
|
|
|
|
Data Day Texas 2015
|
|
|
|
On reading the source code, not the docs
|
|
|
|
Programming doesn't belong to men (it belongs to me)
|
|
|
|
Fear makes you a worse programmer
|
|
|
|
Reproducing awesomeness
|
|
|
★
|
Diving into concurrency: trying out mutexes and atomics
|
|
|
|
Spying on Hadoop with strace
|
|
|
|
LD_PRELOAD is super fun. And easy!
|
|
|
|
PyData NYC (I gave a machine learning talk! yay!)
|
|
|
|
Harm reduction for developers
|
|
|
|
Fun with machine learning: logistic regression!
|
|
|
|
Fun with machine learning: does your model actually work?
|
|
|
|
What women in technology really think (150 of them, at least)
|
|
|
|
Working remote, 8 months in (seeing humans is important!)
|
|
|
|
How to set up a blog in 5 minutes
|
|
|
|
How does SQLite work? Part 2: btrees! (or: disk seeks are slow don't do them!)
|
|
|
★
|
How does SQLite work? Part 1: pages!
|
|
|
|
Strange Loop 2014
|
|
|
|
You can be a kernel hacker!
|
|
|
|
How is a binary executable organized? Let's explore it!
|
|
|
★
|
What happens if you write a TCP stack in Python?
|
|
|
|
Pair programming is amazing! Except... when it's not.
|
|
|
|
Open sourced talks!
|
|
|
|
Ruby Rogues podcast: systems programming tricks!
|
|
|
|
Fun with stats: How big of a sample size do I need?
|
|
|
|
How I did Hacker School: ignoring things I understand and doing the impossible
|
|
|
|
!!Con talks are up
|
|
|
|
Machine learning isn't Kaggle competitions
|
|
|
|
Asking questions is a superpower
|
|
|
|
Working remote, 3 months in
|
|
|
|
Should my conference do anonymous review?
|
|
|
|
Anonymous talk review is amazing.
|
|
|
|
Diving into HDFS
|
|
|
|
I can spy on my CPU cycles with perf!
|
|
|
★
|
Computers are *fast*!
|
|
|
|
Stopping to think
|
|
|
★
|
Don't feel guilty about not contributing to open source
|
|
|
★
|
Debug your programs like they're closed source!
|
|
|
|
♥ PyCon
|
|
|
|
Becoming a better developer (it's not just writing more programs)
|
|
|
|
"Ask if you have questions" isn't enough
|
|
|
|
Reports from remote-land: remote pairing works great!
|
|
|
|
Recovering files using /proc (and spying, too!)
|
|
|
|
My Rust OS will never be finished (and it's a success!)
|
|
|
★
|
Writing an OS in Rust in tiny steps (Steps 1-5)
|
|
|
|
Debugging shared library problems with strace
|
|
|
|
Hacker School's Secret Strategy for Being Super Productive (or: Help.)
|
|
|
|
Pair programming
|
|
|
|
More practical uses for strace!
|
|
|
|
Using strace to avoid reading Ruby code
|
|
|
|
A resume workshop idea
|
|
|
|
A bookmarklet to flee from Mailman archives
|
|
|
|
Spying on ssh with strace
|
|
|
|
"How was Hacker School?"
|
|
|
|
A few blogs I really like
|
|
|
|
Three steps to learning GDB
|
|
|
|
Sounding confident in interviews
|
|
|
|
CUSEC = fun
|
|
|
|
What my technical interviews have looked like
|
|
|
|
You should give talks. They will be awesome. Here's why!
|
|
|
★
|
4 paths to being a kernel hacker
|
|
|
|
Some things my kernel can't do
|
|
|
|
Sketches for a graph layout engine
|
|
|
★
|
Questions I'm asking in interviews
|
|
|
|
Coding strategies
|
|
|
★
|
When is "guys" gender neutral? I did a survey!
|
|
|
★
|
A pandas cookbook
|
|
|
|
Understanding how killall works using strace
|
|
|
|
Day 46: Never Graduate
|
|
|
|
Day 45: I now have Rust code for executing executables!
|
|
|
|
Day 44: qemu + gdb = so great
|
|
|
★
|
Day 43: SOMETHING IS ERASING MY PROGRAM WHILE IT’S RUNNING (oh wait oops)
|
|
|
|
Day 42: How to run a simple ELF executable, from scratch (I don't know)
|
|
|
|
Day 41: Linkers are upsetting
|
|
|
|
Day 39: Writing malloc wrong, for fun
|
|
|
|
Day 40: 12 things I learned today about linkers.
|
|
|
|
Day 40: Linkers are amazing.
|
|
|
|
Day 38: After 6 days, I have problems that I can't understand at all
|
|
|
★
|
Day 37: After 5 days, my OS doesn't crash when I press a key
|
|
|
★
|
Day 36: On programming without malloc
|
|
|
|
Day 35: Types in Rust, for beginners
|
|
|
|
How to call Rust from assembly, and vice versa
|
|
|
|
Videos from PyData NYC are up!
|
|
|
★
|
What happens when you run 'Hello, world'
|
|
|
|
Writing a kernel using rustboot & rust-core
|
|
|
|
Day 34b: Writing curl using my TCP stack
|
|
|
|
Day 34: The tiniest operating system
|
|
|
|
Day 33: How to make music with ClojureScript
|
|
|
|
Day 32: Magical Orchestra!!!
|
|
|
|
Day 31: Binary trees with core.logic!
|
|
|
|
Day 30: Making music in Clojure with Overtone. Clojure bugs with laziness! Fun!
|
|
|
|
Day 29: Trying out Emacs!
|
|
|
|
Day 28: Made a git workflow visualization webapp!
|
|
|
|
Day 27: Automatically testing changes in state! Visualizing my Git workflow! Floats!
|
|
|
|
Day 25: ACK all the things
|
|
|
|
Day 26: Trying to describe the TCP state machine in a readable way. Failing.
|
|
|
|
Women in Technology workshop at PyData NYC
|
|
|
|
Day 24: Unit testing this TCP library
|
|
|
|
Day 22: Got some TCP packets back!
|
|
|
|
Day 23: Started writing a TCP stack in Python
|
|
|
|
NYC Python talk
|
|
|
|
Day 21: Trying to TCP
|
|
|
|
Day 19: A few reasons why networking is hard
|
|
|
★
|
Day 20: Traceroute in 15 lines of code using Scapy
|
|
|
|
Day 18: ARP cache poisoning (or: In ur connection, sniffing ur packets)
|
|
|
|
Day 17: How to write a buffer overflow exploit
|
|
|
★
|
Day 16: gzip + poetry = awesome
|
|
|
|
Do Rails programmers use node.js? Visualizing correlations in command usage
|
|
|
|
Day 15: How a .gz file is structured, redux
|
|
|
|
Day 14: When it's hard to write tests, that's when I should be testing
|
|
|
|
Day 13: Off by one errors
|
|
|
|
Day 12: Why Julia likes Julia
|
|
|
|
Day 10: Goals. Goals? Maybe I need to be *reading* more code?
|
|
|
|
Day 11: How does gzip work?
|
|
|
|
Day 9: Bytecode is made of bytes! CPython isn't scary!
|
|
|
|
Day 8: Julia writes Julia! And remembers that open source is hard.
|
|
|
|
Day 7: An echo server in Clojure
|
|
|
|
Day 6: I wrote a rootkit!
|
|
|
|
Day 5: I wrote a kernel module!!!
|
|
|
|
Where to find bike sharing systems' data feeds
|
|
|
|
Day 4: Processes vs threads, and kernel modules!
|
|
|
|
Day 3: What does the Linux kernel even do?
|
|
|
|
Day 2: netcat fun!
|
|
|
|
Day 1: What does a shell even do?
|
|
|
|
Hacker School Day 1: Messing around with the stack in C
|
|
|
|
Hacker School Day -4: unit testing in C. checkmk!
|
|
|
|
Julia Serano's 'Excluded'
|
|
|
|
PyData Boston 2013
|
|
|
|
Open Data Exchange 2013
|
|
|
|
Transit maps: 1941 vs 2011
|
|
|
|
Graphing bike path data with IPython Notebook and pandas
|
|
|
|
Trying out Octopress
|
|
|
|
Montreal All-Girl Hack Night #2: now with cookies
|
|
|
|
Montreal All-Girl Hack Night #1: AMAZING
|