Mesa (programming language)

Mesa[1] is a programming language developed in the late 1970s at

the Xerox Palo Alto Research Center in Palo Alto, California, Mesa[1]
United States. The language name was a pun based upon the Designed by Computer Systems
programming language catchphrases of the time, because Mesa is a Laboratory (CSL)
"high level" programming language.
Developer Xerox PARC
Mesa is an ALGOL-like language with strong support for modular First appeared 1976[2]
programming. Every library module has at least two source files: a
definitions file specifying the library's interface plus one or more Stable release Mesa 6.0 (Version
program files specifying the implementation of the procedures in the 41) / July 1981
interface.[4] To use a library, a program or higher-level library must Typing Strong, static
"import" the definitions. The Mesa compiler type-checks all uses of discipline
imported entities; this combination of separate compilation with
type-checking was unusual at the time. Influenced by
ALGOL
Mesa introduced several other innovations in language design and
Influenced
implementation, notably in the handling of software exceptions,
thread synchronization, and incremental compilation. Java, Modula-2, Cedar, PostScript[3]

Mesa was developed on the Xerox Alto, one of the first personal computers with a graphical user interface,
however, most of the Alto's system software was written in BCPL. Mesa was the system programming
language of the later Xerox Star workstations, and for the GlobalView desktop environment. Xerox PARC
later developed Cedar, which was a superset of Mesa.

Mesa and Cedar had a major influence on the design of other important languages, such as Modula-2 and
Java, and was an important vehicle for the development and dissemination of the fundamentals of GUIs,
networked environments, and the other advances Xerox contributed to the field of computer science.

Contents
History
Main features
Semantics
Syntax
Cedar
Descendants
See also
References
External links

History
Mesa was originally designed in the Computer Systems Laboratory (CSL), a branch of the Xerox Palo Alto
Research Center, for the Alto, an experimental micro-coded workstation. Initially, its spread was confined to
PARC and a few universities to which Xerox had donated some Altos.

Mesa was later adopted as the systems programming language for Xerox's commercial workstations such as
the Xerox 8010 (Xerox Star, Dandelion) and Xerox 6085 (Daybreak), in particular for the Pilot operating
system.

A secondary development environment, called the Xerox Development Environment (XDE) allowed
developers to debug both the operating system Pilot as well as ViewPoint GUI applications using a world
swap mechanism. This allowed the entire "state" of the world to be swapped out, and allowed low-level
system crashes which paralyzed the whole system to be debugged. This technique did not scale very well to
large application images (several megabytes), and so the Pilot/Mesa world in later releases moved away
from the world swap view when the micro-coded machines were phased out in favor of SPARC
workstations and Intel PCs running a Mesa PrincOps emulator for the basic hardware instruction set.

Mesa was compiled into a stack-machine language, purportedly with the highest code density ever achieved
(roughly 4 bytes per high-level language statement). This was touted in a 1981 paper where implementors
from the Xerox Systems Development Department (then, the development arm of PARC), tuned up the
instruction set and published a paper on the resultant code density.[5]

Mesa was taught via the Mesa Programming Course that took people through the wide range of technology
Xerox had available at the time and ended with the programmer writing a "hack", a workable program
designed to be useful. An actual example of such a hack is the BWSMagnifier, which was written in 1988
and allowed people to magnify sections of the workstation screen as defined by a resizable window and a
changeable magnification factor. Trained Mesa programmers from Xerox were well versed in the
fundamental of GUIs, networking, exceptions, and multi-threaded programming, almost a decade before
they became standard tools of the trade.

Within Xerox, Mesa was eventually superseded by the Cedar programming language. Many Mesa
programmers and developers left Xerox in 1985; some of them went to DEC Systems Research Center
where they used their experience with Mesa in the design of Modula-2+, and later of Modula-3.

Main features

Semantics

Mesa was a strongly typed programming language with type-checking across module boundaries, but with
enough flexibility in its type system that heap allocators could be written in Mesa.[6]

Because of its strict separation between interface and implementation, Mesa allows true incremental
compilation and encourages architecture- and platform-independent programming. They also simplified
source-level debugging, including remote debugging via the Ethernet.

Mesa had rich exception handling facilities, with four types of exceptions. It had support for thread
synchronization via monitors. Mesa was the first language to implement monitor BROADCAST, a concept
introduced by the Pilot operating system.[7]

Syntax
Mesa has an "imperative" and "algebraic" syntax, based on ALGOL and Pascal rather than on BCPL or C;
for instance, compound commands are indicated by the BEGIN and END keywords rather than braces. In
Mesa, all keywords are written in uppercase.[1]

Due to a peculiarity of the ASCII variant used at PARC, the Alto's character set included a left-pointing
arrow (←) rather than an underscore. The result of this is that Alto programmers (including those using
Mesa, Smalltalk etc.) conventionally used CamelCase for compound identifiers, a practice which was
incorporated in PARC's standard programming style. On the other hand, the availability of the left-pointing
arrow allowed them to use it for the assignment operator, as it originally had been in ALGOL.

When the Mesa designers wanted to implement an exception facility, they hired a recent M.Sc. graduate
from Colorado who had written his thesis on exception handling facilities in algorithmic languages. This led
to the richest exception facility for its time, with primitives SIGNAL, ERROR, ABORT, RETRY, CATCH, and
CONTINUE. Because the language did not have type-safe checks to verify full coverage for signal handling,
uncaught exceptions were a common cause of bugs in released software.

Cedar
Mesa was the precursor to the programming language Cedar.[8][9] Cedar's main additions were garbage
collection, dynamic types, better string support through ropes, a limited form of type parameterization, and
special syntax for identifying the type-safe parts of multi-module software packages, to ensure deterministic
execution and prevent memory leaks.

Descendants
The United States Department of Defense approached Xerox to use Mesa for its "IronMan"
programming language, but Xerox declined due to conflicting goals. Xerox PARC employees
argued that Mesa was a proprietary advantage that made Xerox software engineers more
productive than engineers at other companies. The Department of Defense instead eventually
chose and developed the Ada programming language from the candidates.
The original Star Desktop evolved into the ViewPoint Desktop and later became GlobalView
which was ported to various Unix platforms, such as SunOS Unix and AIX. A Mesa to C
compiler was written and the resulting code compiled for the target platform. This was a
workable solution but made it nearly impossible to develop on the Unix machines since the
power of the Mesa compiler and associated tool chain was lost using this approach. There was
some commercial success on Sun SPARC workstations in the publishing world, but this
approach resulted in isolating the product to narrow market opportunities.
In 1976, during a sabbatical at Xerox PARC, Niklaus Wirth became acquainted with Mesa,
which had a major influence in the design of his Modula-2 language.[10]
Java explicitly refers to Mesa as a predecessor.[11]

See also
History of the graphical user interface

References
1. Mitchell, James G.; Maybury, William; Sweet, Richard (1979): Mesa Language Manual -
version 5.0 (http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-79-3_Mesa_Language_
 Manual_Version_5.0.pdf)" XEROX PARC, Computer Systems Laboratory (CSL), Technical
Report CSL-79-3. Online copy at www.bitsavers.org, accessed on 2019-05-15.
2. Mesa (http://www.softwarepreservation.org/projects/lang/mesa), Software Preservation Group
3. Perry, T.S. (May 1988). " 'PostScript' prints anything: a case history". IEEE Spectrum. 25 (5):
42–46. doi:10.1109/6.4550 (https://doi.org/10.1109%2F6.4550).
4. Mesa Language Manual, chapter 7. (The Manual uses the term module to mean a source file.)
5. Sweet, Richard; Sandman, James (March 1982), "Empirical analysis of the Mesa instruction
set" (http://dl.acm.org/citation.cfm?id=800050.801839&coll=DL&dl=GUIDE&CFID=345283299
&CFTOKEN=93216930), ASPLOS I Proceedings of the First International Symposium on
Architectural Support for Programming Languages and Operating Systems
6. Geschke, Charles; Morris, James H.; Satterthwaite, Edwin H. (August 1977). "Early
Experience with Mesa". Communications of the ACM. 20 (8): 540–552.
doi:10.1145/359763.359771 (https://doi.org/10.1145%2F359763.359771).
7. Lampson, Butler W.; Redell, David D. (February 1980). "Experience with Processes and
Monitors in Mesa" (http://research.microsoft.com/lampson/23-ProcessesInMesa/Abstract.html).
Communications of the ACM. 23 (2): 105–117. CiteSeerX 10.1.1.142.5765 (https://citeseerx.is
t.psu.edu/viewdoc/summary?doi=10.1.1.142.5765). doi:10.1145/358818.358824 (https://doi.or
g/10.1145%2F358818.358824).
8. Lampson, Butler W. A Description of the Cedar Language (http://research.microsoft.com/lamps
on/32a-CedarLang/32a-CedarLangAbstract.htm). Xerox PARC Technical Report.
9. Swinehart, Daniel C.; Zellweger, Polle T.; Hagmann, Robert B. (July 1985). "The Structure of
Cedar". SIGPLAN Notices. 20 (7): 230–244. CiteSeerX 10.1.1.110.9565 (https://citeseerx.ist.p
su.edu/viewdoc/summary?doi=10.1.1.110.9565). doi:10.1145/800225.806844 (https://doi.org/1
0.1145%2F800225.806844).
10. Wirth, Niklaus (2007). "Modula-2 and Oberon" (http://portal.acm.org/citation.cfm?id=1238847).
Proceedings 3rd Conference on the History of Programming Languages. San Diego: 3-1–3-10.
CiteSeerX 10.1.1.91.1447 (https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.91.144
7). doi:10.1145/1238844.1238847 (https://doi.org/10.1145%2F1238844.1238847). ISBN 978-
1-59593-766-7..
11. Gosling, James; Joy, Bill; Steele, Guy; Bracha, Gilad. Java Language Specification (http://java.
sun.com/docs/books/jls/second_edition/html/intro.doc.html#237601) (2nd ed.).

External links
Mesa Programming Language Manual, Version 5 (1979) (http://bitsavers.informatik.uni-stuttgar
t.de/pdf/xerox/parc/techReports/CSL-79-3_Mesa_Language_Manual_Version_5.0.pdf) at
bitsavers.org
Other Mesa documents (http://bitsavers.org/pdf/xerox/mesa/) at bitsavers.org
World-Stop Debuggers (http://www.ece.ubc.ca/~gillies/note1.html), Don Gillies, Xerox
SDD/ISD Employee, 1984-86.
Teitelman, Warren (April 1984). "A Tour Through Cedar". IEEE Software. 1 (2): 44–73.
CiteSeerX 10.1.1.105.3163 (https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.105.31
63). doi:10.1109/ms.1984.234050 (https://doi.org/10.1109%2Fms.1984.234050).

Retrieved from "https://en.wikipedia.org/w/index.php?title=Mesa_(programming_language)&oldid=958631375"

This page was last edited on 24 May 2020, at 21:42 (UTC).

Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using this
site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia
Foundation, Inc., a non-profit organization.