29 Monday Dec 2025
The last three posts (see here, here, and here) have taken us through Python’s standard tkinter module from the basics to a simple windowed application with a text window for editing and the usual features for loading and saving text files.
I mentioned in the second post that I’d “implement a simple word-counter to replace the calculator parsing and execution code.” That’s what today’s short end-of-the-year post is about.
22 Monday Dec 2025
In the last post we used the Python tkinter module (which is standard) to build a shell window for script-based calculator app. To do anything useful, the shell needs a back-end calculator object to implement script parsing and executing functions.
In this post we’ll look at code for a script-driven prefix calculator that can be easily extended to include other (mathematical) functions.
15 Monday Dec 2025
The previous post laid out the basics for creating windowing (GUI) apps in Python using the tkinter (Tk Interface) module. The module has been part of the standard library since Python versions 2.7 and 3.1.
In this post, as a small seasonal gift, I’ll start presenting a working GUI application — a script-driven pre-fix calculator with variables. Between the calculator code and its window code, there is too much for one post, so there will be (at least) a second part next week.
24 Monday Nov 2025
Posted in Fun, Interesting, Python
Python has included the Tk interface module (tkinter) since versions 2.7 and 3.1. The module is a binding to version 8.5 of the Tk GUI suite for making windowing applications. My first installed version of Python was 2.7, so I’ve been aware of the module for over ten years but never explored it.
At the beginning of this month, I decided to dive in. It led to an intense two-week bout of 12+ hour days, but I emerged with working apps (and my sanity). This post and ones to come document and share what I’ve learned.
17 Monday Nov 2025
Posted in Interesting, Python
The last two weeks I’ve been on a serious coding binge teaching myself Python’s Tk module. Once I wrap things up, I plan to publish a series of tutorial posts.
In the meantime, here’s a trick I learned recently that allows one to start with a series of data point and use those to (quickly!) generate a set of corresponding data points that are the derivative of the function implied in the first set. The trick uses something called the dual numbers.
29 Monday Sep 2025
Posted in Interesting, Python
Tags
I’ve been working on an arbitrary-precision numeric class (in Python) that stores numbers in what amounts to base-256 — that is to say, in machine-native binary. It differs from the variable-length integers in Python by supporting fractions (and from Python’s Decimal number type by being binary).
It occurred to me I could implement multiplication with a lookup table rather than actually doing the math (at the CPU level, that may be what in fact is going on). So, I thought I’d compare the two implementations.
16 Monday Sep 2024
I’ve never been particularly interested in puzzle games. Figuring out software has filled that niche for me (plenty puzzling enough). So, I’ve never done a Sudoku puzzle. Recently I read a post about Tredoku, which is a kind of three-dimensional Sudoku.
In that post was an unsolved Tredoku puzzle. I wasn’t tempted to try to solve it myself, but I did think it might be fun to see if I could write some Python to do it.
19 Monday Aug 2024
I recently learned about Bloom filters (and was then able to fully understand the joke in this xkcd comic). While I don’t have a good application for them myself, I found them interesting enough to play around with a little.
Python uses them under the hood in a way that has some potential for other applications. In this post I’ll explain Bloom filter basics and go over some simple implementations.
01 Sunday Oct 2023
Mathematician and educator John Baez has an excellent series of blog posts about music theory. The seventh concerns generating scales by using notes separated by fifths. Shifting the start point generates the seven major scale modes. Shifting the root key generates those seven modes in the twelve keys (a total of 7×12=84 scales).
John asked if any of his readers would be interested in creating that table of all 84 rows. It sounded like — and turned out to be — a fun exercise. This post explores in detail the Python solution I came up with.
22 Wednesday Apr 2020
Posted in CS101
Tags
computer code, computer programming, function currying, Python code, software design, software development
I saw a video recently about function currying, and it triggered the realization that currying might solve a problem I’ve been pondering in the context of language parsing. The problem involves knowing how many arguments an operator expects, what’s called the arity of an operation or function. It can vary from zero to many.
It occurred to me that, with currying, there could be a language where operations always take just one argument. That would solve a challenge for a mathematical expression language I have in mind.
The Hard-Core Coder 