Transput is an awesome term! We need to bring that back.

I think they also introduced “overloading” for multiple definitions of an operator that were chosen according to context. That term is commonplace nowadays.

So that's the reason why INTERCAL has its own terminology. xD For a parody esolang, that was sure the best joke they could pull out.

ALGOL-W was also known as “Wirth-Hoare ALGOL”. Think of it as a prototype of ideas that Wirth would later embody in Pascal.

I agree

But he is the David Attenborough of Computer Science.

winnie the pooh of computer science

I wonder what you may think of current version of Free Pascal... Because it's way different from the 70's.

I would probably say ```thePort[0]->theGDevice[0]->gdPMap[0]->pmTable```, but I agree that pointers to pointers inside structures look clumsy. Shame on Apple for using those. Regarding the theological issue of whether variable declarations should bring first the name or the type, I agree that starting with the name is better because it is in a more visible location (which is why when I write C myself I break a line between the type of a method and its name so it starts in column 0), but it is indeed a question of style, or _tomayto-tomahto,_ as you say. We can definitely cope with programming using both paradigms without difficulty.

It wasn’t Apple’s fault for coming up with a situation that C cannot handle gracefully.

@@lawrencedoliveiro9104 It's not bad because C cannot handle it gracefully (the -> operator is there as syntactic sugar for (*).), it's that there is no need to keep a double pointer in a structure unless you're doing an array of references, which does not seem to be the case (though I have not programmed that particular interface myself to affirm it categorically). If you need to change the object the structure is pointing to then you go and overwrite the pointer, since you have the structure on hand. This is the same whether you're writing C, Pascal, Python or Rust.

@@tiagorodrigues3730 Data in classic Mac OS was meant to be moved around to compact ram usage. To allocate memory, you requested the OS a “handle” (pointer to pointer), not a pointer. Any pointer could potentially be invalid after the next allocation/deallocation.

Heh, predicting the future was never easy, and will never be. Funny how decades ago people were calling C ridiculous, and now C is like the golden standard

When he saw C++, did he have a heart attack?

BCPL was really a kind of interim bootstrap language for implementing CPL (either “Combined Programming Language” or “Cambridge Plus London”, named for the two universities collaborating on the spec while each producing their own compiler). I can find very little detail online about the actual features of CPL. Think of it as an all-singing, all-dancing 1960s kitchen-sink programming language that would have gone up against PL/I, except with some slightly more advanced computer-science concepts behind it.

@@supernenechi Bit of yes and no. Go back to working with Windows 3 for an extended period of time; most programs were written in C. Written by programmers who thought that if a language gave you tricks it was your job as a programmer to implement as many of them as you could in as little space as they'd fit in. Then you try running multiple programs along one another. Preferably on an operating system that does not utilize a CPU's memory protection hardware. Nowadays, the most important place where C's used is inside the Linux kernel. The way in which C is the golden standard is that other languages base their syntax heavily on C. Then again, at least it's not Java. :P

I never got to meet John Peck but Peter Hibbard, who spent a sabbatical year with him at UBC, is a close friend. Yes, C is not in any way a language for purists but as a portable System Implementation Language it has a lot going for it.

The difficulty to wrap one's head around is that these 2-level vW grammars are capable of notating any language, as they were designed as notating tools for a Turing-complete implementation. The resolution mechanism for this was the genius of Adrian van Wijngaarten, and probably lit up the implementation efforts for the Prolog language because Colmerauer seemed to get the gist of this, and made a resolution machine based on an interpreted notation called horn clauses. At its core, there are a series of axiomatic operations that preserve the mathematical intention of the recognized language, which is what is so brilliant about setting up the 2-level grammar. Even though I don't develop for a living anymore, the art of parsing is still a preoccupation, and I did play with awk (Aho, Weinberger, and Kernighan) for a long while to write a parser table generator that has the ability to generate a LR(1) or LR(0) parse table if no productions in the input language resolve to an empty terminal. Part of that involves representing the item sets and transitions into a representation that happens to look a lot like an operator precedence grammar encoding the item sets. In fact, I think it is, but this is also a bloated and symbolic way to construct a parse table. This is still being toyed with at a recreational pace, but I hope something can be useful with investigating properties of such domain transfers, because I am potentially going from a deterministic context free language (DCFL) that has a parsing table representation that is recognized as a regular expression grammar, but still preserves the origin input DCFL grammar because the elements still require a stack to keep track of nested constructs. To remember, regular expressions don't need a stack to keep track of state, so this separates this class of languages from the next, which is the context free grammar. These classes of languages require a stack of sorts to keep track of parsing elements. Context sensitive grammars have a need to keep information across a set of relevant productions, so these need a separate structure such as a heap to glue together elements by implied intent (which is provided for in the second level) and to checklist other attributes of the language to see if an aspect is properly defined, etc. The vW-grammars also note this, so these are clearly context sensitive, but are defined in an axiomatic fashion that requires some time to work through. I believe some of the most advanced work in this area still is in the UK and Netherlands, though I've seen lots of Indian authored videos are around for explaining parser generation methods using the same methods as in the "Dragon Book".

"Well, you have a thing and you cast it against the wall and see what falls out of it."

So many terms from CS come from the most intriguing origins, got to admit. (edit: bootstrapping for instance 😉)

'So you cast your fishing line out over the water, hook some type, and then reel it in...'

Quite likely George 3, if that was the late 70s

Oooh Swift lets you do that now I believe

I think R, and newer versions of C/C++ do too

No, C++ and Python do not let you define new operators, they only let you overload existing ones. ALGOL 68 did allow you to come up with new operators. But you couldn’t use non-alphabetic/numeric characters for them.

OK, but still, there is a mighty span of years between Algol68 and R. Algol68 was a gem of a language for it’s time!

d i g i t a l s p o n g e

Sounds like they copied the idea from Burroughs.

wats a distinction. r u ok

On the BSc E & E Engineering course at Kingston (on Thames) in the mid-70s we were taught Algol 60, running on an ICL1900 that was upgraded each year. The last year I was there it was running MAXIMOP.

Lol, I spent a year coding in Pascal in 2013.

No, no... Our state school in the US used Pascal back in '90 - '94 years for a few of the CS core classes. No regrets! Pascal is a far better CS foundational language than Java or Python, which are used in so many programs today. I don't know how graduates function without courses using assembler or at least C these days, but some programs eschew those entirely.

It helped that Pascal was designed to be implemented using a single pass recursive descent compiler. So with Pascal you got a great mix of an expressive language that could be implemented quickly and compiled fast. During much of the 1980s I made a lot of money as a real-time programmer using Pascal.

@@mandolinic Did you ever use Borland's Delphi?

@@johnlinley4375 No, not Delphi. I used the UCSD P-system quite extensively.

Pascal was such a (relatively) small language, there were loads of compilers available, including ones you had to pay for and ones that you got for free. ALGOL 68, on the other hand, was much larger and more complex, so in our little neck of the woods, we never saw a compiler for it.

We had some projects in my first job that some colleagues did with Borland Turbo Pascal, and in this case one of our engineers specified a GPS satellite health model that was transcribed into code. Pascal being what it was is a language built more or less with a LL(1) grammar, which means that the first terminal in a production pretty much called out the rest of the syntax pieces for a production. Languages can still be quite elegant and the parser would be reliably one pass because the grammar was unambiguous and could be figured out by a short prefix at any time. If my understanding is right, LL(1) grammars are likely also SLR(1) because they would be easy to follow.

What's your reveiw of today's Free Pascal compiler? Current version 3.2.0

I had the same experience here in Sweden. We had to learn Pascal in computer ed. (I never did tho)....

Learn pascal, it’s great. Much better than C.

Fortran was king for engineering students for decades, principally because of native support for complex numbers and then subsequently the extensive numeric libraries available to Fortran programmers.

apologies. hope to have captions with Sean within next couple of days

“JOVIAL” = “Jules’ Own Version of the International Algorithmic Language”. That “International Algorithmic Language” being one of the names for ALGOL-58.

Love your bernaise and lasagna boxes!

Eclipsing binaries? Named for “al-gul”, aka “the demon”.

xd

That kid never liked to C

If they go, Algol

BCPL fans...lol

Isn't he? Avantgarde of Computer videos.

The original pascal doesn't exist anymore, but it is still alive and very well through FPC. And I agree with you, FORTRAN (all capitalized at that time) was incredibly wide used.

games are running on cutting edge tech and is a billion dollar industry nowadays.