So there was considerable borrowing from PASCAL, CLU, MODULA(-2), CSP. It's possible that the elaborate system for specifying machine representations of numbers was truly novel, but I'm not sure how much of a success that was.

There are features common to Ada and Modula, but those have been taken by both languages from Xerox Mesa.

The first version of Modula was designed with the explicit goal of making a simple small language that provided a part of the features of Xerox Mesa (including modules), after Wirth had spent a sabbatical year at Xerox.

Nowadays Modula and its descendants are better known than Mesa, because Wirth and others have written some good books about it and because Modula-2 was briefly widely available for some microcomputers. Many decades ago, I had a pair of UVPROM memories (i.e. for a 16-bit data bus) that contained a Modula-2 compiler for Motorola MC68000 CPUs, so I could use a computer with such a CPU for programming in Modula-2 in the same manner how many early PCs could be used with their built-in BASIC interpreter. However, after switching to an IBM PC/AT compatible PC, I have not used the language again.

However, Xerox Mesa was a much superior language and its importance in the history of programming languages is much greater than that of Modula and its derivatives.

Ada has taken a few features from Pascal, but while those features were first implemented in Pascal, they had been proposed much earlier by others, e.g. the enumerated types of Pascal and Ada had been first proposed by Hoare in 1965.

When CLU is mentioned, usually Alphard must also be mentioned, as those were 2 quasi-simultaneous projects at different universities that had the purpose of developing programming languages with abstract data types. Many features have appeared first in one of those languages and then they have been introduced in the other after a short delay. Among the features of modern programming languages that come from CLU and Alphard are for-each loops and iterators.

It was by far the best language that I used for my entire working career where I had to endure such languages as PL/1 (and PL/S), C, C++, Java, JavaScript and PHP. While Java as a lang was not too bad it still paled in features and usability compared to MESA and it too was influenced by MESA.

But as was true at Xerox was it was the complete network that was revolutionary at the time in the early 80’s. The fact that I could source debug any machine remotely on the corporate would wide network of over 5000 machine and that the source code would be automatically done loaded to my machine (mean I could easily debug from any nearby random machine) was just something I could never “easily’ do elsewhere.

MESA was missing a few things (which CEDAR solved and used generally within only Xerox PARC partially because at the time it really only ran on Dorado class machine) such as Garbage collection and in the case of Star it would have been much better if the language supported OOP. For Star we had had a system called Traits to support objects but it had some serious issues IMHO (which would be fodder for a separate post.)

When talking about Mesa you also need to talk about Tajo, its development environment built onto- of the OS Pilot (Star also used Pilot.) But systems also supported a mouse and a large bitmapped monitor and had overlapping windows (although most of Star have automatic non overlapping windows that was a UI usability decision.)

There is also more because the network was very important. Print severs, file servers, mail servers, cloudless store for all of Star’s user files/desktop. All this in the very early 80’s was unheard of elsewhere. It’s very similarly to what Steve Jobs missed when he saw Smalltalk where he only really saw a new UI and missed much more that was demoed.

It was a magic place to work at the time, I had left in the very late 80s for Apple and it was a huge step backwards at the time (but did amazing stuff with their limited tools but made working not fun.)

https://bitsavers.org/pdf/xerox/mesa/

Some information may also exist in other subdirectories of "pdf/xerox".

There have been many references to Mesa in the research articles and the books published towards the end of the seventies and during the eighties, but those are hard to find today, as most of them may have not been digitized. Even if they were digitized, it is hard to search through them to find the relevant documents, because you would not know from the title whether Mesa is also discussed along with other programming languages.

In general, bitsavers.org is probably the most useful Internet resource about old computing hardware and software, because no secondary literature matches the original manuals of the computer vendors, which in the distant past had an excellent quality, unlike today.

Ada provides many features of Mesa, but not all of them and I regret that some Mesa features are missing from the languages that are popular today.

The loops with double exits of Python (i.e. with "else") have been inspired by Mesa, but they provide only a small subset of the features available in Mesa loops.

Mesa had DEFINITIONS modules, exceptions, subranges, and threads.

Examples would be a nice bonus but I think the author eschewed such because they weren't interested in writing a tutorial. They had a very specific point to make and stuck to it, resulting in a very informative but concise article that reads well because of its highly disciplined authorship.

Especially if we assume that most readers are not Ada experts and that enough languages are mentioned that most people don't know the details of all of them.

    Generic
      Type Index   is (<>);                                      -- Any discrete type.
      Type Element is limited private;                           -- Any non-discriminated type.
      Type Vector  is array(index range <>) of element;          -- An array-type of Element, indexed by Index.
      with Function "="(Left, Right: Element) return Boolean <>; -- Equal, defaulted.
      with Function "<"(Left, Right: Element) return Boolean <>; -- Less-than, defaulted.
    Function Generic_Sort( X : Vector ) return Vector;

    Function Sort is new Generic_Sort( Index => Integer, Element => Integer, Vector => Integer_Array, "<" => ">");