40 years of Turbo Pascal, the coding dinosaur that revolutionized IDEs It is 40 years since Turbo Pascal revolutionized the coding marketplace with a slick (for the time) Integrated Development Environment (IDE) and performance to spare. So why aren't we all using it today? Turbo Pascal was released in 1983 and represented a shift from the traditional way programming tools worked in the early …
Pascal was popular for teaching due to its clean syntax and lack of simple foot-shooting that C provided, or nests of goto that basic encouraged.
Some programming courses would teach you the whole thing, proper software engineering including how multi-pass compilers & linkers worked, etc. However, often programming was and add-on to another science or engineering course and there all that really mattered was you know the basic concepts (such as variables, loops, if/branching, function/sub-routine, etc) and there was not the time to cover how and what a .EXE was compared to .COM and the odd vagaries of 8086 memory segmentation and resulting memory models (how and why 64k blocks, or bigger, might be used for code and/or data).
I sort of wandered in sideways from all of that after starting with programming on an PSION Organiser II where the programming language was a bit of a blend of Basic and Pascal, including the need for 'compiling' it to an interim code, and a bit of machine code hacking to make OPL (Organiser Programming Language - from the days of naming things as they were - take that, Microsoft Entrails, sorry, Entra) do things that weren't in the manual - and yes, I did that manually, I only learned about assembler later - I was just making things work the way *I* wanted them to work :) ).
I was already using Borland's Paradox DB and its language PAL (Paradox Appliction Language ) as I didn't get on with DBASE and I needed to write some glue code to translate reports dumped from the VAX into something that Paradox could import as its reporting was far more slick and simpler to set up than I ever hoped to cobble together. Enter Turbo Pascal, and after some buffer tweaking it munched through the reports so quickly I executed it twice as I thought it had not run (checking the output would have been the smart move, but it surprised me). The joy of simple text files..
Borland, like IBM at the time, embarrassed Microsoft multiple times by not only making more usable interfaces but also showing that Microsoft's compilers were hopelessly inefficient - both Borland and IBM recompiled Windows and produced more compact and far faster executing code and also faster executing software in general, so obviously both had to go.
If you wonder what a lack of competition brings, just look at the resources Windows 11 needs, and the UX of Microsoft applications in general. They only break new ground in the sense that they ought to be buried.
Oh, you could still shoot yourself in the foot; I remember running the computer out of memory doing stuff with linked lists back in high school with TP.
If you wanted basic, you got one of the macs and whatever version of BASIC it had. However, most people tended to just screw around with making goofy icons in Resedit and breaking things (or playing Nettrek with other classmates...)
My understanding was that Wirth designed Pascal to be a teaching language
Wirths interests and research were in the area of "language design", and Pascal was his example of "An optimum programming language, from first principles". On the other side, Kernighan thought that c had "a useful implementation, particularly for putting unix on new processors"
They both were right. Modern implementations of Pascal languages are more useful, modern designs of c compilers are Pascal-like, and subsequent changes to the language were to make it more Pascal-like.
I think you need a bronze or silver badge to use HTML, and otherwise you can't link.
My 1981-1984 degree was primarily based around Pascal, at Imperial College, London, but it was too early for Turbo Pascal of course, we used an IBM 4331 running VM and it suffered when too many people used it at the same time. Of course we used other languages as well, but primarily Pascal for teaching.
Really? Wow! I started the Comp Sci course at Imperial in Oct 1981 too! Unfortunately I flunked the exams at the end of the first year, and at to figure out how to make my way in the world...
... which started with BASIC on a CP/M machine, and then morphed to Turbo Pascal on DOS quite quickly. And the Pascal (and associated skills) I'd learnt in that single year did come in useful
I'm not sure what school you went to, but when I was learning Pascal, it was not done in an IDE, and we did compile binary executables.
As for why it wasn't use commercially, the short answer is performance. Compared to the other languages at the time (BASIC, Fortran, Lisp, C, Forth, and a few others), Pascal was extremely inefficient. It was great to teach concepts, but doing type-safe checking in the compiler, rather than relying on the developer to do it, resulted in lots of processor time spent on bounds checking and other things that the other language compilers simply didn't do.
In an education setting, performance is less important that the ability to teach the concepts. In industry, the reverse is true. I did some timing tests once of an application that had been written (very elegantly, I might add) in Microsoft Pascal for the PC, to a hacked version that had been written in Microsoft C (this was at the time when Microsoft C was just rebranded Lattice C). The Pascal code was much easier to follow, the logic flow was cleaner, and it would have been a lot easier to maintain than the C version, which was doing address arithmetic and never checking array bounds. However, the Pascal version required 50% more memory to run (at a time when memory was very expensive) and was about 30% slower.
Since time is money, Pascal lost out.
There were several attempts to make Pascal more commercially viable, but with every attempt, they ended up needing to make certain tweaks to the syntax ot meet the performance goals, at which point it wasn't Pascal anymore, it was Modula 2, or Modula 3, or even Ada. Of course, Pascal itself had the same relationship to Algol, so it was just continuing the trend.
As for why it wasn't use commercially, the short answer is performance. Compared to the other languages at the time (BASIC, Fortran, Lisp, C, Forth, and a few others), Pascal was extremely inefficient.
That's just the implementation. I used Fortran with type-safety and bounds checking: we just switched to the other compiler when we wanted something smaller and faster.
Pascal and Fortran objects were intrinsically faster and smaller because of language design decisions, but that also meant that you could just do a very simple compiler and the result was good enough. In particular, Latice C was an optimizing compiler: if you looked at the executable, you would see that the result had no direct relationship to the original code at all, because it had all been rebuilt and re-ordered as part of the optimization process.
Regarding size, the Microsoft Pascal compiler used a monolithic library that was shared with other languages. By design, Pascal doesn't have any library at all, so a size-efficient implementation has zero library overhead, both in the library code and in the linkage.
And .... there were certain tweaks to C to make it meet performance and usability goals, at which point it wasn't K&R c anymore. Not to mention the whole standardization process for the language and the library..
As for why it wasn't use commercially, the short answer is performance
Wrong I used it in a commercial environment for industrial process control. The MAIN reason was it was considerably safer than any other language. In process control the last thing you want is your oil refinery or chemical plant to explode!
Also you cannot compare a commercial release of a PASCAL compiler on proper hardware to MS PASCAL on a PC. They are completely different beasts. For example at the time there was no way you could safely us a PC for any real-time or near real-time work they were just a toy.
Pascal was designed to be a block structured language primarily for teaching. It required just a single pass compiler which was ideal for the university CS departments prior to the universal availability of PCs because the compiler could run on the front end processors belonging to the university mainframe, accommodating numerous students while not impacting routine use of the mainframe. This made the language ideal for implementing on an early PC, the sort of thing that had very little memory (~56K was the norm) and just a floppy disk or two (early disks would have 330KByte capacity only). The COM file restriction would have come from not needing to make a full blown linker/locator.
TP worked far too well. Its still around in some form as Delphi (you'd have to go back many versions to see the resemblance, though).
Pascal taught people structure where in COBOL and BASIC there wasn't that much (other than the really stiff punchcard-style structure of COBOL or the basic stuff in BASIC). That said, if you did play with BASIC, Pascal was a doddle, whereas if you knew COBOL better, Pascal was... an adjustment.
If you knew C, Pascal was... "Why are you stopping me from doing X!?"
Ironically, I found TP7 to be the best thing for anything non-Windows (i.e. DOS and protected mode), because it included the option to write assembler code inside Pascal. For Windows GUI apps, Delphi made a lot more sense, because the GUI was fully OO and you could actually let the GUI handle all its own events while you got on with whatever else you needed. Delphi Standard was pretty good, Delphi Enterprise was of course the dog's bollocks.
Famously, the SRHTML98 tool (awesome for doing search & replaces in Windows on huge files, compared to Notepad) was a Delphi app.
My little text editor with word processing ambitions.
It was all done in TP (mainly 5.5) with all sorts of nice stuff. It was lucky that I wasn't in a relationship at the time (1989) as I spent hours/days/weeks building and refining it. It got good reviews by Dick Pointain & other magazines. It kept my in computers (in the days when a 386 with an 80Mb disk cost (£3k)). Eventually it went out as shareware. I was working at DEC at the time (they let me sell it as mine) and I put Gold key functionality into it (if you know DEC, you know what I mean) just to sell a license to DEC themselves.
Bad bit - it was only DOS and even though it used extended memory and had overlays, it was killed off by WIndows 95. But it was fun while it lasted.
I've still got the source and executables and occasionally I roll it out in Dosbox to see how good I used to be :)
The company that I was working for back then in the late 1980's started using Turbo Pascal and created a program they sold a lot to medical hospital users around the world for about $15,000 each - it was totally based on an early publicly shared application written and shared with users with the Oregon Software Pascal 2 in 1984. The big advantage of Pascal is that you can take one set of Pascal code from one version and quickly make it work on another version of Pascal.
I worked with the original creators who wrote the first public shared version, they gave all the public users a copy of the Pascal source code instead of a formal manual or documentation - the users just read Pascal to see how the data was processed.
I used Turbo Pascal to write data recovery tools (hardware and software). I liked to mention that when 'real' programmers tried to take the mickey out of me :)
I did eventually move on to C++ but only because we took on more developers and had settle on the most common language. I will always defend Turbo Pascal because it was a very powerful and capable development environment. So was Delphi.
Two answers to the first. Delphi replaced it and C and derivatives took over the programming world.
As to the second, Delphi cost more but it did include the right to redistribute. I lost track of Delphi after 7 but as far as I can make out Delphi the Microsoft IDE replaced Borland's own. It also got more and more ambitious and expensive.
I had a longish gig using Delphi (it helped that I'd used UCSD Pascal earlier). I like the RAD way of doing things. It forces the developer to start with the UI. I've seen too many examples where the developer seems to have looked on the requirement as a series of technical tasks, got those working separately and then jumbled them into a UI of sorts.
Believe me, some developers will still try and force something completely different and incompatible into the mix, I've had to fix Delphi Apps where they started with a state machine and hammered the UI onto, rather than use natural state flow a Delphi UI would give you.
Believe me, some people can write truly awful Delphi programs. Today, I was looking at a D7 app with a single procedure (fired by a timer every second) that was over 4000 lines long with 18 levels of indentation.
And the interface has to be seen to be believed.
> with a single procedure (fired by a timer every second)
I bet you 5 pieces of the lowest denomination of your local paper currency that the original developer of that program used to program embedded micros using assembly (or possibly C).
Amazing how much you can do with main ( while ( true ) {} ) as your main program and everything else happening in ISRs.
I used Mac pascal for first year of Uni and Delphi 1 or 2 just after Uni for a bit and Delphi was fine for the time. Like most other GUI first IDE apps they were horrendously easy to build bad database apps. Apart from apps written in Gupta SQLWindows (which became CenturaTeam developer, this IDE/language was fantastic), I don't think I've ever seen a scalable database app created using a GUI first IDE where people just dragged and dropped database components.
After a 20year stint of SQL with various languages and a lot of C/C++ I switched jobs 10 years ago to one that uses Delphi & SQL as the primary languages, the Delphi Object Pascal language itself is sort of okay but a reasonable number of problems and bugs with it and it's libraries, especially the IDE which make it a real productivity drain. The Delphi IDE works fine for our small apps but is annoying for large ones - some of our devs have given up on it and use VSCode for editing and only use the Delphi IDE when they really have to.
I've seen too many examples where the developer seems to have looked on the requirement as a series of technical tasks, got those working separately and then jumbled them into a UI of sorts.
That almost sounds like the process Microsoft seems to use, except for the 'getting to work' part..
:)
its maker, Borland, wanted a little extra if a customer planned to distribute the binaries.
My father bought me a copy of TP4.0 from a trip to the USA. If I recall correctly, for around $50 you got the compiler and a big honking manual with ALL you needed. I had a lot of fun with that.
Some years later Borland released TP5.5, and then Borland had an official reseller in Brazil. I recall they had some discounts for users of older versions. I called them and asked about the discount and a very naughty representative told me that since I bought my version outside Brazil it was not considered a legal copy (!!) and I would have to pay the full price for the new version, which was way outside of my budget. Thus, a pirate was born.
Just read today's 'Who, me?' and gave a wry smile at the mention that 'a Pentium 133 running Office 97 on Windows 95 was the height of business computing - after all, I can reasonably convince myself that was only a handful of years ago, right. scandisk? Yup, I remember using that, too, and it really wasn't that long ago surely.
Now you come along and mention an IDE I remember using (with some fondness, too) but mercilessly highlight the year of its release. 40 years ago. Damn you. I'm now officially an old git ;)
My memory may be totally off, but TP was not *that* different from Pascal, if there ever *was* a pure form. No different than, say, UCSD Pascal. That's speaking from using TP and UCSD on my Apple 2 and then learning the "pure" form at uni. Not sure saying Hejlsberg was the inventor is that correct, compared to Wirth.
That said, maybe later versions that then arrived on MSDOS were indeed quite different. Never used those. Only the Holy Trinity of 64KB, Z80-CP/M and 80-char cards! Who needed more than 64KB anyway?! ;)
This post has been deleted by its author
Pascal had the notion of file, but no way to bind it to the actual filesystem of the actual machine the program was running on. (C got round this by simply insisting that all implementations emulate Unix.)
Borland got round this by a non-standard, but essentially compatible mechanism using a special comment syntax. You could (often) compile the code on another system, but of course the non-standard stuff didn't then get executed at all which wasn't especially useful.
Well, I used TP on an Amstrad PC1512 to create my coding assignments and then Kermited them into the educational establishment's Unix box. That dates me.
The genius of Borland's pricing/shareware model was evident when in my first coding job we had to migrate a program from Pick to DOS and elected to use Turbo C due to familiarity. They must have picked up a lot of future customers while they were students.
-A.
Part of the reason for the lack of named file access in PASCAL was perhaps portability, in those days every OS had its own notion of file name syntax, and they were even more divergent than the tension between Windows and Unix/Linux file names.
It is also clearly meant for a batch environment. In the original, your PROGRAM statement could have file-type parameters and your "control cards" were expected to assign them to real files.
Another place where the batch-orientedness shows is that strictly-speaking the original did not even support any interactive IO, because notionally opening a file read the first element from it, so that INPUT^ which denotes the next unread element (usually character) would always have a defined value, and this INPUT (correspondings to C's stdin) was opened when the program started. So the program could not print a prompt before it required input!
Most implementations used "lazy IO", where INPUT was notionally opened at first reference. I think Turbo Pascal solved this by eliminating the silly file^ syntax entirely and required always using READ. A sane solution.
One implementation, PAX, that I had to use at the HUT (where it was written) took alternate route: The INPUT would always begin with a fictional line-delimiter, so to read from the terminal you would have to write
READLN;
READ(whateveryoureallywantedtoread);
Thanks, but that made interactive PAX programs automatically incompatible with all other implementations.
There was no "special comment" needed for I/O..
assign(fin,"hello");
reset(fin);
readln(fin,rawline);
Now special comments _did_ come in handy if you wanted to catch errors and be friendly. So you might do
{$I-}
reset(fin);
{$I+}
if (IoResult<>0) then
begin
Writeln('Could not open file');
halt(2);
end;
The special comments stopped auto-generated I/O checks which would have created a runtime error.
Yes! Turbo Pascal! First year at university ... programming in Turbo Pascal ... a big room with 40 PCs (XT? 286?) in 1987. Turbo Pascal was superfast. No need to think long if a line was correct, just compile and see what Turbo Pascal said. It made you a lazy programmer. Great.
Later on, I tried Turbo C ... wow, that was slow. Luckily, in 1989 I did C on a SUN pizzabox. Multi-tasking. I still use Linux for the non-office stuff.
Been there done both. VMS PASCAL from green screens over an X.25 PAD in first year, then Turbo Pascal on PC's in second year. I already knew BASIC and Z80 (guess how?) so Pascal was distinctly underwhelming. I suppose for the complete newbies it was a lot less arcane than C would have been.
Did my industrial placement with Ford Motor Co where they were also using VMS Pascal. Now that had a *lot* of proprietary extensions. That placement was very good fun.
Then moved on to C++ on SunOS. Read Bjarne's book on the train on the way to the interview... Now *that's* a proper programming language, still doing it and learning fun new things 30 years later.
I did have a short-lived gig maintaining a Delphi application. Nice little environment, if you like the whole UI and persistence hopelessly integrated with business logic, style...
It doesn't have to be like that, although when I started using Delphi in about 1997 the systems I inherited would generate a whole invoice in the "InvoiceButtonClick()" procedure for example. It was only way later that I realised all this should have been put into a datamodule or plain class - my education pre-dated OOP and in work it was mainframe/mini stuff which was strictly procedural.
Anyway I actually first used Pascal in the sixth form when we went to a local poly at the the time but I don't even think that was interactive...then in university it was Pascal on a Pr1me system. I dropped out to MVS/Fortran and VMS/C for a while but then moved to that Delphi job which kept me in Delphi employment up until about 2018 when we dropped the Delphi/OpenGL marine tracking application that I blagged a position with being the only Delphi programmer within a 100 mile radius and rewrote from scratch in Unity/C#
I like Pascal
Maybe C++ is little like PL/1 in that regard; My initial impression on trying to read that book was: this is probably a great language.....for coding geniuses.
It may be that the mere mortals among us eventually settled into mostly using a common subset of the language, which is more manageable.
| "Is modern C++ easier to understand?"
In some ways it is. There are lots of ways to abbreviate and let the compiler work it out for you, like auto deduced types or range for loops. As an old crusty C++ developer a lot of it looks really alien to me and I'm having to re-train myself.
Then there is stuff like generics and lambdas that are absolutely wonderful to work with once you know them, but initially look like someone was bashing their head on the top row of the keyboard.
Yes, the Bjarne book is terrible, but that's all there was in 1992.
> 4 kinds of loop ...
I count only 3: WHILE-loop, REPEAT...UNTIL, and FOR-loop. Using them appropriately made the code readable. C and C++ also have 3 loops, but C:s version of REPEAT...UNTIL, which is do...while is less readable, but, hey, it saves by reusing a keyword.
No, no it wasn't. Although, I could write it in the CS department's main lab on their VAX 11/780 connected VT102's, or on a 286 in one of the computer labs, or from my office, on the DPS-90 downstairs. Being a system admin on the DPS-90 meant that I had a private modem line into the university computing center so I could use my Wyse50 on the table next to my swimming pool at home, along with a bottle of Bacardi, to complete my assignments.
God! To be 18 again...
This takes me back to computer science classes in 1988, where we all shared a copy of TP5. Lots of fun writing our projects with it. I loved coding with it. I even wrote a leisure centre booking system in it for my A-level project.
For the more mischievous of us, we wrote TSR (terminate, stay resident) programs that would run on our Research Machine 286 workstations, that would just emit a beep at random times - drove our head of computer science mad with that one!
Fun times.
I used to program c++ applications as a hobby (and if we needed a utility at work). Sadly, I don't get nearly enough time to do anything more than basic scripting now, but I did become quite proficient in writing utilities in C++ using Visual C++/Studio.
After a while, needing an easy way to create interfaces, I took advantage of the fact that being a student, I got a decent educational discount on Borland software, I bought myself a copy of C++ Builder. While it always seemed like the annoying little brother of Delphi, the fact it was based on the same Visual Component Library basics meant I could write some decent applications (nothing earth shattering, but they performed the functions required of them well enough) in c++ and didn't need to worry too much about the interface (which is something I've never enjoyed anyway).
Turbo Pascal was a very good language to learn programming. The IDE was good, compiling was fast, and the inline debugger of version 6 (my fav at the time) was so useful. At that time, we used it for several university's projects, like a FEM software for 2D beams or a basic CAD software... happy times.
The UI framework evolved nicely over the years. The transition from Turbo Vision to VCL was pretty painless so I'd say continuous evolution encompassing DOS, Win16 and Win32 (the latter in both C++ and Pascal sharing each other's 3rd party VCL libraries) and - arguably - .NET since WinForms is basically Delphi for .NET designed by Anders when he moved to Microsoft. There was even a cross platform version - CLX - which sadly failed to gain market traction because the desktop application market for Linux has never been very big.
And in reference to a previous comment I made about MS UIs: Take a damn' good look MS! This is how you design and maintain a UI framework! You don't need to keep throwing the bath water out with the baby and forcing your users to learn something new. Just bloody do it right the first time! The only weakness I encountered was with how WinForms handles scaling but that might just be because I've only seen how MS failed to handle it. It might be the current VCL handles it perfectly well.
Footnote: Borland did also develop OWL which was something of a dead end. But if you compare it to the competitor of the day - MFC - it wins hands down. OWL was still a much better UI framework and a lot of its philosophy made it into the VCL anyway.
> Footnote: Borland did also develop OWL which was something of a dead end. But if you compare it to the competitor of the day - MFC
OWL was released before MFC, it really didn't have a competitor for a good year or so.
Sadly, the story at the time (which I don't have a citation for - anyone?) was that Mucrosoft had developed a Windows framework that was on par with OWL (basically being nicely Object-oriented) but it was chucked away because it didn't "look like proper Windows programming", so they spent 2 & 1/2[1] days writing MFC and making sure that all the data members were public...
Then, because it was "official", MFC steamrollered OWL (making OWL into a dead-end unless you were allowed to be a maverick). Even after Paul DiLascia's book "Windows++", published the same year as MFC, showed just how much nicer Windows coding could be, even if you weren't fortunate enough to have BCC and OWL.
[1] well, it couldn't have taken any longer to do MFC v1! Even years later, MFC was refusing to make full use of basic stuff, like const ref parameters, causing so much pointless object copying. You could markedly speed up programs that did a lot of, say, time-based calculations by duplicating the code for CTime then adding in all the missing constness and refness. At least they provided the source, so that was possible, although it probably went against the licence.
IIRC OWL was bought by Borland from a third party and whilst it nicely abstracted all the Win API stuff, it had a steeper learning curve than MFC which was essentially Win API but without the window object handles, and given that most C and C++ devs had previously used the raw WinAPI, MFC wasn't much new to learn and so took off as the framework of choice.
Kylix was the product name. CLX was the cross-platform component library. According to that article it was based on Qt but the API followed the VCL so it's unclear whether it really was a cross-platform version of the VCL. I never used it.
"Its aim was to replace the popular Microsoft Foundation Classes with Visual Component Library. CLX was based on Qt by Nokia[citation needed].[3]: 196 The API of CLX almost completely followed VCL. It was envisioned that existing applications using VCL would be recompiled with CLX.
However, due to lacklustre performance on Windows, subtle differences from VCL, and bugs, it didn't become the expected successor to VCL. Commercial failure of Kylix stopped further development of CLX."
The answer is, Turbo Pascal lives on today as Delphi.
The cheapest "Professional" edition costs £1140, but if you want support for Databases, which is a kind-of essential feature, you need the most expensive "Architect" edition, which costs £4,200. That is quite a bit more than $49 even adjusting for inflation.
Python is available for free, and can do a *lot* more than Delphi.
Turbo Pascal was so popular that at one point Microsoft had its own competing version, QuickPascal, which also came with a IDE and compiled quickly. I guess it did not sell too well. because I got a copy cheaply from the discount shelf of a computer store in Helsinki. I think it was around 1990 or so, The language was mostly similar to Turbo Pascal, but not exactly so for some reason. In particular, the OO extensions differed.
As an undergraduate I used a copy of Borland's Turbo BASIC for some of my final year project. No idea where it came from but it was easy to use and worked really well.
When I did my postgraduate degree I switched over to Turbo Pascal and taught myself Pascal from a book in the library, and used it for all sorts of things during my degree. My supervisor was doing something in Turbo Pascal and hit a problem, his program would compile but crashed when you ran it. I said I'd have a look at it for him, after I'd finished for the day. It turned out that the compiler must have had a bug, as one valid line compiled okay, but wouldn't execute. If you broke the line in two or restructured it, the maths was the same, it didn't crash. Anyhow my supervisor made my second author on the paper (I did talk other things through with him and not just fix a bug), and as result of that paper I got a job in the US. When I moved to the US, my new boss said the best person in my lab isn't coming with me (he was changing universities), and that best person is now my wife....!
In the US I used Borland Delphi which was good and Turbo Pascal like but with a Windows GUI, which was useful for somethings, but in many respects overkill for what I was using it for.
Ironically I once helped my now wife debug a program in Turbo BASIC, where there was a fundamental error in the code and all the maths was consistently wrong. She couldn't believe that she had found the bug as the program had been used for years and several papers had been published based on the data it processed. However she was right and all the previous datsets were wrong...!
I did a lot programming with TurboBasic. Borland eventually sold it back to the original developer Bob (forgot the last name). Bob renamed it to PowerBasic and it's still available. I wrote a mutli-user point of sale system in the early 90's using PB with Novell Btrieve as the file manager.
A friend of mine still uses Pb/Win to write custom DLL's.
There is, but I couldn't get my Delphi Programmer to change over (thus saving me the cost of the frequent Delphi upgrades) and nor could I wean my Test Equipment Manager off VB6 and onto something more portable (I wanted to use Linux in some test equipment).
It's a while back now, but from memory the basic core of Lazerus was good enough, it just didn't work well with the third party libraries we had to use.
I'm fairly sure all parties have retired now, so who knows what their successors are using ...
"Also, the Delphi Super Page was last updated in 2006, and is possibly the last surviving website that still uses frames."
Goodness, I'd forgotten about DSP - one more blast from the past in an article full of them. Have an upvote:)
I first used Turbo Pascal in A Level computer science in 1989 - previously I'd only used BASIC or 6502 on 8 bit micros. Moving on to uni, PC programming was taught Modula 2, with an optional C course if you wanted to show up out of hours just for the fun of learning it. I did.
Turbo Pascal 6 showed up in other modules though, and my final year project was done in TP for Windows 1.5. I owned my own copies of Turbo Pascal 6 Professional, and TP for Windows, before moving on to Delphi. I did a LOT of Delphi in the 2000s, but I lost touch with it after Delphi 5 for quite a while. And yes, as someone mentioned above, they did come with a whole stack of excellent manuals, which I still have somewhere.
These days I have Free Pascal / Lazarus installed. It's great for knocking out quick tools / utilities, but it does seem to have limitations when it comes to using third party libraries. Last time I looked (admittedly a long time ago) Internet Component Suite didn't work (or work properly, I can't remember which), for example, and I've run up against a other similar issues. Even so, it's very handy to have. Ideally, I'd be using Delphi Community Edition, but the licensing terms are prohibitively expensive and Lazarus is good enough.
Of course, there are more modern alternatives, and python is great for many things, but for windows gui apps that you want to distribute as a single exe, you can't beat the combination of free and Pascal.
My programming career was: Sinclair Basic -> Locomotive Basic -> BCPL (yes, really!) -> C -> Turbo Pascal -> Delphi -> Borland Builder C++ (still using the VCL - oh how I smirked at the idea of so many other C++ programmers using MFC) -> C# (WinForms -> WPF & Xamarin) where it eventually ended last August.
I liked C#. It was an easy language to work with and made me very productive. But I did miss the cut and thrust of C++ (templates were both fun and scary) and I certainly missed RAII. C# has using but it ain't the same thing and not being able to just put objects on the stack and have them cleaned up when it unwound was irritating.
Almost 30 years later, Turbo Pascal was my first semester introduction to Programming ~ in any language, and I did later do some assignment work in Modula2. I do have a soft spot for the old Turbo Pascal. It isn't as elegant as c, but it's a whole lot harder to tie yourself in knots with pointers. You can do it, but you don't have to explicitly use pointers to do almost everything the way you do in c.
In the mid-90's, our local schools and colleges went crazy for TurboPascal in CompSci A-level.
It was one of the major deciding factors in why I avoided going for those courses. Having dabbled with the various Borland "Builder" tools I had no interest in wasting time on UI wrappers when I could either use a higher level language for fun stuff or something much closer to the hardware when I needed power.
Trendy VisualBasic Drag-'n-drop has a lot to answer for, and you can see it in the bloated state of many current tools.
Yup. I endured TP5.5 at college. It was good to get to understand the idea of modular programming, declaring variables before use, sanity-preserving variable scope rules... all the sorts of things that home micro BASIC just doesn't do.
But I found the language to be somewhat tedious with the amount of nonstandard extensions required in order to actually do stuff. If I remember correctly there was a weird syntax for passing addresses of things, because Pascal didn't (normally) do such a thing.
One lunchtime wandering around the server drive looking to see what else was available, besides Windows 3.11, I came across TurboC.
And that was a total joy. It was like Pascal with the training wheels removed, and the IDE being able to stop on an error with the offending line highlighted was so far ahead of practically everything else. Bizarre WordStar keypresses aside, that IDE was one of the friendliest text based IDEs I've ever used.
So, yeah, fond memories of Borland. Not so fond of knowing how long ago it was.....
Turbo Pascal on the Amiga was freaking awesome. It automatically created a Windowed UI for your application, and was an excellent gateway to C and C++. Really miss those days.
As for what it created, it was a stand-alone executable. Not sure what the deal was with the PC version, but the Amiga version created software you could distribute without the need to include anything other than the executable on the disk / CD. Was is a bit slow? Sure. But it worked. It's not like we were writing games with it, so it didn't matter.
You could distribute DOS applications for free as well with early version of TP but it was restricted to the .COM executable format. Which wasn't really a 'format' at all and was restricted to 64kiB. The .EXE format allowed for significantly larger applications.
There was a period where I could argue TurboPascal was the very best environment available for simple-ish programs on CP/M and MS-DOS.
When PC's were still very expensive, CP/M machines were merely expensive and hard disks were rare; I could develop on my Kaypro or Commodore 128 using a single floppy and then compile and run it on MS-DOS PC's.
That 128, once a RAM disk was added: awesome fast development. I still miss it sometimes.
For a project that could be done in a day or so; very pleasant. Fast compiles and it would pop you directly into the IDE at the first syntax error it found, pretty amazing for its day and what it was running on.
I can't speak to speed of execution as I didn't have the hundreds of dollars to get something to compare it to; but its primary competition in the space and time I was playing in was interpreted Basic and it was a lot faster than that!
Turbo Pascal war story: A project to retrofit Bear automotive pollution inspection stations with anti-fraud measures.
Situation was that mechanics in Pennsylvania were swapping in clean cars for tailpipe readings. For a small gratuity, repairs thereby could be avoided by customers.
So, "just" randomly capture an image of the vehicle with license plate and probe in view, store these and sometimes upload them to state regulator. And let mechanics know about it, and that image uploads without a clear shot would generate a phone call.
This was ca. 1992 or thereabouts so this involved sourcing an affordable digital camera suitable for the job, reasonably robust. As it shook out, this turned out to be the Connectix QuickCam. The Bear machine was centered on an embedded PC so a parallel port was available for connection. After quite a bit of correspondence we negotiated an NDA with Connectix and obtained complete documentation for talking to the camera (and they sent us a handful of free cameras for development!).
In order for the image capture to function with adequate speed, we needed to use assembly language. Turbo Pascal's inline assembly option made this a snap, was a huge timesaver. As well, this add-on was super simple for Bear to integrate as it was a standalone chunk that the machine's main software could call. Almost no effort on Bear's part, and no administrative hassles as the capture/upload process was entirely independent from their process.
I know people did a lot of real work with Turbo Pascal, but for me the real legacy was that it led to Turbo C and forced MS to get their [poop] together. Borland bought Wizard C, so the first Turbo C 1.0 was missing a lot of stuff you expected from a Borland Turbo product, but after a year, Turbo C 2.0 had the familiar blue IDE.
We were using Microsoft's cack-ass Microsoft C compiler (which they bought from Lattice) in 1988, but it was clunky, slow as hell, and buggy. Replacing it with Turbo C was a revelation and a godsend. MS's would chunk for minutes on the disk then spit out obfuscated errors, and of course you had to bring your own editor (like Brief!), then subshell to run the compiler and hope that didn't cause it to choke. With Turbo C, wow, you just hit Go and it instantly compiles and runs in mere seconds! And zOMG it would help you do GUI stuff!
MS reacted with QuickPascal and QuickC clones, which never really went anywhere, But eventually they released Visual C++ in the 90s - it was amazingly awkward and expensive and slow at first, but after being pounded on for over 30 years Visual Studio is quite nice... and free! And it all started with Turbo Pascal, or MS would have just milked their terrible disk-based compiler forever.
Visual Studio is quite nice
I think there was a time around about 2008 when that statement might have been correct. Oh and possible 2019 (when I think they finally released the 64 bit version) but aside from those two brief moments of time VS has been a bloated and often unstable pile of shite. I credit it as being one of the main reasons why I finally retired last August. I was sick to my back teeth of it and its foibles.
Well, it really depends on what you're looking for. I absolutely understand your frustration with VS's freakouts. Last month I had it complaining about multiple things compiling to the same assembly since I had a form broken up into multiple partial classes and somehow it generated a resx for both the partial classes. So had to delete the extra resx to fix it. This is completely outside anything sane you should have to do.
But I've been using a LOT of stuff. On Linux I've been using xemacs and gcc, because I have 30+ years of emacs shortcuts burned in my head.
I've had to use Eclipse (and its spawn like Code Composer) a lot, and I find it far slower and buggier (in minor things) than VS.
And then I've used VS. And there is nothing I've ever used (including Qt Creator, Android Studio, Xcode, Delphi VCL, etc. etc.) that does integrated easy UI like VS does for WinForms. Yes, if you go WPF then it's bloated and enterpisey as all f#$%, no question there. But when I'm using xemacs I completely miss VS's UI stuff, and I also miss how it helps you understand *other people's code*. If I'm editing my own code I understand it completely, but if I'm editing someone else's code, and they're using (of course) a home grown DB shim, and I'm trying to fix some of their twaddle, and I have their DB shim, I don't know if their sync method is 'sync', 'Sync', 'flush', 'Flush', or 'write_everything_to_disk'. With VS I can just enter the class variable, then '.' and it will tell me all the public methods/variables. So I can find it's 'sync', and then I can hit F12 to see the implementation and any gotchas. Eclipse can do that too, but as noted above it's far slower and eccentric.
I'm probably privileged because I'm mostly using C# these days and VS seems exceptionally well tuned for that. I used to use VS for C++ and it was very clunky, but these days I only use C++ for DLLs for things that C# is too slow for (which is <1% of code).
So if you found VS too spazztastic for C++ I can't blame you, but I'm using it for the most efficient path to what I want to do (even works with Linux with Mono), and it is absolutely the most productive for that.
TP was a game changer. I learned Pascal at uni where it ran on a PDP-10 and all coding was done on punch cards. If you were lucky you could get maybe two compiles a day. A slight improvement came later when they introduced "mark sense" cards which had keyword etc printed on the card with angle brackets < > beside each one and you put a pencil line between the brackets to indicate the word or symbol. It alleviated the queues for the punch machines but you still only got a couple of compiles a day. After I had left uni I heard that they had bought a number of TRS-80s and they had put in custom PROMs to allow students to code in Pascal and submit and run their jobs.
The first Pascal I actually used was Tiny Pascal for the TRS-80 which loaded from cassette. Slow but cheap. At work we had an Apple Lisa and we bought LisaPascal which was horrendously expensive. It had a few quirks but it was a pretty good system.
When I bought my first PC I got TP which even in Oz was around $50. Back then the AUD was pegged to the USD 1:1. TP was great. I don't recall any issues with the speed of running applications.
I also bought FTL Modula-2 written by David Moore a Queenslander. He later went on to work for Intel in the US but I still have the floppies floating around somewhere.
While Pascal is not a perfect language, for it's time it was brilliant and simple to learn and encouraged good programming practices. It was designed for teaching but it was also suitable for doing real work. Thus, it needs to be "judged" against the other languages of the time. In particular, compared with C (which, IMHO, is a write-only language), the Pascal compiler saved the programmer from a lot of silly mistakes. TP took the simplicity of Pascal, packaged it up and made it readily accessible to would-be programmers. I wonder whether Windoze (and the M$ Office applications) would have had as many bugs and exploits had they been written in a type-safe language such as TP.
‘Dear Bill, I have received your letter of May 17. Since it looks like it will be impossible to convince you of the facts, I see no hope in responding to your letter point by point. For now, it is enough to say that your letter contains many inaccuracies. It is necessary, however, to stress three key items:
1.- After all our exchange of letters, you still have not assured me that information you want from us will not be leaked to your business and language application groups who are developing and marketing products that directly compete with Borland's products.’
‘For some time we have been having the kinds of discussions you mention with the understanding that the information we provide will only be used by your operating system group, only to later learn that our information has been used to help your applications people compete against us. You don't believe me? Ask Brad. I was disappointed that a solution to this was not listed among your “concrete suggestions.”’
Fond memories of fast compilations, bug free programs. A delight to use.
I migrated to Delphi 1 as soon as it came out, all the way up to XE something or other.
Those were the days when writing software was a pleasurable activity.
I remember going to a Borland TP software launch at Thorpe Park. Even their giveaways (an umbrella in that instance) were damn solid. Shame I left it round someone's flat, otherwise I'm sure it would still be going strong.
Out of interest, at work, I used Intel's MDS (together with various ICE tools) at round about that time. We had a Coral 66 on floppy which was also a joy to use. This was not pc compatible.
Both these tools proved beyond shadow of doubt that algol-like compilers could produce extremely lean, fast code for most applications other than kernel or device driver uses.
Actually Delphi is still a very quick and enjoyable IDE for Windows and with some limits to other platforms too. Compared to C/C++ compilation times it's way better.
Bottlenecks are hard to use external C libraries and the price, there's no way I pay about 1000 Euros every year for quality fixes and maybe one improved feature that's is useful for me.
Lazarus is the free way, has some flaws, but actually usable on any platforms and OK for real world use, though I only made smaller projects on that.
Doing A Levels 1991-93. Apparently TP was used as its structuring was a good basis for the real world apparently.
Knowing what I know now I work in the sector myself, it was probably as much to do with the fact it was cheap! I am pretty sure there were grumblings back then it was already obsolete although I can appreciate why for someone's the first dip into programming how it would have been a reasonable choice back then. Maybe. I don't know, I never took it up in any sense afterwards.
(And for those outside the US, college here in Blighty is post compulsory school, so was then usually attended between 16-18 years of age)
...spanning some 35 years to TP (and then Delphi). My first job was writing add ons in UCSD P-System Pascal to for an accounting suite as well as a 3D carpet design system written in Turbo Pascal 3.0 (still remember F1, S to save, followed by C to compile). Then went on to more accounting software in Turbo Pascal, then Delphi. Switched partially to .NET & web apps, then Node/React but I still maintain a few systems written in Delphi. I still miss the speed and simplicity of the DOS days.
the IDE seems a little clunky nowadays when compared to modern tools
To some, perhaps. TP 3 was the only IDE I ever really cottoned to. (I enjoyed working with ISPF and OS/400's PDM, but more as a sort of demonstration of arcane knowledge than because they were actually good to use.) I think every IDE I've seen since — and I've seen a lot of them — is a step backward. Too complicated, too noisy, too much of a black box, generally obnoxious.
For many years my preferred IDE has been vim, make, a decent lightweight symbolic debugger, all of the standard UNIX command-line tools, and ksh or bash to integrate. That's far more flexible than any GUI IDE I've seen.
Somewhat of a weird article. I used Anders' compiler when it still was called PolyPascal. And I am not aware that back then, Turbo Pascal was available for anything but Z80 CPU & CP/M-80 as the OS as well as 8086 and DOS (and CP/M-86).
And 64KB was the maximum address space on a Z80&CP/M-80 and even on a PC, a lot of machines in '83 had rarely more than 128 or 256KB of RAM. So that COM (tiny) memory model was quite sufficient, beside that it supported overlays. It was also a compromise to the speed of generation, as it didn't create OBJ files but created directly binary code that got copied to the end of the runtime system.
Yes, Turbo 4 was a complete rewrite, and by that time, PCs had also developed quite a bit, so a compiler could take advantage of more than the one 64KB segment of the COM memory model....
I cannot find the graphics demo from the 80's that opens with Sierpinski Curves, Splines, and Windows. It would have been mid to late 80's Just before Windows 1? Nothing on Youtube.
8 years later I saw "Alice, the personal Pascal" as my first LSE.
My first actual Pascal program ran on a Cyber via CRJE in 1984.
But yes it was the Python of the age. I also had to deal with Modula2 at Uni. Happy times....
I wasn't even a teenager yet when I got into programming. I started out with TP7, and wrote hundreds of utilities for personal use because my parents didn't have the money to be spending on the programs I wanted. I wrote binary patchers, scrolling document viewers, database programs, disk utilities, hex editors, TSRs, all in TP7. By the time I wrote something I felt would be good for commercial release, Windows 95 came along. The infamous "runtime error 200" bug had become apparent, and I had no desire to rewrite everything in C++/Windows API or Delphi.
But TP7 was great. Fantastic, even. Even if it was only for DOS.
The Register 
Biting the hand that feeds IT
Copyright. All rights reserved © 1998–2025
