I'd like to ask about the history of programming languages - specifically, the role of hardware in language development over the past 20-30 years.

I have been reading about the history of Python, and the ABC project. It seems to me that there were lots of lessons learned about language structure, abstraction to a more natural ('expressive') syntax, extensibility etc.

I'd like to know what role hardware had to play in the development of modern languages. For example, did more RAM mean that languages could be less efficient with memory allocation, but become more convenient to the user? Did faster processors mean that prohibitively expensive operations could move into the mainstream?

  • 1
    The reverse certainly happened: en.wikipedia.org/wiki/High-level_language_computer_architecture – Lyndon White May 13 '17 at 9:01
  • Hardware improvements allowed real multitasking across multiple cores. In order to use this efficiently good language and runtime library features needs to be present in the language. – Thorbjørn Ravn Andersen May 14 '17 at 9:02
  • I had forgotten about multi-threading. Do you think that needed a fundamental change in language design, or was it just extra functionality within the existing paradigm? @ThorbjørnRavnAndersen (I spent a summer studying in the Black Diamond btw - great place!) – geonaut May 14 '17 at 9:12
  • @geonaut Consider that Java had thread support from the very beginning so this was considered from the start. Even so this was changed substantially in later releases to scale better and more reliably. C-Python today suffers from a global interpreter lock because the memory management is not threadsafe so C-Python does not scale as well as e.g. Java. wiki.python.org/moin/GlobalInterpreterLock – Thorbjørn Ravn Andersen May 14 '17 at 11:37
  • @geonaut: I'd say multi-CPU (in hardware) did need fundamental changes in language design and software design, and this didn't happen (at least not for "mainstream"), and most software is bad (constantly failing to handle locks, etc properly, scalability problems, people just giving up and not bothering, etc) because the changes didn't happen. – Brendan Jun 5 '17 at 10:56

No, the available hardware resources do not seem to have a significant impact on programming language design.

  • Garbage collection was not an innovation by 90's languages. Instead, it was available since the late 50s, one of the many concepts invented for Lisp. Since then, GC has become to be expected in very high level programming languages. C++ is the exception to the rule, since it intends to be usable as a system programming language like C.

  • Interpreters and virtual machines are similarly old: Lisp introduced interpretation in the late 50s, and UCSD Pascal (late 70s) used a bytecode interpreter runtime that in some respects looks eerily similar to Java. Many early home computers like the Commodore 64 offered a BASIC interpreter as primary interface. However, the reduced performance of interpreters was far more noticeable back them, restricting “serious” development in interpreted systems mostly to academic users, or users with powerful workstations.

  • Human-friendly syntax design isn't new either. Being able to write code for mathematical expressions in a way that looks like maths was the major innovation of Fortran (late 50s). COBOL (also late 50s) is very verbose and tries to read like plain English. This was also a goal of the SQL syntax (70s). ABC and Python are not unusual, especially as they are part of the ALGOL–Pascal language family that relies heavily on keywords. Their syntactic innovation is marrying the off-side rule (i.e. indentation-delimited blocks) with ALGOL-like syntax.

There are some minor aspects where the hardware imposed constraints that are less relevant today, or opened new opportunities:

  • C and C++ are designed in a manner that supports single-pass compilation, which reduces the amount of memory by the compiler. You therefore have to pre-declare all functions that you use in a C or C++ program. However, modern machines have much more memory, and no mainstream compiler does single-pass compilation.

  • Better computational resources mean that compilers are able to perform much more complex optimizations and analyses. Some languages like Scala would be unfeasible without this kind of processing power.

  • As computers became more affordable, the barrier of entry to get started with programming has been greatly reduced. Scripting languages in particular do not require to compile your program first, and allow easier tinkering. This seems to be connected with the explosion of the internet in the 90s: Perl was exceedingly popular for CGI scripts, but was largely replaced by PHP since it was much easier to add a bit of code to an HTML page. Nowadays, everyone has a JavaScript IDE built in to their browser.

  • 1
    "UCSD Pascal (late 70s) used a bytecode interpreter runtime that in some respects looks eerily similar to Java." – Pascal p-code seems to be somewhat influenced by the Burroughs B5000, Alan Kay cites the Burroughs B5000 as the main inspiration and Pascal p-code as a secondary for the design of the Smalltalk VM, James Gosling cites the Smalltalk VM and Pascal p-code as the main inspiration for the design of the JVM. And let's not forget that the most popular mainstream JVM, HotSpot, actually started its life as a Smalltalk VM. So, there is a pretty strong connection there. – Jörg W Mittag May 12 '17 at 10:52
  • BTW, I think occam (1983) may pre-date ABC in its use of the offside-rule to delimit ALGOL-style blocks. The offside-rule itself was introduced in ISWIM (1966) and used in e.g. SASL (1972) and Miranda (1985). However, I believe ABC's predecessors A, B, and C (not related to the B and C programming languages by Dennis Ritchie) may have already used the offside-rule in the 1970s. – Jörg W Mittag May 12 '17 at 11:07
  • The promised availability of floating point arithmetic for the PDP-11 in combination with the 16-bit word size was one of the major influences that lead to the planned addition of types to B and the creation of C (the Dennis Ritchie flavors). "Floating-point operations had been added to BCPL in our Multics and GCOS compilers by defining special operators, but the mechanism was possible only because on the relevant machines, a single word was large enough to contain a floating-point number; this was not true on the 16-bit PDP-11." – 8bittree May 12 '17 at 16:58
  • Garbage Collection in Lisp was made necessary by postponing the problem until memory became an issue. Then it was found that putting the clean up in the runtime instead of rewriting all the programs was the best solution. – Thorbjørn Ravn Andersen May 14 '17 at 9:05

I found an article that explains exactly what you are asking.

Here's the link to the article -


The 1980s were years of relative consolidation in imperative languages. Rather than inventing new paradigms, all of these movements elaborated upon the ideas invented in the previous decade. C++ combined object-oriented and systems programming. The United States government standardized Ada, a systems programming language intended for use by defense contractors. In Japan and elsewhere, vast sums were spent investigating so-called fifth-generation programming languages that incorporated logic programming constructs. The functional languages community moved to standardize ML and Lisp. Research in Miranda, a functional language with lazy evaluation, began to take hold in this decade. One important new trend in language design was an increased focus on programming for large-scale systems through the use of modules, or large-scale organizational units of code. Modula, Ada, and ML all developed notable module systems in the 1980s. Module systems were often wedded to generic programming constructs---generics being, in essence, parametrized modules (see also polymorphism in object-oriented programming). Although major new paradigms for imperative programming languages did not appear, many researchers expanded on the ideas of prior languages and adapted them to new contexts. For example, the languages of the Argus and Emerald systems adapted object-oriented programming to distributed systems. The 1980s also brought advances in programming language implementation. The RISC movement in computer architecture postulated that hardware should be designed for compilers rather than for human assembly programmers. Aided by processor speed improvements that enabled increasingly aggressive compilation techniques, the RISC movement sparked greater interest in compilation technology for high-level languages. Language technology continued along these lines well into the 1990s. Some notable languages that were developed in this period include:

  • 1980 – C++ (as C with classes, renamed in 1983)
  • 1983 – Ada
  • 1984 – Common Lisp
  • 1984 – MATLAB
  • 1985 – Eiffel
  • 1986 – Objective-C
  • 1986 – LabVIEW (Visual Programming Language)
  • 1986 – Erlang
  • 1987 – Perl
  • 1988 – Tcl

  • 1988 – Wolfram Language (as part of Mathematica, only got a separate name in June 2013)

  • 1989 – FL (Backus)

  • Great information - thanks. The RISC movement is exactly the kind of thing I was looking for. Nice quote from Alan Clements here. "In brief, RISC architectures redeploys to better effect much of the silicon real estate used to implement complex instructions and elaborate addressing modes in conventional microprocessors of the 68K and 8086 generation." – geonaut Jun 6 '17 at 11:52

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.