In this episode, Matt talks to Gabriella Gonzalez about how basic concepts from the branch of math known as abstract algebra can help us simplify our computer programs and organize our thoughts. Click here to download episode 147 of Elucidations.

Algebra. That thing they make us do in school. What was that again? Oh yeah, that’s right; it’s where you get to manipulate equations containing variables. Like, if I have an equation that looks like this:

$$ 2 \cdot x = 16 $$

Then I can divide both sides by two and get a new version where `x`

stands alone, i.e. *solve for x*:

$$ (2 \cdot x) / 2 = 16 / 2 $$ $$ x = 8 $$

If you took algebra in school, you might remember learning a bunch of
tricks for pushing parts of equations around to get one of the
variables to appear only on one side and thus *solve* for it. Being
able to solve for variables in equations proves useful for lots of
things: like, if you can translate a word problem into one of those
equations, finding the answer is often as simple as tinkering with the
equation in some obvious way.

Abstract algebra is somewhat similar in that it also involves manipulating equations containing variables, except the twist is that now you aren’t necessarily manipulating numbers anymore. The variables can stand for something else, and there are more general versions of plus-like, times-like, etc. operations that you can do on these other things. You might be wondering: what on earth could a variable in an equation stand for other than a number? Well, in this episode, Gabriella Gonzalez gives a bunch of examples. You can have equations for cooking recipes, for computer programs, for transactions performed on databases, and for regular expressions. (A regular expression is a special type of computer program for identifying strings that fit a particular pattern and pulling information out of them.)

Gonzalez then goes on to argue that the point of all this is to avoid re-inventing the wheel. Often, when you write a computer program to add some numbers, though this isn’t necessariy obvious at the time of writing, you aren’t actually drawing meaningfully on the fact that they’re numbers. If that’s the case, then what you can often do is make your code that adds things abstract so you only have to write your program once, but then you can re-use it on all these different other kinds of entities other than numbers.

The overall payoff of all that, according to this month’s distinguished guest, is that by following algebra-driven design, you can keep your code simple and easy to understand, while still having it do fancy things. This is particularly important today, when our software just seems to keep getting fancier and fancier, but the usual ways of accomplishing that goal make it unreliable and well nigh impossible to keep up to date.

Join us as Gabriella Gonzalez gives us the tour through various algebraic systems that occur all over the place in computer science, philosophy, and linguistics!

*Matt Teichman*