14 ms·
The seven programming ur-languages (2021)
- SunnyHorsey 4y ago[dead]
- SunkissedSue 4y ago[dead]
- AboveSkies 4y ago[dead]
- CandyRandy 4y ago[dead]
- CandyRandy 4y ago[dead]
- PreciousPenny 4y ago[dead]
- PreciousPenny 4y ago[dead]
- PatootieRu 4y ago[dead]
- PatootieRu 4y ago[dead]
- SugarJeez 4y ago[dead]
- SugarJeez 4y ago[dead]
- BlondieZ 4y ago[dead]
- WaterWanderer 4y ago[dead]
- BlondieZ 4y ago[dead]
- Switcharoo 4y ago[dead]
- Switcharoo 4y ago[dead]
- CheekyBum 4y ago[dead]
- CheekyBum 4y ago[dead]
- MagicMaker55 4y ago[dead]
- MagicMaker55 4y ago[dead]
- WaterWanderer 4y ago[dead]
- SupDiana 4y ago[dead]
- SupDiana 4y ago[dead]
- GorgGorl 4y ago[dead]
- GorgGorl 4y ago[dead]
- JollyJester 4y ago[dead]
- JollyJester 4y ago[dead]
- UniLove 4y ago[dead]
- UniLove 4y ago[dead]
- DragonShoot 4y ago[dead]
- DragonShoot 4y ago[dead]
- MoonBabe 4y ago[dead]
- MoonBabe 4y ago[dead]
- MapleDreams 4y ago[dead]
- MapleDreams 4y ago[dead]
- PeachyCupcake 4y ago[dead]
- PeachyCupcake 4y ago[dead]
- SunkissedSue 4y ago[dead]
- DireFire 4y ago[dead]
- DireFire 4y ago[dead]
- Moonshining 4y ago[dead]
- Moonshining 4y ago[dead]
- SunnyMaylor 4y ago[dead]
- SunnyMaylor 4y ago[dead]
- WiseWolfie 4y ago[dead]
- WiseWolfie 4y ago[dead]
- LuckyBug 4y ago[dead]
- LuckyBug 4y ago[dead]
- CuriousCatty 4y ago[dead]
- CuriousCatty 4y ago[dead]
- FriendlyFlame 4y ago[dead]
- FriendlyFlame 4y ago[dead]
- WoozyWarrior 4y ago[dead]
- WoozyWarrior 4y ago[dead]
- AdorableLama 4y ago[dead]
- AdorableLama 4y ago[dead]
- TurkeyTurtle 4y ago[dead]
- TurkeyTurtle 4y ago[dead]
- DuskyHusky 4y ago[dead]
- DuskyHusky 4y ago[dead]
- PenguinPeace 4y ago[dead]
- PenguinPeace 4y ago[dead]
- SunnyHorsey 4y ago[dead]
- WiseSnail 4y ago[dead]
- WiseSnail 4y ago[dead]
- ZappyHippo 4y ago[dead]
- ZappyHippo 4y ago[dead]
- PudgyPanda 4y ago[dead]
- PudgyPanda 4y ago[dead]
- SassyStarlet 4y ago[dead]
- SassyStarlet 4y ago[dead]
- BeingBean 4y ago[dead]
- BeingBean 4y ago[dead]
- LovableLily 4y ago[dead]
- LovableLily 4y ago[dead]
- SappyHippo 4y ago[dead]
- SappyHippo 4y ago[dead]
- FoxyFox22 4y ago[dead]
- FoxyFox22 4y ago[dead]
- LetFree 4y ago[dead]
- LetFree 4y ago[dead]
- FreeBee 4y ago[dead]
- FreeBee 4y ago[dead]
- SuperDud 4y ago[dead]
- SuperDud 4y ago[dead]
- QueenBean 4y ago[dead]
- QueenBean 4y ago[dead]
- NerdAlerts 4y ago[dead]
- NerdAlerts 4y ago[dead]
- LadyXaga 4y ago[dead]
- LadyXaga 4y ago[dead]
- ChillNilly 4y ago[dead]
- ChillNilly 4y ago[dead]
- SmoothBooth 4y ago[dead]
- SmoothBooth 4y ago[dead]
- AboveSkies 4y ago[dead]
- UnrealBean 4y ago[dead]
- UnrealBean 4y ago[dead]
- ScreenQueen33 4y ago[dead]
- ScreenQueen33 4y ago[dead]
- MicBase45 4y ago[dead]
- MicBase45 4y ago[dead]
- DoodieButt33 4y ago[dead]
- DoodieButt33 4y ago[dead]
- StinkyPete56 4y ago[dead]
- LoudMouth2 4y ago[dead]
- LoudMouth2 4y ago[dead]
- LittleRooster09 4y ago[dead]
- LittleRooster09 4y ago[dead]
- McPoopie24 4y ago[dead]
- McPoopie24 4y ago[dead]
- PooFace45 4y ago[dead]
- PooFace45 4y ago[dead]
- TheSniffer55 4y ago[dead]
- TheSniffer55 4y ago[dead]
- StinkyPete56 4y ago[dead]
- CrazyLegs78 4y ago[dead]
- CrazyLegs78 4y ago[dead]
- BennyNana67 4y ago[dead]
- BennyNana67 4y ago[dead]
- jleyank 4y agoIt is sort of angels dancing on pins but who came first between cobol, Fortran and Algol is curious. Even this article seems to be putting Algol afterwards. It was a more collective language, but I didn’t see it penetrate as much as remain a discussion topic. Perhaps the thread through C gave it entrance? And then there’s basic…. Maybe that is just pidgin, giving those who could not speak at all some words?
- surprisetalk 4y agoI've always considered Fortran to be the "first", but with some quick research, it looks like Algol was the first C-like lang to add an if/then statement. My guess is that the author was trying to approximate modern imperative programming. [1] https://craftofcoding.wordpress.com/2021/01/11/why-algol-bested-fortran-for-a-bit/ https://craftofcoding.wordpress.com/2021/01/11/why-algol-bes...
- AnimalMuppet 4y agoFortran was the first compiled language, that is, the first language at a level higher than assembler. But Algol was a block-structured language in a way that Fortran wasn't, and virtually all languages of that "group" are block-structured today ("goto considered harmful" and all that). So Algol is more appropriate as the "prototype" of what exists today.
- bloak 4y agoMercury Autocode is perhaps a "missing link" between assembler and Fortran, though I'm not sure of the dates and whether the people developing Fortran knew about Mercury Autocode. Things developed quite fast in the 1950s.
- gumby 4y agoAn article like this is hard to write. This is a good one. I have a few quibbles, but they are just quibbles. IMHO* a distinguishing feature of Algol like languages (aka "procedural" languages) is the distinction between expressions and statements. Though personally I've never seen the appeal, that distinction seems to be popular for some reason. * this isn't even a quibble -- the article is fine without it. Just something that has always seemed weird to me.
- programmer_dude 4y agoThe distinction in ALGOL, Pascal etc. is useless. But if you change your definitions such that expressions always evaluate to a single value and do not have any side effects while statements produce some kind of side effect (and may or may not yield a value), the distinction becomes important. Especially if you believe side-effects need special handling (i.e. you are a functional programmer).
- Joker_vD 4y agoIt's been done in some Pascal descendants: functions were required to be pure but procedures were allowed to mutate global state. Some even went as far as to remove functions altogether (with quite unpalatable results).
- colonwqbang 4y agoThe only popular language I can think of that requires side effects to be declared is Haskell. Which doesn't have a distinction between statements and expressions. Are there any good examples of languages that have it, where it isn't "useless"?
- epgui 4y agopython, javascript, pretty much any language that is popular. I believe everything in Haskell is an expression, even the do notation, no? But I think the argument being advanced is that the distinction between statements and expressions is fundamentally unnecessary. I don’t really know of any good argument in favour of them: I tend to think lisps have the perfect and simplest possible syntax.
- netbioserror 4y agoVery useful for an intermediate programmer who appreciates the craft and wants to extend their skills by becoming a true polyglot. As for total beginners, it can be demeaning to explain why asking which language of the ALGOL descendants to learn is a pointless question. For their case, I don't bury the lead: I tell them "They all have the same lineage and are fundamentally similar, so just pick the one you'll learn the most robustly with. Most everything else is learning libraries."
- felixgallo 4y agoIMO the eighth ur-language is Erlang (with cousin Elixir), which brings the ultra-scaling actor model, an abstract operating system designed for high reliability and low latency, and a bunch of nice rare features like builtin binary structuring/destructuring and pattern matching. While it had its origins in prolog, it's now sufficiently far away from prolog's inner machinery that it only has syntactical similarity. Learning erlang made me definitely at least 10% smarter as a programmer. Highly recommend, even if you never use it in anger.
- kqr 4y agoI agree. Many of the core language concepts from Erlang you can get from Self and Prolog, but experiencing the OTP is something different that I think you only get from the Erlang family.
- taneliv 4y agoLikewise, experiencing JVM is something different from ALGOL ... And not quite sure if SQL could be grouped together with Prolog due to its declarative nature. But if so, DBMS is, like OTP, quite far from Prolog, just in a slightly different direction :) I guess what I'm trying to say is that the list of ur-languages seems quite fine to me.
- danabrams 4y agoThat was my first thought, reading this. Although it’s almost like a combination of lisp, self/smalltalk and prolog, with OTP being the innovation.
- colanderman 4y agoErlang is a nice and unique language, but I feel at its core it falls into the object-oriented/message-passing paradigm, very much in the vein of Smalltalk. Consider these paragraphs from Smalltalk's Wikipedia entry [1]: > A Smalltalk object can do exactly three things: > 1. Hold state (references to other objects). > 2. Receive a message from itself or another object. > 3. In the course of processing a message, send messages to itself or another object. Replace "Smalltalk object" here with "Erlang process" and the description holds. > Unlike most other languages, Smalltalk objects can be modified while the system is running. Live coding and applying fixes ‘on-the-fly’ is a dominant programming methodology for Smalltalk and is one of the main reasons for its efficiency. Erlang's famed robustness similarly owes much to its ability to update code in a running program. [1] https://en.wikipedia.org/wiki/Smalltalk#Object-oriented_programming https://en.wikipedia.org/wiki/Smalltalk#Object-oriented_prog...
- deleted 4y ago[deleted]
- OskarS 4y agoPretty excellent summary, this is roughly the taxonomy I have in my head. I would maybe add SQL as an ur-language as well. It's not quite general purpose like most of these, but it should have a place in this list, I think. It has some kinship with Prolog and the declarative style, but it's really it's own thing. You could also maybe argue for something like LabView. Many programmers look down on purely graphical programming languages, but with Houdini, Unreal's Blueprints and the various node-based shader/material systems in gamedev, I think it probably deserves it's own little branch of this family tree.
- 0x445442 4y agoI think you’re first instinct is correct given libraries like Linq and GQL in Groovy. The relational algebra is decidedly different versus say map, filter and reduce.
- camtarn 4y agoNot to mention the various graphical programming languages used in industrial control - ladder logic, continuous function chart, and sequential function chart. Ladder in particular is incredibly widespread, as it was a direct descendant of the diagrams used to document and debug relay logic, and was adopted in some of the first PLCs (programmable logic controllers) in the late 60s/early 70s. Programming PLCs sometimes feels like going to, say, Australia or New Zealand, and being immersed in an environment which went down a different evolutionary tree very on in its development.
- marcosdumay 4y agoSQL is on the same group as Prolog. In fact, it is a simpler and purer implementation of a constraint-solving language, so it is probably a better option for learning the group than Prolog. For the signal transformation ones, there are also the hardware definition languages on the same category as LabView and animation languages.
- ucarion 4y agoTo your point, Berkeley's intro-level CS class, CS61A, used to use teach Prolog as an example of logic programming. They use SQL now instead. I can't really attest to whether that's a better choice for learning logic programming, though. It's easier to "run programs" in Prolog. SQL wants to be a cog in a machine where Prolog is more freestanding.
- fzeindl 4y agoI'd add probabilistic languages like Figaro.
- Rochus 4y agoWell, a bit arbitrary, especially the choice of Self as the "ur-language" of object oriented programming.
- iainmerrick 4y agoI thought the choice of Self was a bit strange too, but if you replace it with Smalltalk, the overall categories are pretty reasonable.
- cratermoon 4y agoYeah, I'd have to go with Simula/Simula 67 as the OO ur-language.
- vidarh 4y agoI'm ambivalent about that. As a technicality and inspiration it makes sense, but having learnt Simula (I studied in Oslo; it was the introductory language for many years) it does not give you the same focus on objects as Smalltalk does. But if you want to put another language than Smalltalk as the OO ur language, I'd certainly pick Simula over Self.
- Rochus 4y agoSimula 67 is much closer to the mainstream OO concepts we see in C++, Java, C# and Python than Smalltalk, or let alone Self. ST was the first dynamically typed OO language (scripting language actually) though.
- vidarh 4y agoIi is, because it inspired both the Smalltalk branch and the more mainstream OO languages, and hence it makes sense to consider it as a possible ur-language in that sense. Smalltalk is a branch, but it's an important enough branch introducing important enough new concepts that unlike with Self I wouldn't have an issue with people considering Smalltalk it's own ur-language, and because I agree with you that Simula at least on the surface will seem more familiar to people familiar with ALGOL-derived languages with OO mechanisms than to Smalltalk. Self, on the other hand, is less important for its concepts (ok, so it has prototypes instead of classes, but classes in Smalltalk are also objects, so I don't buy that it's that conceptually different, especially in a dynamic language where you can dynamically instantiate and mutate classes) than it is for the papers on its implementation.
- rwmj 4y agoI think you could make a case for including Ada and/or COBOL, separately from ALGOL. Ada is/was an early attempt to remove errors from programming, and COBOL was an attempt to make a "business language" that would be understandable by suits.
- 7thaccount 4y agoCobol or Mumps for sure. I think Ada is close enough to Algol to not need its own category.
- rwmj 4y agoAh Mumps. I did a very little bit of programming in that. It should definitely be on a list, but maybe not this one. Perhaps the "languages you should run away from screaming" list :-)
- vidarh 4y agoMy big quibble with this is that the OO category is way too narrow. The way it is worded it excludes almost all languages we'd currently consider OO, and is so strict it largely makes the category pointless. Loosen it to exclude the "You do conditionals..." bit, and focus on the message passing, and e.g. Ruby and other languages that are message passing focused to the point of it tending to dominate semantics over it's Algol-related syntax fits firmly in this category. Listing Self rather than Smalltalk as the basis of OO languages is also a bit odd. Calling it a "purer form" I guess is a justification, but the other view is once you losen the definition as above, self is just the root of one small (albeit influential, via Javascript, branch of OO languages that almost all owe more to Smalltalk than Self. If another language than Smalltalk should be at the root, it should be Simula, for inspiring message passing, not Self.
- TheRealPomax 4y agoI'm a bit confused about this quibble when the article text is about "Self and Smalltalk", not just Self? If anything the quibble should be "why is the section called Self when it's about the _two_ ur languages Self (the ur language for prototype based OO) and Smalltalk (the ur language for class based OO)"?
- vidarh 4y agoThe title is "Self (object oriented programming)" and it ends with "Self disposed of the notion of class and worked solely with objects. As this is a purer form, I have chosen Self as the type specimen for this ur-language", so while it gives Smalltalk the space it deserves, it then turns around at points out Self as the ur-language for OO.
- TheRealPomax 4y agoYou seem to confuse "ur language" for meaning "the original that others came from", which makes sense if you're familiar with the term "ur", but is not how this article uses the term. They use it to mean type specimen (as noted in the article). As type specimen, Self makes a lot more sense: it took the OO concepts pioneered by Smalltalk and then made them even more OO.
- horeszko 4y ago>Every programmer needs to know a language in the ALGOL family well. Once you do, then it’s worth branching out. Learning a new language that traces to an unfamiliar ur-language each year will pay dividends I second this. I would consider myself an intermediate level programmer and learning Scheme (via the excellent book "Structure and Interpretation of Computer Programs") took my programming to a new level and made me think of programming from a completely different angle.
- slavapestov 4y agoThere’s a missing “minimal language” with a combination of features that doesn’t yet exist, but should: - value semantics with both implicitly-copyable and move-only values - unboxed generics with type classes/traits/protocols and associated types - as little syntax and sugar as possible for everything else
- mlochbaum 4y agoThe first point jumped out to me as contradictory: for immutable values copying is only an implementation detail. Apparently "value semantics" can also refer to mutable values with exclusive ownership, is that the idea here or something else?
- slavapestov 4y ago> Apparently "value semantics" can also refer to mutable values with exclusive ownership, is that the idea here or something else? Yes, that's what I meant here.
- rileyphone 4y agoMaybe Austral? https://austral-lang.org/ https://austral-lang.org/
- nottorp 4y agoYou just described your next hobby project?
- hayley-patton 4y ago> A lot of work was done on how to make Smalltalk run fast and efficiently, culminating in the Strongtalk project. The Strongtalk technology also came from Self; it was thought that Self would be too hard to make fast, until it wasn't.
- sebstefan 4y agoWhich category does Coq go in? https://github.com/coq/coq https://github.com/coq/coq With code example: https://github.com/coq-community/coq-100-theorems/blob/master/birthday.v https://github.com/coq-community/coq-100-theorems/blob/maste...
- AS37 4y agoML
- codeflo 4y agoOnce you recognize the patterns, it seems clearly in the ML tradition. Some bits and pieces look exactly like Haskell at first glance.
- navaati 4y agoOh it’s a ML alright, fits right next to Agda for example.
- tel 4y agoIt's definitely ML-relevant, but I'd argue that it's in its own league, and is maybe a suitable ur-language for that league.
- yread 4y agoanother ur language that could be added is Spin or other formal verification tool or LTL-based language
- xrayarx 4y agoWhere does TLA+ and PlusCal fit in? They do not match any of the listed families, do they?
- gjadi 4y agoProbably because they aren't programming languages in the sense you won't produce a program = executable with it, but rather a proof.
- navaati 4y agoAnd yet Agda, which is a proof language, was included (in the ML family). Looking at some TLA+ examples, I’d say, squinting a bit… somewhere around Prolog ? I’d love to hear someone chip in !
- colanderman 4y agoYes, having used both TLA+ and Prolog extensively, they share many similarities (both having roots in first-order logic). In practice -- TLA+ code is often a bit more "imperative" owing to the fact that unbounded existential quantification isn't implemented in the TLC interpreter (whereas in Prolog, it is a core aspect of any interpreter). And of course, TLA+ has a suite of temporal operators used exclusively for declaring contracts in service of its role for verifying specifications. Which (as @hwayne points out elsewhere) stem from mathematics -- Linear Temporal Logic specifically -- and not programming.
- Warwolt 4y agoEh, even though you prove things about your specs (possibly) there's still a difference between proof assistances and spec languages
- colanderman 4y agoPlusCal is very much in the ALGOL family (with the extension of nondeterminism, which is needed to serve its purpose of verification). TLA+ is similar to Prolog, extended with a next-state operator and the temporal operators (again, to serve its niche purpose). (Though the main TLA+ implementation, TLC, doesn't implement logic variables as richly as Prolog does, so coding style within a relation tends to be almost a bit more imperative. They exist in the language though, via the unbounded ∃ operator.)
- seanhunter 4y agoYears of bitter personal experience have taught me that FORTRAN is the real ur-language in the sense that a suitably determined programmer can write FORTRAN code in just about any language. I have certainly had to debug this code all over the place.
- lamontcg 4y agoDoes this make Perl a FORTRAN?
- seanhunter 4y agoI have unFORTRANned thousands of lines of perl code in my time.
- ochrist 4y agoIs this from https://www.usm.uni-muenchen.de/~hoffmann/roff/tmp/rpdup.pdf https://www.usm.uni-muenchen.de/~hoffmann/roff/tmp/rpdup.pdf (Real programmers don't use Pascal)?
- seanhunter 4y agoThat is where the quote originally came from yes. Thanks! I have been looking for that - couldn't remember it precisely. Here's the actual original: > Besides, the determined Real Programmer can write fortran programs in any language.
- neallindsay 4y agoI think this taxonomy is interesting, but I have some quibbles on the characterization of the languages I use the most. If I were to put Ruby into one of these categories, I would place it first under Self (the object-oriented languages). Ruby is the most object-oriented language that I've ever used in that everything is an object that you send signals to. Even classes in Ruby are objects (they are instances of the `Class` class). Ruby was explicitly inspired by Smalltalk, one of the two exemplars cited by the post. After the "Self" category, Ruby would fit better under the "Lisp" family than the "ALGOL" family because of Ruby's deep metaprogrammability. I'm guessing the author was fooled by the availability of C-style `for` loops in Ruby, but that's generally not how Ruby programmers write a loop. It's much more common to write `list_of_things.map {…}` or use any number of other iteration methods available through the `Enumerable` module. JavaScript to me fits better under the ML (functional languages) family than "ALGOL". The first-class nature of JavaScript functions is the core feature of the language. Of course, if you define "functional languages" by having static type systems this grouping wouldn't work for you. But for me it's all about the functions. You can pass functions around and return them from other functions. You can write utility functions to memoize or otherwise transform functions. And while not everything in JavaScript is an object the non-object values in JavaScript have "object" versions. JavaScript still has some object-oriented chops. Functions are themselves objects, and while method calls are usually just reading a function off of an object and calling it, you can intervene in the property-reading step to enforce a more "message passing" style. I'm guessing that most developers will have similar quibbles about the categorization in this article of the languages they are most familiar with. But this is still an interesting frame of reference. And if you only work in languages that fit squarely in the "imperative" category (or write code in an imperative way), I encourage you to explore some of the others.
- JW_00000 4y agoI agree with your characterization of Ruby as a Self/Smalltalk category language. (Or, a language with an ALGOL-style syntax and a Smalltalk-style OO system.) > After the "Self" category, Ruby would fit better under the "Lisp" family than the "ALGOL" family because of Ruby's deep metaprogrammability. I don't agree with this: Lisp's metaprogramming capabilities come from its macro system, while Ruby's metaprogramming capabilities are due to metaclasses (which is exactly why it fits in the Smalltalk category). JavaScript is also not a ML-style language in my opinion. ML-like languages have not just types, but also pattern matching and algebraic data types. First-class functions is not unique to the ML category, it also applies to the Lisp and Smalltalk categories (and maybe APL, I don't know it enough). I also still think of JavaScript as an ALGOL-style language augmented with Self concepts (Self, not Smalltalk!), but this may be because when I first started with JavaScript it didn't have classes yet. The good old days...
- codeflo 4y agoRuby is mostly a Self in this classification, right? Or maybe a Self/ALGOL hybrid. It does have iteration as a method (.each), but also has traditional if statements.
- jewel 4y agoRuby's if statements are actually expressions, they behave the same as the ternary operator : ? foo = if bar 1 else 2 end
- Mesopropithecus 4y agoTo some extent yes, it's certainly influenced by Smalltalk. I just wish the author hadn't focused that much on control flow in that paragraph. Ruby afaik also supports live programming up to a point (REPL), but it's still not the same live-ness as in Self or Smalltalk.
- CalChris 4y agoI've never heard of ALGOL both predating and influencing FORTRAN. FORTRAN was announced as a product at the Western Joint Computer Conference in 1957 [1]. ALGOL was developed at a meeting in Zurich in 1958 [2]. [1] https://www.softwarepreservation.org/projects/FORTRAN/paper/p165-backus.pdf https://www.softwarepreservation.org/projects/FORTRAN/paper/... [2] https://en.wikipedia.org/wiki/ALGOL https://en.wikipedia.org/wiki/ALGOL
- adjav 4y agoALGOL has certainly influenced the development of FORTRAN at least, with Fortran 90 and later fitting in pretty neatly amongst the various ALGOL-likes.
- todd8 4y agoThe comments here are interesting, lots of possibilities for other ur-languages. My suggestion is macro based languages. Macro based programming predates all programming languages other than ASM[1]. The simple macro systems, like early assemblers provided, aren't ur-languages, but once macros can expand other macros and generate definitions of new macros, the macro systems can become general purpose programming systems. The two earliest macro systems that were clearly designed to be general purpose languages that I know of are Christopher Strachey's GPM[2] and Calvin Mooers TRAC[3] programming language. These languages appeared at roughly the same time, the mid 1960s. I prefer the syntax of TRAC, but otherwise they are almost isomorphic. TRAC was featured in Computer Lib/Dream Machines[4] by Ted Nelson where the author said it was one of the three important languages for programmers to learn. A good introduction to TRAC and it's implementation can be found in Études for Programmers[5]. Other more contemporary examples of macro programming languages are m4, and TeX. LaTeX is programmed in the TeX macro system. [1] Daniel Weise and Roger Crew, "Programable Syntax Macros", ACM SIGPLAN, 1993, https://dl.acm.org/doi/pdf/10.1145/173262.155105 https://dl.acm.org/doi/pdf/10.1145/173262.155105 [2] Christopher Strachey, “A general purpose macrogenerator,” Computer Journal, 8(3), pp. 225-241, 1965 [3] Calvin Mooers, "TRAC, a procedure-describing language for the reactive typewriter", CACM, Vol 9(3), March 1966, pp. 215-219, https://dl.acm.org/doi/10.1145/365230.365270 https://dl.acm.org/doi/10.1145/365230.365270 [4] Ted Nelson, "Computer Lib/Dream Machines", 1974, Self-published. (There is a 2nd edition from Microsoft Press, but I'm only familiar with the 1st edition). [5] Charles Wetherell, "Études for Programmers", 1978, Prentice Hall. (It's out of print and available from Amazon for $427. I'm going to have to start locking up my old books.)
- t-3 4y agoMacro/concatenative languages should replace the Forth line. The author is off-base in thinking RPN or stacks are important to Forth rather than concatenativity. RPN is just an easy way to make interpretation simple, an implementation detail, not a functional requirement. It would be like defining APL as being evaluated right-to-left.
- pulvinar 4y agoThe stack is important to Forth, but equally so is its threaded-subroutine-call nature, which isn't present in other early languages that I know of. That puts Forth halfway between assembly and higher-level (and easier to read) languages. I never saw it as a macro language. At least that's the viewpoint I'm familiar with from back when we heavily used it.
- nostrademons 4y agoAgree on the families, but I would pick a different representative for many of the categories. Algol -> C. Mostly because you can actually do things with C, and yet it remains a fairly small language that's a relatively pure exemplar of the Algol tradition. Lisp -> Scheme. Also because it's a tiny language that tries to push the fundamentals of the Lisp family (code-as-data, recursion, functional programming, macros) as far as possible. ML -> Haskell. ML is eager, Haskell is lazy. If you're going to learn about the ML family, you might as well learn the concept of lazyness, which results in a very different style of programming than FP of the Scheme variety (in the Lisp family). APL -> J. The usage of special symbols is largely irrelevant to the concepts in APL, and it's a barrier to accessibility. You can learn all the important parts of array-oriented programming with J and use actual words to do it. Self, Forth, and Prolog I would keep as exemplars of their type. I would also add TCL as another ur-language for string-based scripting languages (with Perl, PHP, and SNOBOL as other representatives of the category).
- codeflo 4y agoI'm not sure if it's common knowledge that "ur-" means "original".
- OkayPhysicist 4y agoIn academic literature, "ur-" doesn't just mean original, as much as it means "essential essence of" or "fundamental". In contexts where you're talking about the first/original thing, or something that provided characteristics that would eventually become a trend, "proto-" would be more appropriate. For a famous example, Umberto Eco's essay "The Ur-Fascist" isn't describing what the first or original fascist movement was, but instead exploring what makes Fascism Fascism. This usage seems to be pretty consistent across academia, who engage in the vast majority of cases of slapping foreign prefixes onto English words.
- Grieverheart 4y agoI hadn’t come across the this before, but in Dutch we have the oer- which is spelled out as in poor, so I somehow connected the dots.
- colanderman 4y agoI think reactive/synchronous languages [1] deserve a category of their own. They share little/no overlap with any of the others. My background in electrical engineering biases me to Verilog, VHDL, and LabVIEW as exemplars, but there are many others. The distinguishing characteristic of the category is that programs are effectively declarative functions of time and can be composed as such, much like electronic circuits. (I categorized the temporal declarative language TLA+ into the Prolog family in another comment -- a main distinction here is, though one can express reactive relationships in TLA+, the intent of the language and design of the TLC model checker is that such relationships are only usable for verification code, whereas implementation code must be written as state-succession pairs. A true reactive language permits and encourages both styles of coding for implementation code -- e.g. Verilog's = and <= operators. Vice-versa, a true logic language includes nondeterminism as a core construct, whereas reactive languages typically do not.) [1] https://en.wikipedia.org/wiki/Synchronous_programming_language https://en.wikipedia.org/wiki/Synchronous_programming_langua...
- eschneider 4y agoVerilog/VHDL isn't so much a programming language as a hardware definition language and woe to anyone who conflates the two. Verilog/VHDL is it's own class of thing and sits outside of software languages.
- dgacmu 4y agoWithout weighing in on exactly if it is or isn't a "language", I think VHDL/verilog absolutely have a place in the list and are a fantastic thing for (some, particularly lower-level interested) programmers to learn precisely because it's such a different way of thinking about programming and huge piles of heterogeneous behavior happening concurrently. It really cooked my head for the first week or two and I think I came out the other side better. (I hated writing VHDL with a passion. It was painful medicine for a software person used to algol-style languages. But I'm really glad I did.)
- denotational 4y agoThis is an overly simplistic take in my opinion. From a PLT perspective they are programming languages just like any other, and one can analyse them using the same machinery (formal semantics, typically of the operational style) as any other programming language. Just because they are not even close to an imperative paradigm doesn’t make them any less of a programming language. They are reasonably close to process-calculus/message-passing languages in the sense that you can treat a Verilog process as a receiver listening to channels that contain messages generated when nets/variables are driven. I agree that a software developer who tries to write Verilog as if it were C will very quickly run into trouble, but that isn’t because it’s not a programming language; it’s because it’s a programming language with a similar syntax to C but with drastically different semantics.
- School-Cotton 4y ago> Lisp is about a year younger than Fortran, which makes it the second oldest language still in use today I disagree with this line since Lisp is not really a "language", but a family of them. If we consider Clojure and original Lisp to be the same language, we should also consider that to be true of Algol and Rust.
- lispm 4y agoThe original LISP was a language and its implementation. It was also documented - see for example the LISP 1 manual and other publications about it. From that a series of languages evolved, which shared the original core (syntax, data structures, operators, ...) That's what I would consider the core Lisp language family. Most of these languages will have 'Lisp' in its name.
- filoeleven 4y agoFTA: > I am aware of seven ur-languages in software today. I’ll name them for a type specimen, the way a species in paleontology is named for a particular fossil that defines it and then other fossils are compared to the type specimen to determine their identity
- ModernMech 4y agoMight add Lucid in here as a dataflow ur-language.
- Will_Parker 4y agoI also think a lot of programmers could get a sort of enlightenment by getting very proficient in SQL. (To the point where you can do general programming in it using recursive CTEs if you have to, even though probably impractical for real use cases.)
- carapace 4y agoPretty good, but I would lump ALGOL, Lisp, and ML together as Lambda Calculus languages.
- Nevermark 4y ago> A reader pointed out to me that getting Forth in a deep way usually involves building Forths, since they’re small enough for a single person to build one from the ground up fairly quickly. I would say the same about Lisp. In fact, each list in Lisp is like its own little stack in Forth. Prepending an element to the front of a list is like pushing onto a stack. Separating the first element from the rest of a list is like popping from a stack. Lists of lists & atoms are like stacks that can contain references to other stacks, as well as atoms.
- Scubabear68 4y agoI feel like C++ needs to go into its own category, seemingly infinite features with only thinly veiled illusionary safety.
- Mesopropithecus 4y agoNot a fan of snarky comments generally, but this one made me laugh. And cry.
- nologic01 4y agoAhh this is good. But what are ur-languages really? Can we tell when we have counted all of them? Is the collection determined more by the application domain (the problems we think are important to solve) or the architecture of Von Neumann type computing)? E.g. I don't know much about quantum computing but I suppose there is an ur-language associated with it. Whenever I see a taxonomy I itch for some underlying logic that unifies them. If the explanatory scheme is successful then you might actually convert the taxonomy into a tree, where the root is some property that all of them ur-languages share etc.
- nottorp 4y agoThey're more grouped by their main abstraction mode, not underlying hardware architecture. In theory you can emulate anything on something that's Turing complete, can't you? It will just be harder or easier. May not be worth the trouble. But still possible.
- paulddraper 4y agoI think there are additional examples, where the syntax isn't necessarily wildly different, but the paradigm is * Shader code: is ostensibly C, but fundamentally different runtime characteristics. * Dataflow (or Signals/Excel): Topological graph of computation. * HCL (or Cloudformation/CDK/etc): Connecting execution via a different runtime. * React Hooks IDK it just seems like there is a lot.
- nerpderp82 4y agoI despise this writing style. What is the point the author is trying to make? Define what a ur-language is up front, don't be so damn coy. This isn't much more than a list of interesting languages for some definition of interesting.
- joatmon-snoo 4y agoIt's talking about different families of programming languages, much like how we classify the different languages that people today speak[1]. I definitely got thrown off by the choice of terminology, but it makes sense once you go through the list. [1] https://www.theguardian.com/education/gallery/2015/jan/23/a-language-family-tree-in-pictures https://www.theguardian.com/education/gallery/2015/jan/23/a-...
- nerpderp82 4y agoThe reader shouldn't have to reverse engineer a document! https://en.wiktionary.org/wiki/ur- https://en.wiktionary.org/wiki/ur- Jesus! I thought these navel gazing low effort language posts went out of favor in 2012. I know all of these languages and Forth isn't foundational for anything we currently use, maybe the JVM because it has a stack if you really try and torture the definition. It is just a collection of languages so the author can look smart. If they wanted to provide insight, they would demarcate how the semantics of computation are different from each of these languages. It doesn't even mention the power of Forth in being able to extend the language and runtime from within the language itself. I'll see myself out.
- tokai 4y agoLooking up words you don't know =/= Reverse engineering
- nerpderp82 4y agoIt is prefix from German, given with zero explanation. The article had no thesis other than, "languages people should know about", sorta. The prefix isn't even used properly.
- garbagecoder 4y agoObjective C is a good example of a Smalltalk derived language that was in heavy use for a while. Even though it's technically a superset of C, in actual use it's more like a message passing language.
- svachalek 4y agoIt's really Smalltalk and C pasted together with hardly any mixing, like JSX=JS+HTML. I can't see how you could put it in either column, it's absolutely in both.
- garbagecoder 4y agoYou're right, of course. It absolutely is and so it might be a bad example, but it might be one where more readers would be familiar with.
- adastra22 4y agoStill in heavy use, given the number of devices Apple sells every year.
- garbagecoder 4y agoMost Apple developers have moved to Swift.
- adastra22 4y agoWhich uses the same Objective-C runtime.
- rst 4y agoThe claim that Fortran and assembly languages "trace to" Algol is... odd. Fortran I was released in 1957; the first fragmentary spec for Algol wasn't released until 1958 (with Fortran project leader John Backus as one of the primary contributors). And there were also recognizable assemblers, in the modern sense, at the time (although terms like that weren't always used with their modern meanings in the 1950s, which lays up all sorts of traps for the unwary).
- golf_mike 4y agoSo why is it called "ur"?
- vaylian 4y agoBecause most other languages descended from these early languages.
- golf_mike 4y agoActually never heard that expression before. Thought I might not be in the know of some very obvious jargon. Turns out it was just plain English.
- thrill 4y agoThat's the essence of the conversation here, isn't it?
- golf_mike 4y agoI had never heard this expression before. I thought it was jargon. Thanks for your kind explanation :)
- pdevr 4y agoFor those wondering, this is a common word used in the academia - you can check #3 here: https://www.merriam-webster.com/dictionary/ur https://www.merriam-webster.com/dictionary/ur
- chunes3 4y agoI take issue with calling stack languages the inverse of Lisp. This isn't really the case since functions in stack languages are fixed arity, while Lisp functions are not. The inverse of RPN would be the fixed-arity prefix notation used by the REBOL family of languages.
- yellowapple 4y agoInteresting to see Erlang mentioned in the Self category instead of the Prolog category, but it makes sense given how much it borrows from both.
- aleph_minus_one 4y agoWhere does Excel fit into this classification? ;-)
- ThinkBeat 4y agoI think mentioning Simula would be fair. The first object-oriented language. "" Simula (1967) is generally accepted as being the first language with the primary features of an object-oriented language. It was created for making simulation programs, in which what came to be called objects were the most important information representation.
- tomrod 4y agoI would love to see a mapping of languages to features. I recognize this might be a large table.
- adastra22 4y agoI would add bitcoin script to the Examples section for Forth. That's a very notable application of Forth in modern usage. Also maybe command / shell languages deserve a mention?
- zaptheimpaler 4y agoMost of these are too old for me but ive always had this idea of fundamental language paradigms too.. my ur-languages are maybe Python, Lisp, Haskell, SQL. If you drop the requirement to choose the oldest language in each paradigm (which is more practical from a learners POV), there are many sets of basis vectors (languages) that cover the entire vector space (all language features).