Trying to sum up what a programming language and software authoring system like Delphi represents, spanning 25 years no less, is almost insurmountable. Where should I begin? Groundbreaking object orientation? Event driven architecture? A thriving component market? Or perhaps a technological wingspan that stretches from x86 assembly-language to high-performance ARM mobile applications?
Instead of blindly listing technological feats, I want to write about Delphi in a more personal manner. It’s a birthday after all, and birthdays are a time for speeches and reflections; of looking back to where it all began while firmly gazing into the future.
In short, I can only try to convey how valuable Delphi has been, and continue to be, for my life as a software developer. And I am confident that I share that experience with the millions of Delphi developers out there.
As I write this my thoughts go to the many students that are now discovering Delphi for the first time. I hope that my post can provide some food for thought as you begin your journey, and that you will come to love Delphi as much as I do.
In the early 1990s the computer market was a very different place compared with today. In Scandinavia and northern Europe, companies like Commodore and IBM still held a substantial stake in the home desktop market. But within just 3 short years, IBM’s OS/2 would be ousted in favour of Microsoft Windows, and the once mighty giant Commodore would meet its inevitable bitter end; both unable or unwilling to adapt to the new business model that was emerging. That same turbulent year of 1993, Microsoft and IBM officially severed bonds, and IBM pivoted back to mainframes and their PPC architecture. A chipset design that would end up powering Macintosh computers throughout that decade and beyond..
The reason I mention these companies is to give you some context to how chaotic the market was at that time. For young students like myself it was almost impossible to know what technology to invest in. I started my coding career using a Turbo Pascal clone for the Commodore Amiga, something called High-Speed Pascal, published by UK based company Hi-Soft. At the time I was in the first year of my engineering education, and at school we mainly used Turbo Pascal and DBase. Sadly, PCs at the time were very expensive, and instead of paying $4000 for a PC, I bought a Commodore Amiga for $700. I think the Pascal compiler cost something like $99. So for a young student struggling to make ends meet, it was a substantial saving.
In 1994 the compiler I was using could no longer cope, and it was clear that Commodore was never going to recover. Thankfully, I bit the bullet and bought my first PC with a real copy of Turbo Pascal. And I am glad I did, because this prepared me for the release of Delphi the following year.
I’m not exaggerating when I say that Delphi was, and continues to be, a product that changed my life. Since its inception, the impact on the software development industry as a whole has been tremendous. Delphi, and before that Turbo Pascal, pioneered many of the technologies and techniques developers today take for granted, none more so than the Rapid Application Development (RAD) cycle itself. Before Delphi, ROI (return on investment) and TTM (time to market) were buzzwords with only marginal differences when it came to languages. But when Delphi hit the scene, the time and money involved became very tangible, because the differences were disruptive (for its competitors) to say the least.
So out of the chaos and technological “wild west” that signified the early 90s, Delphi emerged as the clear winner. Deservedly so.
One of the things that has always fascinated me, is the concept of evolution with regards to thought and ideas (a branch of teleonomy); something I often mention in my articles.
We like to think that evolution is a slow, gradual and linear process. But when it comes to ideas, and especially technology – my experience is that it moves forward in rapid, unexpected leaps. Incubation times may vary, but eventually something amalgams and becomes the path forward.
When Delphi hit the market in 1995 it was so far ahead of the competition that people struggled to understand it. The notion of event-driven programming had existed for quite some time (Visual Basic for example), so Delphi didn’t incubate in a vacuum. There were C/C++ compilers that had evolved similar language features that Delphi brought to the masses, but they all lacked the simplicity and elegance of Delphi.
On the Commodore machines that I grew up with you had plenty of software that enabled drag & drop form design, and to some extent a similar approach to programming (albeit in a more primitive state). But what was unique with Delph is that no company had ever merged these ideas into a coherent whole where everything added up. The world had never seen anything like the VCL framework, or an IDE that adapted and integrated so closely with your code. As you wrote it no-less.
And what brought all of these elements together, was an extremely powerful compiler that was lightyears ahead of everyone else. The C/C++ compilers of the day (from a Pascal developer’s point of view) were absolutely powerful, but visual design was largely done separately (the exception being Borland C/C++ which had frameworks like OWL, so UI’s could be done by code). So in competing products, like Wacom (1984 ~ 2010) or Storm C++ (1995 ~ 2016), you would make the UI in one program, then import these designs into your C/C++ project as a resource file; not unlike Apple .nib files to this day. Once that was done you could finally build your program; a process that could easily take five minutes or five hours depending on the size of your codebase. Even a minor UI change would result in minutes worth of code generation and linking.
Delphi’s aggressive compiler and smart linker reduced this to seconds. And it was for over a decade the fastest compiler in the world. It was so fast, that most developers would use the compile function as a quick and dirty syntax check. An unthinkable task with other languages.
The field that Delphi without a doubt took to the next level, was object oriented programming in the true sense of the phrase. Up until that point object orientation for Pascal had been somewhat half-hearted; Turbo Pascal 5.5 being the leading toolkit for DOS (marketed as “Turbo Pascal with objects”) where objects really was little more than record types with procedures. Unless you were fluent in C++ you had to venture to languages like Modula II or Smalltalk to find object models that resembled what Delphi would bring to the table. But they both lacked the RAD (rapid application development) layer that Delphi excelled at.
With Delphi, the entire spectrum of technology that was sown and incubated through the 80s and early 90s, leaped forward into a system where OOP was a fundamental aspect of the language itself, rather than tacked on as a bonus feature. Since Delphi programs operated with a full VMT (virtual method table), developers could enjoy clean inheritance, virtual and abstract methods and reliable data encapsulation – all of it from an easy to learn, easy to use and highly competitive language.
The proverbial frosting on this already impressive cake, was Delphi’s dedication to visual programming. That you could drop a button on a form, double-click on it, and fill out the event handler ad-hoc without leaving the IDE or switching a tab. This had already been done before, but Delphi was a real native compiler, not a bytecode or managed system where the IDE could operate with its own rules (at the expense of performance). It was the first time you could approach C/C++ level performance and depth – from the ease and elegance of Object Pascal. The fact that you could also write machine code side-by-side with Pascal put Delphi in a whole different league from say, Visual Basic or SmallTalk. Visual Basic literally went from hero to zero overnight.
Above: Modern Delphi has evolved side by side with C/C++ but retains its strong focus on visual OOP programming
This point, that Object Pascal had the same depth and power as C/C++, was strengthened by the fact that Delphi’s repertoire of components, both visual and not, were made in Delphi. In other words, you had no forced dependency on third party vendors for components (which was the modus operandi of competing solutions). Anyone could sit down and write their own components; components that could be sold and shipped as both binary or source. This gave rise to a thriving component market that eclipsed the competition utterly.
I will even go as far as to say, that had Delphi been released for IBM OS/2, it would have saved the platform. It was that significant.
In my final year of College we had Visual Basic on our curriculum, but behind closed doors it was Delphi we were using. I actually never attended a single class for my Microsoft certification, and aced the exam without reading more than the bare essentials. By then I was already writing COM components in Delphi and had gone far beyond the curriculum.
I vividly remember how our teacher put the curriculum aside one day, solely to present Delphi for us. He was a passionate developer and could hardly contain his excitement as he put the Delphi box in front of us. Wide eyed and mouth open we absorbed every bit of knowledge we could about this wonderful new system. Eager minds bursting at the seams with fresh ideas; it was a marvel.
When I picked up my exam papers I was offered a job as a teacher, which I respectfully declined. The idea of teaching anything but Delphi felt like a step backwards.
After my initial College education (or the European equivalent of College) I spent a couple of years working as a technology journalist while honing my development skills. By the time I returned to my studies at university level, Delphi was not just included in the curriculum, it was the curriculum. Young developers today often wonder why RAD Studio contains both Delphi and C++Builder; but this combination is what constituted the backbone of a traditional software engineering degree. A trend that continued as late as 2002 (and still does in parts of the world).
These two languages have evolved side by side, and share a rich history that began in the 1970s. And although many developers wrongfully regard Object Pascal as old, while C/C++ is seen as modern, C is actually the same age as Pascal. Just like Delphi did not evolve in a vacuum, neither did C. And Brian Kernigan and Dennis Richie based their standard on already existing (and often conflicting) tools from the mainframe industry.
So Pascal and C as languages, and further Object Pascal and C++, have evolved side by side, although formally they are separated by three years.
Thankfully, Embarcadero continues to do a spectacular job bringing Delphi as a product up to speed with the latest features. Features like generics, anonymous methods, helper classes, attributes (and much more) have been a part of the language for years now. As a consequence of this work we are seeing a steady adoption of Delphi in the marketplace. Both mature developers returning from other languages, and new developers who are discovering the productivity and power of Delphi.
One of the things that warms my heart is that Delphi and C++Builder are once again making headways in education. During my time as an SC for Embarcadero I helped set up two universities here in Norway with Community Editions. There are also institutions in Scotland, Italy, Portugal, South America,.and Russia (to list a few) where Delphi is thriving.
In both cases here in Norway the teachers were thrilled, because they taught Delphi during the Borland years. As one of the professors elegantly put it: “[it is] like greeting an old friend”.
Last month Embarcadero announced that Turkey will be offering Delphi free of charge to their students. With an estimated one million students involved this is wonderful news! First and foremost for the students which reap the benefits of learning a reliable, modern, and archetypal programming language. Something that will make them better developers, like it did for me and countless others.
Without venturing too far off topic, there is something to be said about archetypal programming languages. This is an exclusive club that both Delphi and C++Builder belong to with only one other language member (although Rust should definitely be added to that list).
An archetypal language is one that embodies the fundamental principles of computing. These principles are immune to things like product variation and market changes, because they represent the logic that a computer is based on; a bit like the laws of physics if you will. And as of writing, only assembly language, C/C++, and Object Pascal qualify as archetypal; with assembly language being the foundation that everything else rests on.
Above: Delphi has a wonderful wingspan, from low-level advanced coding to high-level object orientation
Several operating systems have been written in Pascal. The most known system is none other than Apple’s classical Macintosh operating system, which spanned both 68k and PPC processors. And while C/C++ have without a doubt become the leading language for this type of work, the fact that Apple used Pascal as their core language until the return of Steve Jobs in 1996 (where Jobs brought with him Objective-C and Unix from NeXT), is a testament to its power and versatility. A versatility that has since been greatly expanded.
I should also mention Ultibo, which is a very popular Embedded system for IoT devices today. This system contains a kernel written completely in Object Pascal, along with all the essential components needed to build modern embedded systems. Everything from the USB stack to networking is written solely in Object Pascal.
While the system is made using an open-source alternative compiler inspired by Delphi (FreePascal, which Delphi temporarily used for early mobile support in the past), much of the Ultibo code originated in the Delphi community.
So 25 years down the line, Delphi is just as powerful and versatile as ever. There are a lot of levels to talk about Delphi, and we have just scratched the surface so far.
Note: Obviously, Delphi and C++Builder are tailored for work in concert with an operating system, focusing on system services, servers, libraries, desktop applications and mobile software. But the languages themselves embody the timeless principles I mentioned earlier; making them distinctly archetypal.
No birthday is complete without a few words of wisdom preceding a toast.
Like a proud family member, because I think we all feel a kinship with Delphi after so many years, I have praised Delphi for its countless accolades in the past, and hopefully conveyed some of the reasons why Delphi has remained important and relevant; perhaps more important today than in the past.
I could probably continue indefinitely if my goal was to cover everything that Delphi has and can do; what it represents and the businesses it has nurtured. They are innumerable and such a task would span volumes. Delphi truly is an inexhaustible source of innovation, and a blog post cannot possibly hope to do it justice.
Above: Delphi and C++Builder covers a vast landscape of technologies. Easy access to documentation from within the environment is essential
For the past 15 years I have dedicated myself completely to Object Pascal as a language, and Delphi in particular – as a matter of principle. I have blogged, written papers, taught Pascal at schools and done everything in my power to remind people of what Object Pascal represents. I even wrote my own development studio so Object Pascal could target esoteric new platforms like Node.js and HTML5. And it was all written in Delphi.
The world of software development has accepted a staggering amount of compromise over the years, and the loss of quality and reliability in the industry as a whole is now painfully apparent. Which is also why academia is eager to turn the trend and get Delphi back into higher education where it belongs.
Those developers that enjoyed a classical engineering education of which Delphi and C++Builder are synonymous, went on to build products and companies that today defines the norm. The movers and shakers of the IT industry did not graduate in Java; they made Java. Everything that truly matters was forged with archetypal languages. This is an unmistakable fact to be reflected on. Linux would not exist if Linus Torvalds had only Java at his disposal. Those might be harsh words, but they are nonetheless true.
We live in a world where it is difficult to make a living from a single programming language. And I’m not saying that you have to pick just one. Each language has their uses, and every developer should keep a well stocked toolbox. But I cannot underline enough how important it is to base that toolbox on an archetypal language.
This has nothing to do with personal preference, fandom or evangelizing. I’m writing this from hands-on experience, from making a living as a developer for 35 years. I feel I have accumulated at least some merit to speak openly on the subject.
If you want to be an average programmer, then specialize in an average language. But if you want to be an exceptional developer, then make sure you learn one of the archetypal languages – of which Delphi is (in my personal view) the most effective.
If you know Delphi or C++Builder, learning any of the other languages will be a walk in the park. Because by the time you have mastered Delphi, those fundamental principles I keep coming back to, will be intimately familiar. At which point you stand a cut above the rest.
The beauty of Delphi is that you can approach it on many different levels. Nobody expects you to write inline assembler or create a database engine from scratch. Delphi has this wonderful wingspan that has been perfected and polished since Turbo Pascal, a forward accumulation of technology that is tried and tested by time.
So you can grow and evolve with the language at your own pace. As long as you are curious and willing to challenge yourself, Delphi will be there to guide and educate you.
And unlike some languages, the knowledge and insight you take away from each deep dive into the depths of Delphi, are timeless and beneficial regardless of future endeavours. Delphi? It is philosophy, it is logic, it is art; it teaches you to think and to distill solutions where others see only obstacles. If you are to take away anything from this article, then let it be this:
A software engineering degree is not a destination, but rather the start of an intellectual journey of a life-time.
So dear Delphi, my wise old friend, I wish you the best of birthdays!
And thank you for the privilege of sharing your journey through 25 marvelous years. I look forward to the next decades together with the same eagerness and joy I first felt at College.
Happy 25th Delphi! #Delpi25th