A look into the last ten years

I turned 30 on Wednesday. It doesn’t really feel like anything, but it’s a good time to take a trip down the memory lane from a web technology perspective. So how has the world changed? (lots of Wikipedia links included!)

I have been programming since I was six and started working full-time in IT almost 15 years ago. Software development, while far from being my only professional interest, has been the most dominant one so far. Ten years ago I was formally leading a team in charge of MikroBitti Magazine’s New Media operations, including ISP services (ISDN! Dial-up!), a BBS and one of Finland’s first consumer-oriented web sites, MBnet. But whenever I had the time, I wrote code. And that’s what this post is all about.

A dissection of a 1999 web project

Ten years ago I had just fathered a computer components price watch site which thereafter evolved into the service nowadays known as www.hintaseuranta.fi. Essentially, it was a web site with a database backend, but also a cluster of background processes that crawled the retailers’ web stores to retrieve pricing information.

As we didn’t have ASP.NET yet, the web front-end code was classic ASP with its nasty VBScript language. Since ASP’s tools for managing complex layouts pretty much ended in the ability to include other source files, masses and masses of copy-pasted source were general. At that time, development tools were far from what they are now. Although Microsoft produced Visual Interdev to support ASP development, most developers preferred text editors for simplicity. Not Notepad though, but there was an extensive market of developer-oriented text editors at the time. They still exist, but Visual Studio grabbed much of the market by growing into an excellent all-around tool.

The produced HTML was chaotic. No surprise there, given that the first browser war was afoot. Internet Explorer 4 had swept the floor with the former king, Netscape Navigator. CSS layouts were nothing but a dream – the specs were pretty well done, but the support was limited to changing the foreground color, switching fonts and a few other things. It was <table>, <font> and <hr> all over.

JavaScript was hardly useful as browser implementations varied heavily. Also, security concerns were high – corporations and governments sometimes totally blocked JavaScript at their firewalls. The term AJAX would be coined no sooner than 2005, and its predecessor XMLHTTP was just shipped in March 1999 (Internet Explorer 5.0). However, given that automatic updates through Windows Update had not been invented yet, new browser versions were spreading pretty slowly. It took quite some time before the JavaScript fever took off.

Behind the web user interface, component-orientation was the buzz – the idea of separating the business logic from your HTML code was something pretty radical, given that SQL statements and markup tags were frequently intertwined in the .asp files. However, creating reusable modules to be run behind the somewhat wobbly (and security-wise questionable) Internet Information Services 4.0 wasn’t easy, and certainly not helped by the fact that Visual Basic and VBScript didn’t support a useful notion of objects.

VB worked well to an extent, and thus COM objects became the mainstream way to package functionality. But when it was too clumsy, you generally resorted to C++. I worked mostly with Borland’s (then short-livedly known as Inprise) C++Builder. There were all the pains of C++, such as the hideously complex templates and manual memory management, but also the lovely freedom of doing whatever you wanted, up to the assembly language level. Usually the bugs soured the taste of freedom, but at least you felt like the old time coders hand-crafting software with love, just for the CPU.

And finally, the backend database choice of SQL Server 6.5 was the first real relational database for me. It was a dramatic change driven by web’s need for “huge” number of simultaneous users. There was this whole new notion of a database server! Before that, we had managed years and years with just files on the disk. And with less demanding applications, Access, Paradox and other flat-file storage mechanisms were still thriving. SQL as a language was just beginning to become a necessity – a few years before, people with SQL skills were really rare.

Why is it good to be here now?

A few reasons why I wouldn’t switch back:

  • There is now significant open-source movement also in the Microsoft scene. So much is done already, and most basic tasks can be significantly sped up by assembling packed solutions from others.
  • Visual Studio is great. Comparing to the command line compilers (ouch), print-based debugging and clumsy editing, the current toolset with IntelliSense, syntax highlighting and remote debugging makes all the difference. In 1999 we already had some of that, but not consistently.
  • Many error sources have been eliminated. Oh, the ease of Garbage Collection! Also, compilers and IDEs catch much of what we fumbled with earlier. In general, technology works much better now: CSS, JavaScript, IIS – much of it just works.
  • Languages live better together. The concept of sharing code libraries between languages sounds like a no-brainer, but until the advent of .NET, finding a Visual Basic solution for a problem didn’t help much, as leveraging that code from a C++ program would’ve been ridiculously difficult. Binary compatibility was a dream, COM was a pain and porting between languages almost an impossibility. What difference does a language-independent framework do!
  • From the database perspective, surprisingly little has changed – SQL is still written as it used to be, and while databases have much more features, most of the basic web apps still repeat the same patterns they did ten years ago.

Kudos to some visionaries

While much of web’s development has happened outside of Microsoft, there are two leading minds in Redmond who greatly influenced so much of what I just wrote. They certainly do deserve special mention at this time.

First, Anders Hejlsberg created the influential Delphi back in Borland times, then stormed on to Microsoft and helped spawn the C# language. While C# 1.0 didn’t have that much edge over Java, the existence of a modern OOP language on the new .NET platform was the key driver to make people flip. Without that, I would’ve quite possibly chosen Java as my next framework of choice (not to say that would’ve been a bad alternative!).

Second, Scott Guthrie was fresh out of university in 1997 and had just joined Microsoft, when he and Mark Anders were tasked to design the next generation web framework. The resulting XSP was first written in Java, then rewritten in C# (dubbed “Cool” at that time), rebranded as ASP+ and finally released ASP.NET. And while much of the modern criticism on Web Forms is well-founded, the ability to come up with something like that over ten years ago shows quite some insight. Oh and by the way, Scott wrote the first version of XSP over Christmas holidays. That’s the only proper way to build a new framework, isn’t it?


I hope I’m still here after 10 more years to document the inevitable progress. There is some comfort knowing that technology evolution isn’t slowing down. But will I be a dinosaur with obsolete technical knowledge when I’m 40? Looking forward to seeing that!

June 26, 2009 · Jouni Heikniemi · One Comment
Tags:  · Posted in: .NET, General, Web

One Response

  1. Cedric Kotow - January 12, 2021

    After study a number of the websites with your site now, and that i genuinely appreciate your method of blogging. I bookmarked it to my bookmark site list and are checking back soon. Pls have a look at my web page likewise and let me know if you agree.

Leave a Reply