25 Years of Delphi and Me

I have two anniversaries coming up this year. Delphi is turning 25 on February 14th, and I am turning another 25 the month after. So I think this is good time for an (overdue) personal introduction in relation to my 25 years of experience with Delphi, and with Pascal before that. Who knows, maybe you’ll see some parallels with your own life…

The Early Years

My fascination with computers started in the early 1980’s when friends of mine got their hands on an Atari 2600 and BBC Micro. Those machines were pure magic to me (as is any sufficiently advanced technology according to one Mr. Clarke).

I wanted to know how computers worked so I saved up for a Commodore 64. In those days, home computers were pretty useless unless you knew how to code. And thus started my interest in programming. All BASIC in those days. But I never forgot the sense of wonder when you could make a machine do what you want and produce something on a TV screen. I still get that feeling once in a while when developing a FireMonkey control or writing a GLSL or HLSL shader. Or when creating a compression algorithm that magically reduces data to a fraction of its original size.

The Pascal Years

1986 was a pivotal year for me. That is the year that the MSX2 home computer was introduced (where the MS actually stands for Microsoft). It was an 8-bit computer with a Z80 CPU, and it became pretty popular in Europe and Japan. It had high-resolution (512 x 424) multi-color graphics and optionally came with this peripheral device called a mouse and a rudimentary graphical operating system and “office suite” called Philips Ease.

But for me the big change was the support for an operating system called MSX-DOS and the Turbo Pascal (3.3) programming language that ran on it. This language used a compiler instead of an interpreter, which I found revolutionary at the time. And the language was so much cleaner and more powerful than BASIC.

Also, Turbo Pascal came with something called an IDE, which made the language much more pleasant to work with. Up to this day the line between language and IDE is still a bit blurred when it comes to Delphi.

Pascal quickly became my language of choice. I started writing articles on Turbo Pascal in the Dutch MSX Club Magazine. I even published a couple of games for that magazine, as well as a game editor.

Then the PC revolution and move to 16-bit CPUs started in the early 1990’s. The Turbo Pascal language had a revolution of its own around that time: it introduced Object-Oriented Programming in Turbo Pascal 5.5. I remember the concept was so new and weird to me, but I immediately knew it was the future. Although it took some time to wrap my head around it.

This was later followed by another revolution in the (renamed) Borland Pascal 7: the Turbo Vision user interface framework for DOS. It introduced this new concept of event driven programming.

Around that time, I started working with Pascal professionally, even though I had no formal education in computer programming. My degree was in information management, but my affinity was always with hands-on programming. I used Borland Pascal and Turbo Vision to help develop applications for calculating and designing pension plans.

Then, as Windows 3.1 became more prevalent, I briefly experimented with Turbo Pascal for Windows and the Object Windows library. But it didn’t take long for a much more powerful solution to come around…

The Delphi Years

Delphi 1 was another true revolution. It introduced Rapid Application Development for the Pascal language with a drag-and-drop GUI builder and event driven interaction model. It also came with a powerful IDE and integrated debugger on Windows. It further blurred the difference between language and IDE: The term Delphi refers to both the language and the IDE nowadays. I used Delphi 1 professionally to create an application to graphically analyse stock markets to help pick pension funds.

But Delphi for 16-bit Windows was short lived. As Windows 95 became the most popular operating system, Delphi switched to 32-bit as well with Delphi 2. It was still a bit buggy though, so I started to make the 32-bit switch with Delphi 3.

In those years, the even-numbered Delphi versions were considered somewhat inferior and buggy. I don’t know it that was warranted though…

For me, Delphi 3 came with another revolution: the introduction of object interfaces. This language feature was primarily designed for interoperability with the Microsofts Component Object Model (COM), but we quickly saw the benefits outside of COM and started using it in its own right. Delphi’s implementation used automatic reference counting instead of manual reference counting. This move was genius and made COM so much easier (and safer) to use with Delphi than with C and C++ for which it was originally designed.

Both the IDE and the language kept evolving over the years, and Delphi remained my language of choice. Unfortunately, because of the RAD approach, Delphi had a bit of a reputation of a “GUI painting program”, where you could quickly slap together a GUI or database front-end and tie it together with a programming language that was mostly designed for educational purposes.

There was this pervasive misconception that you needed to use C or C++ for anything high-performance and powerful. So I set out to prove that Delphi was every bit as powerful as C(++), but with a cleaner syntax. I started writing articles for The Delphi Magazine (the paper version) about decoding MPEG video with Delphi. Can’t get much more high-performance than that.

I kept writing for The Delphi Magazine over the years, with articles about DirectX, code hooking, resource monitoring, image manipulation and other topics.

These were also the years of the famous Delphi 7 version. Because this version was so lean and rock-solid, it became one of the most popular Delphi versions of all time. Even to this day for some people (but seriously: move on already!).

After some (arguably) missteps into the .NET and Linux (Kylix) world, Delphi regained its footing with Delphi 2007 (under the CodeGear name). I moved to the United States around that time to work on a video conferencing project for a company founded by Allen Drennan. A long time interest (and eventually specialty) of mine was data compression in general, and image and video compression in particular. I developed algorithms for efficiently compressing screen images for a screen sharing feature. All in Delphi of course, with some help of MMX assembly code here and there in performance-critical paths.

Delphi started picking up more momentum after it was sold to Embarcadero. This resulted in support for additional operating systems in 2011 (initially OS X and iOS) and a new cross-platform GUI framework called FireMonkey.

The Delphi language had evolved too over the years, and added support for generics, anonymous methods, closures, nested types, attributes, extended RTTI and inline variables among others.

As FireMonkey started to become more mature, we started migrating code from VCL to FMX so we could support OS X, iOS and later Android. But sometimes, you must be brave enough to dump your legacy code and start from scratch…

And that’s when Allen Drennan and I started Grijjy in 2015. Without the burden of legacy code, we could start fresh. No migration or retrofitting, but modern, cross-platform and FireMonkey from the start.

FireMonkey had matured a lot in recent years. It enabled us to build a mobile chat and contact management app that used an hexagonal grid of animated selfies to interact with your contacts, instead of a boring old list.

I started to work on GPU programming at that time, by writing custom GLSL and HLSL shaders that run on the GPU. In combination with a custom NEON assembly optimized H.264 decoder, this resulted in a mobile 3D FireMonkey app that could decode and render 40 running video clips simultaneously at 30 fps. We created this as a proof-of-concept for an alternative way of browsing a video (YouTube) library.

And that brings us to the present day. We are seeing a definitive move to 64-bit platforms, and will hopefully leave 32-bit behind altogether in the not too distant future. And Delphi is following suit with 64-bit support for all of its platforms. And I am sure we will see lots of exciting new technologies and new Delphi language features in the years to come…

For us, all this Delphi experience has culminated in a new product and platform called Lumicademy. We are busy getting ready for an early-access release. Allen Drennan will tell you more about it in another post.