August 2014

Reference Counting, Finalization and Resurrection

I've been enamoured of reference counting since devouring Smalltalk-80: The Language and its Implementation in 1987, and actively using it since reading Coplien's Advanced C++ in 1993.

Continue reading "Reference Counting, Finalization and Resurrection" »

February 2014

WireOver - Fast, Free, Secure File Sending

WireOver is a Mac, Windows and Linux application for sending and receiving files. It's easy to use and very low friction, requiring only entry of an email address and click on a received web link to set up. Receiving an unsolicited send is even easier, as acting on the receipt of the notifying email naturally associates that email with the recipient.

Continue reading "WireOver - Fast, Free, Secure File Sending" »

June 2013

Glass Ceiling

Glass Ceiling is the ultimate female revenge fantasy. In Glass Ceiling, our hero Moxie fights her way up the corporate ladder—literally. By battling fresh men, backstabbing co-workers, asinine accountants, bad bosses and other office stereotypes.

Continue reading "Glass Ceiling" »

June 2012

Unwind_SjLj the Top Items in Your Profile?

You've been diligently optimizing your iOS application -- static and stack allocations instead of dynamic, inlining code and removing virtual invocations that turn out not to be needed, algorithmic simplifications ... you know, the usual. You expect to see 'operator new' and 'operator delete' working their way up your profile, but what are '_Unwind_SjLj_Register' and '_Unwind_SjLj_Unregister'?

Continue reading "Unwind_SjLj the Top Items in Your Profile?" »

March 2012

SPARKvue Augmented Reality

Working with Sally Ride Science and PASCO I extended the desktop version of SPARKvue to support augmented reality views of the experimental setup.

Continue reading "SPARKvue Augmented Reality" »

February 2012


Representations of rectangles and points are essential in any system working with graphics. Every API and many applications define their own. Depending on the era of the API there may be a full suite of algebraic-style operations, or the types may be simple data carriers with a handful of manipulating functions provided.

So what happens when bodies of code collide? Well, we end up with ad hoc transference of information from one representation to another, and chunks of code using a rich representation just look different from chunks using something more primitive.

Continue reading "Cartesian" »

November 2011


The MOTOACTV communicates with servers to share and manage its user's fitness information. The device is very small and interacting with a complex network configuration UI is not viable. So, when tethered, it communicates through an HTTP proxy I wrote that runs on the user's desktop machine.

This is not my first full HTTP proxy; that was the desktop component of iMobimac Modem. In this case there were a couple of requirements that made things interesting.

Continue reading "MOTOACTV HTTP Proxy" »

May 2011


As a new parent, especially once the children started at school, I was amazed at the number of prescriptions for minor ailments that we'd have to manage at once. Hence the iOS application Wellness!, developed in collaboration with IRMAcreative.

August 2010

Smalltalk in Byte Magazine, August 1981

Smalltalk has been immensely influential over the years, in some respects never more so than today (see Objective-C and Ruby). It was unveiled in the August 1981 edition of Byte. Most of that issue's editorial pages were dedicated to articles on the language, its implementation, the integrated programming environment it provided and some discussion of practical applications.

Continue reading "Smalltalk in Byte Magazine, August 1981" »

July 2010


A couple of projects required that I get fairly serious about working with Javascript. And like so many I found a nice little language muddied by the vagaries of DOM implementations and some unfortunate syntax edge cases. The flexibility of having functions as a first class entity was something I'd been aware of in the abstract, but working in Javascript really drove it home. About the same time I had to do real work with Objective-C and Cocoa, both on Mac and iPhone.
The compositional flexibility of Javascript and Cocoa was liberating and disconcerting. After all there's real utility in the rigidity of C++'s type system; the compiler becomes an ally in the exploration and definition of a problem's characteristics. But those Javascript and Objective-C callbacks are themselves compelling.

Continue reading "Callable" »

June 2010


Multiplexing comms over a single bidirectional channel is a useful ability. ZStreamMUX has proven itself, but to support fully bidirectional substreams it uses a pair of threads for each MUX instance, and another thread for each pending listener. For RPC-ish situations this is overkill.

Continue reading "Natter" »

April 2010

Jabber (XMPP) and AIM (OSCAR)

To integrate with existing social networks, the team at Zorap defined a mechanism that passed structured information via instant messages. My role was to implement Jabber (XMPP) and OSCAR, the AOL instant messenger protocol, in a portable and robust fashion.

Continue reading "Jabber (XMPP) and AIM (OSCAR)" »

April 2009


YadTranscode is a useful little command line tool. There's a bunch of data formats out there that might look different at first glance but on reflection can be seen to be isomorphic.

Continue reading "YadTranscode" »

March 2009

ZooLib BBDaemon

The ZooLib BBDaemon lets multiple Mac applications talk to USB-connected BlackBerrys concurrently. Obviously this is something that Research in Motion could make possible, but as they haven't we're posting a pre-built installer that takes the pain out of getting things working.

Continue reading "ZooLib BBDaemon" »

February 2009

The Missing Sync for BlackBerry

Mark/Space has released The Missing Sync for BlackBerry 2.0. This latest version provides a rich suite of synchronization options, made possible by a device-side Java application developed by Electric Magic. The Mac application uses our ZBlackBerry Mac/Black SDK for its USB communications.

December 2008

Zorap, Web-Based Video Chat

Zorap web pages are multi-party multimedia environments. Video from your webcam and audio from your microphone, photos, music and video from your own computer are shared to tens of your friends via a Zorap Server. Web content, including YouTube and other video sites are similarly shared, all in an exciting and customizable drag-and-drop interface.

Electric Magic implemented the Mac-specific portions of the Zorap web plugin, supporting Safari, Firefox and other modern web browsers.

September 2008

SiteGrinder Photoshop Plugin

If you’re a Photoshop virtuoso, MediaLab’s SiteGrinder carries those skills over to the creation of exciting web pages. The SiteGrinder Photoshop plugin takes your document’s layers and attributes, crunches through them and generates HTML, CSS and optimized web graphics ready for the public.

SiteGrinder’s UI is beautifully implemented in Flash, and Electric Magic helped MediaLab get that UI working in older and newer versions of PhotoShop.

July 2008

OS X Accessibility from Java

Our client’s application is a scriptable form-filling engine, used by their customers to automate computer-based form submission. Their engine is written in Java, and uses the Abbot GUI testing framework to drive third-party UIs. For Mac OS X support we implemented a JNI shim that made the AX API usable from Java.

March 2008

Mac/BlackBerry SDK

The BlackBerry is a very popular mobile communications device. Official Mac support from Research in Motion is limited to providing the PocketMac utility as a free download. With no official SDK the Mac/BlackBerry ecosystem has seen very little activity.

ZBlackBerry is a suite of code that implements the BlackBerry USB communications protocol in a generic fashion. A few hundred lines of code let Macs use that protocol. A few hundred more allow multiple Mac applications to talk to a single BlackBerry simultaneously, something that has not been possible till now.

Continue reading "Mac/BlackBerry SDK" »

January 2008

iMobimac Modem

The Research In Motion BlackBerry is famous for its connectivity. iMobimac Modem runs on a BlackBerry and the Mac to which it is connected, and lets Mac applications access the Internet using the BlackBerry's connection.

Continue reading "iMobimac Modem" »

October 2007

Embedding Lua in Zen

Lua is a very nice little programming language, which combines a clean C-ish syntax with the power of Scheme. Rather than requiring a particular programming style it provides building blocks that allow one to work in any combination of object-oriented, functional or imperative styles. Lua is something of a hidden gem, having found a keen but un-publicized audience amongst game developers who generally use it for scripting in-game behavior. My interest in it is to provide customizability of behavior in the Zen home automation system.

Continue reading "Embedding Lua in Zen" »

May 2006

Knowledge Forum 4.6

Knowledge Forum 4.6's minor version number change belies just how different from its predecessor it really is.

Under the hood KF 4.6 has moved from using ZDBase for its backing store, instead using a tuplebase. This makes it possible to split HTML page generation into separate processes, potentially running on multiple front end machines. It also restores support for a rich client application, now written in Java, using ZTSoup to efficiently communicate changes in the tuplebase, whether made by other clients or by the web interface.

January 2006


WebDAV is an extension to the HTTP protocol. It is the basis for Apple's iDisk and Windows' Web Folders, standard features of Mac OS X and Windows XP. It is thus the easiest way for a server to make data available to a client machine without requiring that client software be installed first.

ZooLib provides a generic WebDAV server. Your application need only implement subclasses of ZNodeRep to represent nodes in your desired hierarchy. Standard subclasses of ZNodeRep let you lay one tree over another, or expose part of the server's file system to clients.

Continue reading "WebDAV" »

December 2005

Windows Services

UNIX does not make an explicit distinction between programs that are servers vs programs invoked by a user. Each flavor of UNIX provides a mechanism for the management of these programs, generally by using naming and placement conventions of descriptor files in the file-system.

In contrast, Windows NT/XP supports servers with a specialized API and management tools. Windows services are packaged as regular applications, but when they are invoked by the service framework they register a callback with that framework to which status and control messages can be delivered.

Continue reading "Windows Services" »

May 2005

ZTSoup: UI-Friendly Tuplebase Access

The tuplebase API is well-suited to data processing needs. But it's clumsy as the mechanism by which data in a tuplebase is to be presented and maintained in a live UI, rather than web pages or generated reports.

ZTSoup gets its name and inspiration from the Apple Newton concept. A ZTSoup is backed by the same data as a tuplebase, but that data is accessed by instantiating a ZTCrouton for each tuple that code is interested in, and a ZTSieve for the result set of any query of interest. Why the funny names? A soup has croutons floating in it, interesting ones are sieved out of it.

Continue reading "ZTSoup: UI-Friendly Tuplebase Access" »

May 2004

Java Tuplebase Access

Initially I provided Java access to a tuplebase instance by implementing Java classes whose most interesting methods were marked as native, and thus invoked via JNI. This was very powerful because Java could use any tuplebase implementation simply by calling the appropriate factory function and I could expose any existing C++ functionality simply by implementing the appropriate JNI glue.

Continue reading "Java Tuplebase Access" »

August 2003

Knowledge Forum 4.5

Knowledge Forum 4.5 was a significant refinement of Knowledge Forum 4.0, with a much richer web interface, although still constrained by the need to support Netscape 4.x-era web browsers.

Continue reading "Knowledge Forum 4.5" »

May 2003


ZDCPixmapBlit uses templates to generate the code for source/destination and source/matte/destination blitting, matte/destination filling, and destination-only munging, using the four Porter/Duff composition operators Copy, Over, In and Plus.

November 2002

Electric Fence and Threads

Electric Fence is an immensely useful library written by Bruce Perens. It uses the standard UNIX memory mapping API to put guard pages on either side of memory allocations, thus causing a segment violation as soon as your code writes where it shouldn't. I made a few small changes to make it possible to use from a preemptively multi-threaded application.

November 2002

Web Browser Plugins

ZooLib's UI code requires only that there be a ZFakeWindow-derivative at the top of the enclosure hierarchy. In the distant past ZooLib included implementations of ZFakeWindow for Mac control panel cdevs, HyperCard XCMD windows, MacroMind Director XObject windows, Zoom closures, MacApp views and of course still does for ZOSWindows.

It was thus relatively straightforward to implement ZFakeWindow_NSPlugin, which translates between the Netscape browser plugin and the ZFakeWindow APIs. What was actually more difficult was finding a decent implementation of the plugin glue code and header files. In 2002 there wasn't anything that would work with current compilers and with current browsers, so most of the effort was in putting together ZNSPlugin, which is a usable implementation of the glue.

October 2002


ZooLib's tuplebase is derived from the tuplespace concept initially explored in the Linda coordination language, another well known derivation of which is Sun's JavaSpaces system. Whereas JavaSpaces is Java-only and relies on many of that languages's features, ZooLib's tuplebase works today with C++ and Java, and is well suited to work with other languages.

Continue reading "Tuplebase" »

October 2002

ZDC_ZooLib: Portable Graphics

ZooLib defines and implements a graphics API that produces identical results across all supported platforms. It is geared towards creating user interface elements and so is pixel-based rather than geometric so that a programmer can know precisely which pixels will be touched by a drawing operation. It supports pixel-plotting, lines of any thickness, text, rectangles, rounded rectangles, ovals, arbitrary regions and the drawing of masked-pixmaps. ZDC_ZooLib is an implementation of this API using no OS facilities at all, and thus can be used in server applications without the difficulties that normally poses (gaining access to a window or graphics server from a low-privilege process).

The implementation uses operations on ZBigRegion instances to decide which pixels to touch, decomposes the regions into rectangles and then calls ZDCPixmapBlit to actually do the work.

IFF and QuickTime File Formats

IFF is a venerable data meta-format, introduced in 1985 by Electronic Arts as a standard framing mechanism for multimedia data. In short it defines a nested chunked format, where the file as a whole is considered to be a chunk. A chunk has as its first four bytes a tag that indicates the type of data in the payload, a 32 bit (four bytes again) count of the number of bytes in the payload, and then that number bytes being the payload itself. Some chunk types are known to contain zero or more other chunks in their payload, so an arbitrarily complex hiearchy can be established. There are other details, but chunk types and sizes are IFF's essentials. QuickTime's file format is almost the same, except that the size comes first, and includes the eight bytes of the chunk header.

IFF/QT are simpler than most file formats, but can still be fiddly to work with. To make it easier for me to parse and generate QT files manually (on platforms which don't have QT libraries) I put together a suite of ZooLib streams that take care of all the bookkeeping.

Tuples Defined Rigorously

For most of my career I've been very suspicious of dynamic data representations. After all, what's the point of having a compiler if it isn't provided with enough information about the shape of the data being manipulated to tell you when your code is going wrong. However, that really only works for data created and consumed within a single application. In the mid-90s, every C++ framework worth its salt had a huge bunch of code dedicated to turning arbitrary C++ objects into something that could be serialized and regenerated as objects later; and in fact that's about as far as most people got with CORBA before giving up.

But most objects in a C++ program, if they're objects at all, simply don't need to be serialized. The ones that do have disparate needs, and special cases abound. The approach I've found most flexible and least intrusive is to provide ZTuple. In this context a tuple is isomorphic to a LISP a-list, Python or Cocoa dictionary, Perl or Ruby Hash or to a Java Map. It's simply a list of name/value pairs, where values can be primitives (strings, numbers, raw bytes etc), tuples or lists of values.

ZooLib provides a suite of facilities that read and write tuples to binary streams, generate and parse a well-defined and easy to read text format, and that can read and write appropriate data formats as tuples.

September 2002

Knowledge Forum 4.0

Knowledge Forum 4.0 took the radical direction of being web-only. We'd had some support for web access by virtue of a perl program that used the client's communications protocol to talk directly to the server, but perl wasn't pre-installed on Mac OS (Classic) or Windows, and it had some performance problems. So we ported the perl software to C++ and incorporated it into the server directly.

Continue reading "Knowledge Forum 4.0" »

April 2002


Most of my work till this point had not required 'interesting' operations with file systems, being restricted to creating and opening files in externally determined locations, then reading and writing the files' contents. When it became necessary to ennumerate the contents of directories, and to deal with permissions and locking I took the opportunity to define an API that would be consistent across Windows, Mac and UNIX whilst cleanly accomodating their differences.

Continue reading "Files" »

January 2002


There's a maxim, a citation for which I can't locate now, which pours scorn on the idea of multiplexing streams over TCP. It kinda made sense when I first saw it, but in these days of ornery system adminstrators and their firewalls that sometimes allow connections seemingly on the roll of a die, there's a lot to be said for the all or nothing of getting a connection to a server, and then sharing it locally.

I wrote ZStreamMUX after coming across an early draft of WebMUX. ZStreamMUX takes a read stream and a write stream, and runs a lightweight protocol over them to support multiple independent sessions. The overall interface is similar to that provided by sockets. The protocol is asynchronous, and uses buffer credits to prevent deadlock at the protocol level.

June 2001

BlockStore: File System in a File

Applications often have to satisfy two conflicting requirements. On the one hand the data created by a user has a structure whose parts should be managed independently of one another, ideally with each piece placed in its own file. On the other hand users like to think of their data as a single entity which can be copied, emailed and backed up in its entirety. Although Mac OS X has the notion of a bundle, a specially marked directory which behaves like a single file when manipulated by the Finder, other operating systems do not.

Continue reading "BlockStore: File System in a File" »

March 2001

Assets: Portable resources

I picked the name 'asset' as an alternative to 'resource', a term that already has too many disparate meanings on different platforms. That said, assets are used in the same situations that MacOS/Win32/BeOS resources would be, although the mechanism is more flexible.

The data making up an asset tree is directly usable by any processor, big or little-endian. It can be kept in a file, loaded into RAM, memory-mapped from disk or accessed from a stream.

December 2000


ZooLib is an Open Source (MIT License) C++ library that makes it easy to write one set of source and build an application for Windows, Mac and UNIX. It provides a foundation suite of facilities that in essence form a virtual operating system API, and wide range of higher-level facilities that build on that foundation.

Continue reading "ZooLib" »

September 2000


ZStreamR_Boundary is a ZooLib stream derivative that uses Boyer-Moore-Horspool to take a source stream and efficiently provide to a caller only that data preceding a boundary. This is very useful when parsing MIME multipart streams, which can be nested arbitrarily and otherwise get very fiddly to deal with.

January 2000

Knowledge Forum 3.0

Knowledge Forum 3.0 took advantage of major enhancements in ZooLib that let the client be released for Windows as well as Mac OS. Much of Knowledge Forum 2.0 had been built around the Mac-only Zoom framework, and so had to be reimplemented. The parts of Knowledge Forum 2.0 built with ZooLib were simply carried forward, with refinements and enhancements.

Continue reading "Knowledge Forum 3.0" »

December 1999

BeOS Audio Driver for Sony N505VE

Putting BeOS on a machine that had previously run only Windows was a revelation. Elegant, efficient, and the rarely needed reboots took only seconds. But Be had a small team and their hardware support was focused on the standard modes of common hardware. Laptop hardware tends to be anything but standard. The Sony N505VE was a very lightweight laptop with a good sized screen. Its sound hardware was powerful, but unique and at the time undocumented, and so was entirely unsupported by BeOS. I wrote and open sourced a BeOS audio driver that used the YMF-744B's legacy SoundBlaster emulation to provide 8 bit audio output.

August 1999


NPainter is a suite of classes that provides a MacPaint-like interface, but supporting indexed and true color, across all platforms supported by ZooLib.

Continue reading "NPainter" »

May 1999

Windoids: Windows Within Windows...

Measurement in Motion 1.0 had an interesting interface. A document contained a set of measurements, and various objects that could display and modify those measurements. The objects were represented as 'windoids', windows within the document window. MiM 1.0 was a Mac application, so the windoids could depend only on ZooLib's graphics API, with no help from the OS. When demand for a Windows version became overwhelming I implemented a full windowing system that conformed to ZooLib's ZOSWindow API, so that any code that worked within a regular OS window could instead be hosted in a windoid. QuickTime by this point was writing to the screen buffer asynchronously, so any change in the visible region of a windoid is notified before it happens and after its completed, somewhat like the BeOS BDirectWindow mechanism.

August 1998


In porting ZooLib to BeOS I found that BeOS's region API was missing key features. Exclusive or and equivalence testing could be handled by composing more primitive operations, but insetting was trickier. So I dug through the X source and found that their implementation of insetting was totally generic, basically shifting the source region for each set bit in the inset distance and accumulating a union (for expanding) or intersection (for contracting).

But BRegion was also quite slow. The internal representation was pretty close to that used by the X code, being a list of non-overlapping rectangles organized into bands. BRegion did not always maintain the same tight constraints as the X code, but it still proved possible to significantly improve performance by manipulating BRegion's internal data using the X code.

By this point I was intimately familiar with X regions and it was a small step to take the X source and rework it, the result being ZBigRegion - a portable region implementation using 32 bit coordinates. Combined with ZDCPixmapBlit it forms the basis of ZDC_ZooLib.

January 1998

ZFiber: Threads At Interrupt Time

Fibers, at least in this context, are threads implemented using setjmp/longjmp to transfer control in a manner reminiscent of co-routines. They are a generalization of the stack-swapping used by NetPhone to run in the constrained environment it experienced when its deferred tasks were scheduled when an application with a tiny stack was current (yes Print Monitor, I'm talking about you).

Continue reading "ZFiber: Threads At Interrupt Time" »

September 1997

ZOSWindow: Abstracting OS Window APIs

ZooLib had always maintained the ZFakeWindow abstract interface between user interface elements and the hosting environment. This allowed ZooLib UI widgets to be used within MacApp applications, standalone applications, Control Panels, XCMD windows and XObject windows. It worked very well.

However, when the portability axis was across platforms rather than hosting environments there was the potential for a lot of replication and ugly code in ZWindow, the standalone application derivative of ZFakeWindow.

So, I abstracted the interface to OS-windows, placing it in ZOSWindow, and modified ZWindow to use a ZOSWindow, rather than be conditionally compiled for different platforms.

August 1997

Knowledge Forum 2.0

Knowledge Forum 2.0 is a computer supported collaboration environment designed to foster the growth of knowledge building communities. It's based on the CSILE project, developed at the Ontario Institute for Studies in Education and is published by published by Learning in Motion.

Continue reading "Knowledge Forum 2.0" »

April 1996


The publishers of Digiphone, a VOIP application for Windows, took a shortcut to getting Mac compatibility - they (indirectly) bought NetPhone from Electric Magic, and had me add support for DigiPhone's communications protocol and audio codec.

January 1996

ZDBase: Portable Database Engine

ZDBase is a relatively simple database storage engine. It's more of an alternative to Berkeley DB (as it was) than a replacement for MySQL. It supports an arbitrary number of tables, records and typed/named fields within those records. Each table maintains as many indices as desired, and the schema can be updated at any time. All data is kept in a blockstore, so everything lives in a single file, and the code and data are portable across platforms.

Continue reading "ZDBase: Portable Database Engine" »

August 1995

QuickTime Conferencing Components

QuickTime Conferencing was a short-lived project that tried to bring live communications technologies under the umbrella of QuickTime. To make it usable for most people's net connections, it needed codecs that were both low bandwidth and required limited CPU power. That combination was tricky, and so Apple asked me to help them by packaging NetPhone's CVSD and modified GSM codecs as audio components that could be used by QuickTime.

January 1995


In 1994 the Internet was just starting to be available in people's homes and offices. NetPhone was the first application to support what's now known as VOIP (Voice Over IP) without requiring a high-speed connection.

January 1994

Measurement in Motion

Measurement in Motion is a pioneering math and science analysis and investigation tool. It lets students take measurements from real-world video footage, then tabulate, graph and derive secondary measurements from their data. Conversely, students can generate data algorithmically and superimpose it over video to provide visceral confirmation of hypothesized behavior.

June 1993


FinderHider was a neat hack prompted by Joe Sparks' lamentations over the occasionally unprofessional look of Macromind Director animations. At the time there were several different screen sizes in use, 512 x 384, 640 x 480, 832 x 624 and even (for the well-heeled) 1024 x 768. But the 'stage' (the playback area) of any particular Director title was always fixed in size, and the computer's desktop would be visible when using a title on a computer with a monitor larger than the stage.

FinderHider simply put a border round the stage that would dynamically size to fill the entire screen.

Continue reading "FinderHider" »

November 1992


Marrakech took the hypermedia concepts I explored in WorkSpace and applied them to the problem of managing workflow and assets for multimedia development.

June 1992

Creative Whack Pack

The Creative Whack Pack was a software version of Roger von Oech's famous creativity-enhancing deck of cards. Scott Kim collaborated with Roger on the application's design, which had some neat features including a system-wide hot-key that would bring up a random card, a click on which would seamlessly invoke the application. The app's window also showed animated transitions between screens (dissolve, rotate etc).

June 1991


WorkSpace was an interesting application that took user interface ideas from Andy Hertzfeld's Servant, and hypermedia ideas from all over, and combined them into a personal information manager that used the web of links between entities to represent meaning. It was never released as a product, but was where I first started creating ZooLib, and formed the basis of Marrakech and ultimately of Measurement in Motion.

June 1990


MediaMaker was a ground-breaking application that provided a Finder-like interface to manage multimedia content, coupled with a timeline for assembling that content into a finished production. It controlled laserdisc players, VCRs and CD-ROM drives, managed video overlay cards, played AIFF files (no mp3s back then), MacroMind Director presentations and displayed PICT files (no JPEG either).

Continue reading "MediaMaker" »

June 1985


Almazz is another Commodore 64 game. This time I had the benefit of the Zoom monitor program, and a macro assembler whose name I forget. Technically Almazz was ahead of the pack, featuring a playing environment 1700 screens in size (8192 x 8192 pixels), with a 2 ½ D view letting you see your Indiana Jones-esque player walk in front of and behind trees, bushes, huts, rocks, obelisks and water fountains.

Continue reading "Almazz" »

June 1984

Bug Squad

Bug Squad is a 'Centipede' clone for the Commodore 64. It started as a BASIC program with machine code only for time-sensitive portions, and over time the BASIC scaffolding got replaced until it was all machine code. Unlike the PET there was no built-in monitor program, so I used a snippet of BASIC that took hex and wrote it to memory, or took memory and dumped it out as hex. The downside being that to this day when I see A9 XX, or 8D XX XX I can't help but read 'Load Accumulator Immediate', or 'Store Accumulator Absolute'.

Continue reading "Bug Squad" »

June 1983

Pan Books/Personal Computer News

1983 saw the crest of the early computer gaming wave. The crash came later, but before it happened Pan Books in partnership with the magazine "Personal Computer News" published a series of books titled "Sixty Programs for the Commodore 64", "...for the Sinclair Spectrum", "...for the BBC Microcomputer" etc. The bulk of them were initially written for the Spectrum or C64, and then ported by a small cadre of subcontractors to the other platforms. I was one of that group, doing about 7 ports between C64 and Spectrum. I'd forgotten all about my early foray into freelance software development, until I stumbled across a copy of my port of Battleships at

Continue reading "Pan Books/Personal Computer News" »

Projects by Category

Recent Projects

Project Archives