Real Programmers Don't Use PASCAL (1982) | Hacker News Reader

Real Programmers Don't Use PASCAL (1982)

pbm.com

41 pointsbrudgers51 comments

I remember taking AP Computer Science in high school and learning Pascal. Anyone else remember doing this? The AP Comp Sci exams were in Pascal until 1998.

Yep, you had to buy a floppy with TurboPascal for $5 I think... I actually liked it, some most fundamental things about programming "clicked" for me in the Pascal class. And then even found the skill useful to write stuff in Borland Delphi later on.

Yes, I did that too; took the test in 1990.

I didn't, because I started programming in earnest somewhat later in life — but I envy people whose first programming language was Pascal. It's not perfect, but it's at least a sensible language, and it enforces some good habits that other, less opinionated languages don't.

My high school taught BASIC in 1981, but then I learned Pascal on my own because some of the nearby colleges were using it. When Turbo Pascal came out, my dad happened to read about it in the Wall Street Journal, and got me a copy for my birthday. I kept up with TP through version 5. I was dead certain that Pascal would displace C, and today, when I have to write in C, my programs are either Pascal-like, or wrong.

The structure of Pascal seemed to be inherently geared towards teaching fairly disciplined programming. Maybe that was the point. I think that Pascal has helped me be a better programmer.

Admittedly, I've always preferred "real programmers don't use" languages.

But my other early influence was Steve Ciarcia. Real programmers program with a soldering iron. ;-)

>The structure of Pascal seemed to be inherently geared towards teaching fairly disciplined programming. Maybe that was the point. I think that Pascal has helped me be a better programmer.

Niklaus Wirth would be pleased to hear that, since he designed Pascal to be a teaching language. He intended students to learn on Pascal and then graduate to Modula-2 for serious projects.

I don't think Modula-2 ever really caught on, though.

>> I don't think Modula-2 ever really caught on, though.

Oberon too. I wonder why Pascal (Object Pascal, to be precise) get most of the spotlight.

Pascal had a commercial ecosystem by the time Oberon came along.

And Oberon is austere where Pascal dialects grew all kinds of warts in the process of adding the features people asked for.

Wirth took away features in almost every iteration of developing his languages - you see this in almost every language he touched going back to the 60's and Algol-W.

It's been the guiding principle of most of his career to ruthlessly simplify.

The Oberon-07 language report is 17 pages.

Oberon takes more of an effort in following Wirth's mindset of addressing deficiencies by looking at how to make things simpler across the board (e.g. including for compiler writers) as opposed to the Pascal dialects which took the approach of addressing deficiencies by making things immediately easier for users to pick up, at the cost of additional complexity all over the place.

The CDC-6600 Pascal compiler from ETH had several small extensions in the same style as Turbo Pascal to integrate better with the underlying platform.

This is just to say that the culture of extensions/escape hatches didn't begin with Turbo Pascal.

FWIW, Modula-2 and Oberon had quite a following on the Amiga back in the day.

There were whole Public Domain disk collections that only consisted of programs done in those languages. Most notably the AMOK disks (Amiga Modula-2 and Oberon Klub).

I think those languages also didn't catch on was partly because they weren't part of any major OS development standard. On Unix or Linux, C was dominant, for historical and cultural reasons, and on Windows, although there was and is a small but vocal Pascal community, most developers are focused on Microsoft's own programming languages.

"Niklaus Wirth would be pleased to hear that . . . He intended students to learn on Pascal and then graduate to Modula-2 for serious projects."

Well, maybe later on. He designed Pascal in late 1960's and Modula-2 in late 1970's.

OK, you've piqued my curiosity. I followed a very similar path to your own, but I have ended up as a C programmer professionally, and I'm curious as to what differences you see in the two languages. To me, they are essentially the same, give or take some syntactical differences. Functions and structs, direct access to memory, no classes, etc etc etc.

Good question. And my answer comes with the caveat that I'm not a computer scientist, and could in fact have been wrong. I've made one or two bad bets. I also bet that programming wouldn't be much of a career.

With that said, it seemed in C that you were closer to the hardware implementation of what pointers do (for instance you could do arithmetic on pointers), making it easier to reference an int with something that was supposed to be a float, or something like that, and to generally make those kinds of memory violation and array bounds errors. Nothing like that was in the original conception of Pascal, because Pascal was supposed to be hardware independent.

I felt like letting your data structures be your program was a natural aspect of Pascal, but something you had to discipline yourself to do in C. Also, the parameter passing syntax for Pascal seemed more readable than all of those *'s and &'s. It could all have boiled down to me understanding Pascal syntax better than C syntax.

This was all based on the C of the early 80s. When I mentioned some of these things to a real C programmer later on, he said: There are compiler warnings for those things nowadays. My favorite language du jour is Python, but I use C when messing around with microcontrollers, so I've finally gotten used to it.

Hah :) I was expecting you to come back with something about typecasting, which Pascal, as conceived by Wirth, was determined to make as difficult as possible, if not flatout impossible. This limitation made writing performant software in standard Pascal quite difficult. Which is why most of the popular Pascal implementations provided extensions to make it possible to use Pascal for real problems. I'm thinking notably of MPW Pascal, which was used to write much of the system software for early Macs.

You guessed right. And after I made that pronouncement to myself about C, I kinda lost touch with the programming community, as Turbo Pascal and my programming skills got me through college and gradual school in physics. When I finally came back up for air, of course C had won out, but programming a graphical platform with a low level language seemed too hard, and I reverted to higher level tools such as HyperCard, Visual Basic, and today, Python.

I write this on https://www.reddit.com/r/programming/comments/33h4t0/lazarus...

Pascal itself have some "obvious" advantages:

1- Fast compilation

This hide a non-obvious advantage: The language is more coherent/well designed/simple in principle. This have a cascade effect along the way.

2- Anything C could do, Pascal too. Even the old Apple OS was done in a dialect of pascal.

BTW, I use Delphi instead of MS C++. Not miss C++ at all

3- More sane type system.

4- A good string type!

5- More readable syntax

Some people will contest the pascal syntax is verbose.

Let's agree about that. However most syntax (with the exception of BEGIN/END) is useful. We can disagree if more/less verbosity is good/bad, but is NOT the point.

Is not just the verbosity, is the predictability and less-ambiguity of it. Even if the keywords were replaced to shorted ones (and clamp down on the verbosity) you will get something very-alike to python in spirit (+ static type system).

This come again from the "obvious" "Pascal compilers ARE fast". They are fast, because, the syntax/language is made to be fast. In fact, most pascal compilers are 1-pass compilers.

Is NOT a coincidence that this is the case: The creator of Pascal wrote one of the most influential papers about build your own compiler:

https://en.wikipedia.org/wiki/Algorithms_%2B_Data_Structures...

A modern take of it is presented in https://github.com/Araq/Nimrod

This is why most people agree is easier to program in a dialect of pascal (like Delphi or FreePascal) than in C/C++, for the same kind of tasks. The clarity that bring the syntax could be a part of it (some of us believe) but in the end is that the language is more coherent. Is similar to "python vs ruby" where one is more "magical" than the other.

C/C++/Perl/Javascript is more about "A millon ways, not well integrated, in how, maybe, depending on ???, to do stuff" versus Pascal/Python "A predictable, single/small ways to do stuff".

Probably, GO is a spiritual sucessor in this area, where fast-compile times are enabled (obviously, among other things) because the language is simpler. That make it in contrast with Rust.

This are some of the most superficial things. As like with any language, is better to spend some time using it to appreciate it more.

I use it (Delphi) when I was a noob, and I can do stuff that was impossible to me to do in C/C++ (ie: C++ is more complex for the same). Where I read how do anything with them was full walls of code/mess, in Delphi I found more simpler ways. Spoiled badly, because the VCL was absolutely superior than the mess that MCF mean to do windows applications. And the the database libraries round around the ADO, DAO, .NET DataSet and that other stuff people still believe are good ideas...

Ada put far more to the table. The main problem was the high cost, that made it out of reach for many. This was a serious trouble with other good languages, like smalltalk.

ADA have a lot of the things modern C#/Java is doing now, with what GO, Eiffel and others give too. Still suffer from the "ADA is mainly a costly commercial compiler", but anyway...

Modula, in the other hand, look great. Sadly not much exposure of it, and Delphi take the whole "Pascal space" to itself

Delphi is amazing, but is the most tragic story of any language ever: Is like if the owners hate it with more passion than any.

Is like the Firefly show: Doomed by the studio, but the fans love it to death!

I took it during that brief, wonderful period when the test covered C++. The other semester of that year was supposed to be a hardware portion, restoring an old pinball machine. That never happened; I guess maybe the C++ curriculum just ballooned into a full year, or else we were playing too much Quake.

In my country I took what I believe is an equivalent course in high school. We were using Pascal in 2007/8. I then did a short work placement at Borland (creators of turbo pascal) who laughed and were very surprised when I told them I'd been using pascal.

My high school taught Pascal in 2014, exams were Pascal too.

I had turbo pascal in middle school compter science lessons in 1999-2002. Also Object Pascal (Delphi or fpc) on university in 2003-2004.

I think it works very well as first programming language (even though my first programming language was BASIC on C64).

Pascal is very simple (skips over tons of corner cases and accidental complexity of C and C++), and strict enough to teach basic good habits unlike BASIC (or js or Python).

I don't think strictly object oriented language like Java is good for learning programming, too much stuff that is irrelevant at first but required. And dynamic languages are nice after you know at least one static language.

I grow up with Borland Turbo Pascal 5.5. My machine was PC XT with 6 MHz, 0.6 MB RAM and 20MB hdd. Pascal had IDE which ran smoothly, supported mouse, could edit multiple files, copy&paste, had debuger, compilation took 10 seconds...

And most importantly documentation was translated to my native language.

C back than would have notepad (NCEdit), manual in english full of assembler and command line compiler.

I liked Turbo Pascal back in my childhood too, even wanted to replicate one myself.

Now I use python, but have a lot of headaches with debugging/GIL.

All I have to say is https://xkcd.com/378/

We could save a lot of typing if xkcd:// was a protocol understood by browsers. For example, xkcd://927

as well as r://

I get the feeling that commenters aren't reading the linked article at all, just latching onto the mention of PASCAL in the title.

This article is almost the opposite of Brian Kernighan's "Why Pascal is Not My Favorite Language". Kernighan criticized Pascal, essentially, for not being as advanced as C.

In contrast, the linked article is written from perspective of old-time FORTRAN programmer and essentially criticizes PASCAL for being too advanced, "structured programming" and all that stupid, frilly, "advanced", academic, "computer science" stuff. "We get stuff done the old-school way; we don't need no new-fangled language!"

The linked article could be rewritten with some appropriate changes and titled "Real Programmers Don't Use Haskell (or Rust, or . . .)" and written from the perspective of a C/C++/Java or Go(!) programmer.

In the future, people who write JavaScript without a framework will call themselves "real programmers".

In the future, JavaScript will be the virtual machine of many languages. But maybe "real programmers" still will use JS code directly.

https://www.destroyallsoftware.com/talks/the-birth-and-death...

Reminds me of 'The Nightwatch' by James Mickens (PDF): http://research.microsoft.com/en-us/people/mickens/thenightw...

This link comes with a bit more context about Mel and the machine he programmed: http://www.catb.org/jargon/html/story-of-mel.html

Ok I know this article as old and blahblahblah, but seriously? This line of reasoning is idiotic.

Life should be simpler, not more complex. By this line of logic a "real programmer" should be soldering wires or building their own CPUs and resistors. Man has evolved higher and higher levels of reasoning and tools for a reason: increased expressivity allows for more sophisticated thought. Try building a modern web browser this way... Good luck.

I hate this bullshit that somehow has still stuck with us over time. Have deep knowledge and understanding -- but expertise and talent isn't the same thing as low level.

Doesn't the article strike you as ironic?

There's enough crusty engineers out there that would agree with this that I can't tell.

> By this line of logic a "real programmer" should be soldering wires or building their own CPUs and resistors.

Of course he should. If you haven't, you're an unreal programmer.

You will find it relevant that 1982 was the year of publication of a book called "Real Men Don't Eat Quiche." That title was tongue-in-cheek. This title riffs on that title, which was topical at the time - which tells us it's not meant literally and seriously.

As someone who got interested in modern Object Pascal recently, any recommendations for influential/canonical books? (Like SICP, Bjarne's TC++PL, etc..)

My first introduction to Object Pascal were the Turbo Pascal 5.5 manuals and the first Turbo Vision application attempts.

Back then OOP was still the new kid on the block, so the other books that helped me get into OOP where

- The Xerox PARC Smalltalk books, http://stephane.ducasse.free.fr/FreeBooks/

- "Eiffel: The Language", Bertrand Meyer

- "An Object-Oriented Environment: Principles and Application", Bertrand Meyer

- "Designing Object Oriented C++ Applications Using The Booch Method"

- "Project Oberon" and "Algorithms and Data Structures, Oberon version", http://www.inf.ethz.ch/personal/wirth/

- "Object-Oriented Programming in Oberon-2.", http://ssw.jku.at/Research/Books/

- "Component Software: Beyond Object-Oriented Programming", first edition uses Component Pascal

There was hardly any Object Pascal representative book, so those books were what made the grasp OO concepts across what were then new languages, more than the specific way of doing OO.

I have always loved this article and I remember it posted on the wall of the CS break room. I enjoyed it so much that it was the first thing I searched for when AltaVista was released. I think it influenced and introduced me to the hacker ethos. Although I don’t qualify as a real programmer as I graduated with Pascal, C, COBOL and Haskell under my belt with no Fortran.

I remember my 14 year old self disliking Pascal and liking C, because C had {} instead of Begin and End and you could do funny stuff inside of C for-cycle.

I remember my 20 self disliking Pascal and liking Java, because while my class-mates were bussy re-writing quick-sort at a beginning of each assigment, I just imported SortedTreeMap :-)

The strength of Pascal is the spirit of the language and the compiler. You can get some really high quality machine code out of something that is cognitively straightforward - it's something that, in my opinion, no language has achieved since.

The syntax is an utter disgrace.

https://en.wikipedia.org/wiki/Real_Men_Don%27t_Eat_Quiche

I was programming Pascal and Fortran in 1982, and I take exception to this. Real programmers drink Diet Coke, NOT coffee.

This link comes with a bit more context about Mel and the machine he programmed: http://www.catb.org/jargon/html/story-of-mel.html

Uh, yeah, I link to Mel's story in the Real Programmer article, at the top.

But not the version with context.

I wonder if real programmers use virtual machines though.

Real programmers have been using virtual machines since CP-40.

https://en.wikipedia.org/wiki/IBM_CP-40

real programmers write virtual machines.

real programmers ARE virtual machines.

Real programmers use editors that have virtual machines.

C-x M-c M-VirtualMachine.

Reply on news.ycombinator.com