Invited talk: Back to the future: SIMULA style concurrent objects


In this talk we will describe the approach to concurrency in SIMULA 67, the very first object-oriented language and the further development of this in the Beta language. We will also discuss what we consider the weaknesses of SIMULA and Beta with respect to concurrency and present current work to improve this.

SIMULA 67 had most of the essential language concepts now available in mainstream object-oriented languages. The SIMULA approach to the modeling of concurrent activities has, however, not caught on. Objects in SIMULA are active in the sense that an object is a coroutine – the head of a thread. SIMULA was originally designed to model and simulate activities in the real world. For this reason it was mandatory to be able to model concurrent activities.

Beta was designed as a successor to SIMULA and the approach to active objects and concurrency was further developed. Concurrent object-oriented programming in Beta is based on semaphores, coroutines, and the ability to define high-level concurrency abstractions like monitors, and rendezvous-based communication, and their associated schedulers. The coroutine mechanism of SIMULA has been generalized into the notions of concurrent and alternating objects Alternating objects of a concurrent object may be used to represent cooperative threads for eventual blocking communication with the concurrent object. It is thus an alternative to asynchronous messages and guarded commands. Beta, like SIMULA, was designed as a language for modeling as well as programming, and we describe how this has had an impact on the design of the language.

Although Beta supports the definition of high-level concurrency abstractions, the use of these rely on the discipline of the programmer, as is the case for Java and other mainstream object-oriented languages. We present the notion of subpattern (including subclass) restrictions as a mechanism for defining safe concurrency abstractions as an alternative to rely on discipline. Subpattern restrictions have been implemented in a new experimental version of Beta.

Speaker's bio:

Ole Lehrmann Madsen is a professor of Computer Science, Aarhus University, and director of the Alexandra Institute Ltd. He was one of the creators of the Beta programming language and the Mjølner software development environment. He is a co-founder and chairman of the board for Mjølner Informatics Ltd., which is based on Beta and the Mjølner project. He has a PhD from Aarhus University in computer science. He has previously worked as a research associate at CSLI at Stanford University (1984-85) and senior research associate at Sun Labs in Mountain View, California (1994-95).

Invited talk: Toward the future of personal computing system construction


The software for today's personal computing environments has become so complex that no single person can understand an entire system: a typical desktop OS and commonly used application suite amount to over 100 million lines of code. Our group's early experiences with personal computing led us to conclude that much of this complexity is "accidental", rather than inherent. In the STEPS project we explored how to reduce such accidental complexity in software, choosing as our domain of interest the entire personal computing environment. This includes the language execution environment (which subsumes the operating system), the graphics engine, the GUI application framework, and desktop publishing applications to edit user documents and programs, etc.

Our approach to reduce complexity is to create "meta-languages" that allow us to make and experiment with new domain specific languages. With these new languages, we can describe different parts of systems in cleaner and more intention-revealing ways. As a notable example, a new stream-processing language called Nile was invented. The syntax of Nile allows a fully-featured vector graphics engine called Gezira to be written in a clean, mathematical manner in less than 500 lines of code. Also, to describe the application framework and applications, an FRP-like language called KScript was invented. The dynamic and late-bound nature of KScript allows the system to be written interactive and incremental manner in concise notation. The editor and GUI framework called KSWorld is written in about 10,000 lines of code. We also wrote a few language execution engines that compile higher-level code down to machine code.

As one of the "next steps", one of the directions we are taking is to incorporate the idea of using multiple constraint solvers to build a system. Solvers can help stronger "negotiation" between objects and languages, and help the system to be written in a more declarative manner. Another direction is to take the idea of ---- loose-coupling to the next level; objects should not know about the other objects directly but should always negotiate and "find" other objects. The implications of these ideas will be discussed.

Speaker's bio:

Yoshiki Ohshima is a researcher at the Viewpoints Research Institute. Recent projects include bringing the Etoys enviornment to children via the "XO" and the One Laptop Per Child (OLPC) initiative, and participating in the STEPS project of Viewpoints Research.

He received a master's degree on the design and implementation of a programming language with transactional facility from the Tokyo Institute of Technology, and he was awarded his PhD for the creation of an end-user oriented massively parallel particle progamming system from the same institution. While at Walt Disney Imagineering R&D, he worked on theme park related research projects as well as end-user computer environments.