Something I just remembered

Roughly 17 years ago, I was in love with QuickBasic. After a while using GWBasic (not to mention years of using BASIC on other systems, such as the Brazilian Sinclair ZX81 clone TK-85, the MSX 1.0, and the Apple II), QuickBasic was a real milestone in my life. It was when I changed from using line numbers and a pretty mangled structure in my programs (using subroutines with GOSUBs and GOTOs) to a more organized one with functions and procedures. I also loved how easy it was to debug inside the Quickbasic 4.5 IDE – you could stop your program at any time, do changes to your code, and then continue running. Programs were interpreted, and while speed wasn’t the best compared to other platforms available for similar DOS machines, immediate execution, easy debugging and the ability to compile executables later made it the platform of choice for all the small programs I liked to create – database merging systems, small graphical or text-based games, and general tools I used on my daily work.

Quickbasic 4.5

QuickBasic 4.5 (click for source)

But even though I used QuickBasic for most of my stuff, I also used other languages like C and Pascal at high school. For the latter, my IDE of choice was Turbo Pascal. And it’s within that development environment that I had my first run-in with Turbo Vision.

Turbo Vision was, in a nutshell, a framework to create user interface elements for Turbo Pascal programs. It allowed you to easily create menus, buttons, dialog windows and the alike – something that was still pretty rare at the time (considering DOS programs were never really about the user interface). Being able to quickly construct a program with such a high-level interface without doing everything from scratch was quite a shock to me.

Turbo Vision example

Screenshot of "Quadra", showing what a Turbo Vision interface looked like (Click for source)

An even bigger shock was understanding that you could actually create common libraries or frameworks and reuse them on different projects. As obvious as it is today, my self-taught understanding of program structures at the time hadn’t grasped this concept yet. Turbo Vision itself was beautiful, but the idea of Turbo Vision was, for my little coder mind, revolutionary.

So after having my first experience with Turbo Vision, I set out to create a similar framework in QuickBasic that I could use for my own programs (while I enjoyed the speed and correctness of languages like C and Pascal, not to mention the speed, I enjoyed the agility I had with QuickBasic even more).

The result was a bunch of subroutines that could be called to draw and control everything. You could create screen elements like buttons, editable text fields, windows, check boxes, radio buttons, menus and the like, with full tabbing/focusing/clipboard support, and control them using a higher-level API. That allowed me to add great interface elements to my simple programs quite easily, without having to worry about rewriting it every time I needed to create something new. The implementation was somewhat ugly, since QuickBasic would run in a single thread and I had to move execution from one element to another and deal with the return result to know what to do, but it was clear enough in a way that allowed me to reuse elements with certain ease. I still have that code somewhere around my computer.

Fast forward to 2003, around a decade later – after I had abandoned QuickBasic, used a few other platforms and languages, until finally settling with development for the web. While I’m working with ActionScript and developing some visual components for a website, I had an epiphany: I was doing the same thing I had done 10 years before.

The operating system was different: Windows, instead of DOS; the language was not QuickBasic anymore, but ActionScript; I wasn’t building a text-based application, but rather one that used graphical user interface elements and the mouse; I wasn’t reading data from the disk, but from some asynchronous network resource. But still, I was doing the same thing: creating graphical elements that were meant to be reused.

A decade before, I had no idea I was going to be working with Flash (since that didn’t exist), or even be building those kinds of interfaces. Of course I had no idea I would be building something meant to be used over the Internet either. And I had even take some pretty odd routes along the way of my earlier career, focusing in graphic design and animation instead of programming, but still, there I was, full circle, back doing what could be said to be basically the same thing I had been doing at high school, only in an updated environment.

And while I’m not really that old, I like to see this as a great example that no technology lasts forever, and that programmers can’t have any idea of what they’ll be working 10 years later. And, perhaps more strongly now, that while the environment they’re using might be completely different, the concepts they’ve learned before will carry on. In a nutshell, your experience is not the language you use, but what you do with that language.

I guess it doesn’t take much to see how that applies to the issue I’m seeing people debating today – “Rich Internet” platforms like Flash, SilverLight, HTML 5, and a few others. I’ll be the douchebag who quotes himself and just paste what I had to say a short while ago in my FWA interview:

Q. Do you think Flash is here to stay?

A. In a way, most definitely. Flash was the first software platform to allow developers to easily create rich interactive animations for the everyday user, so whatever Flash has brought and is still bringing is something other platforms are playing catch up to adopt.

But on the other hand, you can never predict what the future will be like. When I started working with interface development, Flash didn’t exist and I couldn’t even predict I’d be working with something like it 15 years later.

I love Flash, but after having worked with it for more than a decade and seeing it radically transformed so many times, it’s as if the name doesn’t matter that much anymore. I think what we call RIA development is the thing that’s here to stay and that’ll just become bigger with time, but the name under the hood becomes almost irrelevant. Even if it’s Flash and ActionScript, it’s going to be a different Flash and a different language in a few years. With similarities, but then again there are similarities between ActionScript, Java, and C#. Being attached to that kind of brand isn’t very healthy I guess

Here’s something a lot of people forget – we’re not in this business because we’re using language XYZ. While a lot of people like to draw that kind of conclusion – because, after all, their experience is usually focused on a single language, not to mention the need to identify with a certain group – the market itself changes over time and it’s natural for one language to replace another as the language of choice for a specific task. Remember when Perl was the de-facto server-side language for the web? If you considered yourself a “Perl specialist”, instead of a server-side programmer, you’d be stuck when people started to migrate their systems to PHP and others.

I see the current state of rich interfaces development the same way. We’re doing Flash today – because it’s widespread, the tools available (official or not) are stable enough, it has an awesome community, and it’s generally easy to develop for. What are we going to use tomorrow? I don’t know, but the knowledge I’ve gathered over the years – developing the interface elements I’ve been using, learning about asynchronous data loading and user interface issues – will carry over, regardless of the new platform I’m using.

Now, there’s a lot that could be said against HTML5. Performance issues, compatibility, much slower user penetration, lack of features, how it’s only adding the same features and problems people criticized in Flash before. All has been said and, I’m sure, will be said as soon as HTML5 start to become a real contender and its flaws become more obvious in a real world scenario.

But you know what? It doesn’t matter. Because HTML5 will either work out or it won’t. And, as a developer, it’s not my job to root for one specific side. It’s my job to absorb whatever there’s to be absorbed and move on. Be it HTML and JavaScript, be it ActionScript, be it Silverlight, I’m pretty sure the higher-level knowledge I’ve gathered through the years that are outside the syntax realm will carry on.

I can’t be sure of what I’ll be working with in 10 years. And neither can you.

9 responses

  1. Completely agree. Althought I had I different experience, it reminds me the discussions I had with VisualBasic developers about Flash, and everytime I was showing my enthousiasm on the upgrade from Flash 4 to 5 and its new capabilities of dealing with XML (10 years ago?). No, I have no idea what I will be doing within 10 years (or even 5!). Nice story, thanks Zeh.

  2. Funny, I followed almost the exact same path as you, beginning with QBasic. In general, I think just about anyone who does any work of any kind in the computer field must always be ready to adapt, learn something new, and change. It’s just the nature of our industry.

    I like your separation of RIA development from Flash. I believe people will store more and more things “in the cloud” including applications that we currently run from our hard drives. New HTML standards will always be necessary, but it will be impossible for such a standard to be “cutting edge”. Things like Flash and Silverlight (or whatever we may be using in 10 years) will always be necessary to push technology forward, so that the standards can follow.

  3. Thanks for this post, all of sudden I saw my entire programming career before my eyes!!!!

    Along all the tools you mention, I still remember the trepidation coming back home to unpack and install the fifteen 3.5″ Disks of Visual Basic 3 (paid roughly a 1000$ of today….) and how can I forget the marvel when I realized that Delphi 1 was compiling everything into a single exe with no DLL, VBX and so and it also allowed me to create my own components with the very same language/compiler….. good times.

    By the way, I recently discovered that there is an open source project with deliver al almost exact copy of Delphi on Mac OS (and other platforms) called Lazarus and it is part of the FreePascal project. It is very good.

  4. Cool post,

    I’d like to think of myself as having more to offer than just programming and learning the latest language.

    If I have to go back to testing how my applications work in multiple browsers, I’d rather open a milkbar!

    I guess it’s difficult to know exactly why there’s no love for flash on the ipad.
    I would love to be building web UIs that leverage multi-touch.

  5. what about your CC number generator?

    And your (i think…) bluewave addon/plugin to select your sig with the mouse?

    and ofc, the super cool MAiDEN app


  6. Holy shit, I don’t even know if I still have those around! I have to find that! I know the executables are on maiden packs and CDROM.NET (was that the name?) packages and such, but I don’t quite remember where the sources are. 🙁

    The CC generator even had a little bit of assembly code inside of it (to change the appearance of characters, and to use text colors other than the 16 standard ones). It used part of my screen framework too, for the buttons. Overall that app was a moment of brilliance despite its, err, shady reason to be.

    The sign one was “Watersig”. That was also pretty cool. I remember I even released it as shareware but I ended up sending it for free to whoever asked. I don’t think it used the mouse though — I had a hard time getting mouse input in QB, I used some assembly to do that but it was pretty flaky so I never really employed it anywhere.

    The Maiden app (and the e-mags I created using part of the code) was awesome, it even had the doom-like “page switch” animation where text would just slide down the screen. And the e-mags would fade in and out *smoothly* from screen to screen, also using assembly, and were all programmed by changing a text file — the emag exe was just an engine to the dat file. Much similar to what I do with XMLs and sites in Flash today!

    My biggest app was one I never released, “Watermail”. It was a QWK reader. It was pretty awesome looking. But I started running into memory problems and just abandoned the project. Learned a lot from it though.

    You know, sometimes I find it really hard to believe some of the stuff I created. That was around 12 freaking years ago. I look back and say “holy fuck that boy was a genius” but then I realize it’s me and then it seems like I’ve been moving backwards. I’m creating some fun stuff, but programming shit for myself and a few nerd friends for no reason at all, and still adding every little detail and perfecting the code and making it super beautiful just because I wanted to… THAT is amazing.

    I don’t know. It’s crazy.

Comments are closed.