All, in all, It was much easier to program for Windows using Turbo Pascal 7 than with anything else. Not only did it provide a programming model that matched the way the Windows user interface worked, the application itself had a Windows graphical interface – many Windows programming tools at that time actually ran under MSDOS, and were entirely text-based. TP 7 also had fully-graphical tools for designing the user interface elements, like menus and icons. Laying out a menu using a definition file with an obscure format, using Windows Notepad, was never an agreeable experience. Microsoft did produce graphical tools for this kind of operation, but Turbo Pascal combined them into a seamless IDE. All I had to do to build and run my programs was to hit the F7 key. I could even set breakpoints for the debugger, just by clicking a line of code. As I said, common enough today, but revolutionary for early Windows programming.
↫ Kevin Boone
Even as a mere child who didn’t even know what programming was, I was aware of Turbo Pascal. It was a name that you just encountered all over the place as a DOS and Windows 3.x user, even if you didn’t know what it was. The author of this article, Kevin Boone, even claims Turbo Pascal “contributed to the widespread uptake, and eventual domination, of Microsoft Windows on desktop PCs”, which is not something I can verify because I was far too young, but I wouldn’t be surprised if it holds water.
This article made me wonder if Pascal is easy to learn, and if someone wanting to learn programming can do worse than start with a Windows 3.x virtual machine and Turbo Pascal. Sure, it’s probably not very relevant today, but it might serve as a good, solid base to work from?
I have no idea.
Fun fact: The original, DOS version of Jazz Jackrabbit was written in Turbo Pascal, Cliff Bleszinski and Arjan Brussee confirmed as much on X (though I can’t find the post anymore).
I think there were quite a few games written in turbo pascal. IIRC prince of persia was too. Battle tanks may have been as well, though I’m struggling to find those details today.
Apparently someone started a list in 2007
https://www.pascalgamedevelopment.com/showthread.php?4519-The-great-list-of-Pascal-Games&s=d2404ae817de8de929c721d6a5ac78e7
The borland graphic interface was not optimal for fast graphics, but you did what everybody else did and access graphics memory directly.
A lot of 1337 stuff of yore was made in TP7 because you could code assembler procedures directly in the IDE.
You declared a procedure using the asm directive (iirc) and you could debug it directly in TP IDE, reference pascal variables without too much sweat and the like.
AFAIK, Fast Tracker 2 — one of the trackers that defined early nineties’ mod scene — was coded in TP7.
And if someone wants to _really_ dive into retrocomputing rabbit hole using TP7, there’s still SWAG (SourceWare Archival Group), a repository of tips and tricks for all things Turbo Pascal.
http://www.retroarchive.org/swag/index.html
Idiran,
I remember this too. Assembly was incorporated right into the language and using it was a breeze compared to create assembly object files, declaring prototypes, and passing everything to the linker.
Turbo Pascal then Borland Pascal under Dos were so fun to use. Compilation was so fast it felt immediate (especially compared to “modern” compilers), the debugger was 80% of what we have nowadays (and I don’t really care about the added 20%). Only con was the reboot when the machine was fully crashed. Good old times; very productive times!
Turbo C++/Borland C++ were a good follow-up.
ChodaSly,
Their main advantage over C compilers was Pascal compiler was not only single pass, it was pretty much integrated to the IDE.
Yes, pressing F7 (or was it F5) meant immediate starting of the code.
Compare that to C, that has to write the code to disk, run compiler, which has a preprocessor, and two main passes, write object files, and run linker which will try to resolve all referenced libraries and assemble those into a program.
Pascal was designed as a vertical solution which worked great for many programmers.
As I remember it from back then, Pascal was devised to teach programming. Wikipedia differs.
For years, I bought and updated every version of every Borland language compiler and additional toolboxes, starting with Turbo Pascal 3 and maybe ending with Delphi – or with the collapse of Borland. I have not done any programming with any of them, though.
You see, around that time (1989) I attended a crash course in programming, aimed at squashing the Millennium Bug. This course hardly helped anyone or any company (here in the Netherlands), but it exposed me to Jackson Structured Programming (JSP).
In my opinion, JSP is a brilliant way of programming: starting with defining an output goal, then discovering the input requirements, then describing how to derive the output from the input. It starts in natural language, then transforms to pseudo-code. Only then does the programming language into play.
In my opinion, this thought-refining process is a better way to learn programming than to learn a programming language’s way of saying “Hello world”.
Instructors’ ways of telling conscripts what to do may amount to the same.
Chris Laarman,
It got quite a bit of use in the commercial space too. Not any more of course, but a lot of turbo pascal applications featured a turbo vision text user interface with quite a distinctive look and feel. There were lots of companies that preferred pascal to C/C++ at the time. Those that tried Microsoft’s tools generally found those worse than borland’s too. Borland’s popularity in DOS would not carry over to windows though.
Learning to program takes different kinds of skills. It’s very important to learn how to do X in a language, but it’s also very important to learn how to structure the program around the requirements. Both skills are very important. Generally speaking, for experienced coders, knowing how to write code in a language becomes second nature. Most of your time goes into gathering functional requirements and mapping them into the structures and state machines that will be needed to produce the desired results.
As for which is more important to learn first, I don’t know. Both are critical. In theory you might learn how to organize a program before you learn the language. Personally though I learned the language first using trivial examples and then learning more programing structures came with practice.
Maybe they should be tough at the same time?
I see that Jackson structured programming stems from cobol, which is quite different from other ways of programming 🙂
https://en.wikipedia.org/wiki/Jackson_structured_programming
@Alfman
I still have to preserve VMs with both Turbo Pascal / C++ and the legacy Builder lines, because you’d be shocked by how much of this persists in the commercial / industrial space. When something doesn’t work with a modern setup, often the fastest way to debug this is to wheel out the museum piece.
I was working on some state of the art laser systems just a month or so back, and the whole back end was written in Turbo Pascal, it’s been in use since the 90s..
cpcf,
Haha, yeah. My last time working on DOS software was around three years ago, in turbo pascal no less! The company didn’t want to rewrite the software on something more modern, but they were plagued by two issues: loosing access to compatible network cards, and 16bit memory addressing. Migrating to a VM solved the hardware issue. They wanted a quick and easy fix for the memory problems too but the application was tightly coupled to 16bit DOS drivers and EMS hacks. My personal feeling was that a rewrite would be less effort than trying to keep using the old code base, but that was actually a bit of a political quagmire…the owner was really attached to the existing code.
Pascal WAS created to teach programming, as is obvious from the limitations of the original language design, but Borland’s dialect made it suitable for commercial development by loosening some of the egregious safety restrictions.
See https://www.lysator.liu.se/c/bwk-on-pascal.html (Why Pascal is Not My Favorite Programming Language
by Brian W. Kernighan) for details on what limitations original Pascal has.
ssokolow (Hey, OSNews, U2F/WebAuthn is broken on Firefox!),
That’s an informative link, thanks for posting that! Some points do ring true, however languages are allowed to evolve and with that in mind I’d like to see a similar write up for borland pascal. Pascal has units, which has long been a deficiency for C/C++ software. When I picked up C, I found the lack of language supported modules to be very regressive and still do to this day.
Alfman,
Pascal was the primary language on Macintosh back in the Motorola chip days, and stayed that way until I think Mac OS X came in.
With some good extensions, it was an excellent programming language.
On the Windows side, Borland Delphi was years ahead of Visual Studio for business applications. Even the once popular Access was not as good for developing database centric forms, and only Borland, later Embarcadero’s own greed and mismanagement caused it to lose steam.
I don’t think it was ever popular on Unix style systems though.
sukru,
I’ve never encountered pascal on unix systems either. While pascal was fairly popular on DOS, I had very little exposure to unix at the time. By the time I was learning unix at university, pascal was already waning.
I think GNU pascal and fortran existed, but almost all unix software was written for C/C++, a legacy make still makes the languages the most critical to have for system development even today.
Aegis, the OS for the Apollo workstations, was also written in Pascal.
I think for a while in the late 70s early 80s, Pascal was viewed as a systems language as well.
I was taught Pascal in 1982, a year after this article was written. We use linked lists to avoid the limitations of fixed dimension arrays. So it didn’t seem like a huge limitation. Maybe inefficient from a memory perspective due to the proliferation of pointers?? I always regretted that they didn’t teach us C at the time.
lapx432
For us it was eiffel:
https://en.wikipedia.org/wiki/Eiffel_(programming_language)
Never used it outside of university though. I think that many academics wanted to fix the world’s C dependencies. The is a good reason for this, we should be moving to more robust languages, but many students were annoyed to learn a language with no real world popularity.
Eiffel is good for learning, but it has not been used very much apart from (French) Universities (maybe event North-East French universities …)
I used Turbo Pascal on Windows, but found the result was constant string conversions: the Windows API expected C strings (NULL terminated) but the Pascal libraries expected Pascal strings (leading length byte) so programs were constantly converting strings. It convinced me that Pascal didn’t have a future, and I moved on.
This article seemed really jarring though, because it’s says Turbo Pascal 7 (a DOS product) when it’s referring to Turbo Pascal for Windows. These were later fused into Borland Pascal 7 (which included both.) It also mentions that other products from the era used separate tools for editing resources compared to code (which is true), and that Turbo Pascal for Windows combined them into one IDE (which isn’t really true.) TP had a distinct “Resource Workshop” editor. WinworldPC shows screenshots of both tools.
malxau,
Yes, very insightful. The windows API strongly preferred C. There was Delphi, which I didn’t use, I think it was more of an attempt to build a framework on top of windows rather than to use the windows API as your framework.
It seems to me that the pascal crowd from DOS got absorbed into the visual basic crowd in windows. Calling the win32s from visual basic was kind of dirty and most VB programmers would seek out higher level components to use. Active-X controls became a huge industry and I still remember active-x product catalogs featuring hundreds (thousands?) of activex controls that you’d incorporate into your VB software.
The more generic/insightful part is that DOS and the PC BIOS used a horribly inconsistent ABI where each call had its own register calling convention. If you wanted to make any kind of consistent programming language, every DOS function needed to be wrapped in something that exposed the conventions of that programming language. Unless the language included an assembler, these needed to be included in the base product, because developers couldn’t write their own shims. For better or worse, this resulted in a level playing field across languages, and we saw a huge variety of languages at the time that could all generate code of comparable efficiency.
Later, Windows, OS/2, and UNIX arrived, all with a native C ABI. From a programming language point of view, the choice is to keep wrapping each function in these environments (and the number was growing rapidly) or to provide some kind of C ABI bridge (and accept that the programmer needs to escape the language convention and work with C.) Neither option is great.
I think we’re still dealing with the fallout of that today. Every time somebody creates a New, Super Cool language that’s Really, Really Safe, they need to wrap every C function in the universe with their safe language construct, or provide an escape hatch to an unsafe form of C, leaving the programmer to bounce between both. Wrapping all the functions in the universe is a bigger task than making a New, Super Cool language.
Yes…but it was fairly good relatively speaking. A VB language developer needed to declare that an API function took a “String”, and pass a VB String to it. They didn’t need to get into buffer lifetime management or understand pointers. That limited the APIs VB could use, but the programmer wasn’t working with anything C-like to call them. Somewhere later (v2.0? v3.0?) VB included an “hwnd” property on each Form, which allowed developers to do some really crazy interop.
Agree. What’s more curious to me though is more recently the hobbyist developer community seems to have entirely moved to Linux; Windows hobbyist software seems very rare these days. The DOS shareware scene looked vibrant in comparison. It still makes my head spin that there’s 50x the number of devices now, with a smaller software ecosystem.
malxau,
Yeah, every time I get excited about a programming language, I have to remind myself of this. To be fair, I think frameworks like .net and java offer some really good building blocks. But as soon as you need to interop with something else you end up in the same boat. In some of our enterprise applications we used out of process methods like soap and other forms of RPC. These kind of/sort of act like a glue, but even there you need to build wrappers. Loads of fun, haha. Over time I’ve leaned towards plain HTTP requests with a JSON payload. It can handle structured data well enough and you use whatever facilities your language has to convert between JSON and native objects. This approach has no fancy language integration but at least it’s fairly universal and easy to decipher what’s going on without language specific RPC tooling.
I remember trying to code with Turbo Pascal for Windows, and it was kinda of a nightmare. It was way too more complex than it needed to be, and Delphi actually went the right direction years later.
The first computer programming environment I used was Delphi, on Windows 98. I had only previous experience in programming Casio graphical calculator, and Delphi was a breeze. It was the successor of Turbo Pascal.
So yeah, I guess that was easy. Visual Basic was nice too, but feels quirky, compared to Delphi.
We used Turbo Pascal 7 at school in the 90s to learn programming. Back then it was still on 386s running DOS. I have fond memories of those days. 🙂
We even did projects like chess computers or very simple 3D engines. It was a lot of fun.
You must be German/DACH and at my age 😀
Apparently, Pascal was the Lingua Franca of most Western European Universities intro to programming classes in the 80s and 90s.
I have a high number of European colleagues who learned programming with pirated copies of Turbo Pascal…
Gut geraten. 🙂
I can’t speak to Turbo Pascal 7, but I can recommend Borland Delphi 1.
It’s effectively Turbo Pascal 8, is included for backwards compatibility on Delphi 2 through 4 discs, similar to what Microsoft did with Visual C++ 1.5 to allow 16-bit legacy programming using Visual C++ 2.x and 4.x SKUs (there was no 3.x).
Think of it as Visual Basic, but with more performance because it doesn’t compile to P-code, single-file binaries, and an online help system that, when I tested it, successfully resolved an identifier to its type and pulled up the page for the corresponding class. (Allowing me, with prior programming experience but no prior Delphi experience, to whip up a demo app that duplicates the contents of a line edit widget to a label widget in 5 minutes or less.)
In 1995, the first release of Delphi was providing a better developer experience than anything freely available today except maybe the Godot game engine and, to a lesser extent, game engines in general.
Turbo Pascal 5.5 (and later 6.0) was my second programming language / development environment after GW-Basic as a teen back in the early 90ies. Wrote several small games and a drawing program in it. I`ve still got very fond memories of it, some of my sourcecode even survived until now. Every now and then I set up a VM with DOS (mainly FreeDOS these days) and compile and run my old programs) Nothing to say against a little bit of nostalgia, I guess 😉
But as for the last question in the article: No, I wouldn’t recommend that. There are so many modern options for kids to start programming. All the visual stuff like Scratch (and many more) and for “real” languages I’d recomment python, even though I have a few gripes with the syntax. It’s widely used, such a big community, so many resources to learn from. Can’t beat that. But for someone who already knows at least one modern language and has a little bit of experiece with that ( and interest in computer history) it could be an interesting trip to the past to mess around with Turbo Pascal on DOS or Windows 3.1.
I’ve not used it, but https://www.lazarus-ide.org/ looks interesting if you wan to go down this Turbo Pascal rabbit hole.
I was just about to reccomend Lazarus, but you beat me to it.
Lazarus can do much of what Delphi does, but is cross-platform and free (whereas Delphi is Windows-only and very expensive). It is my go-to development environment to make small, fast apps that will run on Linux and Windows. It is based on Free Pascal, which includes the additional language features that Borland introduced to make Pascal a practical (as apposed to a teaching) language.
Lazarus is a bit tricky to set up (and uses the bonkers old multi-window Delphi interface by default), but it is possible to set up a fairly modern IDE in Lazarus having done a bit of background reading.
It’s also as fast as Turbo Pascal (and early Delphi) used to be: when you install a component the whole IDE gets recompiled. True, it sounds bonkers, but it takes few seconds on my aging I7-6th gen laptop.
I suggest installing all Laz packages that contain the string “dock” and re-compile the IDE. (This takes not much longer that just starting Visual Studio.) Then look on the web for “StudioPlusComplete.xml” and install it under “Tools/Desktops”, and you should be away with a cross-platform visual design IDE for simple but fast, native-code applications. For Linux, the Qt6 variant is very nice, although you will need a recent distro (e.g., Fedora or Arch).
The Online Package Manager will fetch you quite a lot of nice stuff for web, email, PDF and database access. You are not going to write a huge modern application with it, but for simple things, it really still works well.
Pascal was my second programming language after BASIC, and it help me get where I am today.
It is very easy to learn, allows high level concepts like loops and structured programming with highly visible intent, and still allowed interfacing with lower levels.
Yes, I also wrote TSRs with it that manipulated hardware in the background, communicated over IPX, and accessed internals of the DOS structures (not at the same time of course).
But let’s not be nostalgic. There was a reason I switched to C, and there is a reason very few people use Pascal anymore.
Even if we move away from existing languages, I don’t think it would be going back to Pascal, but replacing it with modern C++, whatever the latest Java variant is (Dart?), Rust, Swift, C# or something similar.
sukru,
I don’t think there’s a compelling reason to go backwards, there’s nothing inherently superior about older languages on modern platforms and many modern languages evolved from the best features found in older languages. IMHO C has been a bit of an exception, it’s popularity trumps it’s merit for modern software. It still acts as a de-facto default for APIs everywhere. I like C# much better than either C or C++, but despite this I still use C and C++ much more often than C# because so many of our operating systems, applications, and libraries reside in the C ecosystem.
In hindsight, we might have been able to save billions arising from software faults by persuading developers to standardize on safer language, or even fixing C itself. Had they known what we know now, everything from languages to network protocols could be very different today. I don’t think they could have known that their little skunk-work projects would still be in use so many decades later.
I see C a bit like Latin — you should not use it for your daily communication but understanding it helps understanding your language (unless you are Thai, Igbo, Japanese or Navacha).
And yes, it glues the languages together since every real language has a C interface.
Fun fact:
If you download a game from GOG, and open its installer in an editor, you can find string like these in it:
“S O F T W A R E \ B o r l a n d \ D e l p h i \ R T L F P U M a s k V a l u e”
“S o f t w a r e \ B o r l a n d \ L o c a l e s”
Because it’s a customized version of https://jrsoftware.org/isinfo.php and Inno Setup is written in Delphi.
I don’t know what they mean. TP7.0 was for DOS. Had nothing to do in Windows. Delphi changed everything.
You are correct! This was before/on Windows 3.11 in DOS environment, pure TEXT IDE and Menus. There was mouse support though.
Pretty much what TK/TCL looks alike today!
Can you still believe we programmed this shit for hours on a flickering 14 inch cathode ray monitor! I still remember the sound this monitor made when switched on/off. (Almost like a camera flash light.)
Correct, it was all ASCII based. Maybe they are talking about Turbo Pascal for Windows?
kwanbis,
It was capable of building windows software and a windows IDE was available (as pictured in the article). Wikipedia has some more information…
https://en.wikipedia.org/wiki/Turbo_Pascal
Personally I only used it for DOS.
A shaping moment for me: Had to buy(!) TP7 myself for 120 Deutsche Mark when my monthly allowance was not more than 20 DM (memory faded on that, only remember it was not much). Walking to the shop because we did not have a car at this time.
It came on 3 (?) floppy disks (3.5 inch at least) and one big printed manual book. I ran it on a 386SX and a 20 MB hard drive or so.
There was no internet, nobody to ask, nobody to share or to discuss. East Germany often did not even have phone lines at that time. Just endless try and error, repeat.
Paid of though: when starting University, internet started to pop and computer courses became regular subject even outside IT studies. I earned my money back solving the programming home work for most of the students in my class.
What a time to be alive!
> This article made me wonder if Pascal is easy to learn, and if someone wanting to learn programming can do worse than start with a Windows 3.x virtual machine and Turbo Pascal.
It was very easy to learn but powerful enough to teach you pointers. Documentation and also the IDE were very good – but no syntax or error highlighting, no code formatting, no easy database access, no online help.
So its time is just over. If you want to learn programming today, start with Kotlin, Groovy or Rust.
Pascal was my first compiled language (TP 5.5 – on 8086 with one 5″25 disk drive).
Is used Delphi 3 for some years til 200x. Very (hyper) efficient. Borland IDEs where very fast, light, powerfull, with great ideas.
In my opinion, Visual studio closed the gap in 2003 with 1997 versions of borland IDEs.
Turbo pascal had quite some good features: text based “graphical” environment with mouse, menus, dialogs, windows in text, incorporated assembler, incorporated debugger with conditional breakpoints, spies, … OWL library (OWL was a DLL to build graphical applications in Windows, and i found it really easier than Windows Win32)
The compiler was fast, but so dumb … ABI was lame, too much relying on the stack, so Assembly was sometimes neccessary, event just to avoid some stack useless instructions (push/pop/push/pop the same values…)
Ah, Turbo Pascal for DOS… I still have an irrational urge to go back & develop something with it 🙂
I started with TP5.5. It was a bit barebones, but lightning fast on a 8086 machine.
Later upgraded to BP7. Spend a good several years developing hobby projects under it. It just felt right. Very convenient editor with syntax highlighting and multi window support, integrated debugging – and a language that felt equally right. Healthy dose of structure, readability and safety, but still with enough power & bare metal access.
My personal biggest achievement was a Win3.1-like graphical DOS shell, complete with windows, controls, application API & concurrent multitasking: https://iv-photo.kiev.ua/polit.gif
Delphi made Windows development a breeze, complete with its elegant form designer & event handlers. But at the same time it somehow felt more cumbersome and less direct that Turbo/Borland Pascal…
I can’t remember if Turbo Pascal had Syntax highlighting yet. Later Borland tools and Delphi surely had, but TP?
TP7/BP7 had it.
Andreas Reichel
I concur with Wayfarer2K:
https://winworldpc.com/res/img/screenshots/5b656ffd6bc13a78e93e35f5a76ef847874d35fa6c6933d8202bf666dd267518.png
I always felt that the shift away from borland IDEs and debuggers to microsoft and linux tooling was regressive. Borland went from being a dominant player on DOS to a niche player on windows. Borland’s OWL might be considered better than microsoft’s MFC, but way more companies would end up targeting microsoft’s framework and tooling anyway. I still maintain some MFC apps today.
Wayfarer2K – that looks cool I like that!
Personally I don’t code at all. I enjoy reading the comments here regardless. Always wanted to learn a prog language but strangely when it came down to it I couldn’t really think of anything to make/develop that I was passionate about. Some basic scripting yes sure to solve a problem but no actual coding. I can imagine ai will take care of it for me in future.
It interesting how our own experiences colour our thoughts of the world, you’d think most of this stuff long gone! But just last week I had dinner with a colleague I hadn’t seen for nearly two decades. Back then 90s/00s he was big time in the Fed / Revenue, screen scraping in Cobol, his gig was a bit like myself, supporting or converting legacy resources. He retired about 15 years ago, and this year he’s back doing you guessed it, Cobol. On a part-time basis they are paying him more than ever before, of course the job in that segment is more about trust than knowledge, but who’d have thunk it.
All that is old is new again!
When I started electric engineering, in 1994, the programming language used was Pascal and the compiler was TP 5.0. Later I got to use TP 7.0, that had really nice improvements in usability, something not easy to do in DOS.
That said, once I learned C, Pascal seems just kinda locked, it had many things that made it less flexible than it should. But I still have a place in my heart for the IDE, I really enjoyed using it.