When you want to measure program performance, you can code up a micro-benchmark or you can time a program on the command line (a macro-benchmark). Both are tricky to get right. I wrote BestGuess to make command-line benchmarking easy and accurate, after trying other solutions.

This post is a list of favorite books and blogs on programming and programming languages. The real treasures are the individual blogs.

I refrained from listing individual books – there are too many – and give instead two book series. There aren’t too many “aggregator” sites that I follow, but I name some. Below those are the gems: lots of individual blogs on a wide variety of topics by some amazing people.

This post is part of a series, though it can be read independently of the others:

• Part 1: Regex and Unicode
• Part 2: The Four Eras of Regex
• Part 3: Back references in regex and grammars (this post)
• Part 4: Why is everything on fire? (forthcoming)

Today, I want to talk about the back-reference feature of regex, and how we can extend it to grammars, in particular to Parsing Expression Grammars. For a few years now, we have had an experimental implementation of back references in the Rosie project. With some experience using the feature, we are ready to remove its experimental status. In the next release, Rosie v1.5, it will be a supported feature, so it’s time to describe it in detail.

Background, specifically my own

I left IBM in the summer of 2018 (after 19 years) to become a professor again, accepting a teaching faculty position in the Computer Science Department of NCSU. This position is not tenure-track, and my primary responsibilities are in teaching and service, not research. Part of teaching, broadly speaking, is curriculum development, and my industry experience puts me in a good position to make positive contributions there.

I’ve been doing some whole-program benchmarks, measuring run times, and seeing the usual noisy results. When I explained the various sources of noise to my fiancé, a data scientist, she asked me how much I really knew about that noise, and if she could look at the data. This post is about the result of that conversation.

This post is part of a series, though it can be read independently of the others:

• Part 1: Regex and Unicode
• Part 2: The Four Eras of Regex (this post)
• Part 3: Back references in regex and grammars (forthcoming)
• Part 4: Why is everything on fire? (forthcoming)

In Part 1 of this series, I explored a number of obstacles to using regex reliably in our Unicode world. I didn’t intend to write that post. It came about because I was examining the regex look-behind operator after seeing some variation in how it is implemented.

The original title of this post was Regex look-behind, Unicode, and a world of corner cases. I started writing it while looking (too) closely at how the look-behind operator (?<= … ) works in regex. I’ve since split that post into several:

Testing. Testing. Is this thing on? Yes?

Well, ok then.

When I started writing the blog for the Rosie Project, to announce releases and talks, and to talk about how to use the Rosie Pattern Language, I also created a space for this personal blog.