I decided to actually write about my experiences and my introduction to computing. I wanted it down for some semblance of posterity. This is part 2; you can read part 1 here. I should warn you though– this is much longer than Part 1. Part 3 of this series will come soon enough.

Oh, and for those in the crowd: this is my space. You might find the hubris a tad bit too much though.


Programming absolutely fascinated me. At first, it was all gibberish and voodoo to me– I really had no clear-cut understanding of what exactly was happening and how it happened. After that fateful day, I kept going back to their library and reading the rest of the book. I didn’t try out the other programs though. I simply wanted to understand how the program we typed in worked. Niño wasn’t as fascinated as I am. I, however, was hooked. I sort of understood what PRINT did, or how to ask for information, or how to run programs (RUN, for those who don’t know BASIC). But I wanted to make the program my own.

That summer, a lot of my time was spent poring over “Make Your Own Computer Games”, the book that I mentioned. The program we typed in was a “fortune teller”– you typed in a question answerable with yes or no, and it’d answer back. It was mystical to me. (Of course, for the tech heads out there, it was simply using a random number generator.) How did it work? I spent a lot of time looking through it, trying to pierce the Greek that was BASIC. I did, however, also spend a lot of time not looking at code. I wasn’t that enthralled yet.

Eventually, I got hold of a BASIC interpreter of my own, and copied it to a 5 1/4” floppy. The original is gone, but I have a descendant of that floppy– considering I still have a more-or-less working 5 1/4” drive, I may one day try pulling my old BASIC programs. But I digress, yet again.

I started experimenting. I copied the fortune teller program we typed in onto my floppy, and spent a lot of time in front of our PC to play around with it. I soon figured out how to add color to the text, and how to make it do really nifty things. My prowess with BASIC grew slowly. At the time, I couldn’t write a program from scratch, and I was actually pretty impatient to try. But no matter. I was enjoying myself.

When the next schoolyear rolled in, I immediately took the chance to go to the library to borrow that book again, and to try the program listing in it. I remember the excitement and anticipation, as I typed it in line by line. And I dug into some other books from the library to teach myself how to program– how to really program, how to think and design programs.

I was at first frustrated. I didn’t know the first thing in writing a program from scratch. Yeah, I knew what FOR loops were, or what use variables are for. But I didn’t know how to write a program from scratch.

Yet another digression: Doogie Howser and the birth of JournalWriter

This was the middle of the nineties. A lot of readers probably remember some notable shows on local TV. Some may remember the Teenage Mutant Ninja Turtles, or even the early incarnation of TV Patrol– both on ABS-CBN. One show that I watched pretty avidly was Doogie Howser, MD, about a child prodigy who becomes the youngest doctor on staff at a hospital. Who didn’t spend evenings watching Doogie? Who doesn’t remember the simple theme song, the one that starts with high electronic keyboard notes and segues into a full melody?

I remember one night watching the show. I remarked to myself that he had a computer. At the end of each episode, Doogie would type in a journal entry, and the episode would end with a shot of the computer screen. I remarked, you know, I’d like to do that too. And that would push me to try writing a program from scratch.

Yes, I was inspired by Doogie Howser. I don’t know if I should be embarassed writing that, but yeah. Doogie Howser.

So for some time, I spent most of my coding life trying to make it come true. I was using GW-BASIC– for those familiar, it was a version of BASIC being sold by Microsoft, but it purportedly had better features than IBM BASICA (otherwise known as Advanced BASIC, and also by Microsoft). Years later, I stumbled onto several web pages about GW-BASIC: speculations on what ‘GW’ actually stood for, and what not. In any case, my copy wasn’t exactly legit. Then again, this was ages ago: nobody in the Philippines was actually using “licensed” copies, and in fact the BSA was at its infancy, if I am not mistaken. (I digress, and I apologize. It’s a hard habit to break, digression)

At first, I didn’t know how to save or write to files. I only knew about the venerable DATA statement, which allows a programmer to store data with the program code. And building a journal program meant DATA just didn’t cut it. I got around that hurdle eventually, when I bought two textbooks on BASIC which described the necessary statements for writing to files. I started calling the project JournalWriter, just because the name sounded right.

I never did finish the program, at least not in BASIC. It was tough. A lot of the things I wanted to do just wasn’t possible in BASIC, including a full text screen-based editor that had find & replace capabilities. In any case, I wanted more. I lusted to do more.

Turbo Pascal and C

I was in sixth grade at this time. I was already pretty well-versed in BASIC, and I could probably boast that I knew more than most of those of my age group. My aptitude with BASIC quickly grew. One time, I decided to impress my mom on her birthday. I had no school that day, and I spent the whole morning and afternoon writing an electronic greeting card. It was mostly basic text manipulation– moving her name and a few messages around the screen, making letters pop up one at a time and in sequence– all the while playing “Happy Birthday”, the notes of which I groped for on our piano. Already, I was starting to gain a reputation for being a computer nerd, something I at first disliked but which I slowly wore as a badge of honor. But I was still disappointed. I didn’t and couldn’t do the things I wanted to do. I wanted to write programs and have them become EXE files, one thing you couldn’t do with plain BASIC. (Strangely enough, around the time I was plotting the building of the journal program, I was also trying to write something like my own DOS shell. In BASIC. I felt that powerful and well-versed. And around that time, Linus Torvalds was starting to build what would become the Linux kernel of today. What’s my point? I don’t have one.)

In any case, there were a few other computer books in the library. And they dealt with two other languages: Pascal and C. I’d eventually learn both, but when I started, I couldn’t really wade in. Everything was theoretical to me, for one simple fact– I didn’t have anything to run my Pascal or C code. So, I more or less plodded along with BASIC while I scoured for some way to run either Pascal or C code. Soon, I was able to copy Turbo Pascal off the school’s computer lab, and run it on my PC. But I was still not yet there, in terms of Pascal.

I would revisit both languages in high school, however.

EXEs from BASIC? Impossible!

I was close to giving up entirely on my dream of writing a journal program. I felt that distributing my source code was klunky, and I wanted to sell the program– and that meant that I couldn’t do so with my source out there. (I was of the proprietary software mindset back then. I’ll come back to that point later). And I wanted an EXE file, dammit.

It was in seventh grade that I was able to get that point solved. I found a way to compile BASIC into EXEs. One day, I dropped by the school’s computer lab. A high school student was mucking about a program of his, a simple countdown timer that would be used for a in-school contest. He was debugging it, and he was stumped by a small problem. I don’t remember what was wrong with it, but I do remember that one of the CompSci teachers was there– and my computer nerd reputation was already well-known, even among the faculty. In any case, she introduced me to the high school student, and I sat down beside him. He was writing it in BASIC, using some program that I wasn’t familiar with. In any case, I looked through the code, saw what was wrong, and helped him solve it. He was quite impressed. (And, annoyingly enough, that same teacher decided to give me the monicker ‘Billy Gates Jr.,’ which she called me, even during school events. Thankfully, almost no one else called me that. If anyone calls me that now, I will punch that person in the face. Got it?)

But anyway. The environment he was using was the one that captured my attention, because he was able to compile his BASIC code into an EXE. Neat!, I told myself. I wanted it, and asked him if I could get a copy. He gladly obliged. And I started to use it to do JournalWriter. The program? The short-lived Turbo BASIC.

Okay, I did know that you could compile BASIC into EXE format, but that meant purchasing a copy of Microsoft QuickBASIC (not to be confused with Microsoft QBASIC, mind you). Earlier that year, I purchased a book from National Bookstore entitled “Peter Norton’s Programmer’s Guide to the IBM PC & PS/2”, which contained various things about the hardware and internals of the PC useful to most programmers, including a listing of ROM and DOS interrupt services. And most of the book was useless to me, because I soon discovered I couldn’t call interrupts from BASIC, not without some other tools I didn’t have– an assembler, for one thing.

But QuickBASIC was simply out of my reach. I thought it was for professionals, and surmised that it would be really expensive to buy a copy– and that there was no way in hell I could have copied it from someone else, considering that it was an application that not a lot of people would use. You can imagine my glee in acquiring Turbo BASIC.

EXEs from BASIC? Impossible? Not with Turbo BASIC.

The machine gives up the ghost

Soon, however, something else would happen, and fate would intervene yet again.

We were still using the same PC my dad bought years ago. It was old and definitely outdated– the Pentium had recently come out, and we were still using a PC with an 8086 processor. People were starting to use 1.44Mb 3 1/2” hard-case “floppies”, and we were relegated to double-sided, double-density 5 1/4” disks with a maximum 360Kb capacity. Everywhere, games were running on resolutions with millions of colors available to the new Super VGA cards; we still had the same CGA card, with either the “medium resolution” mode of 320x200 pixels and 4 colors, or the ironic “high resolution” mode of 640x400 pixels and two colors. We were that behind, but there was no real reason to upgrade, at least for my dad. He was still running Lotus 123, and it serviced all of his needs remarkably well.

Until one day.

A PC without a hard drive is still relatively vulnerable to computer viruses, and we were hit by several in the past– mostly through my fault, having copied games and files indiscriminately, especially from the school’s computer labs. In any case, my dad would often blame me for most of the PCs troubles, even if I wasn’t even remotely involved. (Not the first time, nor the last though)

So, when the PC started conking out in the middle of things, my dad immediately called me and pointed to the message that came up. I knew that the PC was free from viruses. For one thing, I was more careful by that time, and I instinctively knew that it wasn’t any virus. So, what was wrong? What was going on? The message that came up was “PARITY ERROR”, and it didn’t come out predictably. I told my dad that it wasn’t me, and that the PC was really on the fritz for no fault of mine. He was extremely skeptical, but I held my ground. I knew that it wasn’t my fault. And it wasn’t.

The PC was giving up the ghost. It was at its final moments. My dad brought it to the shop. It turns out that one of the RAM chips was already failing, and was close to burning out. And since the machine was that old, there was no way in hell they could get parts. The RAM chips for that generation of PCs were soldered in, and RAM of the then-current generation was sold as pluggable DIMM sticks. Which meant that we definitely had to buy a new computer.

Which, come to think of it, was a good thing. We finally moved into the present day.

It took a while, but we eventually got a new PC. Although it wasn’t bleeding-edge, it was pretty much current– a 486-like chip from now-defunct Cyrix, a real hard drive, and a Super VGA card. The only thing that actually survived from the old era was a 5 1/4” floppy drive. One of the 5 1/4” drives from our original PC did survive on another unit purchased for my dad’s new office– in fact, I still have that particular drive in my room, although I’m not sure if it still works. In any case, both machines had Microsoft Windows installed– one had Windows 95 (with Microsoft Plus!) and the other had DOS and Windows 3.1.

One bonus was the shop that set things up also installed several other apps on the machine with Windows 95 on it. One of the things installed was a copy of Visual Basic 3.0. Visual Basic. At that point, I was quite ready to give up writing JournalWriter in BASIC, as it was getting pretty hard for me to do a lot of things (like the aforementioned screen-based editor). I tested the waters, and eventually I learned VB. And was amazed. A lot of programming in VB simply involved “drawing” windows and such. I wasn’t able to move my code to VB, but I did quickly rewrite everything in it. And the VB version quickly became more functional than my BASIC version.

And yet, I still hadn’t and haven’t released JournalWriter. Eventually, I did really lose interest in it. Good grief.

(Next: Growing Up, The Internet, And Free Software!)

Previously: My Journey Into Computing (Part 1)