▲ 119 points
back
103 comments
Too soon :`(!
Ah, those were the days! TP v4, v5, v6... i'd graduated to C by the time 7 came out.
> That almost nobody has the skills these days to implement something like TP is something we could eventually come to regret – or, rather, our grandchildren could. Software development is becoming a semi-skilled industry, and I doubt that the rise of AI will entirely compensate for this.
If anything, the rise (read as: shoving-down-our-throats) of AI/machine learning will hurt the collective ability to code, rather than compensate for it in the least. So many modern developers take pride in using their CoPilots and related AI/machine-learning tools to assist in coding, all the while ignoring that such usage actively keeps them from improving their own coding skills, in the same way that copying a classmate's test answers might let the copier pass the test without actually teaching them anything.
When that day comes that AI can pump out a complete, working, bug-free application based on natural-language descriptions, we will have lost the ability to code entirely, as any code such a thing generates will never be maintainable by a mere human being.
_Sigh_.
Well, it'll be fun while it lasts. The Machines can pry my makefiles and C compiler from my cold dead fingers.
PS: _GET OFF MY LAWN!_
> "Ah, those were the days! TP v4, v5, v6... i'd graduated to C by the time 7 came out."
Mee too, and it is painful to realize how much ahead of its time the IDE was. I am talking about the TUI version and yet:
- It already supported a dual monitor setup - one monitor for the IDE, one for the app - live debugging was a charm.
- The debugger had everything current debuggers have, but it was fully IDE integrated - no messin' with GDB or JDWP.
- The context sensitive help was the best, I never encountered a better one. I think a large part of it was that it really was context sensitive and it tried to solve the problem at hand, regardless if it was caused by the IDE or the language.
>i'd graduated to C by the time 7 came out.
I've never seen C as an improvement. Macros encourage all too clever code that's impossible to parse at first glance. The string handling is horrible. The fact that there are multiple contradictory ways to express pointers.
The only thing holding Free Pascal/Lazarus back is the documentation. There's no way to work on a small part of it, Wiki style, so it's always going to be an albatross. The auto-generated descriptions of variables used in library function calls just don't work as proper documentation.
On the plus side, it's fast and has all of the linking built in. You can stuff gigabytes of binary in strings and never have to allocate anything. It does object oriented stuff, generics, is strongly typed. It can spit out code for almost any platform, including WASM, Android, etc.
> the rise (read as: shoving-down-our-throats) of AI/machine learning will hurt the collective ability to code
You sound like Socrates lamenting that the invention of writing is hurting people's collective ability to think, since their brains no longer need to hold many things simultaneously.
heh... IMO AI often works better when you ask it "how do/can I?" instead of "do this for me!"
> all the while ignoring that such usage actively keeps them from improving their own coding skills
That's an opinion not a fact backed by any data.
In fact it feels like "you hurt your hacking skills by using an IDE rather than a simple text editor, or higher level language than assembly, or managing your memory manually rather than using GCs".
Also, maybe coding skills will become more and more irrelevant for most developers the same way knowing how memory or CPUs work is largely irrelevant for all but a tiny part of the industry.
In fact, if AI assistants will keep getting better, the best skills to have will be ability to direct those assistants and overseeing their output while meeting business and product needs.
> So what happened to Turbo Pascal? Three things, at least, contributed to its eventual downfall
The fourth thing is that it lives on as Delphi:
https://www.embarcadero.com/products/delphi
And there's Free Pascal and Lazarus. One of the goals of Free Pascal is to be Turbo Pascal and Delphi compatible:
You mentioning Delphi reminds me of the Miniatur Wunderland in Hamburg, a large model railroad with a day/night cycle, cars driving on the roads and planes "landing" and "taking off", a lot of it controlled with Delphi: https://www.embarcadero.com/case-study/miniatur-wunderland-c...
A video of their control center with English subtitles: https://www.youtube.com/watch?v=u9SGsxauu7o
> it lives on as Delphi
Regrettably, Delphi is closer to a zombie now than to something that's alive.
It also lives on as .NET and C#, at least a little bit.
Turbo Pascal was by far my favorite programming language in the 1980s. I switched to C reluctantly in college because it was portable to the 32-bit Sun workstations we had, then I was a Linux Zealot for a decade or so so I never jumped in the Delphi (sequel to TP) train.
In the early 1980s there was a push for “anything but BASIC” for teaching languages. Before TP, in my mind PASCAL had the stink of failure between the watching-protons-decay slowness of UCSD Pascal and the inadequacy of ISO Pascal to do anything but solve leetcode problems.
C on the other hand accomplished what PL/I had set out to do in a “worse is better” way. TP added enough of what ISO Pascal was lacking to be fine for systems and applications work like C but it was saner, didn’t have the null terminated strings which made strcpy() + a later return Turing complete in C.
TP felt just a little more disciplined than C, like a pop version of Ada.
I really do miss the days I was locked in an office with no internet connection with a free coffee machine and could be productive. Things were small, understandable and had documentation on paper.
Yes, the best time to be a programmer. I remember being several hours doing productive programming. Nowadays you cannot spend a few minutes without having to search for some information that is not available locally.
back in the day , started my first job as intern (VC++ dev) and I was so excited to get a stack of MSDN CDs for reference.
I spent a fair bit of my career in that sort of environment writing embedded software on MSDOS. Have fond memories of that but I wonder if I re-created that today would I be able to mentally cope? Might be the technology equivalent of becoming a monk in remote Tibet with the same needed commitment and rewards.
A younger self used to look forward to the latest (paper) shareware catalogue arriving by (snail) mail, posting back the order form and waiting for the floppies to arrive. True story :-)
I have my doubts you were around in those days, because believe me, on average people were no more productive and certainly code quality was lower.
I miss that too. Where can I find such jobs in Canada? I don't care too much about pay as programming usually gets paid well enough.
The builtin help in Borland IDE's was supreme. I used to everyday choose a random help page, read it, copy the example and modify it until I understood what it did. That's probably the best programming tutor I ever had and how I learned programming by myself in my teens without Internet.
This, and the help in QuickBasic has not been beaten for how instant they were.
Hit F1 on some bit of code and instantly see help on the keyword, very quickly find stuff via the index etc.
> It did this using highly-optimized code, written in assembly language, by very skilled people.
"People" here meaning Anders Hejlsberg almost single-handedly.
It's funny how Denmark could produce two computer scientists with very distinct opinions on what makes a computer language good (I'm happy ate least one of them knows the right answer)
Anders Hejlsberg, also of C# and Typescript fame. Oh, how I wish we had a RAD Delphi-like IDE for the web.
> But what really made TP 7 special was its CP/M heritage. Turbo Pascal came to Windows by way of CP/M and MSDOS, which meant it had a compiler core that was designed to run with tight memory and a comparatively slow CPU. In the days when most compilers had to write a stack of intermediate files on disk, TP just constructed everything in memory. [...] It doesn’t matter much today if your compiler spits out a heap of temporary files, because disk storage is fast and cheap. But in the days of the floppy disk, you had to minimize disk access. Unfortunately, you also had to minimize memory use, because there wasn’t much of that, either.
Of course, the “heap of temporary files” is itself originally an adaptation for low main memory. The genius of Turbo Pascal is exactly that on those early PCs main memory was large enough / mass storage was small enough that for the program sizes in question the architecture of many passes communicating via disk files just wasn’t worth it. As far as I know, that was never true on minicomputers that our compiler tech was born on, and it’s very much not true on PCs now. (Consider: DOS machines had 100s of K to perhaps 4M of RAM and a couple megs to several dozen megs of floppy or disk, amounting to a proportion of perhaps 1:20. The laptop I’m typing this on has 4×10¹² bytes of mass storage and 64G bytes of RAM, a ratio of about 1:60, and I specifically made sure to get an abnormally large amount of RAM.)
You’ve got to wonder though: why in the world do we need that much memory?
I was around back then and there is a lot of nonsense in this article. The biggest one being overstating Turbo Pascal's role in Windows' adoption. Nobody cared what tools programmers used back then. MS-DOS dominated and Windows dominated because they were the OS that came on IBM compatible PCs. And that platform was by far the dominant hardware platform at the time. All the software users wanted was on MS-DOS and Windows 3.1 was backwards compatible with MS-DOS. Etc. Etc. (And while some of that software was written in Pascal, most of it was not.)
Pascal at that time was like Ruby or something is today. Definitely widely used but a far distant to the incredibly dominant C. There's no way to explain to folks today how dominant C was back then. If you were a software engineer learning C was just a given. You may or may not have bothered with BASIC, you may or may not be comfortable getting down to Assembly, but if you were serious about coding, you knew C.
The new hotness was C++. Object orientation was the AI of its day. TP jumped on it so fast with 5.5 it ended up throwing away that object model for Delphi a few years later.
TP had little impact on Windows, I agree. TP was for a particular niche, small software shops targeting DOS. And it was a big success, it paid for a nice building in Scotts Valley, but it also fuelled the ambitions of a bunch of executives who got derailed, getting into databases, a multi-pronged bet (Paradox, dBASE, Interbase) that didn't really pay off.
if you were serious about coding, you knew C.
I think this is fundamentally the same toxic thinking that is still with us today.
C offered no actual advantages over Turbo Pascal for DOS/Windows programming. I'm sure one can come up with platforms or releases that weren't supported by TP, since C was the defacto standard. Regardless, they're fundamentally equivalent.
Meanwhile, Turbo Pascal was blazingly fast compared to C. The C linker in particular used to take forever. Turbo Pascal was seen as a toy language. My AP Computer Science exam results were disregarded by colleges because it was in Pascal.
A few years later, I was a C++ snob and looked down on Visual Basic "macro hackers". Meanwhile, at least one true genius electrical engineer I worked with would rapidly prototype software in VB that would take me weeks to replicate in C++.
There's a weird disdain in software development for approachable, efficient tools that create actual business value.
I'm curious why we don't see more TUIs like Borland's. I.e., menu bar at the top, multiple panes (IIRC), etc.
For software like neovim and gdb, it could help a lot with discoverability.
Visidata is a relatively modern example.
fp-ide from FreePascal, XWPE, gdb -tui...
> The familiar ‘green tick button’ was an OWL enhancement, which graced so many Windows applications that it eventually became an irritating cliche.
Fun fact: this lived on in Delphi, TP's successor. The TBitBtn component, a button with an image and one of the oldest Delphi components (probably from Delphi 1?), has a Kind property that auto-sets all sorts of glyphs; Kind := bkOk sets it to a green check.
About a year ago the glyph was updated to look a little more modern :) But it lives on. I love occasionally seeing it on apps in the wild.
I definitely miss hitting F5 and instantly seeing the output my program compiled with the change that I just made.
That’s what modern web development is like as long as you’re not using something like Next/React with a massive build process.
Was TP for Windows considered TP7? I spent my youth in Turbo Pascal 7 writing graphics based apps in DOS and never even know they made a Windows version. Not that my 286 could run Windows.
286 likely could run at least Windows 3.0 (and you could play minesweeper).
I also started learning programming in high school days (2001 - 2004) using TP 7.
Fast, affordable internet connection wasn't pretty common on those days, so have to rely on internet cafes and books/magazies.
As the name implies, it's indeed TURBO. I mean, to achive similar snapiness when running Eclipse or VS, you'll need pretty powerful machine.
The legacy is carried on by Free Pascal folks (there's the text based IDE). I only use this for fun/nostalgia purpose. For actual work, well there's Lazarus IDE.
Borland C++ was the most desired software when I was a kid among my friends. We tried like hell to pirate it. This brings back memories.
If you couldn't afford Borland products, you were poor indeed.
Its so successful and nice that Microsoft poached the good employees.
Article from 1997
https://www.zdnet.com/article/borland-sues-ms-over-staff-poa...
FTA: “That almost nobody has the skills these days to implement something like TP”
I don’t think that’s true. Percentage-wise, the number may have dropped, but there are many more programmers now than there were back then.
I even am not convinced that percentage is lower today. There are plenty of people in the demo scene who, if incentivized, could write something like it.
You also have to realize that TP 7 is relatively simple compared to today’s development environments. To mention a few items:
- pascal is a lot easier for an IDE than C
- no messing with character encodings
- the editor may be fast, but does it stay fast when confronted with very large files?
- TP need not be cross-platform
Whatever Anders Hejlsberg has done had been great. Really great.
Flashbacks to high school CS back in the 90s. Started with basic then moved on to this. I understand now they use Java to teach kids, and I can't imagine trying to learn to code with that language.
This was the first easy way to write Windows software. Our company had develped software to send pages to Motorola pages via the dial-up interface provided by most pager providers in TPW 1.5/ TP 7
Let's work out whose intellectual property it is and see if they will license it as MIT.
Microsoft has shown MIT to be a good standard under which to license retro software from DOS to Windows file manager.
This brought back memories. Pascal was what was taught in my first intro to programming class so many years ago.
>But who needs a Turbo Pascal, when you have 128Gb of RAM attached to an 5GHz CPU, for a hastily-written, bloated Java program to burn?
I mean we are in 2024 and should be well past the Java joke. Not only is modern Java seriously fast and could be efficient as well as natively compiled with Graal. ( Where 20 years ago GCJ was experimental at best ). The modern equivalent should really be Electron.
But back on the topic, I really miss Pascal and Delphi.
The article ends with an unwarranted jab at "bloated Java apps". If anything, Java nowadays is like Turbo Pascal back then, striking a reasonable compromise between complexity, readability and performance when compared to Electron apps.