HN Reader

Related:

Why Pascal Is Not My Favorite Programming Language - https://news.ycombinator.com/item?id=37044792 - Aug 2023 (2 comments)

Why Pascal Is Not My Favorite Programming Language (1981) [pdf] - https://news.ycombinator.com/item?id=22222117 - Feb 2020 (62 comments)

Why Pascal Is Not My Favorite Programming Language (1981) - https://news.ycombinator.com/item?id=19221143 - Feb 2019 (55 comments)

Why Pascal Is Not My Favorite Programming Language – Current Status - https://news.ycombinator.com/item?id=8273608 - Sept 2014 (1 comment)

Why Pascal is Not My Favorite Programming Language (1981) - https://news.ycombinator.com/item?id=8260694 - Sept 2014 (64 comments)

Except he missed the part where Modula-2 was made available in 1978, exactly to fix all the original issues with standard Pascal, everything that he complains about, minus type safety.

The thing we are still trying to add back into C, 50 years later.

Apparently, this is a game that two can play. Niklaus Wirth, the creator of Pascal, had this to say in turn:

"From the point of view of software engineering, the rapid spread of C represented a great leap backward. It revealed that the community at large had hardly grasped the true meaning of the term “high-level language” which became an ill-understood buzzword."

Source: Niklaus Wirth, A Brief History of Software Engineering, 2008 (https://people.inf.ethz.ch/wirth/Miscellaneous/IEEE-Annals.p...)

'Throughout the paper, Kernighan sets up a strawman of "standard Pascal" in "its pure form".'

http://lambda-the-ultimate.org/classic/message4322.html#4671

Interestingly, Donald Knuth created an entire new system of programming to make up for the deficiencies of Pascal in the programs he was trying to write (TeX and METAFONT):

http://literateprogramming.com/

WEB is expressive enough that there is a tool to directly transpile to C for compiling:

https://tug.org/web2c/

Looks like in the 70s and 80s, it was wild west for programming language design. So many ideas floating around. But over the decades, most converged to the Algol-style (statements, curly braces, often using semicolons, type before identifier, etc.). Look at what we did to programming:

- Java, C, C++, C#, Kotlin, Rust, Swift, Go, TypeScript, JavaScript, ... → they look more or less the same

Compare with these ones that didn't catch on as much as the ones above:

- ML/Haskell, Erlang, Elixir, APL, Common Lisp (and other Lisps), Lua, Pascal, Delphi, BASIC, Visual Basic, VBA, VBScript, SmallTalk,... → each one bringing something refreshingly new to the PL design space

Folks keep talking about how Modula-2 was released in 1978, to fix Pascal's defects. Well, yes, but.

I used Pascal a lot for about ten years starting in the late 70's: multiple flavors of UCSD Pascal, consecutive versions of Turbo Pascal, and VAX Pascal, on six distinct hardware platforms. Pascal was readily available for all of them; Modula-2 had no market share at all, so far as I could ever tell.

And market share is the right word: most compilers cost money in those days, sometimes quite a lot of money. Turbo Pascal took off because Borland sold it for $50, as opposed to something like $700 for Microsoft's compilers.

I wrote a letter to Borland International, asking if they were going to release a Turbo Modula-2, and was told yes. I'd have been first in line. It was never released.

So yeah, Modula-2 existed, technically, but it mostly wasn't relevant, at least not for microcomputer programmers.

I think almost all of those criticisms are solved in newer versions of Pascal.

> There is no null string, perhaps because Pascal uses the doubled quote notation to indicate a quote embedded in a string:

    'This is a '' character'

That doesn’t seem like a good explanation. There’s nothing preventing a tokenizer from interpreting two quotes not followed by a third quote as an empty string literal. In fact, that’s what current Pascal compilers accept (e.g. `writeln('')`).

However, an empty string and nil are also the same in Pascal, there is no distinction between an empty string and the absence of a string. This is because in early computing, strings weren’t separate objects that you pointed to (and hence could be a null pointer), but more like (usually fixed-size) arrays allocated as part of a larger contiguous memory structure. The array could be empty (based on some length variable), but it couldn’t not be there as part of the fixed memory layout.

Actually, in certain systems strings couldn’t even be empty, in the sense that there was no stored size in addition to the fixed-length array. Instead you padded the rest of the array with spaces. The CHAR type in SQL (as opposed to VARCHAR) is a remnant of that practice.

In the 1980s, CNET (one of France Telecom R&D labs) wrote a UNIX clone in Pascal.

Note that Pascal of 1981 is not the same as Object Pascal compiled with FPC in 2025, although many of his points still stand.

My first thought when reading the title was: because you're not living in the 1980s anymore. But it's an article from 1981, so it's got to be something else.

Pascal taught a generation of coders that you test for end-of-file before trying to read any data from the stream.

When they hit C, they wrote code around fgets that processes the last line twice:

  while (!feof(instream)) {
    fgets(linebuf, sizeof linebuf, instream);
    process_line(linebuf);
  }

Or processes the EOF value from getc as a character:

  while (!feof(instream)) {
    char ch = getc(instream);
    switch (ch) ...
  }

>

    type
        apple = integer;
        orange = integer;

> then any arbitrary arithmetic expression involving apples and oranges is perfectly legal

Same in Kotlin sadly. The whole point of giving a different names to a type is to make them incompatible.

For me Pascal was an awesome language in the 1980s. Oracle PL/SQL reminds me of it.

Kernighan probably disliked PL/I as well, but it had better memory safety than C; Multics was never plagued with buffer overflows.

Pascal implementations typically support index and range checking, while Ada provides even more extensive memory and concurrency safety.

Fortunately for C, clang's -fbounds-safety seems to be making progress. It's implemented in Apple's LLVM fork, so this now works on macOS:

    clang -Xclang -fbounds-safety program.c

https://clang.llvm.org/docs/BoundsSafety.html

I miss Pascal. Learned Object Pascal end of 90s but used it nearly never in my professional career (only a few months with Delphi during a student job). I really never used C or C++ in my professional career which is also interesting.

Nowadays it's all Javascript and more specifically Typescript in my case.

That PDF would be probably much longer about Javascript but it seems Kernighan is quite okay with that language nowadays https://www.youtube.com/watch?v=AB60_uUetJs

Some of his grievances:

Lack of external static storage class, the pinnacle of C programming.

Lack of oh so powerful C strings, terminating in zero (hopefully).

"There is no way to override the type mechanism when necessary, nothing analogous to the "cast" mechanism in C."

"begin" and "end" are bulky compared to { and }.

Folks should also appreciate that BK was also working on the “Software Tools in Pascal” book.

This was an update to the earlier “Software Tools” book, which was written using RATFOR.

If you read the book, it has a very “C in Pascal” coding style, and you can see how uncomfortable it is by doing so.

To put it in a single statement: Pascal is only suitable to study computer science. This is why he doesn't like the language.

Heh so it seems because the Pascal arrays and strings were so atrocious, Mr.Kernighan avoided them completely in C. Everyone is supposed to roll their own, with quite disastrous consequences.

Why is it that Pascal is supposedly so good for Rapid Application Development? Is it simply a historical accident, or does Pascal have some features that make it easier? What features would need to be added to C to make C a viable language for RAD?

The 80s war between C and Pascal, has been resolved, each side gave its arguments, the judge of history has decided that the clear winner was C.

The new battle has begun with three major contenders: C, Golang, and Rust. Which one will be chosen for the future?

Also see

"Software Fault Prevention by Language Choice: Why C is Not My Favorite Language"

https://people.eecs.berkeley.edu/~fateman/papers/software.pd...

> Pascal, in common with most other Algol-inspired languages, uses the semicolon as a statement separator rather than a terminator (as it is in PL/I and C). As a result one must have a reasonably sophisticated notion of what a statement is to put semicolons in properly.

I wonder how the non-programmers succeed to write commas correctly, because those follow the same logic: e.g. "red, green, blue". In author's opinion, I guess it should be "red, green, blue," instead.