I'd rather not comment on current popularity of Delphi, Free Pascal and family. I won't touch commercial situation with a ten feet pole either.
But I would like to mention what exactly made Delphi so nice to work with: language enabling design-time information, run-time type information, flexible memory management (some of it automatic, but also possible to do it manually), 95% of time safety but still possible to mess with internals, component architecture, clear exception handling and a very nice community.
There was a joke about Delphi convention being canceled because one dev got sick, second had a funeral and third one could go but, what would he do on his own?
> I won't touch commercial situation with a ten feet pole either.
Why?
I mean, Delphi seems a good language... what prevent you from developing with it?
I wrote a hypertext system in Turbo Pascal - this was before NCSA Mosaic. What sold me was that it was one of the first IDEs. A friend mentioned that, when the compiler found an error, it would bring up the editor and position you at the error. This was huge! Plus, it selling for maybe 1/10th the price of other compilers.
I also wrote a hypertext-like front-end with Turbo Pascal, pre-Internet, back in the day .. there was a 3rd-party UI framework that made it so reasonable to mix graphics and GUI elements in MSDOS, so .. we made a bunch of internal company apps that rendered the data off the network, allowed the execs to point and click things, change graphs, etc.
I remember seeing a plethora of amazing GUI plugins for Delphi too ..
One language feature from Delphi (or Pascal?) that I wish modern languages had is class properties
No getter/setter bs. When creating a class you declared a field a property, it looked like this
type
private
FBar: Integer;
procedure SetBar(Value: Integer);
published
property Bar read FBar write SetBar
so you specified what method was to be called when assigning to the propery and when reading from it. You could start with both read and write accessing the field directly and then later make them use getters-setters while keeping the class interface the same. Somehow this knowledge got lost by designers of modern languages unfortunately :(
In python nowadays you use data classes for that. Essentially nice with the frozen attribute. Before that there were named tuples - still useful to subclass instead of frozen data classes, as long as you don't need inheritence or any of the advanced data class field attributes.
Lazarus is nowhere near as polished and nice as Delphi, despite having years to get it to that point.
There are no native GUI components, everything is the same old and ancient custom Lazarus VCL design. Why can't I just drag, drop, and use a native Qt5 component?
They struggled for years getting a dockable interface, and it's still shockingly bad bordering unusable. The community seems stuck in the Delphi 7-interface era.
I used to love and use Delphi. It was my first "proper" programming language, and it's what I learned. But I just cannot advocate for its use in the current climate, especially after having been exposed to other developer communities and the superior tooling and availability. I try to go back every couple of years or so and try to use it, but it's just not there.
Last time I used Lazarus I could figure out how to layout controls. I was also disappointed by the control selection, although it was interesting watching the entire IDE recompile when I pulled in a 3rd party control.
That sounds great, any pointers to get started writting more complex apps? In particular I can't seem to find a proper description of the memory system (when do I need to manage memory myself) and strings (it looks like those are managed automatically, but not? And there are like 4 types of them? Which would I need for UTF8?)
I couldn’t figure out how to do API calls, get tokens, etc. Stuff that is necessary for most applications today. Would love to see more example apps that involve networking
> Today Delphi is still extremely successful compared to Oberon
Yes, but not compared with just about anything else. I used to make some of my living as a Delphi consultant, but I had to give it up as you couldn't make any money doing it, particularly when compared with C#, C++ and Java.
Do you suppose Delphi would have wider adoption if it were open-source? E.g. are the Delphi language features and ecosystem compelling when compared with more widely adopted languages with a community governance structure?
At least in Germany there is still enough to be made, that guaranteed an yearly conference (pre-covid) and regular presence on Windows and .NET developer magazines.
Pascal to this day remains one of the most readable languages around. It's not fancy, it's verbose, and very clear. I think the only reason it fell from grace is the simple fact that it came from an era when best implementations of it were commercial, and that's not something that is acceptable in this day and age.
What killed delphi were its proprietary closed roots. With a single vendor with erratic market history behind it, it was risky to use it for anything that was needed to be updated frequently and last long.
They need to provide tooling at the same level, otherwise they will only succeed in niche areas where security is the top level concern, and good enough static analysers aren't acceptable.
Think of Qt, WinUI, CUDA, Unreal, Visual Studio debugger, C++ Builder kind of tooling.
"Sometimes I wonder if the failure of languages like these - along with Ada is purely aesthetic one."
Possibly part of the reason. Pascal has a very readable syntax, but for some (most?) programmers it is too "verbose" and that is enough for them to never consider it. This is probably true of any language labelled "verbose".
Python and Ruby advocates probably feel these languages have found the right level of conciseness and readability. But everyone has a different opinion. Of new languages, Nim and Julia seem aiming for the same balance: not too terse, but still easy to read. Have they succeeded?
I find it fascinating that C's influence on language syntax continues today with new languages (e.g. Rust, Zig) in a way that Pascal does not.
Turbo Pascal, Borland Pascal and Delphi all suffered from the curse of units. Units were great, way superior to C/C++ compilation allowing fast compiles and efficient stripping of unused code. But they were version incompatible. If you lacked the source code for a compiled unit, you could never move to a later version with it.
But give it its due, the stuff you could do with Delphi for example COM made it probably the only Win 32 compatible language to compete with C++. It was the Betamax to the VHS of VB...
Units between versions were mostly not a problem due to the culture.
Virtually all third party commercial libraries had source available, which had a raft of benefits (even if you often needed to pay more for the library to get the source.)
Meanwhile for other languages, libraries were often sold without any source, and you were royally screwed if you had a problem later.
The forerunner for Delphi was Turbo Pascal. Before it became Turbo Pascal it was called Compass Pascal and then Poly Pascal (it was sold by a danish shop/company called Poly Data).
Anders Hejlsberg wrote the first Compass Pascal compiler when he was 16. And it still lives on in Delphi so many years later. Anders is now driving TypeScript development at Microsoft.
I have written at length, in past Pascal posts, about my affinity for the language in my early days... specifically Borland Turbo (later Borland) Pascal[0].
I ended up hacking on some leaked Telegard source code, decided to scrap it after discovering something I thought was suspicious and realizing I couldn't expect to understand every detail of these thousands of lines of code that I shouldn't have had in the first place. I ended up completely rewriting it in time to run it on my own, and a few friends' BBSes for about two years until we all found romance, the internet or both.
Just thinking about one of the reasons why I did the rewrite reminds me of how incredible that language/ecosystem was--given the early-90s when I used it. The "final nail in the coffin" for me was the code that authenticated a user. Bear in mind, this is the early 90s. You had a "handle" and a number, which a 16-bit unsigned integer (0-65535), assigned sequentially with the admin always being "0", and you could login with the number. Passwords were not only stored in plain-text in a relatively readable format in a file on the drive, but the Admin panel helpfully displayed the user's password every time a 'sysop' viewed a user's account. The background is provided to make clear: this was not a complicated login routine designed to avoid side-channel attacks, perform string comparisons in deterministic times, etc -- if they were, it'd be an amazing waste of time given the total disregard for security throughout the code (and most projects of this era)... and if it were, I wouldn't have been a good enough developer to even identify it.
However, this code had a few `goto` statements, and some inline assembly. The three places that had inline assembly in this code were the ANSI implementation, that I wrote, the 16550 UART driver, that I wrote and this login routine that I did not write and as far as I could tell had absolutely no good reason to be there. After hours of refactoring, I broke the code out into "code that logs a user in" and "code that makes something"; That "something", IIRC, was a round-about way to generate a "master password" that could be used to login with any account (and `0` was `root`). During testing, I discovered that my "skipping the code that makes something" part resulted in an empty string value which meant I could login with no password to any account. I rewrote the whole login routine, and then the whole thing.
Would kind of love to look into that, now, since I'd actually be able to understand what is going on, now (maybe!).
[0] IIRC, the IDE fit on a 5.25" floppy, and Version 5.0 had a whole bunch of new, elaborate, syntax highlighting. It was amazing.
Wirth's article also "ignores" Ada. But that's fine, the article is a personal account, not a survey of all Pascal family languages. The penultimate sentence:
"The sequence Pascal—Modula—Oberon is witness to my attempts to achieve [perfection]."
I seriously view OCaml as a descendant of Pascal. If you look at some of its imperative syntax (for loops, while loops, mutable assignment), comments (* ... *), modular programming style (distinguishing interfaces and implementations), and fast compilation speed, it's clear that the OCaml engineers took a lot of Pascal's (and its descendant Modula-2) lessons to heart.
At the same time, OCaml's ML heritage greatly simplifies the majority of the syntax (getting rid of semicolons, making identifiers case-sensitive), and bringing the expressive power of functional programming.
It fuses together the best of both worlds. It's why I often say that OCaml is like a midpoint between Haskell and Go. The 'Go parts' are from their common ancestor, Pascal.
I think that very much depends on your definition of "descendant", given how many language designers mention how much they were inspired by Oberon, Modula, or even just Wirth's writings in general. This is both on a technical level and on a language design level.
Historically speaking Go would qualify as being descended from Oberon, philosophically none of the current crop of languages would qualify, most of them being too complex and brining in elements Wirth wasn't too fond of (like most of FP).
[+] [-] narag|5 years ago|reply
But I would like to mention what exactly made Delphi so nice to work with: language enabling design-time information, run-time type information, flexible memory management (some of it automatic, but also possible to do it manually), 95% of time safety but still possible to mess with internals, component architecture, clear exception handling and a very nice community.
[+] [-] blibble|5 years ago|reply
[+] [-] ozim|5 years ago|reply
[+] [-] daitangio|5 years ago|reply
[+] [-] musesum|5 years ago|reply
[+] [-] fit2rule|5 years ago|reply
I remember seeing a plethora of amazing GUI plugins for Delphi too ..
[+] [-] skeletal88|5 years ago|reply
No getter/setter bs. When creating a class you declared a field a property, it looked like this
so you specified what method was to be called when assigning to the propery and when reading from it. You could start with both read and write accessing the field directly and then later make them use getters-setters while keeping the class interface the same. Somehow this knowledge got lost by designers of modern languages unfortunately :([+] [-] facorreia|5 years ago|reply
https://docs.microsoft.com/en-us/dotnet/csharp/programming-g...
[+] [-] pdonis|5 years ago|reply
[+] [-] m_mueller|5 years ago|reply
[+] [-] beagle3|5 years ago|reply
[+] [-] yawaramin|5 years ago|reply
[+] [-] sglienke|5 years ago|reply
[+] [-] pjmlp|5 years ago|reply
[+] [-] wtetzner|5 years ago|reply
[+] [-] analognoise|5 years ago|reply
One codebase, compile everywhere. Small executables, compiled rapidly. Cross platform. LGPL. Super friendly community with a LOT of awesome talent.
It's really great!
[+] [-] Mayzie|5 years ago|reply
There are no native GUI components, everything is the same old and ancient custom Lazarus VCL design. Why can't I just drag, drop, and use a native Qt5 component?
They struggled for years getting a dockable interface, and it's still shockingly bad bordering unusable. The community seems stuck in the Delphi 7-interface era.
I used to love and use Delphi. It was my first "proper" programming language, and it's what I learned. But I just cannot advocate for its use in the current climate, especially after having been exposed to other developer communities and the superior tooling and availability. I try to go back every couple of years or so and try to use it, but it's just not there.
[+] [-] the_only_law|5 years ago|reply
[+] [-] tomjen3|5 years ago|reply
[+] [-] olah_1|5 years ago|reply
[+] [-] criddell|5 years ago|reply
[+] [-] zabzonk|5 years ago|reply
Yes, but not compared with just about anything else. I used to make some of my living as a Delphi consultant, but I had to give it up as you couldn't make any money doing it, particularly when compared with C#, C++ and Java.
[+] [-] brylie|5 years ago|reply
[+] [-] pjmlp|5 years ago|reply
[+] [-] Schectmar246|5 years ago|reply
Who knows, maybe Rust and something like Ada++ http://www.adapplang.com/ will be able to dethrone C++, or Java some day.
[+] [-] lordgroff|5 years ago|reply
[+] [-] marcodiego|5 years ago|reply
[+] [-] Galanwe|5 years ago|reply
Delphi was not a failure by _any_ stretch of imagination. In terms of RAD, it was only second to VB.
Also keep in mind that a lot of people at the time knew Pascal, in that regard Delphi was completely esthetically pleasant.
[+] [-] pjmlp|5 years ago|reply
Think of Qt, WinUI, CUDA, Unreal, Visual Studio debugger, C++ Builder kind of tooling.
[+] [-] open-source-ux|5 years ago|reply
Possibly part of the reason. Pascal has a very readable syntax, but for some (most?) programmers it is too "verbose" and that is enough for them to never consider it. This is probably true of any language labelled "verbose".
Python and Ruby advocates probably feel these languages have found the right level of conciseness and readability. But everyone has a different opinion. Of new languages, Nim and Julia seem aiming for the same balance: not too terse, but still easy to read. Have they succeeded?
I find it fascinating that C's influence on language syntax continues today with new languages (e.g. Rust, Zig) in a way that Pascal does not.
[+] [-] davidhbolton|5 years ago|reply
But give it its due, the stuff you could do with Delphi for example COM made it probably the only Win 32 compatible language to compete with C++. It was the Betamax to the VHS of VB...
[+] [-] robocat|5 years ago|reply
Virtually all third party commercial libraries had source available, which had a raft of benefits (even if you often needed to pay more for the library to get the source.)
Meanwhile for other languages, libraries were often sold without any source, and you were royally screwed if you had a problem later.
[+] [-] pjmlp|5 years ago|reply
In all modern languages that is a build system responsibility.
[+] [-] unknown|5 years ago|reply
[deleted]
[+] [-] useerup|5 years ago|reply
Anders Hejlsberg wrote the first Compass Pascal compiler when he was 16. And it still lives on in Delphi so many years later. Anders is now driving TypeScript development at Microsoft.
[+] [-] mdip|5 years ago|reply
I ended up hacking on some leaked Telegard source code, decided to scrap it after discovering something I thought was suspicious and realizing I couldn't expect to understand every detail of these thousands of lines of code that I shouldn't have had in the first place. I ended up completely rewriting it in time to run it on my own, and a few friends' BBSes for about two years until we all found romance, the internet or both.
Just thinking about one of the reasons why I did the rewrite reminds me of how incredible that language/ecosystem was--given the early-90s when I used it. The "final nail in the coffin" for me was the code that authenticated a user. Bear in mind, this is the early 90s. You had a "handle" and a number, which a 16-bit unsigned integer (0-65535), assigned sequentially with the admin always being "0", and you could login with the number. Passwords were not only stored in plain-text in a relatively readable format in a file on the drive, but the Admin panel helpfully displayed the user's password every time a 'sysop' viewed a user's account. The background is provided to make clear: this was not a complicated login routine designed to avoid side-channel attacks, perform string comparisons in deterministic times, etc -- if they were, it'd be an amazing waste of time given the total disregard for security throughout the code (and most projects of this era)... and if it were, I wouldn't have been a good enough developer to even identify it.
However, this code had a few `goto` statements, and some inline assembly. The three places that had inline assembly in this code were the ANSI implementation, that I wrote, the 16550 UART driver, that I wrote and this login routine that I did not write and as far as I could tell had absolutely no good reason to be there. After hours of refactoring, I broke the code out into "code that logs a user in" and "code that makes something"; That "something", IIRC, was a round-about way to generate a "master password" that could be used to login with any account (and `0` was `root`). During testing, I discovered that my "skipping the code that makes something" part resulted in an empty string value which meant I could login with no password to any account. I rewrote the whole login routine, and then the whole thing.
Would kind of love to look into that, now, since I'd actually be able to understand what is going on, now (maybe!).
[0] IIRC, the IDE fit on a 5.25" floppy, and Version 5.0 had a whole bunch of new, elaborate, syntax highlighting. It was amazing.
[+] [-] mlinksva|5 years ago|reply
"The sequence Pascal—Modula—Oberon is witness to my attempts to achieve [perfection]."
[+] [-] protomyth|5 years ago|reply
[+] [-] themodelplumber|5 years ago|reply
https://nim-lang.org/
[+] [-] yawaramin|5 years ago|reply
At the same time, OCaml's ML heritage greatly simplifies the majority of the syntax (getting rid of semicolons, making identifiers case-sensitive), and bringing the expressive power of functional programming.
It fuses together the best of both worlds. It's why I often say that OCaml is like a midpoint between Haskell and Go. The 'Go parts' are from their common ancestor, Pascal.
[+] [-] txdv|5 years ago|reply
[+] [-] T-A|5 years ago|reply
[+] [-] vanderZwan|5 years ago|reply
[+] [-] mhd|5 years ago|reply
[+] [-] oaiey|5 years ago|reply
[+] [-] mseepgood|5 years ago|reply
[+] [-] peterbmarks|5 years ago|reply
[+] [-] facorreia|5 years ago|reply