My Delphi era between 1997-2004 was probably my most productive time. I can't even count the number of apps I wrote with it. The compilation speed, VCL, IDE, compiled code performance, they all contributed to its success I believe. I even wrote three different half-finished Norton Commander clones using Delphi. I also wrote the most popular Turkish social platform with it too.
The things that slowed Delphi down was getting distracted by hype: Kylix (Delphi for Linux) and Delphi.NET both contributed to its decline along with the rise of C#. Ironically, I had cheered for both when they came out, but they basically lacked Delphi's magic: fast iteration and native performance. Also, cross-platform dev apparently didn't have big enough market at the time.
Basically, Delphi was Golang of early 2000's: self-contained native binaries with native performance in a language high-level enough. Unfortunately, they got lost on the way.
The downfall of Borland started long before Kylix.
Around 1996-1997 is when you had early signs of things going awry, when Borland tried to rebrand as an "enterprise middleware" company focused on what they called a three-tier architecture, with COM/CORBA clients talking to server middleware and databases. They bought a CORBA company called Visigenic at a time when CORBA was arguably already old hat, while also betting on COM and Microsoft Transaction Server. They were trying to get into the same enterprise space as Microsoft and Oracle, but then the web arrived and everything started moving away from desktop apps. I don't think they had the enterprise DNA as an organization, and renaming Borland to Inprise couldn't magically fix that.
It arguably started long before then. Borland had a messy history of spreading themselves too thin, trying to do too much, constantly betting on the wrong horse, and ultimately never really finding their feet. Buying Ashton-Taste to buy the already-antique dBASE strained the company, and they went off on weird wild goose chases like Borland Office when WordPerfect was already dying, and they missed the web revolution with the whole Inprise thing. They might have survived if they shed some weight and laser-focused on development tools like Delphi, but a lot of the company seemed to have been pulling in multiple directions.
LOL .NET was absolutely chock full of ex-Borland people. They laid off just a ton of people in some late 90s pre-dotcom downturn. Indiscriminately I assume because a lot of them went on to be very prominent at MS and especially in .NET. My first director as a new software engineer in MS VC++ had been 'accidentally' laid off by Borland. Apparently they tried to hit the undo button the next day but he'd already been hired by MS, so Borland fired his manager. I guess that's one way of reducing headcount.
Back in 2005, CORBA was still pretty much the foundation of Nokia Networks products, no idea where they went to nowadays.
And to this day COM's stronghold on Windows APIs only increased, as the Windows team is very much anti-.NET, most Win32 C APIs are from Windows XP days.
Agree on the other Borland stuff, I was a mostly happy customer starting with Turbo Basic 1.0, Turbo Pascal 4.4, Turbo C 2.0 and Turbo C++ 1.0, until 2000's, using most versions of their products.
My point was that not that Borland-as-Inprise failed because of COM/CORBA, but because the attempt to get into the enterprise application server space.
Early Java-based applications servers like iPlanet, NetDynamics, and WebLogic all did CORBA, but they fit into the shift to the web, and that wasn't where Borland were going. In fact, I don't think they had any web tech at all aside from Borland Enterprise Server, which was another J2EE thing competing in the same space.
I did not do many things in Delphi but I have studied the language and VCL architecture for the very purpose of determining why it is so aproachable and productive (as compared to C, Java, JS, Python and the tooling around them).
In my opinion, it is the result of following qualities:
1. The language direcly supports concepts needed for live WYSIWYG editing (i.e. properties and events) while other languages only simulate it by convention (i.e. Java Bean specification)
2. The language syntax is simple enough for the IDE to understand and modify programatically, but powerful. The properties files that define the forms are even simpler, support crucial features (i.e. references and hierarchy) but do not bring unecessary complexity as general-purpose formats do (XML files or JSON)
3. Batteries included - you can do very powerful stuff with the included components (gui, i/o, ipc, sql, tcp/ip, graphics - all the practical stuff) without hunting for libraries
4. Discoverability - the visual component paradigm with Property editor lets you see all your possibilities without reading the documentation.
5. Extensibility - you can build your own components that fully integrate with the IDE. This is my litmus test for low-code and RAD tools: For any built-in feature, can I recreate the same using the provided tools? Many tools fail this, and the built-in components can do things that are inaccessible to user-defined components.
6. Speed - both compilation and runtime, thanks to one-pass compilation and native code. Leads to fast iteration times.
7. The VCL component architecture is a piece of art. The base classes implement all the common functionality: They automatically manage memory, can store and load persistent state, have properties for visual placement (position, size) etc. The language features really help here (I remebmer something about interface delegation) but there is no magical runtime that does this from the outside, it's an actual implementation of the component that can be extended or overriden.
But of couse there are the ugly things as well: alien syntax, forward declarations, strict compiler blocking the Form Designer on any error preventing you to fix the very error and most of all: while there is very good abstraction for the components, there is none for data and state. There is no good tooling for data modelling and working with the data models. That leads to poor practices as having state in the visual components or in global variables.
I've often compared Anvil (it's web-IDE for web-apps in Python https://anvil.works) to Delphi. I'm curious how you'd rate it on those qualities (off the bat it ticks a lot of those boxes
Which is especially sad because their IDE was the best WYSIWYG GUI editor in existence, then and now. The only alternative that got even close was VB6. If they had made the transition to large screens and responsive design I think they could have dominated mobile app development when it rolled around.
They didn’t just get lost, they got sucked into Pan’s labyrinth.
The weird thing is I love Lazarus for the GUI but I'm too used to VS Code to deal with their source code editor. Coupled with the non-C-based language, I kind of feel like I couldn't write a complex program in it if I tried.
For example, if I wanted to display a .webp in a desktop GUI, I'm confident I could manage it in Python, Zig, C++, C#, and even Java although I don't have a lot of experience with it. With Pascal, I won't have my Python libraries, nor my out-of-the-box C interoperability. In fact, I don't think I've even learned how to use a library with Pascal.
I don't know if in Delphi the editor is better, or the documentation is more accessible. It feels like it has a lot of potential but barriers for entry make it not as interesting as just programming something in Python with Qt.
Yeah, Delphi (and for me now, Lazarus) still provides a substantially richer desktop experience than the web framework of the day. After having written some beautiful, rich apps with this tool, tweaking css makes me want to puke.
Even thinking of css makes me want to puke. It’s just unbelieveable how far the DX has fallen, and everyone is okay with it! Imagine starting your project from implementing poor man’s TForm and TDBEdit. And all new devs actually believe that it’s completely normal.
Yeah that's what blows me away about the fpl/laz open source UI framework, along with the whole library from fpl/laz. Labor of love I guess...it is right up there with sqlite and and linux itself as one of the greatest open source projects in history.
Definitely, Delphi, C++ Builder, Qt, Windows Forms, WPF, heck even MFC.
On Web projects I happily focus on backend and devops, every time I touch CSS there is a new tool in town, apparently now everyone is supposed to be using Tailwind.
Nothing beats Delphi for GUIs. Unfortunately, there were more VB4/VB5 jobs and I had to switch :(
Borland was in trouble long before Kylix and .NET. They wanted to be everything: enterprise, Quattro, dBase, Sidekick ... Lack of direction killed Borland.
I agree, but a lot of it was caused by the C# hype, and the FUD that Delphi was dead or dying, that got dragged up by every IT Manager, IT expert, forum, user group, etc I worked with at the time.
Unfortunately Delphi then tried to transition to dot net itself (remember Delphi 8.0!) and became a pile of crap for the next couple of versions. It got better, but by then it was too late and too steep a climb to attract new developers
I have one more big journey in Pascal to take, that is to re-write my Delphi winemaking system as open source when I retire, but at US$1350 for the Delphi professional license, I will be writing it in Lazarus.
I don't know if it's the rose tinted glasses of looking into the past as I'm getting old but I really feel we missed something along the way on the transition between desktop to web and now mobile.
I remember how approachable Delphi and VB6 were for me as a 12-year-old who loved computers, everything was set up so you could just get things done. You didn't have to choose a UI library, a database layer, a build system with transpiling chains, or a particular language stack. You could focus solely on writing the code that solved your specific problem.
Now, when I try to teach my child how to code, I struggle to keep him interested because we spend so much time dealing with dependencies problems, boilerplate or having too many choices, none of which have anything to do with the actual goal of what we're trying to do.
I don't know, maybe Javascript or Python might take this place one day?
Something is definitely lost, I'd unpopularly argue with FLASH too. You could just start templateing with VB6 and Delphi, etc, and then start writing specific code or script blobs as needed.
Tools today seem like a hot mess, perhaps more powerful, but much less... human
I loved Turbo Pascal, then Delphi. It was the most productive I've ever been as a programmer. I kept upgrading and was a very happy camper, right up to the point where they went insane with their pricing and I couldn't afford to keep going with it. Lazarus is pretty good at filling that gap, except for the horrid documentation.
The knife twist in the back was when Microsoft hired away Anders Hejlsberg and pushed him into the evil that is/was C#. The whole .NET thing was, and will always be, evil and bloat.
As a childhood user of QB45, VB, and then VC++, the whole .NET branding to me was confusing and abysmally explained, and I swear my gut reaction when I see it is that I still don't understand it. At the time it felt like a completely out-of-touch attempt to get in on the dot com craze, and the name itself made no fucking sense.
QB45 had that function-list feature (F2) that I wish all editors had since. It was so clean to see only the current function in “the buffer” rather than a scroll of them in a single file.
The name had to do with web services, which were the Hot New Thing at the time, at least as far as "enterprise" development went. One of the things that were prominently featured in all .NET 1.0 promotional material is first-class support for SOAP.
Delphi is still reasonably popular in some niches. It has a powerful but easy WYSIWYG GUI builder and is close to the hardware without being C++, making it decently popular for tooling for industrial hardware.
Though their website makes me suspect they have given up trying to find new customers and are just building new features for the customers they have
I started with version 1.0. Such an incredibly elegant language. I choose it not to feed the Microsoft Monopoly, but in the end, and after the most incredible f*ck ups by Borland, VB won. I used D7 for many years. Now I use it only as a hoby language.
What do you mean Microsoft bought it? IT was never bought by MS.
I was thinking the other day how people really don't want to pay to buy a programming language - this was the doom of Delphi because it was super popular and alot of people liked it but people really hate paying for programming languages.
On the other hand, people seem OK with paying for IDEs - witness Jetbrains with maybe $1BUSD revenue versus Embarcadero at $100MUSD (extrapolated from 2021 numbers). The numbers are a guess but the point remains.
So perhaps Delphi might have had a different future if it explicitly made all its language free and sold its IDE. People might have been pretty happy with that, because as I recall the Delphi IDE was really nice.
Interesting take. Although, back then people did pay for some other languages right (via paying for the de facto IDE license, ala Visual Studio/.NET).
I think Delphi 7 was very successful, and then 8 and 2005 were just horrible products. It didn't help that around this time native OS apps were replaced with web apps. Paying to write Delphi for the web is insane since it's just transpilation at that point.
It died well before the era where most people began to use free free tools and compilers. Microsoft killed it by hiring Hejlsberg and then doing a decent job with C# and WinForms.
One reason Delphi was productive was that it was a "real language" with a decent object model (more so than VB).
You had a simpler display environment of drag and drop "stuck" components vs dealing with layout managers, plus most of the screens were at best 1024x768. So, you just put buttons and controls where you like. You didn't have the complexities of the portable, cross platform web.
While Object Oriented, for many it was more a component toolkit ala VB. The underlying power was there, but mostly unnecessary. Drag, drop, and wire it up.
The DB model was simpler. Tables instead of raw SQL. VB and MS Access has similar models. The data bound controls connected to a cursor on the back end. There was no ORM to fight. It uplifted the dBase world view of the time on to a RDBMS server.
It was single layer (well, client/server). You had the app, and a SQL connection. No app servers, no transaction managers, no four different layers to get the data through. At best you were using stored procedures on the database. Folks didn't have a data layer. There was no data model. The forms and database table connection was the data model.
And it was just plain fast to use. Fast to build, fast to run, fast to debug. I don't remember waiting for hardly anything back then with Delphi.
Most interesting is that something like Java did not go the Delphi way. It was not "Delphi with a JVM". No doubt some Java product tried to adopt the data model of Delphi, with the data bound controls, and such. But none of that stuck, really. You could a cursor and record set from JDBC, but if you wanted to wire it to the Swing components, well, that's what the hammer and chisel in the corner are for.
Naturally, the web completely blew that model out of the water.
Or focused on improving Swing as opposed to inventing yet another half baked idea to be abandoned, it wasn't a bad start. I couldn't even get JavaFX to run, too weird.
I loved Delphi (used it from 1.0 to 4.0), and wrote some quite major stuff in it. The ease of writing components that you could drag and drop into an app (not just visual ones) was phenomenal. It could have been a VB killer, except that it was based on Pascal, possibly my least favourite programming language ever, not that VB is my favourite.
Delphi was far superior than all other languages of the time, it had all the necessary bullet points to become what is Java now.
Borland really failed on the marketing and sales side, while providing the best tech, they completely missed the importance of having a strong sales team capable of scaling the language inside corporates, which were the driving force back in the days.
I have a lot of good memories of Borland Delphi 4.0 and 5.0 on Windows 95 and later 98/2000.
I was never a Borland guy because I didn’t know pascal or c++ when they were big. But I (believe) I’ve heard stories that Microsoft was especially aggressive about poaching their talent. Things like pulling up in a limo with not-insignificant amounts of actual cash to lure them away. At least I think it was Borland. All’s fair in love & war I suppose, but it does feel dirty, lol.
Anyway, it’s hard to execute when your best and brightest keep jumping ship to the competition.
Please let me know if it was not Borland, because this is a good anecdote.
He got a technical fellow title, the money, and the company that enabled him to make all the good things in the future. He would have never made any of that if he stayed with Borland.
> had all the necessary bullet points to become what is Java now
The language itself was hacked together in a haphazard way. It didn't even have a formal grammar which I found out because it stopped us from creating some pretty important tooling for it.
Edit: I think there was a commercial company that offered a parser, which they created by tweaking a grammar until it got a high enough pass rate on megabytes of publicly available Delphi code.
by accident I got Marco Cantu's Delphi 5(?) book when I was in elementary school, around 11. it had a huge influence on me and on my professional life later on.
Reminds me of Unity. Maybe it's a curse of all technical companies when they stopped to improve the core of their core product but instead flow horizontally.
I've never used Delphi, but I had a manager who had worked with it in a previous job, and he utterly hated it. It was kind of funny, because just mentioning it could get him started complaining about it for a good three minutes. It never looked that bad to me, but of course a quick glance on the Wikipedia page isn't equivalent to maintaining a large codebase.
This manager was also a big advocate for the ColdFusion language, so take that for what it is, but I think his ranting about it has made it so I never tried it (or any of its derivatives).
I hated maintaining a mid-sized Delphi code base too. Although this one might have to do with the fact that the main product code base was basically "a separate repository per each customer, copy-pasted from the least messy one when the development started".
I also remember it was very easy to slap a simple CRUD GUI on top of an existing DB. The trouble started when you had to evolve this. Putting some non-trivial reusable business logic between the UI and the DB was non-trivial.
> Putting some non-trivial reusable business logic between the UI and the DB was non-trivial.
It took me a good long while to figure it out too, but once you got the hang of it, it wasn't really all that complex. AFAICR, the trick was mainly to put object definitions (that pretty closely reflected your DB table structures) and functions/procedures to manipulate them in your data modules with the DB components.
The main problem, IMO, was that these strategies weren't really documented anywhere, you had to figure them out for yourself. This, in turn, was AIUI probably because Borland itself wanted to upsell you to the Enterprise (and later Architect) version, while independent companies also wanted to sell you their various (more-or-less-)fancy "middleware" alternatives.
Happy memories. I discovered it around Delphi 2.0 when I was using Visual Objects in school. As soon as I starting playing with Delphi, it was an immediate realization, "Oh, this is what VO aspired to be"... It was such a great IDE and tool for developing small "event driven" apps back in the day.
“The story of Apollo at Delphi begins with the god's conquest of the Python. According to some ancient accounts, the Python protected the oracle of Gaia, the mother of the gods and first inhabitant of the site. As described in the Homeric Hymn to Apollo, Apollo slew the serpent and then spent eight years on leave, in order to cleanse himself. Zeus also played a role in Delphi's mythological construction. Wanting to find the center of the Earth, Zeus sent out two eagles at opposite ends of the Earth. They collided at Delphi, and Zeus concluded Delphi was the "omphalos," or navel of the world.”
According to Guido's timeline, Python began development in 1989, had its first release to `alt.sources` in 1991, and had its 1-point-0 release in 1994, so it's possible that people at Borland could have been aware of it by 1995: https://python-history.blogspot.com/2009/01/brief-timeline-o...
Wikipedia suggests not however: “Delphi was originally one of many codenames of a pre-release development tool project at Borland. Borland developer Danny Thorpe suggested the Delphi codename in reference to the Oracle at Delphi. One of the design goals of the product was to provide database connectivity to programmers as a key feature and a popular database package at the time was Oracle database; hence, "If you want to talk to [the] Oracle, go to Delphi".”
The things that slowed Delphi down was getting distracted by hype: Kylix (Delphi for Linux) and Delphi.NET both contributed to its decline along with the rise of C#. Ironically, I had cheered for both when they came out, but they basically lacked Delphi's magic: fast iteration and native performance. Also, cross-platform dev apparently didn't have big enough market at the time.
Basically, Delphi was Golang of early 2000's: self-contained native binaries with native performance in a language high-level enough. Unfortunately, they got lost on the way.