Future Tense: Turbo Redux

Alex Castle

Back in the pre-Cambrian era of programming for the personal computer, there were only two options: assembly language and BASIC.

Assembly language was a compiled language, producing object code that was the machine’s native language, but it was hard to learn and writing good code was a time-consuming process. Debugging it was even harder.
BASIC was an interpreted language. It was easy to learn, but because each line of code had to be interpreted on the fly, it was slow. And it wasn’t a structured language with functions and procedures, all you had were subroutines, so you ended up with a lot of spaghetti code. If your local dialect of BASIC allowed it, you could write your heavy-lifting functions in assembly and call them from BASIC, but that pretty much defeated the whole ease-of-use thing.

Yes, there were implementations of Fortran and UCSD Pascal and a few others as well, but for the most part, those weren’t the best solutions for desktop machines. In those first years, the greatest limitation in the world of personal computing was the lack of great programming languages.

Then one day Turbo Pascal crawled up out of the primordial ocean and triggered a Cambrian explosion of software evolution.

Turbo Pascal had several significant advantages. It was as easy to learn as BASIC. It had procedures and functions—as you wrote your library of routines, you were essentially expanding and customizing the language. And unlike early iterations of BASIC which used variable names like A10 and Z3, you could give your variables and routines actual names that made sense in the context of the code like FirstName and LastName and AreaCode, so your code was essentially self-commenting. For me, the real value of Turbo Pascal was that it made powerful programming not only accessible, but understandable. Not just the day you wrote it, but a week later when you came back to it as well.

Before Turbo Pascal, the common specification for Pascal was that the compiler would produce fast P-code and any machine that had a P-code interpreter could run that Pascal program. So it represented a halfway step between assembly language and interpreted language. Ease of use plus a significant improvement in speed.

But Turbo Pascal went that one better. It compiled to native code. While not quite as fast as hand-coded assembly language, the result was more than fast enough. (It doesn’t really matter if a program produces its result ten thousand times faster than you can see or only one thousand times faster, does it?)

While Pascal had been created as a ‘teaching language,’ Turbo Pascal proved that it could also be a very rugged production tool. The other great thing about it was that it combined the editor and the compiler into a single interface, so you could write code and generate test builds quickly without having to switch from one environment to another. The compiler was fast, often producing test builds in a few seconds for short projects and less than a minute or two for large ones.

Turbo Pascal cost $50 and shipped on a single disk, not copy protected. The manual was an easily understandable perfect-bound book. It was a gamble on the part of the company, they were betting the farm on those first ads, but Turbo Pascal was an immediate hit. Within months, Turbo Pascal pwned the market and it became the standard interpretation for Pascal on the PC. The first iteration was for CP/M, the second was for DOS.

Turbo Pascal was written by a young genius named Anders Hejlberg. A marketing genius named Philippe Kahn licensed the software and marketed it through a new company called Borland. Throughout the seventies and well into the eighties, Hejlsberg continued to expand and improve Turbo Pascal, adding powerful new features with every release: an integrated debugger, units (external libraries), case functions and variable records. With Release 5.5 Turbo Pascal evolved into an object-oriented language.

Object-Oriented Programming (OOP) was an important evolution for programmers. It required a different way of thinking. Fortunately for the Turbo Pascal community, a programming guru named Jeff Duntemann wrote a brilliant introductory manual that shipped with TP5.5. It was a very thin book by comparison with the rest of the manuals of the time, but it walked you up the learning curve so easily that by the time you finished the book you were thinking in OOP and writing OOP code.

The importance of OOP was immediately obvious when Windows 3.0 shipped in 1990. Programming for Windows requires OOP. You can’t think linearly, you have to think in terms of event-driven software. There were several versions of Turbo Pascal for Windows, then it became Borland Pascal and eventually part of the Delphi Rapid Application Development tool.

And somewhere on that long evolutionary path, Turbo Pascal became a dinosaur. Now, that wasn’t exactly a bad thing. Dinosaurs owned their environment. They survived for sixty-five million years, approximately sixty-four million and nine hundred thousand more years than human beings. Dinosaurs were big, which made them hard to kill, but you can’t exactly characterize a dinosaur as friendly.

Today, it seems as if we have no all-purpose programming tool as easy or as accessible as Turbo Pascal once was. Feature creep is inevitable, but it ends up making software bloated and harder to learn, and harder to use effectively. Adding too many ‘usability’ functions can actually weaken usability. (You know all those ‘tips’ articles about Chrome and Photoshop and Excel and Word? That’s because the programmers added all that extra usability that you wouldn’t know about otherwise.)

I used to write a lot of my own special-purpose utilities in Turbo Pascal. I don’t need to as much anymore. It’s faster and easier to Google around and see that someone else has already solved that same problem. And that may be the real reason why programming software has faded from the marketplace. We don’t need it as much as we used to.

If I need a special-purpose database, I can create it quickly in Filemaker Pro, tweaking, adding, and adjusting as I continue to use it. Anything that needs a chart, I can do in Excel, faster and more efficiently. And MicroLogic’s InfoSelect and Microsoft’s One Note are both good for free-form text storage. I don’t need to go back and rewrite my FLOG (Fast Little Organizing Glommer) utility when there are so many better tools already available.

But despite all the wonderful special-purpose tools, there are days when I still wish for a fast-and-simple programming environment for Windows—the contemporary equivalent of Turbo Pascal, rugged, easy, fast, and immediately useful—something I can use for fast-coding a specialized utility or even play with a game idea I have.

I could be wrong (it wouldn’t be the first time), but I suspect there’s a healthy market for a new ‘Turbo Pascal’ targeted for the weekend warrior. We don’t need another Cambrian explosion, we’re still in the middle of the current one with no signs of any impending slowdown, but I wonder if perhaps easy computer programming might have moved out of reach for the common user…?

What do you think? What would you suggest?

Around the web

by CPMStar (Sponsored) Free to play