I taught myself Pascal in high school. I was not admitted to the AP course my high school was offering due to my overall GPA, so I taught myself to 1. spite the arrogant jerk of a teacher who denied me, and 2. follow along with the course so I could spend time with my friends. I had been taught other languages (LOGO when I was 12, and BASIC when I was 13) so I wasn’t a stranger to programming. What I was a stranger to, however, was discipline.

My early code, which includes my early demo coding, is sloppy. Oh, the code is nice to look at and doesn’t contain spelling errors, but it is incredibly sloppy. Instead of using REP MOVSW to copy memory around, or even Turbo Pascal’s move() procedure, I would copy one array to another byte by byte. Instead of sorting an array by inserting an array set into a sorted binary tree and then copying it back to the array (heapsort), I would loop through the array and swap crap as necessary (bubblesort). Instead of learning how to use pointers, I would try to trick the compiler into giving me multiple data segments (which had the side effect of bloating the executable). Essentially, I lacked experience, insight, and wisdom — and my programs were buggy and slow as a result.

Today, nearly 20 years later, that is not the case. I still program in Turbo Pascal, but I use pointers/heap, objects, inheritance, and especially in-line assembler in places that need it. I understand proper data structures a lot better now (still struggling with tries, but I’ll get it eventually).  I write my code as if I am delivering it to someone else to maintain.  I can’t say that I am ashamed of anything I’ve written past 1997.

I mention all this because the PC Speaker tracker, something that most people bang out in a day, has taken over two weeks and I haven’t written more than 50 lines of code.   What I have done, however, is:

• Spent 3 hours writing up various design and structure ideas in a notes file
• Spent 2 hours last night laying in bed trying to visualize object-oriented tracker design while preventing playback performance from turning to shit (answer: a Song object that controls entering and retrieving note/effect data into the song, and a Player object that retrieves song data one row at a time… still thinking about this one, since a single object makes more sense, but would be harder to virtualize playback methods for other output devices)
• Spent an hour researching the frequency and amplitude characteristics of Vibrato (not just the human voice, but woodwinds and stringed instruments) so I could be sure to make the best use of the effect bits I have available (answer: most pleasing vibrato has a frequency within 4 to 7Hz and amplitude of about 10 cents)
• Spent an hour revisiting various tracker formats, looking for ideas on how to pack notes+volume+effects into two bytes (answer: 7 bits for note, 3 bits for effect, 3 for effect 1st parm, 3 for effect 2nd parm)

…but no code.  Yet.

I believe it was the demogroup Silents who proclaimed, “If you can’t do it better, why do it at all?”  That is simultaneously democoding’s greatest motto, motivator, and curse.

I haven’t watched many modern demos in the last 10 years; I usually watch maybe 1 or 2 a year.  My demoscene friends are always shocked when I tell them that, given my past involvement with all things sceneish.  In fact, they’re always shocked, no matter how many times it comes up.  I’m going to try to explain why, briefly, and then hopefully either I will change, or it will never come up again.

In a nutshell, I feel shame and self-loathing when I watch modern Windows demos.   Before that completely confuses you, I’ll hurriedly explain that I always regretted not having the time, skill, intelligence (my math has always been poor), and inclination to create Windows demos.  So when I watch one, I am reminded of how I have failed at that particular aspiration.  I have succeeded at others, but watching a 64K from Fairlight or Farbrausch just gets me depressed.  Yes, I’m screwed up.  The better and more impressive the demo/intro/4k is, the worse I feel.  I know it’s not rational.

So now you know.  This also conveniently explains why I have actually gone backwards in my democoding (I started out on 386+SB+VGA and my latest efforts are geared toward an 8088+PC speaker+CGA) instead of most people, who go forwards.  For example, I’m writing a small utility as a favor to a friend, but it needs to support long filenames in Windows XP and memory over 640K.  Regardless, I’m writing it in DOS, on the XT, because I feel safe and comfortable doing so.  Once it runs within the restrictions of DOS, I’m going to port the code over to WinXP and compile it with a WinXP compiler.

Related topic change: We’ve started talking about MindCandy volume 3.