I remember this like it was yesterday. Delphi was an absolute fucking game-changer at the time, and we could churn out Windows GUI programs at an alarming rate. My favourite IT product, of any kind (after Space Engineers).

Given the mess desktop development is right now, I'm tempted to take a look at Lazarus...

It absolutely was. For once you could believe the hype, the ease of BASIC and the speed of C/C++.

Used to be able to churn out Win16/32 apps with ease. Was happily using Delphi commercially from versions 1 to 7. Post that felt the IDE got too bloated and much like visual studio.

Lazarus is defo worth a look, been using it occasionally for a few years now and its very close. Compilation speed not quite up to Delphi but all the old libs like RX will work and there's even libs for connecting to DBs like Mysql and it has a built in package manager for adding new libs.

Having been in the last year group at uni to be taught Pascal rather than C in the early 90s, and having then spent a few years using Turbo Pascal, when I first heard of Delphi I was very keen to try it out, and as soon as Borland started giving away versions on coverdiscs (late 90s?) I was a convert. Continued using it through into the mid 2000's at my first two employers, but then following a change of jobs I lost access to the paid for versions I'd had previously, and by then IIRC the licencing rules had changed to make using them within a commercial setting questionable at least, and so forced to look around for alternatives, I learned about the existence of FPC/Lazarus, which has now had a constant presence on both my work and personal PCs for the past 16 years.

Unless you were a power Delphi user and needed access to some of the Delphi-specific stuff not replicated in FPC/Lazarus, then it really will feel very much like you're slipping into a familiar old pair of shoes, and before you know where you are you'll be bashing out code just like the good old days - I'd definitely recommend giving it a try.

Same experience at uni. Programming was all taught in Pascal, no C. In the late 90's, I was wondering why I was learning Pascal vs. C. I figured they wanted to focus on teaching the concepts / logic and not focus on language or syntax.

When I entered the professional world, knowing Pascal was more helpful than I thought it would be. At that time, Visual Basic (for better or worse) was very popular and listed above Turbo Pascal on my resume. During my interview, I was a bit surprised my future boss noting "Oh, you know Pascal?" I got zero questions about VB / ASP experience. I ended up working in the IT department, but the developers were all Pascal / Delphi programmers. That experience taught me a lot about software development. Using in-house software can make a large difference for a company. There's a huge benefit to the business if the software is good, but if done poorly it will hold it back. We had both scenarios when I started. We rewrote the main application in Delphi and moved from DBase to MS-SQL. Web was done in ASP. Not long after launching the new software we were acquired by our largest client for the software and database we built.

I really believed I would never use Pascal after college. This is one of those occasions when I was happy to be wrong.

Give it a try! I dabbled with it recently and loved it !

I have yet to see a RAD IDE that I like as much as Delphi and/or the early Visual Basic's.

You could just... make an app. Then throw in some code. Then it would work.

I do not understand what toolkit modern app developers are using, but it must suck in comparison because every app looks different and they don't work well and clearly haven't been prototyped for users except the developer himself.

Last time I bothered to look, I got bogged down in a dozen GUI "frameworks" just on Windows alone.

Would give my right-arm for a RAD tool like this or early VB plugged into an IDE like Eclipse for C development, though.

I started my business with a Turbo Pascal application. I used Paradox too. When Delphi came along is was a no brainer and I used it for a lot of applications.

When Embarcadero took over the business the costs, even of upgrades, went sky high so I stopped using it.

Add to that the lack of Linux compatibility and I chose to move to Lazarus.

He says it's much easier and faster to knock up small visual utilities used to make development easier and is currently porting them all from Delphi to Lazarus. I don't doubt it's easier but all I know is that when he retires it's going to be a hell of a problem getting any changes made to them.

Perhaps Qt Design Studio could be a suitable replacement.

Why do you think getting changes made to your colleague's Lazarus code will be 'a hell of a problem'?

Nobody knows Pascal apart from him.

I'm sure that things can be moved around and a field added, but anything more than that means people who already have more than enough work to do have to find the time to learn... well... Object Pascal. You couldn't even use it for CV bragging rights.

"Nobody knows Pascal apart from him."

This is certainly untrue. It may be that there are no people with Pascal skills whom you know. Or possibly there are no people you know that you know have Pascal skills that you're aware of.

However Pascal was designed as a teaching language so it should be easy to learn although IME it's at just the worst distance from C to make learning one from the other tricky.

Also once your mate retires he could have a nice little earner maintaining all his old stuff.

Object Pascal is clear enough that anyone understanding object-orientated concepts can pick it up pretty quickly.

There's some surprising syntax, but nothing all that significant.

:= for assignment, = for equality, and begin...end for blocks are really the main things that get noticed as almost everything that's around today uses =, == and either braces or indentation.

I found it too "wordy", even compared to C++, but for relatively simple GUI applications it's still hard to beat.

Shame Borland/Embarcadero effectively killed it by license costs - hence Lazarus, back from the dead...

Another thing to keep in mind is that you have to declare everything in the proper blocks and before it is called elsewhere: you can't make a call to "getAverage()" if it's only defined further below in the code. Thankfully, the error messages tend to be very helpful

It's been a long while since I wrote any Delphi / Lazarus code (20 years since I last did it professionally, 15 years since I last did it for fun) but I do remember you can do forward declarations of functions and methods. Ah, yes, there it is https://www.freepascal.org/docs-html/ref/refse97.html

It's a bit of a chore, but it helps catch a ton of problems I frequently see in PHP, and JavaScript which is what I mostly deal with these days. If you are not anal about declaring everything, it won't compile. I prefer catching the problem at compile time than running into head first in production because a unit test didn't actually have as much coverage as its author believed.

So... How many are intimately familiar with QT design Studio?

The problem is that small programming, specially for windows is a dying art all around. The alternatives superficially might have more buzz, but if they are not already available in the team, the value of it is debatable

Any half-decent developer should be fine maintaining Pascal code. As mentioned it's a bit more wordy than c-likes, but code is code.

No, Object Pascak and Delphi (and it FPC clone) have their specific semantic, and also you need to know its RTL and libraries. Put it in the hans if a C developer and they will fire into their own feets (saw that). Not long ago I had to fix FPC code where the developer stubbornly avoided to use finally statements to cleanup. And converted exceptions to function boolean return codes...

It's fairly noddy tbh - it was easy to pick up, and produce things quickly, hence it's popularity back then. If people can read Javascript and/or Python, there's not much to worry about in Delphi or equivalents - it's just a bit more "wordy".

Try to modify any moderately complex Delphi/FPC code and tell me... it's not garbage collected, and you need to know which RTL functions to call and the class libary structure. You have to know how parameters are passed... and Python doesn't help you here. Do it the wrong wa and you can use too much RAM or leak it. You might re-invent the wheel.

It's just like starting from Delphi and going to Java (not JavaScript) or Python - even if you can grasp the syntax easily enough, you then need to know a lot more to code efficiently.

Delphi was awesome back in the day when Borland was in charge. But it all turned to shit when Embarcadero took it over and tried to "modernise" it.

Some bits of the language did need modernising to work with newer versions of windows, but they went about it all wrong.

Every new release changed something fundamental and broke all your existing code in ways that were sometimes hard to detect and often time-consuming to fix.

And when customers complained and asked if they could please have a compile option to keep the old behavior, the answer was always no.

"You don't have to use the new version. If you don't like it then stick with the old version."

They didn't seem to understand that customers have deadlines to meet and want to get on with developing their product, not spend months fixing up and testing problems caused by Embarcadero changing the language.

Contempt for your customers never works out well. Many customers got fed up and moved to other languages that weren't so much hassle.

"You don't have to use the new version. If you don't like it then stick with the old version."

I guess I took that to heart - still using Delphi 2007 in 2025!

I still have a legit Delphi on a W2K VM. Arguably the high point for both products.

When Borland lost Hejlsberg it never found a real replacement. Allen Bauer was fine, but he had not Hejlsberg control. While a lot of the wrong people started to work on the product design.

In the past years they borrowed too many langugae features from .NET and Java, and implemented them in a non-OPascal way. That was a mee-too approach, not a sound evolution design of the language. Anyway I didn't found many compatibiliy issues - moved a XE2 application to the last year version and didn't find issues.

Development was moved to Alicante (Spain) and Iasi (Romania), later when acquired by Idera to Ukraine - don't know what happened when the war started.

very encouraging.....

Everything that can go wrong has, and the way to get things right is unfathomable to me at this time.

I downloaded from Lazarus but it didn't install, just sits in downloads.

I used Synaptic package manager and downloaded and installed Lazarus.

No that didn't work either........Upon starting the program I got nothing but error messages.

MAN pages reckon It could be installed in any number of locations on Linux, with libraries here, other bits go there, and then some go somewhere else.

Needless to say, if I want to use this IDE I am going to have to dedicated a lot of time to installing it properly first

SHEESH.........

ALF

I was intrigued by your report, so I tried myself using the non-gui command: sudo apt-get install lazarus

It is a BIG install (about 1.4GB), and several of the dependencies take a long time to unpack or install, and look like they are hung. Maybe that is why it looked like synaptic wasn't doing anything?

It did install, but after seeing a warning about a non-existent lazarus directory, I bailed and uninstalled.

HTH.

> It did install, but after seeing a warning about a non-existent lazarus directory, I bailed and uninstalled.

That was probably the warning it gives you when it's about to set up a local configuration directory (~/.lazarus or similar) to hold the IDE's state.

Most people would consider that a courtesy...

However I would say that most users get it from the Lazarus repo rather than from Debian/Ubuntu, since that way you've got some level of confidence that you've got a version with bugfixes etc.

I dunno boss, just a dumb Windows guy here, only ever used Lazarus on Windows, but I spun up a Mint VM, downloaded the three .deb packages from the Lazarus site, double-clicked them from my downloads folder to install, in the order it stated to do so on the download page (fpc-laz, then fpc-src, then lazarus-project), then typed startlazarus in a terminal, and it worked perfectly. Only glitch was it didn't show up on the Mint application menu until I went into the menu settings, unticked it, then ticked it again, hence I had to look up how to start it from the command line initially. As a Windows guy, I can't guess what might have gone wrong with your install though, but it certainly was straightforward for me.

What a trollish subheading.

I remember there was a time when Delphi was everywhere , and then it just wasn't any more.

C, meanwhile, is not only still around but the younger devs and random politics are whinging about this and that, like this isn't a known problem...

And so was VB6, then MS killed it. But VB.net is pointless compared to C# and neither can do some of the things simple on VB6.

I shall look at Lazarus, especially as I'm now using Linux instead of Windows.

Long ago before Windows, I was using Modula-2 on CP/M and MS-DOS.

Back in the day, I needed to build import tools that (mostly) relied on calling functionality in third party apps. so my 'glue' wasn't particularly time-sensitive - there was no need to build it in C/C++ but these tools occasionally needed to call on image manipulation libs. Not all the time, just once every a few thousand iterations.

In VB, all the libraries for these occasional calls would had to have been bound 100% of the time - soaking up RAM. The magic of Delphi was _late binding_ so I could call a DLL, use it as required then free up the memory again once I'd done. When memory was rare (we're talking 16Mb being about the most anyone ever had) this meant my code could almost always keep ticking away at full speed rather than pause while the OS swapped stuff about to satisfy other tasks. Given an import could take the better part of a week, this was a significant performance difference.

I miss those days. I rather liked using an IDE and language was alien to other people - made me feel I was doing something 'different'! That was also the downside: calling other API's always needed me to mentally translate everything into Delphi friendly routines before I could cut the code. However, I stuck with it from D1 through to D5 because it was just so elegant and efficient to use.

...is that "more sexy" languages have nothing remotely comparable with the Lazarus IDE, which as well as including a form designer etc. has fully-integrated debugging.

Rust, in particular, is going to find that a very high bar to clear.

Rust will just be VS Code and an ever growing choice of extensions, which is how it’s done now.

Rust seems to be explicitly ignoring GUI.

Some of its core concepts are basically incompatible with GUIs - no inheritance at all seems to be an explicit choice, and that's pretty much a requirement for GUI.

C's idea of inheritance is somewhat icky, but it does at least work. Rust couldn't do it like that without the whole damn thing being "unsafe".

No, it isn't. Win32 for example is plain C, not C++. Still Delphi VCL made it far more easier to use, even without the RAD form designed, than using it directly, or even MFC, which was a tiny OO layer only.

The adage "you neeed 100 lines of C code to show hello world" with Windows was true, Delphi made it a one line of code.

It looks to me recent languages are only simplified version of older ones, aimed at more specific use. Desltop development became a more niche sector (albeit large), and more and more application abandon the OS widget set and try to use their own one. Good bye to ease of use...

As @Knightlie said, game changer at the time. I came in at something like version 3; mostly used it to write various utility programs - initially for internal use, but they "escaped". Still maintaining them to this day. A big plus point was that the output was a single executable; so simple to "install" (just copy into an appropriate place). Then version 8 appeared to sell its soul to Microsoft - went all "dot net" and suddenly needed an installer and multiple files. So we stopped at version 7.

Still not sure what to replace it with; unfortunately we used a couple of non-Delphi libraries, so Lazarus isn't an easy way out. I'd also like to drop Pascal, if possible, and have the option of multi-platform support. QT seems the obvious choice, but I'm not sure how our distributing software at no charge in a commercial environment would sit with their free licensing tiers (I've not bothered to check), and there's no way we could afford or justify a paying licence.

They are mostly stuck at the Delphi 7 era of many eons ago. And they waste resouce in compilers for architecture nobody uses, while missing important features. A lot of code is from old libraries barely maintained. And they of course lack the high-end commercial libraries that could make Delphi very powerful. I'm maintaining right now an application written in FPC (on Linux, which is going to be replaced by a Python one), and regardless how much I like Object Pascal - the IDE, compiler and debugger are very far behind. I also developed a small network utility with a recent verision of Delphi for fun, and while it's clear the IDE and compiler made fewer improvements from the last time I used it for large applications (more than ten years ago), it's still far more advanced than FPC/Lazarus. But current Idera commercial policies are really bad - and since skilled developers became rarer and rarer, it's a suicide to invest in it anymore.

Unluckily, since Borland fell on its own sword, Delphi development happened at a glacial pace, and many mistakes were made (like turning it into a .NET language). Anyway, it was sold the wrong way, as a VB replacement, while it should have been sold as an "easier C++" - since it was truly compìled and fully OO.

I do not know why many people didn't like Pascal, just because begin..end while using exoteric character and make code less readable make people look like wizards? Or because it was invented by a Swiss guy (hence probably why characters not common on non-US keyboards were used...) unconsciusly triggered chauvinistc sentiments? Don't know, if Wirth, being a scientist, didn't design new incompatible languages (Modula-2 and Oberon) but had developed Pascal itself, maybe it would have been better accepted. Still the Borland version had a lot of nice features - from COW managed strings (hard to introduce buffer overflows if you didn't try hard) to a C compatible ABI. Also I do not know why Go and Rust get rid of exceptions, that's how to get robust code. Probably because stack unwinding is hard... let the developer check for each error. Object Oriented development is also no longer fashionable, and again I wonder why. Guess it's too complex to grasp for the new generations, used to HTML and Javascript.

Anyway, it's a pity IDEs so powerful no longer really exist. It is true most applications are web frontends now, but native applications didn't go away. And they got worse because the tools to develop them became worse as well.

"characters not common on non-US keyboards"

What characters? I use a non-US keyboard & haven't encountered such a problem.

Which keyboard are you using? A British one?

Getting curly braces on an Italian keyboard, for example, require EMacs-style key combinations. Other characters may require Alt+xyz sequences A Swiss keyboards needs a lot of accented characters from different languages (remeber Switzerland has four official languages). Unlike C and C++, Pascal uses characters quite common in most Western keyboards. C has been designed with a specific language in mind only. And took many shortcuts to make writing the compiler easier, like case sensitivity. I like Pascal, like people, is not case sensitive. But again German has more complex capitalization rules than English.

> Swiss keyboards needs a lot of accented characters from different languages (remeber Switzerland has four official languages).

This Swiss laptop's keyboard is set to the Queen's English, Brenda would be proud!

The nearest thing we have to Gin and Dubonnet -->

A lot of Pascal development was also in Belfast, (QUB) and Professor Hoare was also involved.

What characters not common on non-USA keyboards? The standard US Keyboard has one less letter/punctuation key, some don't have AltGr. It's the least useful On MS Windows/DOS unless you are only using American English and no accents. The US International layout is better on Windows. Linux has both more characters on AltGr and the Compose Key.

I don't think any version of Pascal or Modula-2 uses characters not used in C.

Most applications are not Web front ends, unless you are using App versions of websites on phone/tablet or so-called "Cloud" services; both of those are a bad idea.

Most European keyboards have to use key for accented characters and the like that are not used in the English language. And they replace less used keys like curly braces, tildes (but in Spain) and so on. Other characters are moved around. Just look for keyboard layouts and you'll know.

"The US International layout is better on Windows"

No, if your PC comes with a specific keyboard - especially laptos, and when you have to use different machines, it's not comfortable to switch from one layout to another.

"I don't think any version of Pascal or Modula-2 uses characters not used in C."

Pascal does use culry braces for comments, but it also allowed to use the (* *) sequence. The tilde which is used in C++ for destructos is not used. And it uses "special character" far less. Some were introducer later, i.e. @ instead of a ptr() call - but in Pascal you don't need to access pointer reference continuolsy like in C. "and" "or" "not" are written as such.

"Most applications are not Web front ends,"

Today, most LoBs applications are web frontends.

When creating passwords for our colleagues in Europe, some folk like to include a couple of £s for a laugh.

I have used Delphi for 25+ years professionally (and all the way back to V1 personally). It really was a fantastic product. Unfortunately, it was owned by Borland who didn't really know what to do with it once they tried to go all Enterprisey and turned themselves into Inprise. After that, it has unfortunately stagnated. Coupled with the loss of community and 3rd party support it languishes in a backwater, used only by companies who invested heavily in it decades ago and now have huge codebases that can't easily be replaced.

Such a shame. If MS had bought Borland (or at least Delphi) when they poached Anders Hejlsburg, it would have been huge. It had its moment in the sun in the late 90's and early 00's but just ebbed away.

The joy of receiving The Delphi Magazine every month. The Saturday mornings lost to browsing what was new on Torrys Delphi Page.

I am sad now.

I'm sure MS would have made it worse.

Anyway Borland and its successors remained stuck into 1995 SKUs, while the IT world evolved a lot. Even today, the Professional SKU can't access remote RDBMS out of the box (you need third party libraries). Now in 1995 RDBMS were the like of Oracle, Sybase and DB2 needing Unix boxes, and many applications run on dBase like shared file database. But when MySQL and Postgres became available, that changed completely, RDBMS were no longer the exclusive of big companies with the iron to run Oracle (and even those database got on smaller servers). But today you get an expensive Pro SKU that cannot connect to MySQL or Postgres, but locally. You need to buy the even more expensive Enterpirse SKU.

And the Enterprise SKU, but some RDBMS drivers, doesn't really offer real "Enterprise" features. Delphi is still inherently a desktop development system, as it was still Windows 3.1 era, and Microsoft didn't sell a server operating system. In Delphi XE2 the Windows service implementation was still limited to Windows NT API only. AD integration, message queues, etc. were unheard of. There was a half backed DCOM server library, very difficult to use. Network and web libraries came only through the third party Indy library, or other commercial ones.

Now you can target macOS/iOS/Android also - but with a different GUI library since VCL is too tied to the Windows API, and the resources to develop all that were never adequate. And there were many missteps dut to FaDD - Fashion Driven Development, i.e. when they tried to switch to ARC for object management.

It was a perfect example on how you can get a very good product, and then kill it by bad marketing and bad management, trying to milk customers until they die.

Pity my memory is so unreliable, I won't have the details, but:

I used Delphi to make programs that allowed users to share a database. When I started this project, I bought the Enterprise version (D5?), but ended up using Firebird as my SQL server, and I wish I could recall what libraries I needed for that, but I know I did not rely on any of the Enterprise-only features, so I upgraded to plain, vanilla D6 then D7. After D7, to upgrade I would have had to practically rewrite everything, so I never upgraded past that. I tried Lazarus when it came out, but could not find a way to continue with the Firebird lash-up I relied on. I seem to recall that Lazarus used the "features" of D8, so forgot about it. Have to give it another look!

Firebird was made from an Borland Interbase fork when it was made briefly open source. It could be accessed through the BDE* with the Interbase drivers, and from some version with its own library without the BDE. I don't remember now if in some of the releases the Pro SKU was allowed to call a remote instance of Interbase. Anyway RDBMS access was and is still used to try selling the Enterprise SKU.

The even more expensive Architect one was just a bundle with other applications that usually lasted a release or two only - making it a waste of money.

"After D7, to upgrade I would have had to practically rewrite everything"

Why? The BDE was still supported for a long time, maybe is still in the product. Anyway the past D7 release had a long string of issues, until Delphi 2007. Delphi 8 was .NET only.

* Borland Database Engine, a dbBase-derived middleware that could manage dBase/Paradox/FoxPro files, or connect to RDBMS with its own driver, and then present a common API to applications. Borland and its successor failed over and over to deliver a good replacement (dbExpress, anyone?) - maybe there's now one since they acquired an external company. Anyway good third party libraries existed, but added to the costs. I was using Direct Oracle Access (DOA) to write applications using Oracle as the backend.

It was a high point in software development that will never be beaten, IMO. I'm jaded, frustrated and bored by modern development now - but NEVER when I was using Turbo/Borland Pascal and Delphi. Such fun times.

I'm sad too.

I also miss Verity Stob.

I don't believe you wrote about Delphi without mentioning [1]our blessed Verity.

[1] https://www.theregister.com/2016/05/20/verity_sons_of_khan_witch_of_wookey/

Actually Borland Object Pascal is not exactly Apple Object Pascal (although related), and for a while Borland tried to rename the language itself Delphi but eventually failed.

It is true that Apple developed Object Pascal first. Borland took inspiration from it, and developed the first version, the one who went into Turbo Pascal 5.5, and was called Object Pascal too.

When Delphi was designed, changes to the language and object structures were made to ease the RAD approch. The two most notable ones were the use of the "class" keyworrd instead of "object", and the automatic instation of a class instance on the heap. In TurboPascal, like in C++, instances could be created on the stack, or in the heap with the new() function call, that was removed in Delphi. Other changes were made, for example "published" properties can appear in the IDE automatically thanks to RTTI.

Without a body able to make a standard for commercial Pascal (unlike C and C++, and ISO standard exists but is very limited), every vendor went its own way, and Borland eventually was the only one selling a successful Pascal-based development tool, and kept developing the language on its own.