Hacker News new | past | comments | ask | show | jobs | submit login
24 years of Delphi and Delphi 10.3.1 is out Today (marcocantu.com)
204 points by mariuz 68 days ago | hide | past | web | favorite | 162 comments



For almost 11 years now, I've been working professionally with Delphi. And it would be wrong to say it's been a smooth ride. There's nothing wrong - per say - with Object Pascal. Or rather, it's not worse than C++, but Delphi - i.e. the library and IDE - is what's lacking behind.

It was definitely cutting edge in the mid-90s, but it has not managed to keep with the times. Most Delphi developers rely on Indy, a third party library of various classes, that provide a lot of functionality the base library should have provided. And even Indy isn't that quick at picking up new features as the world moves on.

When Embarcadero took over from Borland around 2009, they clearly tried to move it on a direction that would encourage more developers. They created ways to build your Delphi application for iOS and Android, which was meant to get more people to write Delphi. It didn't, since the IDE still cost over $1,000 a year. I'd imagine the people who used that functionality were those who were already 'stuck' with Delphi.

Indeed, even as one who engages a lot in the Delphi community, mostly through necessity, notice that very few people join the community without having some legacy application to maintain. And the community as a whole is dwindling anyway.

Embarcadero should have focused on core aspects of the language, which they are finally getting around to. You can now declare variables in the middle of function? That's so 21st century! (Although the forward compiler can't figure it out, so you'll see a lot of red lines in your IDE if you do.)

I won't be writing Delphi professionally a lot longer, though. As I am taking a new job this March, where I am moving on to Go. So it's more a bittersweet good bye for me. Because Delphi is frustrating to work with on a daily basis, but there is a lot nice about it.


I think the $1000 price tag is totally wrong. I would never pay that kind of money for an IDE unless it was _really_ better than anything else. But this means:

  - the language has huge community (so I'm not stuck with a dying language)
  - it allows me to do anything (huge extensibility)
Unfortunately it is difficult to change the pricing model once you have existing clients. On one hand they are the only ones paying for your development, so you can't lower the price tag. On the other hand building a bigger community takes time, and it won't happen at this price. So unless they become really creative, Delphi won't survice. Pity, I have used it (yeeeears ago) and it was a brilliant product for building UIs, very easy to use and powerful. Haven't seen anything similar since.


The pricing model is the main reason newer people are not getting into Delphi. This is why they tried to lure people with iOS and Android capabilities. But when there are alternatives that are free, why bother?

Yes, Delphi has a Community Edition now (which is free), but the fact that are excluded from a large portion of the library, because you cannot afford it, is always going to alienate some people. And it is always going to feel frustrating, when other languages don't have those limitations.

My office only uses the Professional Edition, because we cannot really afford the Enterprise Edition, which means there were some problems we ended up 'inventing ourselves', because they were only available in the Enterprise Edition.

Delphi probably won't survive another decade (in my estimation), but Pascal will live on as FreePascal/Lazarus.


"Delphi has a Community Edition now (which is free), but the fact that are excluded from a large portion of the library"

That's not really the case. With Delphi Community edition you get support for 4 operating systems, VCL and FireMonkey, it only lacks access to Enterprise databases like Oracle and some of the multi-tier architectures. Community has a large percentage (80%+) of the features...


You are correct, saying 'large portion of the library' was a mistake. But as I remember, you don't have access to the VCL source code with the Community Edition. The feature matrix says that this is 'limited in Community', whatever that means.

We wanted to do MongoDB connections, which comes with FireDAC. But that's only available in the Enterprise Edition. So we ended up rewriting TMongoWire[0] to fit our needs.

I am sure you can do most things in Delphi in the Community edition, but it's a little too late, unfortunately.

[0] https://github.com/stijnsanders/TMongoWire


You are right about MongoDB... as for "VCL source code" it is available, but with licensing limitations


Oh FireDAC is no longer available for Professional version either? Geez.. really not going to lay down $3k for an EE.

How is that "professional" if you cannot even read/write to sqlite.


Both Professional and Community Edition include FireDAC.

https://www.embarcadero.com/products/delphi/product-editions

"Build database apps with local/embedded connectivity" is in every edition.

The only difference is you need Enterprise or Architect to connect to "Enterprise class" databases like a remote Oracle server.


unfortunately "Enterprise DBs" means also Postgresql, Mysql, SQL Server etc. (anything Client/Server)

you can probably just use another Framework like (free) ZeosDB (http://zeoslib.sourceforge.net/)

or some paid ones e.g. from Devart (https://www.devart.com/dac.html)

but still, its frustrating to have to use something else for such basic functionality ...


Ah ok, it doesn't mention FireDAC, fair enough. At least you can save data in a database.

Thanks for the correction.


@fmxexpress thanks for the info. That's exactly what I am doing now, but I am not on the latest version.


This is incorrect. I have Pro. I use FireDAC. SQLite can be used with Pro.


As a person who has used Delphi since around 1997 and Turbo Pascal I find it frustrating and extremely disappointing that people like Marco Cantu who are leading figures in the Delphi community do not do enough to criticize the absolutely crazy Delphi pricing and products such as this ludicrous "community" edition with the $5K/year limitation.

Why would any company want to start developing in Delphi if the pricing/developer is suddenly going to jump to a ridiculously high number the moment they touch $5K/year limit?

But even the $5k/year limitation came in far too late.

I am very sad to see the way the Delphi community is languishing and slowly dying out.


Yes, thank goodness for FreePascal/Lazarus.

Also have the Professional Edition and would update if only they took the macOS platform seriously. Again with this update, like the previous few, there are zero improvements for macOS.

Really regret to ever have invested any time (and money as I bought several updates) into their FireMonkey platform. It looks bad on macOS for not using native controls and it looks bad on Windows because the fonts are blurry.

With macOS only being 64 bits around the corner and openGL being declared end of life, one would expect to see some movement or improvements. Nope.


@fmxexpress you are showing up marked dead here.

Yes, they have it on their roadmap for 2 years now. Doesn't offer a lot of confidence in that it will actually show up on time. Right now you cannot release a 32 bits app anymore in the apple app store.

So I'd argue that they are very late already. Who is going to invest time into a product you cannot release, but that -pinky promise- will be delivered before you can not even run existing 32 bits apps anymore.


They have macOS64 on their roadmap. I agree though that they should keep up with the macOS support better than they do. Even if it is probably the smallest platform by marketshare they support.


Their community edition is kind of a joke when compared to Microsoft's VS Community Edition which basically brings everything.


Does VS Community Edition let a developer compile to Android/iOS/macOS32/Windows with a single codebase and single UI? I've used Xamarin and it doesn't really seem to do that.


Depends on what you use. You could use Cordova instead, but I'm not primarily a mobile developer. I'm mostly web / back-end.


I mean companies pay that and more to become Microsoft shops, at least before .NET Core and Visual Studio Code, and this isn'. I agree entirely with you. I would love to learn Delphi from a hobbyist perspective, can I get a license for like $299 or around that range? No? Hell why isn't there a freebie edition anymore.

Except, I can get all of Visual Studio for free for Community use, and yet I can't get a completely free edition of Delphi. I think I got a trial, and it failed to compile / run certain projects. It was basically crippleware for me, I couldn't get it to do a damn thing for a number of the projects it generated code for. I will say though, the IDE is fast as hell and it was a very tiny install.

I also would of loved them to have somewhat teamed up with the FPC group to make it so Delphi compiles for Linux in exchange for either monetary support for the FPC group, or enhancements that would make their compiler awesome.


Since July last year, a free Community Edition of both Delphi and C++ Builder has been available. Feature wise, it is essential the Professional edition with a few license limitations.


Delphi does compile to Linux. With the FMXLinux third party add on the Delphi FireMonkey framework compiles apps to iOS/Android/Windows/macOS32/Linux with a single UI and single codebase.


Delphi community edition includes Windows, Android, iOS, macOS, with FireDAC database access and full access to the source for the VCL, FMX & RTL. https://www.embarcadero.com/products/delphi/starter

Basically everything in Professional, but free for hobbyists.


I just took a job taking over for a retiring guy in a factory and he wrote everything in vb6 and ladder logic which I swear looks exactly like Delphi. Ladder logic itself is annoying as hell to work with but I do like the little bits of Delphi mixed in for the complicated math stuff.

The other guy wrote everything in gcode macros using notepad.

Lots of memories though. Giant Enterprise applications we created 20 years ago.

Have to admit I really prefer go and rust and python though. I think I still have all those Dr Dobbs in my basement too. :)


I started with Delphi3, worked a lot in Delphi4, and then the version 5 came, but in meantime the web became THE THING, and Delphi didn't really find a fit in that new world of open-source tools and web apps instead of monolith desktop apps. Which is a shame, as in 90s it was the best IDE, with one of the best and most useful help systems I ever used.


For almost 11 years I worked professionally with Delphi (2-6) before retiring from programming completely in 2006. Then in 2019 I'm back modifying some Delphi programs (microservices against Oracle DB) that I wrote over 15 years ago...and using Delphi 6! Of course, the long term plan is to rewrite in .NET but luckily domain knowledge is worth more.


I'm amazed about once every three years when I hear or read something that reminds me delphi is still around. For nostalgia's sake, here's a link to the pre-release review of Delphi 95 that I wrote for Dr. Dobb's back in the day: http://www.drdobbs.com/a-quick-look-at-borlands-delphi-95/18.... Doesn't seem like such a quick look now, but articles were longer back then :).


Nice review ;-) I think I read it, back then


I started working professionally in Delphi around 1998, and then spent 13 years evolving and maintaining a sprawling 2+ mloc reservation system.

They had a great thing going around that time, but then the pivoting and squeezing started. Instead of evolution we got enterprices, buzzwords and bit rot. By Delphi7, I'd say it was already as good as dead.

All owners so far share an unfortunate tendency to oversell half-baked solutions with no future, all the way up until the point where they pivot and push a brand new successor with no future while deprecating the previous attempt asap.

Their database, Interbase; was open source for about a month. Until the suits realized that no one would buy their shiny enterprice crap if they could simply download it for free, and it was closed again asap. Only now all the people who knew anything had joined effort in a fork called FirebirdSQL.

It was even released for Linux under the name Kylix, free for non-commercial use if I remember correctly. Until Microsoft bullied them into dropping the cross-platform game right now in return for cozy time with the centerfold creep and his side kick sweaty monkey. I just threw up a little in my mouth writing that so I'll stop here.


This. I completely agree. Delphi was killed by the suits who suddenly jumped onto the Application Lifecycle management fad. Sad.


Back in the late 90's this was my favorite development environment. Still have fond memories of it. Back when "Rapid Application Development" was the buzzword of the day, it actually delivered.


I cut my teeth on Delphi 1.0. Got tons of mileage out of Delphi 2 & 3. Delphi 5 Enterprise was the last IDE I paid for out of my own pocket ($2000!).

I missed it terribly when I moved on to Java (getters and setters?!? the horror!). I can't imagine going back now, though. Java is mostly a memory. Javascript, Clojure, and Rust in programmer's editors are enough.


Also related, lazarus 2.0 was recently announced. It even has an online package manager.

http://forum.lazarus-ide.org/index.php?topic=44161.0


Embarcadero tools and ides, are super expensive considering that most developer tools are either free (visual studio developer is free for individuals), or way cheaper (jetbrains)

I really dont know who their target customer is, but then again, when I look around, I find tools like windev (PC-Soft) and Clarion (softvelocity) have a loyal following

Except of course that embarcadero, is way more expensive

Free-pascal is cute and probably productive, but there are way more intellectually and technically interesting options, even tcl/tk in my opinion is better intellectual and technical investment of time compare to free-pascal


Most of their target audience is stuck maintaining a legacy system developed decades ago and will happily pay the premium as long as it's cheaper than rewriting everything using a modern stack.


We're in the process of migrating off a 4+ million line Delphi application that basically runs the whole business, but it's a 10+ year project to "grind the monolith", so who knows when we'll actually be done. In the meantime, we don't have much choice but to keep paying the licensing costs...


What do you migrate to over a period of 10 years that won't be obsolete 1/3 the way through that effort??

As much as I love making old code new I'm not sure I could stomach a 10 year project.


Microservices, essentially.

It's not really 1 x ten year project as such, but heaps of smaller 3-6 month projects (many running in parallel) to add chunks of new functionality (as microservices) and rewrite parts of the monolith that we can cleanly cleave off.

New parts of UI that are needed don't get added to the Delphi app, but get built as web pages (using React mostly at the moment), which get launched in Chrome windows from the Delphi application.

One day our Delphi app will be an empty shell of it's former self and we can have a huge decommissioning ceremony (party!), but that day's still a long way off... :)


Out of curiosity, have you evaluated a migration to lazarus?


I remember reading that a former Borland or Embacadero CEO said that he absolutely preferred having 99 $1M customers that 1M $99 customers.

I think that enterprise-first strategy has dried up any chances for a community to exist.

We use primarily use Delphi for productivity reasons and think that unless they change their go to market approach, chances of a community reappearing are low.

Perhaps after they have already completed milking enterprise customers, they try to switch to a model of $99/year subscription-only model with a single high quality IDE product and then a community suddenly reappears.


Here's another intriguing compiler suite I came across in the past [1].

For both elements, embarcadero and freepascal the promise of easy cross compilation is the most attractive feature in my eyes.

I started programming in Turbo Pascal 20 years ago or so, but I don't know... coming back to the language these days doesn't sound like the most efficient use of my time.

1: https://www.elementscompiler.com/elements/oxygene/


FPC is far better at it, though, given how many platforms and architectures it supports.


Looking at their price / feature matrix, they are running this platform like it's still 1999. The cheapest option is outrageous, and has no client/server DB support. So that means spending at least $3,600 (on sale!) for a usable development platform. Batshit crazy.


You're not the market for these tools. There are loads of enterprise systems built on top of this which need development and yes, they're still bought and sold like it's 1999. A lot of enterprise systems haven't been 'disrupted' yet and as long as Embarcadero is kicking then there is still a market for them. Oh, you've got this early 2000's system written in Delphi which you need to continue supporting, way too expensive to rewrite (think of the auditing and the requirement gathering, oh my.. this is gonna take years!) and now it needs to run on the latest version of Windows because of security constraints? Yup, you pay top dollar for that.


The existing "market" for this are enterprises who are stuck with Delphi for legacy reasons. As far as I can tell no new projects are starting with Delphi - which means it is only a matter of time when Delphi as a platform is relegated to history.

Embarcadero/Inprise/Idera or whatever they are calling themselves these days have zero vision.


It does seem strange in this day of cloud databases and connected everything, to differentiate their "Enterprise" product based on local vs remote databases[1]. A very outdated way to do things. I think Delphi has had that model since the 90s. On the other hand, they now have a Community edition that is free until your company reaches $5k in revenue.

[1] See: https://www.embarcadero.com/products/delphi/product-editions


It is even more strange given the fact that the value of the database support is in the MVC-ish TDataSet/TDataSource/TDBWhatever framework which obviously comes even with the local edition and not in the database drivers, which truly suck and have better opensource replacements (and in reasonably large application get rewritten from scratch anyway)


It is expensive, but you're being overly critical I think. There are a lot of paid tools in the $1500 - $5000 range just for a single user and some cost even more for deployment. If it had cost $10k I would call it insane, but $3,600 isn't too crazy.


I suggest you to have a look visual studio pricing: https://visualstudio.microsoft.com/vs/pricing/

$5999 first year, $2569/yr renewal


That's for the Enterprise edition, which is very rarely needed outside of very large projects that will normally have a budget for it.

Even with a Pro it's also not just VS itself, but a bunch of other MS products. The exact list depends on how you arrive at getting a subscription, but if you are to take the BizSpark (?) route, it will get you Windows, Windows Server, Office licenses and a handful of Azure credits.


You have to look at VS feature matrix (for free vs paid editions) as well to compare it properly.


Few years ago they obviously realized this and created free of charge "community" edition (IIRC it is licensed in the "it's free unless you make more than X with this" way, like Unreal Engine).

The target customers for the paid editions obviously are developers of custom line of bussines applications. And in that case the license cost is somewhat justified, as the IDE and it's libraries are essentially directly usable for that, while everyone developing similar things in notionally free of charge Visual Studio is going to buy DevExpress and ReSharper.


https://www.embarcadero.com/products/delphi/starter

"If you're a small company or organization without revenue (or up to $5,000 per year in revenue), you can also use the Delphi Community Edition. Once your company's total revenue reaches US $5,000, or your team expands to more than 5 developers, you can move up to an unrestricted commercial license with Professional edition."


If your team is over 2 developers and you don't have a revenue of $5k then I don't think you will be in the market for long.

In other words, CE only caters to students and those will not invest their time in a dying platform if they are smart.


Or hobbyists. Personal projects don't need to bring in money.


$5,000/yr revenue is not a lot. I made more than that my first year freelancing in highschool. All I did was write HTML (in Notepad).


Isn't this more an Idera issue? Buying up somewhat entrenched properties, outsourcing development, the squeezing for what it's worth.

Same happened to ExtJs.

Kinda weird for Delphi, as it wasn't really enterprise software during its heyday, but very popular for mid-sided businesses.


I find free-pascal to be an intellectually and technically interesting option. It's not new and shiny that's why it's not compelling to many people.


Their target customers are enterprises, the ones that pay for their tools.

Embarcadero prices aren't much different from DB2, Oracle, Visual Studio Ultimate.


Most Delphi software I've seen was more a replacement for Clipper than IBM/Oracle-grade Fortune 500 stuff. One step above Access. Heck, it seems to have kept Firebird alive.

And in turn, you get a lot of job offers rewriting Delphi software in C#.


I do know a company doing life sciences robotic control software in Delphi.

Scheduling software and low level control for stuff like BioTek and PerkinElmer devices, for example.

http://www.perkinelmer.com/product/envision-hts-plate-reader...

https://www.biotek.com/peripherals/index.html

In Germany you still get Delphi related conferences.

https://entwickler-konferenz.de/


The article mentions that the binary size of the listbox example is significantly different. Well, we used to say that Delphi 1 is totally wasteful as the default empty project compiled into 39kB .exe, obviously full of bloat ;)

Edit: 39kB was nothing even in the 1995. But there was other more significant issue: if you went for all the database and line of bussines suport libraries you ended up with application that used more 3.5" floppy disks than contemporary Windows 3.1, one for your application and 7 additional for the redistribuable frameworks ;)


140KB+ for that simple app even in 1995 would've been an insane level of bloat, considering that the Windows 3.1 Program Manager (PROGMAN.EXE) also shown in the screenshots is only 112KB, and it certainly has much more functionality. The File Manager, WINFILE.EXE, is 167KB. As an experienced native Win32 programmer, the same thing in pure Win32 would be <2KB. (Edit: I mean the app with 3 controls on a dialog, not the File Manager...)

What's even more disturbing is the fact that an app which does the same thing in 2019, using a newer version of the programming environment, now takes nearly 6MB or 30MB, depending on which field of the newer versions' dialog you're looking at ("code size" or "file size").

My first experience with a Delphi application was similarly disappointing: I distinctly remember a 300KB binary whose only function was drawing a few lines on the screen (to act as a ruler), and disassembling it in an attempt to figure out why.


You don't need to disassemble it, just check the box so that the VCL libraries are loaded dynamically rather than statically linked in the binaries and you get your answer.

There is a reason your app starts at 30 MB and then after you add dozens of forms, database calls, ..., it's still at pretty much the same size, it's the VCL (Delphi's library).


300 Kb was basically the fixed-size overhead for any VCL app.

But by late 90s, it was "good enough", and that's when Delphi was at peak popularity.


I may be misremembering but the early visual basics exported even heavier results.


I think you were - I remember the .exes were much smaller, but they weren't self-contained/stand-alone, so you needed to make sure msvb*4.dll (can't remember what it was exactly) was on the system you wanted to run it on, and it was > 1.4 MB, so you couldn't fit both the small .exe and the runtime .dll on a floppy disk...


Yep, it was msvbvm??.dll. However, it just about fits on a floppy.


It was probably the combined size I recall then.


Now compare Delphi in 1995 with Electron in 2019....


Well notice that info is for application with DEBUG information, not release...


Got to say, other than the font being much nicer now, some of those old screens look a whole lot better and easier to navigate. I miss buttons that look like buttons.


One interesting observation is that Delphi 1 copied the Word 6/Excel 4 "ctrl3d" UI style, but not quite exactly. Typical Delphi-ism are the Paradox-like (well, duh) tabs on bottom edge of the window, which look good as long as the window isn't modal dialog (compare the tabs on code editor window and on the project settings dialog). And another more subtle, but sure signal of Delphi 1 application are the black borders inside text fields (and then also TBitBtn, but that is another thing which in the 3.1 days looked reasonable and not totally ugly as it does in anything after windows 95).


I have a weird feeling these days, that improvements didn't happen at the right place and that old GUI paradigms were just right and that if you knew how to leverage what a computer can do (mind you you could do sml and prolog back in the days) you wouldn't much fancier presentation..


> old GUI paradigms were just right

It's a permutation of "worse is better". Skeuomorphism and hierarchical organization cargo-culted as evil, ignoring that our traditional built environments work using these paradigms.

User-hostile design. Let's replace all buttons and text labels with arbitrary flat abstract icons! See also: nosql and SPAs.


Well, Microsoft is a good illustration. They imposed a ribbon on all customer UIs, except of course the one software that their developers actually use (Visual Studio).


I'm not sure I parse your comment well. I think I've seen enough UI/GUI/UX paradigm to know when something is near the sweet spot. It seems you agree ?

The flat trend was a reaction to abusive skeymorphism; arguing that visual information should be reduced to a minimum.. but somehow ~serious interaction requires a little bit more than layout and font to be enjoyable.


Extreme skeumorphism a la Mac sometime ago is also undesirable, though. You want them to look just close enough to trigger recognition, everything above that is cognitive overhead.


>Extreme skeumorphism a la Mac sometime ago is also undesirable, though

Mac never had extreme skeumorphism. Extreme skeumorphism would be like the common case of DVD player apps made to look real-life DVD players (with all the frustrating LCD-like text displays and tiny cryptic buttons).

It's not about having 3d looking buttons, or having faux-leather on your Notes app, which are the kinds of things Apple did.


I'm probably using the word wrong, then. But those 3D-looking buttons with glare, or faux leather, is exactly what I'm talking about - it is unnecessary cognitive overhead.


A button that looks like a physical real world button that I'd push, with a clear text label beneath it, is less cognitive overhead for me than an abstract squiggly icon with no border or text that I have to interpret.

Bonus points if the icons are hidden inside various hamburger menus sprinkled across the interface - Atlassian I'm looking at you.

I shouldn't be forced to learn some designer's personal visual symbology to use an app. It's hieroglyphics.


I'm not advocating for either of those extremes. To remind, in this thread, we were talking about UI aesthetics of the times when Delphi was popular. That's Windows 9x and NT, classic MacOS 7.x to 9.x, BeOS; and on Unix: Motif, NeXTSTEP, Gtk 1.x, Qt 1.x to 2.x.

So, basically, buttons are chiseled gray (or other color of user's choice), with prominent 3D borders, but flat where the label is for maximum readability. Just enough to capture the essence of a physical button, but without actually rendering one.


faux-leather falls into abusive skeu IMO


The bad skeuomorphism is about replicating physical world design and constraints in digital apps -- and thus imposing constraints that don't exist in the digital world.

Merely looking like a physical product (but with interactivity that takes advantage of what the digital world affords) is not the skeuomorphism people complained about.

One might like or not like faux-leather, for example, but that's just an aesthetic preference (and those things come in circles, in 10-15 years it could be all skeuomorphism in vogue again, as a backlash against too minimal / plain vanilla designs).


Comparing the sizes of the apps made with the two different versions, and the environments they ran under, is most revealing: the old one has a more complex and 3D UI, yet uses a fraction of the resources of the new one that looks bland and lifeless. What's more difficult to draw, a 3D button with an integrated icon or a flat one that just has a single piece of text?

Whatever it is, this is not progress.


I remember using Turbo Pascal, basically the predecessor of Delphi. I had tried Amiga Basic before, but this was the first time that I was being helped by a teacher and actually understanding what I was doing, rather than just copying scripts from Amiga Magazine line by line. I was in my first or second year of high school and, IIRC, we had PCs with 486 CPU (Pentium had already launched but it was very expensive). I remember one day a friend of mine came and told me that Intel was going to make a 1Ghz CPU, I didn't believe him. It would take a few more years before I tried the Internet for the first time.


Delphi was a great way to get into programming as a kid. You could just drop an image and a timer onto a form, set it to 50ms, edit the onElapse event to move the image according to key-presses, and you've got the start of a simple game! All in a way that is visual and makes intuitive sense to any non-programmer.

And the beauty of the language/IDE was that you could develop serious, complex applications with it, too.

Is there anything similar on the market today? I had a ton of fun with Delphi as a teenager!


There are lots of drag and drop tools on the market. Why not just download the Delphi Community Edition for your hobby projects though? It's free.


I've been a Delphi developer off and on for 20+ years (since 2, though dabbled with 1). A lot of people focus on the object pascal and it is dated as a language, though the latest is catching up. The IDE has problems now and then with code completion - it pauses a lot and sometimes just stops working, if you come from Visual Studio or XCode this is incomprehensible and annoying.

Where Delphi shines is the VCL - the Visual Component Library and the third party component market. You can integrate components into the IDE by writing them in pascal. Even now there are still lots of components for pretty well anything - even web development.

It also has cross platform components that you can run on iOS/Android/Mac and Windows (edit: theres also a server side linux one) all with the same code, they are compiled to native and if you want you can write native components on all these platforms.

A lot of windows C# components available for sale are actually written in Delphi

You can connect to databases using components, I've written native socket servers by just dragging a couple of components on to a form. For writing business apps there is nothing superior imho

There are components for web development where you can write an SPA all in Pascal and use components

There's a free community edition available now https://www.embarcadero.com/products/delphi/starter so if you've never looked at Delphi have a look.


Delphi shines in so many ways - I tried to develop something in Go but I hit a brick wall with a sub-par editor (Visual Studio Code), all kinds of restrictions, no way to make halfway acceptable GUI apps, a slow runtime, a slow compiler, unacceptable formatting rules, totally hopeless. Rust has even worse issues. I considered C, C++, Java and PHP 7.3 but I'm basically forced into using Delphi again for a new major project.

I'd rather not use Delphi, since it's hard to find developers for it and investors won't like it. But there just aren't better or even acceptable alternatives for the type of development I do (3rd wave AI, building a graph database from scratch, processing TB's of data, dynamic visualisations etc.)

So the plan is to build all this unique functionality with Delphi and then, when I have something sellable, perhaps get it rewritten in Rust or something, when those tools have become better.

Even though I'm an old fogie and highly experienced with Delphi, I also do embedded dev. in C and have done so for decades, plus I recently built an enterprise-level PHP online store from scratch. I've been a vocal critic of Delphi for decades as well (even banned on Embarcadero's forums) and in 2019, I do not know of anything that compares to Delphi...


> hard to find developers for it

Our last two hires were guys without any prior Delphi experience. They did have Java, C++, Python etc background, tho. We sent them off to a two day intro course and with some assistance they were doing useful work within a couple of weeks.

A small investment IMO if you plan on keeping your employees for a while...


Exactly... The only issue is that many developers will prefer to get experienced in other languages, go with the times so to speak.


The last time I was seriously using object Pascal was in the Turbo Pascal days. Even after all this time, it's had a warm place in my heart, despite myriad languages beneath my belt.

It's great that there's community edition for Delphi now. Thanks for the link!


An update to the 'free community edition':

You absolutely MUST click on "I agree to receive Embarcadero marketing communications via email and phone call" before being able to download it. How is this compliant with GDPR? I also notice that if you change countries, the whole form to be filled out also changes (but the above stipulation remains).

Then there's also:

> Licenses are valid for a one-year term subject to the revenue restrictions.

This is definitely the least 'community oriented' product Ive ever encountered!

I'm sorry, but companies doing stunts like this simply cannot be trusted. It's a shame, because I really did want to consider rekindling my love of development in Pascal, but dealing with a company like this is an utter deal breaker. The sad thing is that it's most likely the marketing people in that company that are pushing for this... and I'm sure the developers there would love to have an open community edition, unlike what is actually being presented.


Delphi was my first exposure to a real programming language almost 20 years ago. I'm very glad that it was it as I look upon the landscape of software engineering nowadays and it's totally opaque to beginners.

Delphi has right abstractions in a right place - you designed the form in a easy GUI and filled in methods with your code [0].

Why it was that way? Because it was designed to be simple and it worked (no need for Bret Victor's magic). (There was a blog of former Delphi developer that explained their thought process)

For the record I worked professionally in JavaScript (TypeScript) (backend and frontend), Java (Kotlin), C# and Ruby. I also did small chunks of support code in C/C++, Rust, Red/Rebol, Python, PHP, Go, Prolog and Lua.

If I wanted to teach kids programming today, something easy to understand but at the same sufficiently complex I'd probably choose Delphi (Lazarus looks like Delphi 5/7 from screenshots).

[0]: manual memory management was harder than GC but on the other hand it thought a lesson...


Delphi (and Borland C++ Builder) was a lot of fun back in the day. Linux ecosystem wasn't as mature, and people who insisted on on using the Microsoft toolchain had to deal with some insane bullshit like MFC, ATL/WTL, or bare Win32 API. In the meanwhile, people using Borland stuff were cranking out superior (and faster) apps out of components downloaded online, and using drag&drop. What would take weeks and a lot of head scratching in MFC was like 10 minutes in Delphi, and you _knew_ you got it right. It was RAD if you pardon my pun.


And then Borland decided to change business forcing us to deal with MFC.

That whole Inprise adventure was pretty bad.


And then Hejlsberg left for MS and took his toys with him. WinForms bore more than a passing resemblance to VCL, and C# more than a passing resemblance to Delphi/C++ Builder. Good for MS to recognize true talent when they see it.

Though their current API situation is still a mess: they can't stop screwing with it. But their .NET situation is as good as it's ever been.


Actually the way he went took a bit of talking with former work colleges then working at Microsoft.

"Anders Hejlsberg: A craftsman of computer language" - interview

https://behindthetech.libsynpro.com/001-anders-hejlsberg-a-c...

WinForms was based on J++'s Windows Foundation Classes (WFC), Hejlsberg's first project at Microsoft. Which of course, was based on VCL.

That mess is the usual DevDiv vs WinDev, for example I read somewhere that WinRT was pushed by WinDev, so naturally it is basically COM Runtime reborn.

My major complain was that we only got NGEN for AOT compilation and not something C++ Builder/Delphi like,

Now there are a few ways of doing AOT in .NET, but it is still not like Delphi.


I do miss near-instantaneous builds on late 90's hardware (!). Much of that was Pascal with its single pass compiler. Productivity-wise that was indispensable.


I have found home on .NET/Java as the best approximation of it, but do agree it could be better.


Nobody mentioned the form inheritance feature of the VCL, the consequent applying of OOP principles for UI. Because all interface elements are implemented as (object) components, in Delphi, you can easily group an arbitrary assembly of UI elements in a frame object and make it readily available as a new “component” for reuse; a great way to reuse standard design in big commercial applications. Another way of accelerating the production is to design similar screens as subclasses of a common screen. You can pack then all the common functionality in the ancestor screen and don’t waste time to copy-paste or worrying about error propagation. Of course, one can group common functionality in classes or procedures but UI functionality is very often bound to a certain UI element and not generic. Thus form inheritance is much more efficient than the (otherwise) standard practice. I designed once an application for museum management with a lot of different working screens but they are similar in some functionality. Using form inheritance I could avoid designing big generic working screens, which could be very confusing and annoying for the users, but offer instead specific screens for specific tasks and still saving a lot of time (and debugging headache). I estimate using form inheritance in Delphi helped me at the time to increase the productivity of the UI implementation phase up to the factor of 5! I guess other systems could do similar things but not as elegant as Delphi though. In term of desktop applications, I believe none other can be as productive as Delphi.


Windows Forms inherited this concept given Anders. :)


Anyone remember Borland C++ Builder? I migrated away from Delphi to C++ Builder as soon as it came out. It still used DCUs tho from memory. Thems were the days


I remember the painfully long compile times. Delphi compiled in seconds where a medium sized C++ app we developed would take about 20 minutes for a build.


Yes, for a while I thought that XAML with C++/CX made Visual C++ finally visual and catching up with C++ Builder, but was wrong.


Yes, I still remember the emotions I had when I accidentally saw the screenshot of BCB. It was a relieve that I won't need to use that ugly language for RAD GUI dev. I've uninstalled Delphi right away :)


I still have a non-trivial internal company application written in BCB that requires the occasional bit of maintenance!


Wow. Delphi.

It was probably the first tool/language I got in contact with while in school. I didn't had any idea what I was doing, playing around with the parallel port trying to read sensor data for a school project.

I think I ended with Delphi 7, most probably some pirated copy of the Professional version, to have all those fancy libraries where I had no idea what to do with.

Wondering whether I should get into it for the sake of the old times. :-)


What's today's equivalent? Something that can produce native binaries for at least windows, mac, linux? The one I see pushed a lot is electron, and there are some cool ideas, but nothing stable that I know of.


Qt and Lazarus are fairly equivalent to Delphi and can generate binaries for all of the platforms you mentioned.


Qt Creator is not on par with Delphi’s IDE, although I would Qt on new projects.


Xojo is worth a look. It has the RAD visual form designer approach of Delphi, is a Basic-like language (it used to be called REALbasic & pitched itself as cross-platform Visual Basic), and makes Windows, Mac, Linux & Raspberry Pi binaries. It can also build for iOS, some weird Web deployment that I've never tried, and Android is in the works. There's a plugin architecture like Delphi had & ways to drop down to native APIs if something isn't supported.

The IDE is best on Mac though. The Windows IDE works, but it feels like the developers are probably all on Macs & not really dogfooding the Windows version as much.

[1] https://www.xojo.com/


Thanks for the recommendation. Looks like it has a similar pricing model to Delphi, too.


Pricing should be much more sane than Delphi's current model - Xojo is $99 for one desktop platform (without SQL plugins), or $299 for cross-compiling to all desktop platforms.

Ignore the "per year" pricing - you can choose not to auto renew & keep using the version you've purchased. You only need to renew if you want IDE / compiler updates (they typically release 4 updates a year).


Delphi can produce native binaries for the major platforms: Windows, macOS, Linux (Currently Enterprise version only, requires third party library for GUI), Android, iOS. The free Community Edition supports the platforms above, minus Linux.


It’s weird that the project options dialog still offers to work around the Pentium FDIV bug. Are any of the current compile targets still afflicted? Like, can 2019 Delphi still compile me a win95 pentium binary?


I found it quite amusing to see that still there too. Unless you have an affected Pentium 100 (or slower) you won't have an issue. A poster on StackOverflow (2014) https://stackoverflow.com/questions/24101125/pentium-safe-fd... raises the issue too, arguing it is safer to leave the option in (which is by default off).


Marco Cantu's (the author of this blog) books on Delphi are/were a great resource for learning the language.

Btw, his website is under heavy load right now (probably the HN hug?), and this is the error I got:

Error in page: /blog/2019-february-24-years-delphi.html

Error Class: EListError

Error Message: List index out of bounds (-1)

Suggesting that the webserver is written in Delphi... that's dedication :)


Sorry, my blog has some issues keeping up with heavy load... I've restarted it and will be monitoring it. I should have imagined, my bad.


Wow..that error message is an ultimate blast-from-the-past.

How appropo it's a website that's throwing it now.


Niklaus Wirth turns 85 today (Feb 15th). Happy Birthday!


We use Delphi, because we are productive with it, but it is seriously sorry.

Yes, you can develop 64 bit apps with it, but the IDE is still a 32 bit app, which causes problems with large projects.

The Indy components (e.g. http) are unsafe and shitty.

Personally I don't think there is much to recommend.


You don't necessarily have to use Indy. There are several open source and commercial network stacks available for Delphi that works across supported platforms.

Also, since Delphi XE8, components for proper HTTP handling, that taps into the host platforms native implementation, has been available. They work really great.


> the IDE is still a 32 bit app

So is Visual Studio, for what it's worth.


I have so many fond memories of putting together quick apps with Delphi "back in the day". Every now and again I'd buy a copy of PC Plus magazine just because they had Delphi 1, 2 or 3 on the cover CD.

I really miss the RAD concept, and I'd love to find a modern tool which had that aspect of Delphi, though perhaps with C++ or Python as a backing language.

I know there's Lazarus (opensource Delphi), but it's C++Builder I miss... wxWidgets is close, but not quite the nice quickly-have-something-presentable environment I remember.

Throwing the cat among the pigeons... does anyone remember Kylix?


Anvil (http://anvil.works) is the closest thing I've come across to Delphi in the modern age. It's python, and it's webapps, but it's stupidly quick and easy (and fun) to get something working.


I've actually found the combination of Python, Flask, SQLAlchemy and Bootstrap really good for throwing together quick web-apps.

I usually use wxWidgets (well, wxPython) for the desktop stuff, but I wondered if there was a better way. It just doesn't feel quite as smooth and polished as Delphi/C++Builder/Kylix were.


I remember you could always tell apps that were written in Delphi by the non-standard Ok/Cancel buttons with the icons.


TBitBtn ;)

In fact in Windows 95 and everything after it simply looks totaly out of place and the Delphi documentation tried hard to dissuade people from using that and instead presented some idea of what MS's HIG say (notice that Delphi 2 does not use TBitBtn anywhere and tries to match W95 UI style very hard, even more than Office 95), obviously for a long time it didn't really work.


This even predated VCL and Delphi. Remember OWL in Borland Pascal?

https://i.imgur.com/esNFWJB.png


I remember there being libraries and components for Delphi which allowed you to pull in BWCC.DLL to get that styling...!

I had to bring up a radio programming tool on a Win98 laptop not long ago ("because legacy kit that still works and is somehow still supported"). First thing I saw, a BWCC styled "Radio Controller Connected -- Please Log On" screen.

Once seen, never forgotten.


I have the feeling that this particular screenshot (given the combination of BWCC and Ctrl3d style in same window) is actually of Graphics Vision, which is open source reimplementation of Turbo Vision with true GUI which uses exactly this styling.


And the mouse pointer when hovering hyperlinks was super-weird!


Which was something that had to be explicitly enabled actually.


I, like many others, loved and used Delphi a lot in the 90s, but for one major client we identified a major risk was the declining availability of Delphi developers (in Australia, at least), and I did a rewrite of the entire app into C#, splitting off the calculation part (it being a financial application) into a separate 'core' which is now re-usable across Windows, MacOS and web. At the time we did this it wasn't even clear if Delphi the product was going to survive. I'm glad it has, but the rewrite was the correct decision (yes, as risky as rewrites can be).


I forgot that Delphi was sort of a mash-up of Visual Basic and Pascal. Two great tastes, I guess.

Are there contemporary products -- for building mobile and/or web apps -- that are similarly easy to use?


You should check out Lazarus. It's basically open source Delphi and cross platform, write once, compile anywhere.

http://www.lazarus-ide.org


And lazarus (ie. free Pascal) will compile Turbo Pascal code without a lot of effort. Was quite amazed to resurrect a discrete event simulation I first wrote on VAX Pascal, ported to Turbo Pascal (and wrote my own replacement to the FORTRAN SPURT libraries) and then used a fair bit till about 1990. Fired it up (from the 5 1/4 disks copied some years ago) and had it running in a few minutes, except that it had a range error that I oddly never spotted with Turbo Pascal that had to be fixed first. (And my link with Delphi, applied for a job, didn't get it but they saw Pascal on my resume and said, we'll we've got some Delphi code that needs extending...)


No, Delphi back in the day was like VS/C# now... or, rather, the other way around, given that MS snatched Delphi's lead dev* to make C#.

*Anders Hejlsberg -- who also worked to bring us TypeScript.


C# and Windows Forms was a spiritual successor to Delphi in many ways, IMO. E.g. VCL had TObject <- TComponent <- TControl, WinForms had Object <- Component <- Control ...


Event(Sender: TObject) type of thing is everywhere in C# now.

Also, to add to your point: The TDataset MVC architecture was light years ahead of its time:

TVisualControl -> TDataSource -> TDatasetDescendant

Everything just fits in snugly.

Whoever thought of that architecture at Borland in the early days (1990s) deserves a legacy trophy truly!


You can build native multi-platform apps with Delphi. The free Community Edition supports, Windows, macOS, iOS and Android development. With third party component stacks you can build and transpile Object Pascal to JavaScript with Delphi too.


Reading through the comments and as a 20+ years developer, using mainly Delphi, and with past 10 years as freelancer exclusively using only Delphi I realize people here don't actually understand what this IDE is doing. So here are a few points:

a - About dying and used only for legacy projects. Well, when a company wants something fast to win their customers hearts and push through next phase of moneygrabbing, do you think they care about latest technologies? Dirty Delphi does the job in 5 hours, what in others takes days if not weeks.

b - price too high. Correct, it is. But when you fly your technicians across entire continental US to deal with a hardware problem at one of your venues do you think 5k USD/year is much? That's pocket change.

c - Younger developers do not learn it. Well, younger developers should not learn anything but only one language for at least 3 years, ideally while still in college, and absorb instead algorithms/paradigms/math - skills more valuable then a computer language syntax. Once you master those and a language, no matter what, the entirety of the rest of languages are nothing more then syntax equivalent. Hence grabbing Delphi should be a maximum 3 weeks venture, after that I'd expect that young developer to be able to solve problems. I did just that, with Pascal in my beginnings and over the years/companies I've worked for I learned Java/C/C++/PHP/ASM/VB/ASP/ etc etc. Knowing how to implement quicksort in Pascal is the same as in C++, it's a syntax equivalent, nothing more.

d - Many comments about native - this is a type of comment from proponents. Well, in my experience that nativity was such a hassle for me that I'd rather go away with it and used Dalvik/the new ART instead in case of Android, but it is what it is.

Feel free to AMA.


In Australia we have the Australian Delphi Users Group. We are having a conference next month.

https://www.adug.org.au/meetings/symposiums/2019-symposium/

It will have a range of topics including showing how to borrow some techniques from other languages and showing how to use some of the new functionality in the latest releases.


I don't know if it's just me but what I noticed right away in those screenshots is that the older Windows 3.1 interface is much easier on the eye that the modern one. You can easily tell what's clickable and what's not, the contrast is good, the fonts and colors are consistent. All that while using a fraction of the resources.


Related: Does anyone else remember the "How to use a mouse" programs on early Macs?

https://gizmodo.com/heres-how-a-macintosh-tutorial-taught-pe...


In 1997 I wrote an application for our state revenue office that helped their customers produce correct pay-roll annual adjustment forms. It was written in Delphi, had to run on Windows 3.1, 95 and NT, and distributed to around 19,000 customers and CPAs on 3.5" diskettes.

Delphi well fit the constraints of the time.


Any mention of Delphi always brings back fond memories of my first job. We were doing amazing things with Clipper at the time, with a bit of Turbo Pascal on the side. Then windows took root and the world opened up with promises from Visual Objects and Dephi - but VB ended up the winner and that was the end of that.

We would play with Delphi and SmallTalk just for fun and there was always a Dephi fanboi around.

Despite these 'primitive' tools we were so much more productive back then - it's quite sad where we have ended up. We would pump out wonderful apps even in the days before we could get our hands on a relational database. dBase files, VSAM files and even trusty CODASYL did the job without any fuss.


Delphi made me lots of applications and money. It was a great tool when it first came out.


What I remember most fondly about the Borland stack was how well it abstracted away all the messy Windows 3.x and 95 UI code and made working professionally as a Windows dev much less stressful.

Also, for a time, it totally blew away MS Visual C, although the VCL was hella inconsistent, and that was rather maddening at times.

To be at max productivity you had to scour the web looking for snippets that showed you how to, say, add strings to this widget or draw on that canvas.

The RAD implementation was rather brilliant, and for several years at least blew its main competitor, Visual Basic (ugh) totally out of the water.


Has the Delphi language evolved - i.e. does it use new ideas and has it dropped old ones? Or is that language substantially the same?

Also, why would anyone use Delphi today except for legacy maintenance?


There have been a few syntactic enhancements over the last 10 years or so. Generics for example. Recently they have also added inline variable declaration (you don't need to put all vars in a function at the top anymore). But these don't really matter to me so much. I think Emb did this as response to "Oh Delphi language is archaic - Java has this, C# has that ..."

I still use Delphi for new projects by default. Static linking of libraries into one distributable dll or exe makes it very appealing. If I wanted this in another IDE, I'd have to use VC++. Also, Delphi's VCL, a near comprehensive wrapper of Win32 (its true strength) and native support for IDLs like COM makes it easy to roll out working software sooner.

I'm currently writing a natively compiled Excel Addin with heavy use of TThread - a multithreading VCL class for the Windows platform. Lightning fast compile & build speeds will spoil you.


Yes the language has evolved, but due to backwards compatibility not much as been dropped.

New things include operator overloading of records (structs), compile-time generics and closures/anonymous functions.

Using them you can write code that looks quite different from old Turbo Pascal days.

As for why using it except legacy, yeah... tough question. Well if your target is a Win32-only GUI application, then I don't know much that beats the VCL in getting things done. But that's a narrow niche these days.


There was this good thread about Delphi on HN some years ago:

Delphi – why won't it die? (2013) (stevepeacocke.blogspot.com)

http://stevepeacocke.blogspot.com/2013/05/delphi-why-wont-it...

https://news.ycombinator.com/item?id=7613543


I'd pick Delphi over WPF/Winforms any day. Better cross-platform options, vector-based graphics via FMX, or traditional Windows graphics via the VCL. COM programming couldn't be easier. Performance is good, lots of components readily available, and finally Object Pascal is a joy to program in. Compilation speed comparable to a C# build.


I get the feeling that, just like cockroaches, Delphi will survive a nuclear apocalpyse...


As long as Win32 exists as a supported api from Microsoft, Delphi will survive in that shade. For a long time Borland produced better tooling for dev on Windows than Microsoft did. Eventually Microsoft just poached the best from Borland including Delphi's inventor, Anders Heijlsberg. Anders eventually created Microsoft J++ rebranded to C#. Many don't know this, but a lot of the event, evensinks and visual design architectures found in Delphi are implemented in C# and the .NET apis.


Delphi was the Power Builder killer way back 20 years ago.


Bloody hell. I've developed with both of these. And Borland C++ Builder.


Delphi is still the best choice for SQL driven apps


is there something Delphi (I mean RAD IDE) for React? Sorry for stupid question.




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: