Delphi Is 30
blog.marcocantu.com
blog.marcocantu.com
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.
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.
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.
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.
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.
They didn’t just get lost, they got sucked into Pan’s labyrinth.
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.
- Create project
- Drag image viewer component into the form, a couple of buttons to open an image selector
- Compile executable
- Done
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.
(Which, to be fair, is obviously very strongly inspired by VCL; and C# has quite a few things from Delphi the language, as well.)
Borland was in trouble long before Kylix and .NET. They wanted to be everything: enterprise, Quattro, dBase, Sidekick ... Lack of direction killed Borland.
That’s true. Maybe I should have said “final nail in the coffin”.
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 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?
Tools today seem like a hot mess, perhaps more powerful, but much less... human
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.
Unfortunately it made my startup more difficult to sell. Eventually Microsoft bought it, but there were a lot of rounds.
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
What do you mean Microsoft bought it? IT was never bought by MS.
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.
Anyhow that's all history.
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.
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.
I have desktop product which I've developed using Delphi and still maintain. Has 10th of thousands of customers. Gets me some cache every month ;)
I do use many languages but Turbo Pascal and than Delphi have special places in my museum. Too bad Borland fucked it up so grossly and lost market.
I think as a tool for generic applications with extensive UI it is still unmatched by anything else.
Not on the news radar of course, because most products don't focus on desktop anymore, hence Electron for JavaScript etc.
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.
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.
Too bad, then, that he / they didn't.
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.
https://web.archive.org/web/20200213131815/https://www.theop...
thank you Delhi and thank you Marco!
After a while they gave me the title "software developer" and put me with this senior guy who became my mentor.
He taught me a lot of stuff and he loved to use Delphi for everything.
Like, leading everyone down the BDE rabbit hole and leaving them there; QuickReport, the list goes on and on.
From here it looks like that tradition is still going strong, not that I care anymore.
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 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.
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.
(page is back up, btw)
“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".”
Cool coincidence at least :)
The Cassandra DB might've been named with a similar inspiration: Cassandra was an oracle nobody believed even though she was right.