Skip to main content
Thoughts from David Cornelius


This time of year in the United States is marked by a major holiday, Thanksgiving, the last Thursday of November. It is during this time that ad campaigns, religious organizations, and families everywhere tend to step up their recognition of everything they're thankful for. As a software developer, I'd like to hook into this theme and highlight features of programming tools I use that make my life better--most notably, Delphi--and create my own "thankfulness" list.

Part of the drive behind this is the fact I've been using Delphi 5 and the BDE a lot lately to support some legacy code. Fortunately, there are plans to majorly upgrade the code base and database connectivity to newer technologies but it has definitely reminded me of how much better the newer versions are--and how much everything has progressed in the last 22 years.

But first, while I'm using Delphi 5, I'll point out a few things for which I am thankful:

  • Backwards compatibility. I guess you could say this is both a blessing and a curse: a blessing because this old compiler still produces Windows applications that run on the most recent versions of Windows but also that very fact means there hasn't been a hard reason to force an upgrade of the code base.
  • GExperts. One of the most popular of all Delphi IDE plugins, GExperts is an invaluable aid as it provides so many wonderful productivity benefits, I can't imagine programming in Delphi (especially Delphi 5) without it. With its Grep Search, Set Tab Order feature, Favorite Files list, Replace Components capability, Code Librarian, Multi-line Component Palette, and (my favorite) Code Proofreader, there are many valuable and time-saving programming aids--too numerous to mention here.
  • Castalia. Another great IDE plug-in, this one provides, among other things, stack-based bookmarks and structural highlighting within your code. This was originally a commercial product by TwoDesk Software but was acquired by Embarcadero in 2015 and subsequently integrated into the Delphi IDE over the next few versions.
  • Optional Parameters: This is a language feature that comes in handy so many times, like when you need to make a small change in a method for a particular case but you don't want to change the functionality for the many other cases for which it was originally written.  By adding an optional parameters and defaulting it to handle all the other cases, you can keep current functionality, don't have change gobs of code, and still handle your new situation.
  • Speed. Because there weren't as many features in Delphi 5 as there are in newer versions of the IDE, it loads really fast on today's modern computers--another ones of those pro-versus-con type of things.

Speaking of newer versions of Delphi, I'm glad the product has continued to evolve and change. There are sometimes lags in features I've seen in other development tools but by and large, Delphi is quite feature-rich and highly productive. Here are the things I'm most thankful for (in no particular order):

  • Even more plug-ins: In addition to the aforementioned GExperts (still available in Delphi 11) and Castalia (features merged into the IDE) there are additional plug-ins. I've written about a couple of these before: Bookmarks and Navigator, originally by Parnassus. These provide additional bookmarking features and add a mini map inside the code editor.  When Delphi XE8 introduced a new Welcome Page, I complained but found a way to improve it; then I was very grateful when Daniel Wolf wrote a replacement which helped me manage the plethora of projects I was working on. Now, in Delphi 11, another interface has arisen but it's much more flexible and has an API--which has already been used for another multi-project management plug-in.
  • Third-Party Components: There are many software vendors that support the Delphi language with libraries and components. I've used several of them over the years to add highly-functional grids, spell-checking, enable a plug-in system, and provide a richer experience for my users.
  • Backwards Compatibility: I mentioned this before but meant something different. Not only can old programs compiled with Delphi 5 run on new Windows operating systems, but old Delphi code can be upgraded with little effort (many times) to compile in newer versions of Delphi. There might be many things that need to be adjusted to take advantage of newer technologies (e.g. migrating from the BDE to FireDAC) but at least you can often get old code to compile without too much heartache--seldom do you need to completely rewrite something unless third-party components are no longer supported.
  • Attributes: At first, I didn't really understand the need for attributes but after I saw a few examples of where you could add functionality to a class without changing the class's purpose or making multiple derivations of the class, it really started making sense.
  • Generics: Another language feature added several years ago, this makes building complicated object-oriented applications much nicer in that you don't have to cast to-and-from a standard TObject.
  • REST Support: It's so nice to tap into a huge variety of public APIs with native libraries that come with Delphi. And by using the REST Debugger and it's Copy Components feature, you can create these applications very quickly.
  • Live Templates: There are many time-saving features in code editors but I think one of my favorites (after color-syntax highlighting, code-formatting, auto-indenting, and so forth that we come to expect in all editors these days) is the ability to type abbreviations and have them immediately expand to words or even context-aware code fragments that understand how to complete a class, add variable declaration, wrap a try-finally around an object, and so forth. I talked about my love of Live Templates over a year ago.
  • Error Insight: I really like having the compiler check my code as I type and warn me of mistyped variable names or invalid method parameters; it saves time later when I compile and then find out my mistake. Read more about this and the related Code Insight features on Embarcadero's Docwiki.
  • Flexible IDE: I like the fact that the IDE's windows are dockable and resizable and that you can save layouts. Every programmer is different and even I use Delphi a little differently when I'm on a laptop than when I'm on my desktop computer with multiple monitors. In fact, I've even had specific layouts for certain projects!  And I really like the fact that you can have a Debug layout that it switches to automatically when debugging an application.
  • Speed: The Delphi compiler is still one of the fastest on the market. I like being able to hit F9 and see only the modified units compiled, linked, and the program start up so quickly.
  • Dark Mode: I was going to say this is a silly thing to mention but the white light from three bright monitors in front of me is a little hard on my eyes--I much prefer dark edit screens. While the code editor in Delphi has had a variety of color schemes available since the beginning (greatly enhanced by the open source project, Delphi IDE Theme Editor), I was pleased when the whole of the Delphi IDE, including menus, dialogs, edit boxes, the object inspector, and other windowed areas were enhanced with an overall consistent theme applied. This took place late in 2017 with Delphi 10.2 Tokyo's second release.
  • Native Compiler: Ever since the early days of Turbo Pascal, which created small .COM files, this line of Pascal compilers has created tight, native compiled code. Even after going cross-platform, the generated applications have been relatively free from runtime environments which are necessary for Java or web apps. Even .NET has the CLR and it's arguably better than the JRE (Java Runtime Environment) and can now be compiled natively (from what I understand). But us Delphi developers seldom run into "DLL Hell" problems or experience application crashes because some underlying framework ot updated (unless you had to use anything related to Internet Explorer); we've been relatively free from these types of pitfalls plaguing other tools.
  • Platform support: With XE2 in 2011 came 64-bit Windows support and soon after that MacOS, iOS, and Android. In the early days, we never would've guessed we would be able take our skills and move them to support other platforms. Sure we've had web server support for a long time but simply spitting out HTML from a console-based Windows app is a far cry from producing mobile apps that look and feel native from a single code-base.
  • Project Manager: I like being able to load multiple projects, save them together in a project group, and change options such as configuration or platform for all projects at once with the Project Manager toolbar buttons. This feature has come in handy when dealing with a program with several plug-ins that are managed as a single application suite.
  • Webinars, books, and forums: While Delphi isn't the most popular development tool on the planet, it definitely has enough of a following to provide plenty of resources for learning the language and discussing issues with fellow programmers. The Delphi-PRAXiS forum is the most popular place to ask questions--and get plenty of answers. And there's a website devoted just to the books available for Delphi.
  • Free code! The community includes developers that give back as well. There are a plethora of GitHub repositories and collections of repositories including Jim McKeethDelphiWorlds, Daniele Teti, Andrea MagniHeidiSQLSkia4DelphiAwesome Pascal, Graphics32Delphi Package ManagerEmbarcadero Technologies, Internet Direct, FastMM4, DUnitX, and many more (including my own).

What about Delphi are you thankful for?

Thomas Müller (not verified) Wed, 11/16/2022 - 23:59

Compatibility of programs compiled with Delphi 5 to the latest Windows versions is not an accomplishment of Delphi but of Windows. Microsoft has put a lot of effort into making Windows backwards compatible to old 32 bit software even to the point of breaking^D^D^D^D^D^D^D^Dadapting the security concepts for some of them so they can even continue to write to the program files and Windows directory, which has not been allowed for normal programs since Windows 2000/XP 20 years ago.

Having said that: Yes, the backwards compatibility of the Delphi IDE to older versions is always astonishing.

david Thu, 11/17/2022 - 07:01

In reply to by Thomas Müller (not verified)

Yes, you're right--I almost mentioned that. I do recall, however, working on an old Visual BASIC app many years ago that actually broke because it relied on some Windows DLLs that were upgraded. I suppose that could happen with Delphi apps as well but I recall VB was especially vulnerable and many programmers lamented its lack of backwards compatibility but that may have been more in code upgrades than old apps working on newer versions--it gets kinda murky after a decade or two.

Thomas Müller (not verified) Sat, 11/19/2022 - 02:14

In reply to by david

Visual Basic relied a lot more an binary extensions for components and functionality. While with Delphi, if you take/took care to always buy the source code with components you buy, you will always be able to move on to new IDE versions and - as long as Windows supports 32 bit applications - to new Windows version, in VB6 and earlier that was not possible. Not sure about nowadays, I never used

Add new comment

The content of this field is kept private and will not be shown publicly.
Please enter the characters shown; no spaces but it is case-sensitive.
Enter the characters shown in the image.