How Software Development has changed in 20 or so Years


A conversation with a workmate made me think back to my early programming days, and how things have changed in the eighteen or so intervening years, so I thought I'd share a time from my early history. No punch cards though (I'll spare you my school days).

Back in 1986 I worked for HiSoft, and my product was DevpacST. This was a development system for programmers, who in those days were almost all assembly-language users. It included a graphical window editor, debugger, assembler and linker, and ran on the Atari ST, a 68000 8MHz machine with 512k of RAM. (A review of the American-licensed version 2 is here)

When I say this was 'my' product, it really was. HiSoft was about seven people total in those days, and every byte on the floppy was mine (except for the linker). I created the 68k assembler and a disassembler as my final year project at University and these ended up a few years later as the cornerstone of Devpac. The assembler got a lot more complicated (macros and conditionals) and the disassembler turned into a fully blown debugger (well as fully blown as 30k of code permits). Everything (except the linker) was written in assembler, and it assembled itself. In fact that was the most rigourous test we had for the assembler: could it build everything, and could everything then run? If so, ship it.

Classic bug: if the same person writes an assembler and a disassembler, from the exact same dog-eared processor spec, look out for bugs. I remember one rare opcode (CMPI?) which assembled to the wrong bytes, but I didn’t notice for the longest time because I made the same mistake in the disassembler. I had misread the spec page in the same way for both sides of the tool, and as I used the disassembler output to verify the assembler codegen, I never noticed. Eventually a customer did and we fixed it.

I remember the day that the source file for the assembler got too big to fit into the editor (over 200k of source) so I had to split it into two files. The assembler could run from within the editor doing everything in memory, so splitting the source meant that build times went from less than 10 seconds, to maybe 40 as it had to hit the floppy. That seemed like an age. (No need for grep in those days: the entire source fit into two files!).

The linker I inherited from one of the senior developers (who left) and was written in C. The debugging of that linker taught me the C language. The hard way: we didn’t have source level debugging back then, all debugging was at the asm level, though we could read global symbols at least. Local variables? Callstacks? Source debugging? I didn't miss those features as I had no concept of them in a debugger: asm was everything then. If you couldn’t figure out the locals from the disasm and the registers, you had no business writing C. If you couldn’t figure the callstack by manually walking though the memory, then either you were stupid, or you had trashed the stack somewhere.

It didn’t stop after the product had been built and tested by me. I wrote the docs too (~200 pages for the 2.0 version using Mac Word), made the master floppy (everything fit on a single 400k disk) and designed the cover (using Pagemaker). At busy times I also loaded and unloaded the floppy duplicating machine, stuck labels on the disk, and packed it all together.

Tech support was also me: we had an hour every afternoon set aside for phone support. We had to set aside a special time else we'de never get any work done. Foreigners, especially our few American customers, tended to call a lot later, and we'de usually break our rule for them. I did mail support too. (That's mail, not email - we didn’t have email then). When bugs were reported, we'd fix it right there and then, and produce a new version to send to whoever reported it. Other users could get the latest version for 5 pounds, if they returned their original floppy. Every now and again we'de get a great suggestion and add that in too, and put the details in the readme file.

So that's how it was, and to be honest it was really great. To be so involved in a product from owning every line of asm code to packing the things in boxes gave me an appreciation for every level of software production. However it was hard work: we worked late almost every night and many weekends, and would rush down the A5 at vast speed to get to our local pub before it closed at 11pm each night. We usually only had time for a single, very enjoyable pint of real ale.

Fast-forward to 2004. Still in the software business, still producing debuggers. However that's where the similarity ends. I work for the biggest software company in the world, and my dev team is the size of the entirity of HiSoft back then. I hardly code at all now (being a manager-type).

The Visual Studio debugger is written mostly in C++. It contains no asm code, and a little bit of C#. It plugs into an IDE and editor supplied by other groups in VS. The minimal spec machine for VS is 500MHz, 128M of RAM. Source code for the debugger consists of thousands of files and generates tens of binaries. I have declared arrays that are larger than an entire .exe was in Devpac.

Building the debugger takes maybe 10 minutes on my machine for one flavor (eg Debug). Building all versions of all of VS takes the build lab maybe eight hours across multiple machines, if it all goes well.

I don’t test the debugger per se (the QA team do that), though I dogfood it and run checkin tests on it. I don't write any docs (sans this blog) though I do review much of what User Ed produce for us. I have never made a CD with VS on it and don't have any idea where VS product is put together, nor do I have a desire to help out in that regard. I do a bit of external support, via this blog and some issues that come in from Product Support. I do a lot of internal support, helping dogfooders using the debugger at Microsoft.

Is it as much fun as it was at HiSoft? Probably not to be honest, but the business is so different, software development has changed a huge amount, plus I'm old now: zooming down the freeway to the pub late at night after a hard day at work isn't on my Must Do list any more. Plus there are no 'pubs' really in Redmond. Plus American cops are a lot more interested in such activites than UK ones ever used to be...

Comments (8)

  1. jaybaz [MS] says:

    We’re all highly specialized today.

  2. Matthew Adams says:

    Good grief – that’s a blast from the past. I used to be a Devpac user (not to mention several other HiSoft products).

    And as to whether it was more ‘fun’ in those days? I guess it depends on whether wringing something remarkable out of a machine that was never designed to do such things at 4am still counts as "fun". And you’re right – age probably has something to do with it…

  3. Thanks – I enjoyed this.

  4. Tim says:

    I guess you don’t catapult harddrives through the air very often at MS, either? 🙂

    This reminded me of something I’ve thought about over the years – productivity. How do you think your overall personal productivity has changed over the years from HiSoft to MS?

    I know I have at various times compared my work rate to the time we worked at CC, and felt that quite often I have not hit that level of productivity…but there are so many factors that seem to affect it, that it’s hard to pin down exactly why. Sadly the main reasons seem to be political ones.

    Of course the improved tools help out a lot on the technical side.

    So get back to work 🙂

    PS. I loved this: "…users could get the latest version for 5 pounds, if they returned their original floppy."

    Them were t’days!

  5. Min Kwan Park says:

    I didn’t realize that you are that old, Andy. 🙂

    At 1986, I was 2nd grade in middle school, and I was playing with MSX(8bit computer from Japan) to play some game and write some punky code with Basic.

    though I have played with computer since 10 year old, my first professional experience started at 1994. I still remember the time. the company was very small. we were only 3 people company to make ATM Cell analyzer. and I was only person who write software for interfacing to human and H/W. Well, if you ask me whether I miss the time which made me spend really much time with logic analyzer and debugger all together to see the issues on H/W and S/W? Well, I don’t know. but I’m sure that I want to experience that time once more because it was precious time which gave me really valuable experiences as engineer to drive from A to Z.

    Yes, I’m having awesome time with many great engineers around me like you, now. but some times, I miss the old time. 🙂

  6. Roger Womack says:

    I remember using Devpac from Spectrum (on cassette) through to ST, and using Hisoft Basic extensively on ST and Amiga, and the technical support that yourself and Dave Nuttall gave was first class, happy days.

  7. Andy Pennell says:

    I was a Devpac Spectrum customer only, never worked on that one. I still remember the wonderment when they revealed how HiSoft machine code could be loaded at any address and still work.

    That was Dave Nutkins actually. I lost touch with him years ago, wonder what he’s up to now?

Skip to main content