All blog posts

1. My Interview with Eelco Visser on Parsing (May 16 2023)
2. Why Split Lexing and Parsing Into Two Separate Phases? (May 2 2023)
3. Displaying My Washing Machine's Remaining Time With curl, jq, and pizauth (April 11 2023)
4. pizauth: dump and restore (April 3 2023)
5. How Big Should a Programming Language Be? (March 23 2023)
6. Rust's Two Kinds of 'Assert' Make for Better Code (March 16 2023)
7. Scheduling my Electricity Usage (March 5 2023)
8. Why Aren't Programming Language Specifications Comprehensive? (February 16 2023)
9. Distinguishing an Interpreter from a Compiler (January 26 2023)
10. try_repeat released (January 25 2023)
11. Why We Need to Know LR and Recursive Descent Parsing Techniques (January 17 2023)
12. Compiled and Interpreted Languages: Two Ways of Saying Tomato (January 10 2023)
13. Software Security Research Position (January 9 2023)
14. How Might Generative AI Change Programming? (December 15 2022)
15. pizauth: differentiating transient from permanent errors (December 14 2022)
16. November Links (November 30 2022)
17. More Evidence for Problems in VM Warmup (November 15 2022)
18. What is a Research Summer School? (November 10 2022)
19. October Links (November 1 2022)
20. pizauth: another alpha release (October 20 2022)
21. UML: My Part in its Downfall (October 3 2022)
22. September Links (October 1 2022)
23. pizauth, an OAuth2 token requester daemon, in alpha (September 28 2022)
24. A Week of Bug Reporting (August 31 2022)
25. August Links (August 30 2022)
26. Making a Video of a Single Window (August 9 2022)
27. Two researcher jobs in soft-dev (August 8 2022)
28. Another Reorganisation (August 1 2022)
29. July Links (July 31 2022)
30. What's the Most Portable Way to Include Binary Blobs in an Executable? (July 25 2022)
31. CHERITech22 and PLISS 2022 (July 19 2022)
32. How I Clean my Glasses (July 13 2022)
33. June Links (July 1 2022)
34. What Metric to Use When Benchmarking? (June 30 2022)
35. Chance, Luck, and Risk (June 15 2022)
36. What Makes a Good Research Proposal? (June 8 2022)
37. May Links (May 31 2022)
38. Multiplicity Choices Are Hard to Model and Change (May 26 2022)
39. Using a "Proper" Camera as a Webcam (May 17 2022)
40. Programming Style Influences (May 10 2022)
41. snare: a Minimalistic GitHub Webhooks Runner (May 4 2022)
42. April Links (April 30 2022)
43. Where do Research Problems Come From? (April 28 2022)
44. Practising Programming (April 20 2022)
45. Making Rust a Better Fit for CHERI and Other Platforms (April 13 2022)
46. When is a Blog a Blog? (April 11 2022)
47. Static Integer Types (June 22 2021)
48. Automatic Video Editing (March 23 2021)
49. The Evolution of a Research Paper (January 19 2021)
50. Automatic Syntax Error Recovery (November 17 2020)
51. Stick or Twist? (October 7 2020)
52. Which Parsing Approach? (September 15 2020)
53. Alternative Sources of Advice (May 6 2020)
54. Minimum Times Tend to Mislead When Benchmarking (August 15 2019)
55. A Quick Look at Trait Objects in Rust (February 12 2019)
56. Why Aren’t More Users More Happy With Our VMs? Part 2 (September 19 2018)
57. Why Aren’t More Users More Happy With Our VMs? Part 1 (September 5 2018)
58. What I’ve Learnt So Far About Writing Research Papers (January 10 2018)
59. What Challenges and Trade-Offs do Optimising Compilers Face? (June 22 2017)
60. Fine-grained Language Composition (September 21 2016)
61. Debugging Layers (July 28 2015)
62. An Editor for Composed Programs (August 20 2014)
63. The Bootstrapped Compiler and the Damage Done (December 4 2013)
64. Relative and Absolute Levels (September 24 2013)
65. General Purpose Programming Languages' Speed of Light (April 9 2013)
66. Another Non-Argument in Type Systems (October 25 2012)
67. Server Failover For the Cheap and Forgetful (August 2 2012)
68. Fast Enough VMs in Fast Enough Time (February 8 2012, last updated February 7 2013)
69. Problems with Software 3: Creating Crises Where There Aren't Any (June 28 2011)
70. Problems with Software 2: Failing to Use the Computing Lever (June 7 2011)
71. Problems with Software 1: Confusing Problems Whose Solutions Are Easy to State With Problems Whose Solutions Are Easy to Realise (April 19 2011)
72. Parsing: The Solved Problem That Isn't (March 15 2011)
73. In Praise of the Imperfect (August 25 2010)
74. A Modest Attempt to Help Prevent Unnecessary Static / Dynamic Typing Debates (April 7 2010, last updated April 8 2010)
75. A Proposal for Error Handling (December 14 2009)
76. The Missing Level of Abstraction? (September 15 2009)
77. Good Programmers are Good Sysadmins are Good Programmers (March 20 2009)
78. How can C Programs be so Reliable? (November 11 2008)
79. Free Text Geocoding (September 1 2008)
80. Extended Backtraces (June 2 2008)
81. Designing Sane Scoping Rules (March 3 2008)
82. Some Lessons Learned from Icon (December 3 2007, last updated October 26 2010)
83. How Difficult is it to Write a Compiler? (August 9 2007)
84. When Are Macros Useful? (May 11 2007)
85. Filling in a Gap (March 21 2007)
86. Are Multicore Processors the Root of a New Software Crisis? (January 18 2007)
87. The High Risk of Novel Language Features (November 21 2006, last updated January 26 2008)
88. Evolving DSLs (October 17 2006)
89. More Meta Matters (August 30 2006)
90. Strategies for Dealing With E-mail (June 26 2006)
91. Debugging Driven Development (March 26 2006)
92. Make Exceptions Work For You (January 29 2006)
93. Home Directory Synchronization (December 10 2005)
94. SREP (October 3 2005, last updated October 7 2005)
95. Metacircularity (September 12 2005, last updated September 17 2005)
96. Timing setjmp, and the Joy of Standards (July 21 2005)
97. Text is Dead They Say (June 16 2005, last updated January 27 2008)
98. The Importance of Syntax (May 1 2005)
99. Predicting the Future of Computing (January 31 2005)
100. Tail Call Optimization (December 21 2004, last updated April 4 2006)
101. Language Orientated Programming (November 19 2004)