Projects

Completed

StatSort:

Statistical Sort

I wrote this so long ago I don't even remember what language I did it in. It's an algorithm that in practice sorts numeric keys in O(n) time (worst-case performance is O(nlogn)). It works by doing a numeric integration of a histogram of the keys in order to predict key placement in the sorted output.

HISM:

Hankins Incremental Storage Manager

I wrote this years ago. It's a Modula-2 library to manage memory allocation and do automatic incremental garbage collection. It was meant for use in environments where system responsiveness is more important than raw speed, such as interactive or real-time programs. I published it on Usenet, and you can get find it at Google Groups with search terms "hism hankins". You can also download it here as a zipped or tar/gzipped archive:

• hism.tar.gz 10k
• hism.zip 18k

QDFC:

Quick and Dirty Flash Cards

This is a proof-of-concept for RecallMaster. It's a text-console based Java program that helps you memorize facts by repetition. It reads a list of "flashcards" from a file, then presents each question to the user, comparing his response against the correct answer. If he gets it right, qdfc goes on to the next card. If he doesn't, the program tells him the correct answer and repeats the question. The question is then repeated at increasing time intervals to ensure that he memorizes it.

As it has no GUI, and the code is rather ugly (hence the name), I haven't published it. I may someday clean it up and make it "RecallMaster Lite" freeware.

Peg Words:

Application of QDFC to mnemonic techniques

This is just QDFC with a flashcard file containing facts about memorizing "peg words", a mnemonic technique for memorizing long strings of numbers that I learned from The Memory Book by Harry Lorayne and Jerry Lucas.

Current

RecallMaster:

Program to aid memorization by repetition

This will be a Java program that helps the client memorize facts by repetition, in a manner similar to the flashcards that some of you will be familiar with from school. It presents a stimulus, accepts a response, and checks the response against the correct one. Clients who give the wrong answer are shown the right one and then the card is repeated at increasing intervals until memorized.

This is to be a commercial program, and the following features are planned:

• Installer
• GUI interface
• Customizable learning parameters
• Graphical stimulus-response pairs (such as clicking the correct icon or menu item) as well as text-based stimuli and responses
• Support for behavioral learning techniques such as backwards chaining and progressive omission
• Card "shoes" that can contain multiple decks of flashcards or other shoes
• Deck authoring tool
• Software available stand-alone or as a thin-client web service
• In-program help as well as user manuals

Future

SuperToDo:

To-Do program incorporating dependencies and priorities

This is to be another commercial program. Features planned:

• You can break down a task into subtasks, and each subtask into sub-subtasks, etc. The program will check off the main task when all of its subtasks are complete
• The program will tell you what you should be working on next, based on priority
• You can assign a priority to each task, and this will be inherited by its subtasks
• You can assign a deadline to a task, and its priority will increase as the deadline approaches
• You can assign triggers to tasks so that they won't start until a date has passed or an event has occurred
• The program will maintain a done list so you can see your progress
• The program will help you estimate how long a task will take
• You can register partial completion of a task
• You can add recurring tasks

XPWorkFlow:

Bring automation where possible to the Extreme Programming process

Features still foggy, but main ones are:

• Similar to SuperToDo, but with multiple people
• Groupware; allows collaborative input and direction
• Tracks XP process and helps direct members as to most important task to do next, when things are due, etc.
• Incorporates XP documents to build dependencies and direction
• Automates daily builds and automated regression testing
• Maintains project statistics such as project velocity

jDROOL:

Java-based Concurrent Futures, Prototypes and Delegation Library

This will be a library for experimentation with ideas in concurrency and variations on object-oriented programming semantics. The primary items being played with will be:

• Transparent concurrency using implied futures, and the Command pattern to deliver messages asynchronously from a breadth-first queue rather than the usual depth-first synchronous call-return model.
• Prototypes instead of classes; all objects are instantiated by cloning an existing class. New kinds of objects are created by modifying an existing object (i.e. adding or removing members)
• Delegation instead of inheritance; any object can be delegated to
• No primitive types; *everything* is an object (similar to Smalltalk)
• No compilation

OOVM:

Virtual machine with object-oriented architecture

This will be a program for playing with the notion of a machine architecture that's not procedural but instead object-oriented. Some ideas to play with:

• Addresses are addresses of objects rather than ordinary memory locations
• No registers
• Instead of instructions per se, messages. Every machine level object has a set of built-in methods
• Messages are also machine objects, as are user-defined methods
• The state of a machine object is its delegate, a pointer to its methods, and some data

Neoterica:

Artificial Life platform

I've already defined the instruction set for this and the ancestor program. What's needed is implementation and instrumentation so that the progress and activities of the organisms can be visualized.

RunAsPlus:

Let restricted users run selected Administrator programs

The problem is that many older but still popular games (such as Diablo II) must have Administrator privilege to run. Unfortunately, this leaves Parent with an irritating choice: the parent has to either

1. give the kid's account Administrator privilege,
2. use RunAs and type the password in every time the child wants to play,
3. log on with an Administrator account and let the child play from there, or
4. not let the child play games that require Administrator.

(2) and (4) are safe but restrict the child's access to the game. (1) and (3) are what most parents will do, but this leaves security wide open. The next thing the parent knows, he's getting a lawyer letter from the RIAA because his kid installed KaZaa and is hosting Britney Spears porn files.

What's the solution? Provide a secure program that invokes RunAs and types in the password (but only for an Administrator-supplied list of programs). A simple VB sendkey script would do it, but would not be secure. What would be better is something along the lines of a service running as Administrator that launches the program in question when a client program asks it to.