This is a mini-biography related to my computer background. If you are looking for a simple skills inventory or work history, see my resume. I never had any interest in computers when I was a child. Instead, I was interested in the natural sciences. I wanted to be a paleontologist when I was 4. By 6th grade, I wanted to be an entomologist. By 8th grade, I wanted to be a doctor. And all through that time I was extremely interested in astronomy, geology, and botany. I really didn't care for math - at least not arithmetic or geometry. So, one wouldn't have expected that I would end up with a career in technology. But when I was introduced to computers in High School, I was hooked.

High School Years

I wrote my first computer program at age 13 or 14 in High School. It was in BASIC on an HP 2000 time-sharing system. It wasn't much (I don't even remember what it was), but it was a start. The computer science teacher was a great guy with all kinds of contacts. He taught us the basics of computers and even arranged to have a microcomputer kit for an Altair 8800 sent to the school that we put together and then used to do programming. Then we got a Processor Technology SOL-20 microcomputer (also a kit, if I remember correctly). We had a PDP-8 sitting in the corner as well, but few of us ever used it. We were occasionally allowed to take the microcomputers home to use over the weekend (those who were in the computer classes). The Altair needed an I/O device so we connected it to a teletype. I'm sure my parents were wondering what wizardry was going on with the clattering sound of the teletype coming up from the basement. The district time-sharing computer went through several upgrades in the HP 2000 line, and then to a Data General Eclipse running AOS, and then finally to a DEC PDP-11. I cut my programming teeth on the HPs, which were okay. The Data General was buggy. But the PDP-11 was awesome. It was running RSTS/E - probably the best general-purpose 16-bit Operating System ever invented.

As the district computers upgraded, so did my programming skills. I admit that my first programming class assignment left me at a bit of a loss. But then things just "clicked" with me, and quickly learned how to think analytically. In my Junior year, I wrote my own shell for AOS, although I didn't really know what the term was for what I was doing. With the PDP-11 and RSTS/E, I purchased most of the manuals that were available - no small task given a high school student whose only income was berry picking during the summer. And I read them all. I began to grasp what went into an operating system and started to write systems-level programs. I wrote code on weekends and holidays and during the summer. But I also had learned a lot about electronics from putting the microcomputer kits together. I also purchased some logic circuit databooks such as the TI TTL cookbook and CMOS cookbook (which I still have). And I started playing around with designing digital circuits as well, including my own microcomputer using the RCA 1802 microprocessor, an acoustic coupler, and some other circuits from kits.

During my senior year, I designed a programming language (Sirius), which wasn't much more than a cross between BASIC-Plus and Pascal (which I had learned from Wirth's book over Christmas break). But a few years later, Sirius went through a major overhaul to deal with coding issues that I had experienced. Some of my ideas showed up in other languages about 10 or 15 years later (I believe they were independently developed - not stolen from me). I had also learned Intel 8080 and RCA 1802 assembler that year and began designing my own CPU hardware (using ECL) and an instruction set for it. As much as I like computers, they were more of a hobby than a career choice, since I wanted to be a doctor. In fact, I was in the middle of applying for pre-med at various universities when malpractice suits suddenly became a huge deal. This made me pause and reconsider my career choices. Did I really want to spend 8 years of pre-med and med school, plus an internship and another year or two of residency just to have to fight frivolous lawsuits? So, I decided to go into a career in computer science instead. It's probably just as well, since my motivation for being a doctor had more to do with my life-long interest in science (ooooh endocrine systems, anatomy, biochemistry!) rather than a desire to help people. Not that I minded helping people, but that wasn't my motivation - and I think it ought to be for a doctor. I would have made a good researcher, but probably not the best doctor.

College Years

My first year of college was at a local community college and I was able to use a terminal at the college to access my old school district's PDP-11 (with permission, of course). This was always at night after my day job as an EKG technician and before my night classes. My second year of college, I went to SPU. About 1/3 of the reason I went there was that they had PDP-11 hardware. Did I say that I loved the PDP-11 and RSTS/E? While I was taking classes toward a Computer Science major I became friends with many of the other computer science students. I traveled in basically the same circle as Larry Wall (inventor of Perl), though I didn't interact directly with him as he was a couple years ahead of me. But there were a lot of really smart people there that had an influence on me. And I spent many evenings in the computer services department with friends who worked there, thus giving me access to the university's PDP-11/45.

I learned a lot about systems management at that time - some from the systems manager employed there and also from the DEC manuals. I read all of the manuals all the way through. When, in my senior year, they got a PDP-11/70 for university administration and dedicated the PDP-11/45 to academic use, I became the system manager for the academic system. This involved normal operations, but I also wrote a lot of system programs to help manage things, including a performance analyzer that helped identify where bottlenecks were. At that time, the students all shared accounts on the PDP-11/45, one per class, as was the practice at the time with most universities. This led to problems with some students copying or deleting other students' work. Thus, I implemented a process that created a set of permanent course accounts for professors, and an account for each student at the university, updated each quarter. As far as I know, this was unique among American universities at the time. I got "practicum" credits for managing the academic system, but it was almost a full-time job without pay. Occasionally more than full-time. This was on top of a full-time class load, so I didn't get much sleep. Thankfully I didn't catch mono or anything serious, but people said that I always had dark circles under my eyes that year.

Of course, the extreme demand on my time didn't prevent me from working a couple of projects on my own, including a text adventure system with a (for the time) advanced natural language parser. This eventually was converted to Pascal and became "Adventure Builder" - a text adventure authoring system that I sold a few copies of. I also had developed a library of routines written in Basic-Plus-2, which eventually were converted to C and Pascal and make up a library that I still use to this day (much enhanced since college). I also finished the digital circuit designs for my CPU, and wrote the microcode for the instruction set. Unfortunately, I couldn't afford to build it. The register set alone would have cost over $900. By the time I had the money, the industry had moved on and my Gigabyte CPU was no longer cutting-edge and there was no way I could ever catch up. Not that I seriously thought I'd sell it.

Besides the programming for classes, I worked half-time during the summer at the Seattle Fire Department as a COBOL programmer using the city's Univac 90-series mainframe running VS/9. I also did some FORTRAN programming and a little bit of BASIC there. I also did some part-time consulting on Apple IIs (using Apple BASIC) and on a spreadsheet program called Digicalc running on RSTS/E (in BASIC-Plus-2).

At that time, the university started to buy microcomputers (TRS-80 systems at that time). I did programming in BASIC, Z80 assembler, and FORTRAN on my own projects. The 64K RAM limit of the Z80 (minus the room taken by the TRSDOS operating system) was severely restrictive for the size of programs I wanted to write. That was when I began to design an interpreter for Sirius that would work with a virtual address code space, in 256-byte pages. With such, I could write huge programs that would run even on 8-bit processors. When I got my first personal computer a few years later (an IBM PC semi-compatible called a DEC Rainbow), the memory was larger, but still limited to the 256Kb that I had installed on the system. That is when I completed the Sirius interpreter and used it as a scripting language for Adventure Builder.

System Manager Years

After graduating and not finding local employment in the summer, due to the recession that year, the system manager at SPU left and the university hired me for the job. Now I was managing the academic PDP-11/45 and both administrative PDP-11/70s and was getting paid for it. I managed a student operations staff of 3 to 6 people. This involved me training them. Where they expressed an interest, I was able to teach them a lot of what I had learned. I actually enjoyed teaching people and was effective at it. I even considered getting a Master's degree just so I could teach occasional classes at the university. Instead, I opted to work toward another BS in botany since I got some free credits from working there.

I had to work a lot of odd hours to keep the systems up and running. I particularly recall one Friday when I stayed late to do a disk defragmentation. It was a long process and had to be started after everyone had gone home. Of course, that was the night when we had a hard disk head crash that took out both administrative drives - a hardware failure on one and an operator failure on another. I had gone home to get a couple hours sleep late that night but was woken by the operator calling me. So I went in and thus began an all-weekend effort to get things working before the offices opened Monday morning. I was up for about 69 of 72 hours and was literally starting to have audio hallucinations at the end of it (I even fell asleep while walking to 7/11 to get something to eat on Sunday night). But the computers were up and running by the time people rolled into work Monday morning and I went home and slept all day.

That was an extreme case, but I spent a lot of time keeping those systems up and running behind the scenes. I didn't have a phone in those days, but I only lived about a ten minute walk from the office, so the security people would call the computer modem line once an hour and if it didn't answer, they literally drove to my house and knocked on the door so that I could go in and get the system up and running. I wasn't married at the time, so it could have been worse. Part of managing the systems had to do with writing system utilities, mostly in BASIC but also with MACRO-11 (the PDP-11 assembler), and DCL.

After that I went to work for Seafirst Bank and managed their PDP-11s. Again, there was a huge demand on my time beyond the normal 40-hours and I was staring to get tired of having no life outside of work. Then I went to VFS, managing both PDP-11s with RSTS/E and a BSD Unix system. So I learned a fair bit about unix system administration. I wasn't impressed. The time demands were not as bad because of the environment and I spent time converting the software from interpreted BASIC-Plus to compiled BASIC-Plus-2. When AMR purchased VFS, they consolidated system administration. I (along with many others) were out of a job. So, now with a wife, I moved on to Timeline. I didn't want to do system management any more, so I requested that I take a programming position. They declined, but said that if I worked a year as a system manager, I could then move into programming. They were true to their word and I've been programming full-time ever since. During that year, I wrote a online disk defragmenter for RSTS/E which the company allowed me to put into the public domain as my first open source project. This was in 1988. It was included in some DECUS distributions thereafter. I don't know if anyone ever wrote another online defragmentor for RSTS/E after that, but mine was the first. In fact, I'm not aware of any online defragmentor for any system that preceeded mine (up to that point, they required that the system be taken down to run). That year I discovered the only two bugs in RSTS/E that I had ever found. However, most of my time was spent managing the VAX/VMS systems.

The computer room at Timeline was the first "professional" set up I had worked in. It had a raised floor (which I spent a lot of time pulling cables through), dedicated air conditioner, and a power unit, to support 4 or 5 minicomputers (mostly VAXes in a cluster). All of my system management jobs also required me to be the telecommunications expert as well, running RS232 and internet cables through ceilings, walls, and floors. I maintained all the hardware, including PCs and video terminals. I extensively documented the cabling, including the patch panels and the DECServer Terminal servers running the LAT protocol. And I managed a staff of two operators. The only time we had a security breach in my entire career came, coincidentally, with a management-mandated security change that I unsuccessfully tried to dissuade them from. After the breach, management relented and we had no further security problems once I cleaned up the mess.

Programming Years

My work as a programmer at Timeline involved writing a couple of add-ons for the company's accounting system, as well as maintaining the code for the rest of the system. The Job Costing system was 140,000 lines of code, from a loose specification written by someone else. I also designed and wrote a Utility Billing system (again, from loose specs) that was acknowledged as being the most flexible system on the market at the time. As the company was switching to a PC-based accounting system, I became the lead programmer for the VAX/VMS products (about 800,000 lines of BASIC code). I wrote extensive documentation, refactored some of the worst spaghetti code I'd ever seen, and led a couple other programmers in ongoing maintenance (mostly bug fixes). With the advent of the AXP line from DEC, I migrated the entire source code base to DEC BASIC which compiled for both VAX and AXP. This was a more intricate process than any of my previous conversion work, but it went off without a hitch. I also had started work on a completely new UI (using SMG) to replace the command-line interface to the accounting packages, though I left before that was finished. I also used CMS (Code Management System), VMS coverage analysis, and CDD (Common Data Dictionary) in the development process. While in this position, I also started working on the PC product using Microsoft Access and Access BASIC.

When I started working at Biblesoft, as a junior member of the team, I was responsible for keeping the company's Windows product (about 65,000 lines at that time) updated and maintained to support the company while the rest of the programmers worked on a new version of the product. As the back-end of that product neared completion, I was moved to the new product to work on the front-end. The decision was made to use C++ on the back-end and Delphi on the front. I designed the basic architecture of the front-end, which ended up being about 750,000 lines by the time I left the company. 250,000 lines of that was the text displayer that was essentially a browser for the company's internal SGML markup. This included features that were eventually made available via CSS in modern browsers, such a floating blocks. It had to support several languages including English, Greek, Aramaic, and Hebrew (the last two are displayed right to left). In fact, it had to support lines with mixed left-to-right and right-to-left text. It also supported tables, nested text attributes, hot links, horizontal and vertical margins, indents, outdents, images, and popup panes. Further, it supported WYSIWYG editing by the user. I should note that I was not responsible for the UI design - only for implementing it as I'm not particularly artistic. This job is where I started using Object Oriented Programming, although I had started using OOP in my own personal projects prior to that. We used StarTeam as the version management system, but it was rather unstable and was constantly self-corrupting.

I was contacted by a previous co-worker to come work at his consulting company which was doing Y2K work. My main task was upgrading the database for a client that they could not afford to have down long enough to do a conversion. Thus, I developed a process that allowed us to take the database down once for only a couple minutes and then update the live database in situ. I, and the client, were pleased that it all went off without a hiccup. The database was User-11 running on a PDP-11, and we programmed in IDML, which was essentially a pre-processor that added features to DEC's BASIC. That was the last paid position I had that involved DEC's hardware or software. Incidentally, this was also when HP purchased DEC. DEC was once the second largest computer company in the world whose minicomputer products were far better than those of the much smaller HP, whose computers I used back in high school. The problem was the DEC didn't recognize the impact of microcomputers on the industry until it was too late. This is an example of the problem with technology tunnel vision.

After my Y2K consulting stint, Biblesoft hired me back as the Lead/Senior programmer. I managed a staff of 2 to 3 programmers as we continued to upgrade the company's product. Eventually the company laid off all the programmers except for me. Management wasn't pushing for a new version at the time, so I took the opportunity to migrate the code base to Lazarus (a free Delphi-like enhancement to FPC) so that it would compile for 32 and 64-bit Windows as well as Mac. However, it was found that Lazarus and FPC were simply too unreliable to use for production. So that effort was abandoned, although the code changes to support 64-bit architectures were kept in hopes that we'd eventually be able to support 64-bit Windows when a stable tool became available. Part of dealing with the shortcomings in the back-end (that I had pointed out to the lead programmer back when I was a junior member of the team) involved altering the back-end so that it still worked with the exiting database, but could also support things that were contrary to the inherent design of the code and database. A one-month effort allowed us to index into the same text with multiple keys. Another effort allowed us to support alternate versification for different versions of the Bible and original manuscripts. Again, this had to be done in a way that didn't disrupt the existing databases in use by our customers. Yet another instance had to do with exceeding some small and rather arbitrary limits placed on some database tables. All of these efforts came off without a hitch. I should note that although I had recognized these flaws in the design early on, I wasn't in a position to do anything about them at the time.

This is not to say that I'm perfect. Most of my gambles work out - but that probably just indicates that I'm too risk-averse. Otherwise, I'd likely make more mistakes. Examples include a electronic switch for magnetic tape drives that I designed for SPU while I was the system manager there. It was put together by a consultant, and it didn't work. Unfortunately, I simply didn't have time to figure out where the fault lay. It could have been the design (either inherent or due to incorrect documentation for the tape drive interface), or in the construction, or because of faulty components. Another example involved the creation of an extensive preferences system that allowed the user control over so many aspects of a program's UI that it was simply overwhelming. Not to mention the extra code necessary to support the multitudes of options and how they all interacted. Plus it added a lot of overhead to any UI changes that were made with each major version release of the product (there were 3 major UI changes over the years). Now that I realize that this is something that most users don't even use, I won't make that mistake again.

At one point I was responsible for vetting potential candidates to come on as junior staff. Having heard about interviewing practices at places like Microsoft, I decided to ask the first candidate to write a simple routine up on the whiteboard. I don't remember what it was, and I wasn't so much concerned with him being able to write the code - I was more interested in his thought process. Unfortunately, the poor guy - already nervous about the interview - just froze up. My heart went out to him and at that point I began to question the wisdom of that approach. Perhaps if one needed to filter out people who never got nervous, such an approach would make sense. But not for every programmer. Although I would be okay with the approach if I was the candidate, not everyone is me. Upon further reflection, I view this whole thing as barbaric. I have to wonder if it is a form of fraternity initiation - you have to pass the test to be admitted. I never did that in another interview. Incidentally, we hired someone else - but that was due to the hire having a stronger background and not because the first guy froze in the interview.

Shortly thereafter, Biblesoft was sold to another party. Once again, I was tasked with keeping the existing software working while others went on to design a new product that would be multi-platform. However, the guy designing the database didn't comprehend the problem domain and created something that was wholly inadequate. I'm sure he was a fine programmer and all, but without the benefit of 20 years of hindsight in the problem domain, he was out of his depth. After nine months and still no product, I was given the task of designing a database for the new platform. I had it designed and created within a month. No major alterations were required to it after that. Just an occasional tweak to add a column here or a secondary index there. Over the next two years, or so, I imported all of our reference work material into the new database. This included about 2,000 titles - some of which were quite large. I wrote a program to translate from our internal SGML to HTML/CSS with custom tags. Since I was still supporting the company's Windows product, two other people wrote the client app using Sencha. I wrote the web services platform (using PHP) that the app used, but did no work on the app itself.

Eventually, due to people leaving, I ended up as the only programmer at the company - in fact, as the only technical person. As a consequence, it was now my responsibility to manage our cloud infrastructure (hosted on Amazon AWS) - essentially systems administration, cloud administration, and database administration. My last year involved setting up an email server, managing our email list (via MailChimp), setting up and managing our linux web servers, elastic load balancer, S3, elasticache, Route 53, RDS servers, and the online store running Prestashop on Linux.

The Sencha app was quite slow - this was mostly due to the nature of Sencha rather than the online nature of the app. We decided that if we were to replace the app with something new, we should aim for a native app on all of the target platforms: Windows 32/64, Mac 32/64, iOS, and Android. To accomplish this with one person, who couldn't dedicate 100% of his hours to the new app, we needed to aim for a single set of source code that would compile natively to all of them. Embarcadero's RAD Studio offered this solution in both C++ and Delphi. However, I left before the app was finished.

As mentioned above, I did a lot of my own programming projects outside of work. Some with the intention to make money, and some simply for the challenge. Many of these were released into the public domain and some of them were quite extensive projects. Most of these can be found on my projects page. Here are some statistics to indicate the scope of these projects:
Code library: over 235,000 lines of code (Pascal)
Sirius compiler: 10,000+ lines of code, excluding library
SVM32 (Sirius Virtual Machine): 27,000+ lines of code, excluding library
UOS: 160,000+ lines of code
CEF (Computer Emulator Framework): 196,000+ lines of code, excluding library