Over the years, of course, I have worked on a variety of projects. Some useful, some experimental, some boring. Mostly for employers or clients, some for myself. A lot has been lost to time, and obviously a lot is owned by other people, but what I can find, by all means enjoy.
(Don’t care? Head back to the main page)
I lean heavily towards “copyleft” or (to use Creative Commons terminology) share-alike licenses. As the world has shifted more in the direction of more liberal licensing, I’ve taken the path from a position of “only public domain counts” and dividing my work into things I might sell and things I want to share (mutually exclusive sets) to thinking I finally understand the point of the GPL and similar licenses.
For me, I now find value in my projects being available, in the sense that people can work with them even if I (or a hypothetical company who uses it) vanish. A BSD/MIT-style license doesn’t cut it, because those projects can too easily vanish behind a paywall and become proprietary. While I understand the occasional complaint that a GPL-style license makes it more difficult to integrate code into a proprietary system—I used to make those arguments, after all—that’s literally asking developers to work for large companies for free.
So, if some big company wants to (inexplicably) use my code but can’t deal with the license, remember that this is a public license. If you’re not willing to repay me by making your changes available (the licensing terms offered to the general public), there are certainly other ways to repay me—money comes to mind—so make me an offer…
With that, back to the actual software.
The project I get the most use out of—in fact, I run it constantly—is uManage.
For a long time, I’ve wanted to keep track of where I spend my time on the computer, if only to get a sense of how much time seems productive and wasted and what I spend attention on but don’t really use. When I looked for time-tracking applications, however, everything I found was paid, required regular manual input, or didn’t allow direct access to the raw data.
Recalling that the (old) Win32API had functions for getting the
title of the window in focus, I looked for an equivalent under Linux,
since I’ve been an Ubuntu user since around 2011. I settled on xdotool,
prototyping the core feature—logging how long each window is
in focus—in a shell script in an afternoon, then developed a
more useful solution in C using xdotool’s API,
adding configuration, an interface, some arbitrary logging features,
and recording to an SQLite
database.
It’s not perfect. Once in a long while, the GTK+ calls trigger a crash with an X server error that I haven’t tracked down, it could access the database in a safer manner, and there’s a handful of features I would like to add, for a few examples. But it does the job and I gather about five megabytes of data per month that lets me quickly keep track of what I’ve been working on, even for a few seconds.
Additionally, I have started working on reports to dig into the activity database and get a sense of the biggest time sinks and attention span. As I have more time to dig into the data and into R, I’ll add to the range of the report.
Note that, while I developed uManage specifically for
Ubuntu and so the graphical interface relies on the notification
bar API, most of the core functionality should be usable
in the command-line version, which would run anywhere that
xdotool runs, meaning most X-based systems.
At some point, I had the thought—similar to tracking the windows in use—that it might be possible to estimate quality of sleep and possibly general health with a simple test of fine reflexes and basic memory on waking up; slower and clumsier would indicate possible problems. The most straightforward test I could think of, since I touch-type, was typing some randomly-generated letters.
I wrote a command-line version in C, Type Time-old, first, and I still use that in conjunction with a script that I run overnight. Wanting something that could potentially integrate with uManage, I also cooked up Type Time in C# and using GTK+ for the user interface.
It appears that there might be some correlation. There are a lot of factors that interfere with performance, of course, but comparing the logs with my sleep and other information, it does seem that the idea holds. Further than that hand-wavy idea is, of course, going to take more thorough analysis of the data. It is definitely promising, though.
One thing I’ve learned over many years of teaching is that
word processors are not future-proof. I have needed to move my lecture
notes from system to system and/or fuss over styles more times than I
care to count. The last straw was moving to OpenOffice and realizing
that the implementation of Office Open XML (.docx)
didn’t include styles as Microsoft’s styles,
making switching styles for printouts (my notes and outlines) difficult
before class where they had Microsoft Word installed.
Class Management is the result of that frustration. It is a set of shell scripts that use antiword, GPP, Pandoc, and PDFtk to take my old notes, convert them to Markdown (which I can easily keep under source control for more permanent storage), and convert the Markdown to convenient PDF packages.
Soon, I also built a special-purpose grading database from CSV files rather than continue on with spreadsheets for each class. Like with the Markdown files, moving to CSV makes it easy to store under source control, which in turn makes it easy to see when I graded assignments or changed grades, complete with an explanation of why in the commit message.
The upshot is that I now need a handful of tools I would use regardless and some standard Linux utilities, rather than a word processor and spreadsheet. That’s easy to find, at least on a single machine long enough to generate the PDFs.
Over at the Digital Comic Museum and similar sites, we have a somewhat steady stream of recurring problems, like mis-numbered pages, extra files in the archive, bad crediting when pages are reused, and a difficulty in keeping track of the latest version on evolving scan projects.
This is the first part (of two; see Scan Data, below) of my attempt to use the nature of the problems to solve other problems. Comic Scanner is a Java applet (development ongoing) that recommends improvements to comic archive files while harvesting file metadata to be stored on a Scan Data server for later use.
If you’re looking for a Java project that will do some good for preserving public domain content, I would be happy to have the help.
Counterpart to the Comic Scanner project, Scan Data is the Ruby on Rails application (yet to be deployed formally) that gathers the file metadata and presents it to both the people scanning comic books and, given viewer software that takes advantage of the API, readers.
The plan is for viewer applications to notify users when a more recent scan is available and what is different. This should also lend itself to managing libraries of scans by identifying duplicates and recommending canonical organization and file names that can be adjusted, ideally.
Like Comic Scanner, if you’re looking for a straightforward Ruby on Rails project that should be of use to people, I’m probably not going to say no…
In working on uManage and a couple experimental projects, I dipped into GTK+ user interface programming. It struck me as fairly primitive. The documentation all seems to suggest that everybody programs by creating the entire interface programmatically on demand, complete with layout. Bleh.
I found Glade, but there was still a lot of manual work to do connecting the generated layout to the various code for actions. Glade Glue is a quick script to solve that for C programs by generating a header and defining variables for the controls and some connection/initialization code.
There are features I would like to eventually add, such as building data structures that match the layout, generating handler stubs when they don’t already exist, and maybe supporting additional target languages. The next time I work in GTK+, I’ll give it some thought.
Most other projects I have available are—at least at this time—more along the lines of interesting diversions and the cores of possible future projects than anything directly useful. Oh, and there are a few small games.
(Don’t care? Head back to the main page)
Rust struck me as a potentially interesting language, so when the first official release came near, I put this together to give it a look. Phauxfiles tries to look like a user search from a generic social network.
It takes the names and the profile pictures from public APIs and displays the fake users either as text output printed to the console or served like a web page.
Rust turns out to be an excellent language to work in. This project didn’t lend itself to a full investigation of Rust’s ownership model, so my understanding of it is still primitive, but it works as advertised and the language has a large number of modern conveniences. I may start using it routinely in place of C for utility work.
I put City Automata together when I started looking at A Pattern Language. I started wondering if municipal design could be automated.
While I never plugged in any of the patterns, this should be a reasonable start for such a thing. The basic premise is that people try to move to the site with the highest value for the cost and value is determined by access to other people. This leads to an even distribution of people, but my hope is that encoding some of Alexander’s patters can show more interesting distributions.
The ideal result would be if the distributions allow for the generation of realistic random skylines.
Years back, I had the thought for an e-mail client that would proactively work in plain text (extracting text from content) and performing some basic analysis on the resulting text, such as estimating sentiment, collapsing common messages, and identifying scams.
The last feature, which has obvious applications beyond e-mail, is prototyped in Ruby as Keywords. To keep the prototype to the minimum possible useful operation, it reads in a text, removes the common English words (which tend not to carry much information), converts words to stems, and uses DuckDuckGo to search Snopes for the most common remaining words in the text, outputting the Snopes assessment of the premise.
Let me repeat that this is a prototype and should not be used seriously. A handful of keywords doesn’t necessarily uniquely identify every document. There is no error-handling. HTML structure is assumed to be constant with no flexibility. It basically scrapes a site that has no public license. It proves that the concept might be workable, but nothing more than that.
Every once in a while, I need plausible-sounding random text. Well, I guess “need” might not be the right choice of words, but you get the idea. Regardless, a Markov process is a nice way to accomplish that goal, and it also often makes a nice example of straightforward, data-driven algorithms.
For both purposes, I put together Markov, which uses a type parameter in the main code that allows the use of non-textual input and output.
I have always been interested in genetic programming, but always had trouble seeing past the examples and demonstrations that tried to assemble unstructured programs from independent instructions. The results are invariably only a first step to actually solving the problems set to them.
A while back, the possibility occurred to me that, just like with biological organisms more or less work, it might be possible to encode the “genetic material” as if the program was meant to be structured, giving the syntax a level of semantic utility. So, VerdigrisGenes encodes both the instructions of a program, the structure into which those instructions execute, variables, and so forth.
As a result, all generated programs are valid enough to run and most should run to completion. And the results over many generations aren’t terrible. For very broad requirements, it is possible to evolve programs that solve some instances of a problem, though this can still use a lot of work.
When I discovered Open Weather Map and its API, I decided to get a sense of what programming in Python feels like, since its programmers all defend it like a religion. So, I threw together the Unnamed Cheapo Weather Client, which pulls forecast data down through the API and displays it in a graphical interface.
It’s hideous and inflexible, but it does work.
I remain unconvinced that Python is anything special, though. Nothing about it seemed to make errors more difficult, make any processes more convenient, or otherwise recommend itself over any other scripting language. It’s not bad, just nothing special.
There isn’t much of a story, here. I decided I wanted to take a good look at the Scala language and the first project that came to mind was to implement Go Fish.
Given that fascinating history, it didn’t turn out badly at all. The game is a console-based interface that plays between the user and a computer player, cleverly named “First Player” and “Second Player,” but it wouldn’t be hard to make it configurable.
For what it’s worth, Scala strikes me as a solid language. Despite having a strong functional influence—which I wasn’t previously familiar with—it was fairly straightforward to learn and there are some clever idiomatic solutions to common problems.
Before I dug into uManage as described above, as mentioned with Glade Glue, I ran some quick experiments with GTK+ user interfaces. Tikili-li-Takili-li-Ptoe was the most significant, and guided a lot of what I did for Glade Glue.
As a game, it’s pretty terrible. The game is just a two (human-only) player tic-tac-toe game that I believe catches all the possible winning conditions. The name, with the Edgar Allen Poe reference(s), is probably the best part about it.
An invisible object is in orbit around your screen. Click where you believe the object should be and it will appear briefly, confirming whether you hit or miss and potentially betraying its speed and orbit radius. You cannot click during this period of visibility.
That’s the whole game. The score, a simple count of hits and misses, is kept in the lower-right corner. Every fifteen seconds, Chasing Phantoms randomly changes the center, radius, and speed of orbit.
It’s a reasonable time-killing game, but more usefully, is a simple but functional example of using HTML and JavaScript for a game.
Another early package I developed is the (I should have considered trademark law back in the day) Virtual Etch-a-Sketch for Windows. In a Windows Programming class, I developed a non-skeumorphic dial control (works with right/left clicks) and the first thing that came to mind to do with it was a screen-based Etch-a-Sketch™.
I recovered a version from the same dusty hard drive. Unfortunately, it doesn’t appear to be the final version. Over the years, I used the program as a testbed for whatever programming ideas I taught myself. At one point, it had a network-capable terminal interface, a LOGO-like interpreter, export into multiple vector and CAD formats, and a groupware/collaborative mode. Sadly, none of those features are in the surviving version.
But that just means there’s a marginally newer hard drive somewhere…
In the meantime, I have renamed it Etch-en-Stein, so that a certain company that might own the relevant trademarks doesn’t feel compelled to sue.