Hah, as someone who has studied at University of Oslo, many of the lecturers make sure that Simula isn’t forgotten, by constantly reminding us that it was the first language with classes etc.
I was actually very surprised at how “modern” it felt. However, neither this code nor the article touches on the real cool parts of Simula: Simulations based on coroutines.
The new informatics building (well, not so new anymore, they built it around 2010) at the University of Oslo is named after Ole Johan Dahl.
Dahl was a professor of computer science at the University of Oslo and is considered to be one of the fathers of Simula and object-oriented programming along with Kristen Nygaard.
Naturally there is a room named Simula. And there are some rooms named after some big languages like Python and Java. Then there are also rooms named after some more niche languages, like Scheme. And even some obscure languages, like Ada.
University of Oslo may have a room named after Simula, but that's nothing compared to Aalto University in Finland, they even have a computer science professor named Simula: https://people.aalto.fi/olli.simula
If you are full-stack it probably seems obscure, and fortran seems outdated. But depending on your country, if you are safety critical embedded it is potentially the only option. It is in the top 2-3 in any case.
Edit: to finish my thought, if you are in physics or meteorology fortran is still common as well. There are a lot of software niches, and full-stack web dev is just the largest, at least as represented at HN, embedded might have more people if you combine planes, trains, automobiles, industrial, manufacturing, and more visibly IOT.
As of today, Fortran is newest and the oldest programming language with its most recent standard in 2023 and its first draft as the first high level programming language in 1954.
ADA was also used as the basis for Oracle PL/SQL, and the later ISO SQL/PSM standard.
These are very much alive, and implemented in major modern databases.
"SQL/PSM is derived, seemingly directly, from Oracle's PL/SQL. Oracle developed PL/SQL and released it in 1991, basing the language on the US Department of Defense's Ada programming language."
And the old(er) building right next to it is named after Kristen Nygaard.
Simula was used as the first programming language for informatics students at the University of Bergen until the mid 1990s, when they switched to Java. I was among the last batch of Simula students there.
There are similar syntax elements since Algol 60 was the common ancestor of all these languages; but in detail there are significant differences in syntax an semantics.
Ada is not a Wirth-language and only marginally inspired by Pascal. Wirth published Modula about the same time as Ada came around, but Ada is much more complex than Modula, with completely different features.
Ada's designers directly referenced Pascal's design and Wirth's theses to create Ada. They themselves call it a Wirth-language, as it follow's Wirth's principals.
Anecdotally, as someone who has coded extensively in Pascal (particularly the Object Pascal variant) and also (though, less so) in Ada; I'm baffled as to how anyone could look at the two and say they're only "marginally related". They're so similar that they're grouped together in much the manner C/C++ are, though Ada took a much harder compatibility break than C++ did:
> Well, what is that Ada language ? For here, it suffices to write: a superset of Pascal with some syntactical differences. Or a Super-Pascal. Or, a Pascal on steroids. In fact it's a better, redesigned language strongly inspired by Pascal. You'll see what I mean in the examples.
Pascal preceded Ada, but does not allow for coverage of most of the specialized topics that Ada does. For nearly every Pascal concept Ada took a different approach. Similarities are rather superficial.
"Pascal itself only meets a small part of the Steelman requirements. Merely to attempt to extend Pascal would have been neither feasible nor a desirable approach. [...] Hence, the goal in the design of the Green language was to retain the Pascal spirit of simplicity and elegance but not necessarily the form of each Pascal feature"
So it's neither a "superset of Pascal" nor a "Pascal on steroids", but a new language design which meets (or better tried to meet since it is much more complex than Pascal) the "spirit of simplicitly" for completely different and much more complex requirements than Pascal did. It's definitely not a "Wirth language" and I don't know of any statement by neither Ichbiah nor Barnes where they would call it that way.
> In fact it's a better, redesigned language strongly inspired by Pascal.
Is the point you should have zeroed in on, not the thrown away comments. If you had, you would realize everyone is saying the same thing as you.
> It's definitely not a "Wirth language"
I specifically stated in my original comment that it was indirectly so, via it's Pascal lineage. If you want to jump through hoops to disavow it of it's clear
and self-avowed forebear, go for it. There's nothing to be gained from continuing down this line of argumentation for me.
For some reason you seem to assume that taking inspiration from a language necessarily leads to a very similar language; there is no reason for this assumption; the language authors themselves have told us in the Rationale in what way they were inspired (see the quote in my previous comment). Those who consider Pascal and Ada to be very similar should study both languages more intensively, and not draw their conclusion from a few superficial features; furthermore, they fail to recognize the enormous difference in scope; Pascal offers a small fraction of the features of Ada and cannot be very similar for this reason alone.
Here is a simple example; both Pascal und its descendants suffered and still suffer from the dangling else problem; Ada solved this by adding end if and elsif, i.e. by integrating structured statements with blocks (Wirth himself came to a similar solution in Modula); superficially you still see the same Pascal keywords, but it's a different and much better approach.
Ada is neither indirectly a Wirth language; Wirth had nothing to do with it at all and came to quite different solutions in his later languages than the Ada authors.
NTNU still has at least one course that uses Simula for coursework. TTM4110 - Dependability and Performance with Discrete Event Simulation. An interesting course but without anyone who had real experience with the language teaching it, it was a slog to get through.
Ha, that’s interesting. I used to TA parts of that course; I had to learn Simula and Demos (a simulation library). If I recall correctly it was the first run of the course, and I had to develop some of the labs.
Yes, the material was specifically describing DEMOS and Simula. The coursework was all about the dependability and performance of a simulation we had to program using DEMOS. Interesting course really, but a bit let down by teaching assistants who didn't know the material very well.
I believe CIM does the work of compiling C as well, but i may be misremebering.
Do you remember how Kirkerud (the lecturer and textbook author) opened the semester stating with absolute certainty that AGI would never, ever be reached in our lifetime, or even the next several centuries?
I don't, but I mostly ignored the lectures as I'd been programming for most of my life already at that point, so I read the textbooks and showed up to the groups (the TA for my group was a member of Crusaders[1], which was fun). I think I attended a grand total of two lectures.
I do remember we found a really embarrassing algorithm choice in the Stack class, though (push and pop at the time were O(n), as it used a singly linked list that they iterated through recursively to find the top of the stack... we found that out on a group project where we kept running out stack space because of the recursion...)
> ...progenitor of the most popular, and reviled program paradigm, Object Oriented Programming. Designed by Ole-Johan Dahl, and Kristen Nygaard in 1962...
In 1962 the first version of Simula appeared which was quite different from Simula 67, not yet object-oriented, and dedicated to simulation.
Simula 67 was the first general purpose object-oriented programming language.
> Then, in 1991 another language would enter the playing field, Java, and the rest is history.
Java actually used the object model of Simula 67; James Gosling gave a talk about it at the 50th anniversary in Oslo. Here is the link: https://www.youtube.com/watch?v=ccRtIdlTqlU
The insight they had with Simula was similar to that of lisp. Code/behaviour as a first class thing:
"In Simula I, Dahl made two changes to the Algol 60 block: small changes, but changes with far-reaching consequences. First, “a block instance is permitted to outlive its calling statement, and to remain in existence for as long as the program needs to refer to it” [11]. Second, references to those block instances are treated as data, which gives the program a way to refer to them as independent objects. As a consequence of these changes, a more general storage allocation mechanism than the stack is needed: a garbage collector is required to reclaim those areas of storage occupied by objects that can no longer be referenced by the running program."
Strings were really more thought of as arrays/buffers at the time. You could create a String class to serve the purpose of a “modern” string, I believe. However, Simula didn’t yet have operator overloading to make it look like a built-in type.
> [case insensitivity... so] both beGIN and BEGIN are interpreted the same way. This was also characteristic of the time, as programmers programmed their computers by shouting.
Case insensitivity is only seen as "rustic" because C is case insensitive. Somehow, case insensitivity is seen as a modern thing but at the same time everyone recommends not choosing identifiers which are close to each other apart from case in style guidelines.
> Case insensitivity is only seen as "rustic" because C is case insensitive
One thing people discovered eventually - case-sensitivity is language-specific. It is easy so long as you assume everything is in English and 7-bit US-ASCII, but once you move beyond that assumption, it becomes significantly more complex. An easy way to avoid all that complexity is to not do it.
People also forget about the related notion of accent-insensitivity - again, if all you support is English, you can ignore that, since English hardly uses accents
Case insensitively is nowadays tied to how (static and dynamic) linking works. You’d either (a) have to use a case-insensitive and thus nonstandard linker, or (b) have to uniformly normalize identifiers before linking, making the normalized identifiers less readable, or (c) have to normalize identifiers based on the casing used for an object’s main definition, which means that changing only the case of that definition still breaks compatibility, so not quite case-insensitive after all, or (d) have at least FFI identifiers be case-sensitive (and use a custom linking runtime for intra-language identifiers).
>nowadays tied to how (static and dynamic) linking works
and this is the case because of C, which was my point. The fact that OS'es are written in C and thus have a C libraries and APIs is why you must respect C's rules for identifier names.
Also, yes compilers for other languages essentially name-mangle anyway, that's how (modern) fortran which is case sensitive and C++ which isn't (but tacks on a bunch of things to function identifiers) work. But the point about naming conventions or recommendations still stands, like a lot of things it is a fact of history favoring C, not that there is anything inherently better about it.
I believe it was already the case prior to C with assembly, and really because originally only one case (uppercase) was available. C just didn't change anything about the case-sensitivity of linking.
>Case insensitivity is only seen as "rustic" because C is case insensitive.
C is case sensitive, but it's also not seen as very modern language these days, so I'm not sure I understand your argument.
I think case-insensitivity is seen as rustic because it's a remnant of the times when some systems simply did not have a notion of case and everything was uppercase all the time. Modern systems handle case just fine so having several character strings being distinct in terms of byte values but equal in the way the language interprets them seems clunky and error prone (because it is).
Modern systems tend to support international character sets (UTF-8, etc.), where the idea of 'case' makes things more complicated than ASCII; and probably more trouble than it's worth. Even if we stick with latin characters, are 'uppercase' and '𝖀𝓟ℙ𝗘ℝℂ𝙰𝒮𝓔' the same identifier?
For anyone young enough not to have used an ASR-33 or similar, the UNIX login: process would assume you were on uppercase only and "work" if you logged in as your username/password in uppercase. Guess it was an extra round or two of password hashing against the salt.
It remained in the "getty" process for some time, well into the {Free,Net,Open}BSD era.
CP/M and the like were pretty forgiving of commands being shouted too.
some languages (IMP, maybe others) used %reserved-word% formatting so you could do things pretty much how you wanted and then the system would know what was instructions.
Sure, that's fair. I didn't care for it during much of the first year I started working with Nim. Once I began wrapping C libs and working with Nim libs whose conventions differ from my preferences, the rationale (explained in the manual) for Nim's partial case-insensitivity "clicked" for me and I eventually embraced it. But I can see it remaining a sore point for some folks.
My reply above was tongue-in-cheek, maybe a bit too edgy. The person I was replying to characterized the language feature as "sad", and that's just silly. Even if it's an aspect of the language one doesn't appreciate, it's no more "sad" than e.g. Clojure involving a lot of parentheses or Haskell promoting monads. Likewise, no one is stupid or partially so for not liking or understanding Nim's partial case-insensitivity.
Both Algol and Simula were ported to the 68000’s Atari ST. I remember having a box of diskettes with implementations of forth, modula , lisp, prolog, smalltalk.
I miss the those times when using a computer meant ‘programming on a computer’, and programming on a computer meant trying to find your foot on any of a dozen languages popping left and right.
Interlisp[28] – developed at BBN Technologies for PDP-10 systems running the TENEX operating system, later adopted as a "West coast" Lisp for the Xerox Lisp machines as InterLisp-D. A small version called "InterLISP 65" was published for the 6502-based Atari 8-bit family computer line. For quite some time, Maclisp and InterLisp were strong competitors.
Indeed there was. The first Lisp I saw was a port of David Betz's xlisp to the Atari ST (in the 1980s). The port was buggy and I didn't have the sources, so I needed to get started on writing my own interpreter. The rest is history, as they say.
There is a lot more to Simula.
I was a student at University of Oslo at the time it was still mandatory
in intro classes.
A fellow student was the son of one of the people who wrote a compiler for Simula.
He knew about all sorts of little documented features.
Some gave precise control when a "simulation was executed".
Thinking back, it makes me think of RTOS like features.
Now Simula was never the fastest language, and these did not offer guarantees
that any real time system would but they were cool.
It was fun when you used language features that the teachers had
never seen before.
Was going to mention that the Netherlands is not in Scandinavia until I remembered that the P is not Python :P
It is interesting that so much foundational tech comes from Europe when I think there is a common perception of that generation of tech as being largely driven by the US (MIT, Bell, etc).
> It is interesting that so much foundational tech comes from Europe when I think there is a common perception of that generation of tech as being largely driven by the US (MIT, Bell, etc).
The UK chronically undervalues its computing sector. Lots of the pioneering hardware/fundamentals work was done at Bletchley Park in the 1940s, but was destroyed or remained classified for decades. We had a disproportionately large slice of the software industry in the 80s, but that seemed to be dismissed as just gaming; and of course games themselves aren't taken as seriously as e.g. cinema, despite being a much larger market.
In that case it could be worth mentioning CSS, by the Norwegian Håkon Wium Lie.
I often feel like the beginning of the 90s was a missed opportunity by Scandinavian companies. There were many great companies and individuals that were innovative, but could not compete due to the lack of VCs from Silicon Valley and a smaller domestic market
Norsk Data was one of the big guys producing minicomputers in the 70s and 80s.
Apparently they held on to minicomputers for too long and quickly lost business to Sun and workstation manufacturers in the early 90s.
https://en.wikipedia.org/wiki/Norsk_Data
Denmark had the mosts c64 groups in the world (the reason for this, I don't know) compared to population size. Most of the people involved with these demo/cracking groups in the 80ies were most likely in their teens. Once the 90ies arrived with the internet, I think it was obvious to most of them what they wanted to do with their life.
Sweden, Norway and Finland came in 2nd, 3rd and 4th. I think US was at place 20.
Prolog stands for "programmation en logique", and as might be guessed from that comes from France (Alain Colmerauer in Marseille, to be precise). Now Kowalski, who also was an important pioneer in logic programming who collaborated with Colmerauer did work in Edinburgh, but from the horse's mouth:
I have tried to document as best I could our various contributions to that idea in an article published
in CACM, 1988, and more recently in a History of Logic Programming, published in 2014. In
summary, however, it is probably fair to say that my own contributions were mainly philosophical
and Alain’s were more practical. In particular, Alain’s work led in the same summer of 1972 to the
design and implementation of the logic programming language Prolog.
'Many' is a word that gains its meaning in comparison to some (implied) quantity, and I'm not sure what you are comparing to: you list 5 programming languages but looking at Wikipedia's list of programming languages* five is clearly not very many at all.
Maybe you mean something like "as a share of top 10 most used languages" or "per capita"?
If we go by nationalities and this list, then that is 3 misses and maybe 1 hit in terms of language design for the Danish. Maybe I should check the creators of the next language I learn and avoid langs created by Danish?
Is simula a forgotten language? While it is less used now I thought it was generally acknowledged as a precursor to all OOP today, although Smalltalk is generally more regarded as a pure OOP language defenders still cite.
Unfortunately he is thoroughly confused about OutImage.
> "OutImage is called to build the final Simula “Image”. From my digging it appears that OutImage is usually necessary at the end of a block, or a compiler error will be generated. I initially forgot OutImage though so, I imagine that maybe Portable Simula is just implicitly adding this if it’s missing, or it was changed in a later standard. Regardless I’ll leave it in from now."
In reality the "image" is just the current outline buffer, and OutImage prints the line feed. Very similar to Pascal later.
From the textbook:
> "OutImage causes the line which is currently being created - the current image - to be written to the printer or terminal and a new line to be started."
Simula was the language my university teached object-oriented programming. This was around 1995 or so. Java had just entered public consciousness but it was too early to be considered. C++ was probably not considered pure enough to get the concepts across.
It was probably a good choice, for the time and for the course objectives. But I never used it since.
I am glad my first year at Uni (1994) they focused on SML a lot. Got a good base for the rest of our programming journey. Even now that I live in mostly Scala-land nearly 30 years later. And yes also a lot of other languages over the course's years. I still remember being forced to do bits of VHDL.
We were taught the history of Simula (and Algol) but had to use C++ as our main object orientated language. They refused to teach my year Java so we had to learn that on our own.
My first experience with an object-oriented language was with Simula in 1982, where it was used for one (if I remember correctly) course at the University of Twente.
> ... By 1983 his “C with classes” programming language would be renamed to C++. Then, in 1991 another language would enter the playing field, Java, and the rest is history
Simula -> C++ -> Java.
Leaves out rather a lot of important object oriented programming languages.
Therefore, a few years back I decided to learn it a bit (I borrowed a really old book from the library) and solved one of the Advent of Code puzzles in Simula: https://github.com/judofyr/aoc2018/blob/master/day3prog.sim
I was actually very surprised at how “modern” it felt. However, neither this code nor the article touches on the real cool parts of Simula: Simulations based on coroutines.