Recently I posted an oldie from the last century. Here’s another from the deep time layers of my file system. It’s a poetic parable any programmer can relate to.

Think of it as the programmer’s version of Sisyphus.

**26**
*Friday*
Aug 2022

Posted Fun

inRecently I posted an oldie from the last century. Here’s another from the deep time layers of my file system. It’s a poetic parable any programmer can relate to.

Think of it as the programmer’s version of Sisyphus.

**03**
*Thursday*
Mar 2022

Posted Fun

inIt’s been a while since I posted here, many balls in the fire and irons in the air, so I thought I’d dig into my archives for an oldie, albeit one more of tin than of gold.

This one comes from a 1995 email from a co-worker who was forwarding something cute she’d found in a Delphi Forum.

**10**
*Friday*
Dec 2021

I’m not sure how I got to thinking about **Turing Machines** (**TM**s). I was going through some files recently and spent some time looking at `busy-beaver.c` (from 2017 according to the file date). It contains an implementation of a TM. But something else got me speculating about my own implementation; I just don’t recall what.

I decided to actually write it when it occurred to me that I could use a Python generator to implement the Turing Machine *tape*. Sadly, I didn’t think of it in time for the trilogy I just published about Python generators (**part 1**, **part 2**, **part 3**).

**10**
*Wednesday*
Nov 2021

in

**Tags**

computer code, language design, little programming language, Python code, recursive descent parser

Last time I introduced a general **Definition Language** (**DL**) I created for defining structured information. The end goal was an extension of DL, called Data Definition Language (DDL), intended for defining memory and file formats. It was intended for tools that examine that data, allowing them more knowledgeable output than a raw hex dump.

I mentioned that DL has been on my mind lately, and as it turns out I spent the day yesterday writing a DL parser in Python.

**01**
*Monday*
Nov 2021

in

**Tags**

I haven’t put nearly the energy into this blog as I have my main blog, ** Logos Con Carne**. My intentions are good, but somehow I never seem to get around to posting here. (It’s certainly not due to lack of interest.)

In an attempt to get more in the habit, I thought I’d write about some simple fun I had recently with a class for calculating polynomials. It was inspired by a lesson from a set of really fun Python tutorial YouTube videos.

**01**
*Tuesday*
Sep 2020

**Tags**

Cartesian product, computer code, Japanese multiplication method, math, multiplication, Pillow (PIL fork), Python code

On my regular blog I just posted about a Japanese visual multiplication method. It’s a cute trick that ties into the notion of grid multiplication techniques. (In general, multiplication techniques are of some interest due to the Mandelbrot set, which requires multiplying large numbers lots of times.)

It turns out code to generate the patterns was a lot easier than I thought it would be. The hardest part was generating the diagonal summing lines.

**15**
*Friday*
May 2020

Posted Fun

in**Tags**

This post contains some simple code for calculating the square root of 2 and then generating the bits of the value.

It’s a companion to a post on my other blog.

**07**
*Thursday*
May 2020

in

Last time I showed you the functions necessary for Life — for John Conway’s *game* of Life, that is. We ended up with a set of functions you can use to generate frames of a Life session.

This time I’ll show you an object-oriented version (a Life class) along with some other tweaks to make things look nicer.

**03**
*Sunday*
May 2020

in

You may have heard that mathematician **John Conway** died last April. To his everlasting dismay, most people only know him for his “game” of **Life** (which he considered trivial and inferior to his real mathematical work). Unfortunately for Conway, his Life game is fascinating.

To honor his passing, I whipped up a Python version that I thought I’d share. Python is about the only language I’ve used a lot in which I’ve never implemented Life, so high time I did, right?

**27**
*Sunday*
Oct 2019

Earlier this month, on my other blog, I wrote about **the Playfair Cipher**, a polygraphic substitution cipher invented by Sir Charles Wheatstone in 1854.

At the time I mused about writing some Python to automate using the cipher, and now I’ve done that, so here it is: