About the Cover: Pascal’s Triangle (Aug, 1978)


Next >>
3 of 3
Next >>
3 of 3

About the Cover

by Carl Helmers

It is rare when one can indulge in one’s prejudices with relative impunity, poking a bit of good humored fun to make a point. The design of the cover, entitled “Pascal’s Triangle” provided just such an opportunity. The cover was executed by Robert Tinney, but the prejudices are all mine and were given to him as a fairly detailed script. The point is that Pascal is here, it is consistent with use by small computers, such as many readers own, and it is available in the form of the UCSD software system at quite a nominal charge above the cost of the hardware required. While today it requires a computer at the high end of the personal computer range of pricing, the utility of the language and advances in both magnetic media and read only memory technology should lower the price of the minimum hardware requirements considerably over the course of the next year or two. With that point, we present “Pascal’s Triangle.”

The primary allegory of the cover is of course the inversion of the “Bermuda Triangle” myth’s theme to show smooth waters. The triangle is an unbounded tri- angular array of buoys numbered with the binomial expansion coefficients. These coefficients are “Pascal’s Triangle” as any high school algebra student will have learned. Pascal’s Triangle on the cover is of course embedded in a matrix of the waters of the FORTRAN Ocean of computer languages, named after the pioneering widely used high level language FORTRAN, and its descendents FORTRAN II, FORTRAN IV, WATFOR, WATFIV and even the mildly reformed RATFOR.

A prominent island graces the bottom of the picture, the Isle of BAL with its rocky and desolate surface. Note the great JCL barrier reef which surrounds the Isle of Bal and borders the Straights of COBOL along the bottom edge of the picture. These dangerous and unstructured reefs have sunk more than one ship on their treacherous shoals, including the good ship SS OS of all encompassing (360 degree) fame. (Much commercial traffic is seen in the sea lanes of the Straights of COBOL.) In the lower right part of the picture where the Straights of COBOL meet the main body of the FORTRAN Ocean, we see a curious fog bank (imagining a view from the deck of a ship in the waters). It is said that this fog bank is always present, hiding the exotic and mysterious jungles of LISP. While unseen by normal mortals, our gods’ eye view of the picture shows the brilliant tropical algorithms, the fabulous nodes growing on trees like in some Eldorado of programming. But who can see brilliance through a fog bank?

Travelling upward (in the picture) through heavy seas we come to the pinnacle, a snow white island rising like an ivory tower out of the surrounding shark infested waters. Here we find the fantastic kingdom of small talk, where great and magical things happen. But alas, just as the impenetrable fog bank around the jungles of LISP hide it from our view, the craggy aloofness of the kingdom of small talk keeps it out of the mainstream of things.

Turning our attention to the lower left part of the picture, we see the famous Floating Point separating the FORTRAN Ocean mainstream from the interactive and weed filled Sea of BASIC.

To all the relative disorder and chaos of the waters of the FORTRAN Ocean and its adjacent coastal features, the smooth, calm infinity of Pascal’s Triangle provides a brilliant contrast. We note vessels ranging from the commercial freighters to pleasure boats to the rafts of hobbyists to the military fighting ships heading for the calm waters of Pascal’s Triangle.

To complete the mythology, we find within Pascal’s Triangle numerous examples of ships enjoying the smooth sailing and untroubled waters.

Is this an adequate picture? Computer languages are like philosophies in many respects, which is to say that the reasons for an enthusiasm are often hard to attribute to anything other than aesthetic grounds. But as in philosophies and religions, conversions do occur from time to time. Very often in today’s microcomputer world, we find the case of the engineer or systems programmer who has been using an assembler (if anything at all) as the first and only software development tool. Such a person will often discover BASIC, FORTRAN, APL, COBOL (yes, even people with engineering backgrounds sometimes see COBOL as a first high level language) or language X. When language X is discovered, the advantages of the high level language technique often become confused with the specific example-and the enthusiasm which comes with the powerful elixir of automated programming aids turns that person into an X language convert with an almost religious fervor.

As the new convert proceeds to use the language, he or she also discovers its inadequacies in detail errors. And the X language devotee starts inventing this or that perfect extension, a new superset of X, which is endowed with even better properties. This particular inventiveness syndrome is most pronounced in compiler implementors since they are in a position to “do something about” the older language by ad hoc implementing personally meaningful extensions when putting a new compiler up.

What has resulted, viewing from the big picture, is a range of languages, each reflecting the context of the group of implementors who are responsible for its creation. Pascal in this global context must be viewed as but another step in that natural sequence of human events.

I personally like Pascal as a method of expressing programs, because of a number of arguments supported by my own prior experience using languages including macroassemblers, BASIC, FORTRAN, PL/I, HAL/S, JOVIAL, XPL and a bit of PL/M.

As a potential user, try a few programs, see if you like the style of expression involved, and if the price is right, that may be the system for you. If you like the arguments presented for Pascal in this issue and by examples in issues to come, by all means express your interest to manufacturers. This issue is a conscious attempt to communicate some of the flavor of Pascal with a spirit of fun and an understanding that even Pascal may not be the be all and end all of computer languages.”

  1. Casandro says: September 5, 20119:41 am

    Of course, Pascal, in it’s newer variants, is still fairly popular for certain uses. However that UCSD Pascal system is long dead.

    But if you read through all the obscure languages, you should always keep in mind that no single vendor language has ever survived for long.

  2. cwnidog says: September 5, 201111:22 am

    Pascal was the first high-level language for many of us back in the day. It was a good first step, as it was much more strongly typed than C and later extensions, e.g. TurboPascal, made it useful in the engineering world as well. It taught us the rules, before we went on to break them in C.

  3. fluffy says: September 5, 201112:46 pm

    I learned (Turbo) Pascal before learning C, and I felt that it made it easier for me to learn modern structured programming. It helped that the syntax went out of its way to be readable.

    Of course, these days Python seems to be the teaching language of choice.

  4. Toronto says: September 5, 20119:42 pm

    I learned non-Turbo Pascal, and always hated the dreaded “missing final ‘.’ error. Still, it was supposed to teach thoroughness. But I was spoiled for all languages by having FORTRAN as my firs language, then several variations on BASIC and various assemblers. Pascal felt like handcuffs.

    C feels like a wrecking bar.

  5. Sean says: September 6, 20115:01 am

    I learned QBASIC, VB, and Pascal in that order. Coming down from being able to do all sorts of cool things that actually looked like what a GUI was ‘supposed’ to look like to spending 10 minutes hunting rogue semi colons before each compile was somewhat less than fun. Moving on to C++ was a breath of fresh air.

  6. Ric Locke says: September 6, 20115:37 am

    As Toronto and Sean allude, Pascal was written originally as a teaching language, and for that reason it was a straitjacket that would more properly have been named “Procrustes”. The compilers for all versions enforced The Rules with pitiless precision, making a HELLO WORLD program into an afternoon’s labor.

    Its worst feature was that it was the last, most shining example of the Hopper-Knuth Illusion, that a language completely independent of the hardware was possible. That might have been true in a mainframe, batch-processing environment, but the widely-proliferating and wildly-varying architectures of the early microcomputer era meant that no matter how many cases the compiler writers covered, somebody in Cupertino would invent one that didn’t fit. That meant direct access to the hardware was necessary, and Pascal was designed to frustrate that to the extent possible. That, in turn, meant that programmers had to learn yet another language, and like as not enough Assembler on top to convert back and forth between calling conventions. It was almost always easier to convert Pascal to the Other Language than to accommodate the disjoints.

  7. Nomen Nescio says: September 6, 20118:50 am

    turbo pascal was the first “real” language i learned, and the structured-programming habits it gave me have served me very well. i’m glad not to have had my brain rotted by goto-spaghetti basic first.

    these days, of course, python is not only the language of choice for teaching but also a very good language for real production use. it may be the first language created that does as well as it does in both of those roles, which is impressive indeed.

    and if there ever were anything that might be termed a “Hopper-Knuth Illusion”, then pascal certainly wasn’t its last example. java, anyone? (or, well, python. except that python, well, actually works pretty decently on most anything it runs on.)

  8. fluffy says: September 6, 20118:53 am

    @Nomen: Have you actually tried comparing execution time between Java and Python? Python is SLOW, while modern Java is actually pretty fast (especially with JIT), and at least for stuff that doesn’t present a GUI it actually does do a good job of write-once run-everywhere now. (And really Python’s the same way – Python has GUI toolkits too but they’re all just as platform-dependent and fiddly as Java’s.)

  9. Nomen Nescio says: September 6, 20119:09 am

    @fluffy: i didn’t mean to denigrate java — well, not on its execution performance at any rate, my personal gripes with it are more syntax- and semantics-related — although on second reading, my phrasing didn’t make that very clear. my apologies.

    i meant to imply that python wasn’t subject to the “illusion” in that it actually works pretty decently. admittedly, if you need high execution speed you may want to choose another language, or write a library in some other language to be scripted with (perhaps) python. i’m unconvinced if there really is any “Hopper-Knuth Illusion” as Ric alluded to, and whether or not java falls to such an “illusion” probably should be judged by people more familiar with it than i am; i dislike java, but that’s from a fairly small number of brief encounters with it.

    if Ric’s correct about this illusion, then certainly both java and python deserve mention as post-pascal examples of it, but python i know is far from a failure. java too has its adherents, though i reserve the right to think they have awful tastes in languages. 😛

  10. fluffy says: September 6, 20119:18 am

    Ah, well, yeah, I’m no fan of Java, personally, although it’s not a terrible language if you can look past some of the more baffling annoyances. Also, most of those annoyances are at least justifiable based on what the language creators had in mind, although of course that doesn’t make them any less annoying in practice.

    Java is way more successful than most people seem to realize, though. It’s the basis of pretty much every cellphone (smart and otherwise) whose name doesn’t begin with a lowercase “i,” and every major ebook reader whose name begins with a “K.” It’s also used a lot in the enterprise server space. Really, the only place it hasn’t caught on is the desktop, which is a bit ironic considering that was the basis of its original rallying cry.

    Personally I try not to get too religiously-devoted to any particular language. My preference is C++ (preferably with STL and shared_ptr), and I’ve been interested in giving Vala a shot some day, but tying yourself to a single language and not even wanting to consider things outside of it is engineering suicide these days.

    Oh, and Javascript has become a pretty good extension language on its own, as well as pretty fast now that the various JIT implementations have gotten very performant. It’s just a shame that its syntax is so inelegant for a few things and that there are so many interpreter-specific gotchas to worry about. (Fortunately, as an extension language you don’t have to worry about that so much, since the embeddable interpreters tend to actually give a damn about ECMA compliance.)

  11. Toronto says: September 6, 201110:28 am

    Annoying language list: Java. Perl. APL. Lisp. SNOBOL. Any of the DEC extended FTNs if you ever needed to port them elsewhere. Any Honeywell extended language (those guys were WEIRD.) Most PL/1 subsets because they never seemed to agree on what to exclude. Lattice C on a 512 Kb machine. C++. ABasiC. All the programming languages shipped as part of Prime Information including the odd syntax constructs you could hide in data dictionaries and treat as real data.)

  12. rs70 says: September 18, 201110:39 pm


    Errr, no. There were tons of things in C before there was ever a usable line of Pascal written.

    Like, um, Unix. And lots of other applications. Besides unix, it also ran on DEC’s RSX11M and got used in a lot of process control stuff in the mid 70s.

    Dave Conroy wrote the RSX compiler. It later morphed into GCC. The GCC poeple deny this, but in 91 or so I FTP’d into Gilmore’s server and fond Conroys comments and code in the “clean rewrite” that was to become gcc.

    I worked with Dave and was the third person to use his compiler. He and I both went to Waterloo.

    I remember Lattice C. Slow as it was on a PC it was even slower on CP/M. You could go to lunch after starting a decent compile, come back and it was still not done. We mostly used PDP-11’s and cross compiled. Nobody wanted to write a word processor for the Z-80 in Assembler. Twice.

    In one sense microcomputers were just so awful. There you are used to an 11/45 using C then suddenly you’re programming 8085’s and Z-80s. Not exactly a step forward. Things didn’t catch up until about 6 years later when the Amiga came out, now you were back where you started from.

Submit comment

You must be logged in to post a comment.