title: A New Cognitive Perspective on Simplicity in System and Product Design

abstract: What is simple? How can we make simple things? Simplicity seems easy to grasp but is surprisingly difficult to explain. “We know it when we see it”, but we don’t know how to describe it. This essay reflects on a number of observations about simplicity and complexity. It invites a perspective change towards a dynamical systems view of simplicity, explores how we can explain what makes things simple, and how we can utilize this knowledge as makers, creators, product and system designers to craft simple things.


venue: onward

title: Programming Languages for the Future of Design Computation

authors:
Robert Aish
Al Fisher
Dominic Orchard
Jay Torry

abstract: Design Computation is the use of programming in the design of physical systems such as buildings and infrastructure. This involves embedding both general-purpose textual languages and domain-specific visual languages within geometry modelling and engineering applications in the construction industry. A unique form of entry-level end-user programming has emerged in Design Computation. However, there are significant usability and representational issues; general-purpose languages present barriers to adoption, whilst visual languages do not scale to complex design problems. In this essay, we explore how advances in programming language research could be harnessed in future Design Computation languages to address these pedagogic, representational and scaling issues so as to improve human readable program structure and semantics and to enable machine-readable program verification.


title: The Hidden Program State Hurts Everyone

authors:
Sverrir Thorgeirsson
Oliver Graf
Zhendong Su

abstract: While visual scaffolding, live programming, and direct manipulation of the program state are considered useful programming paradigms for novices, they might not always offer the same benefits to experienced software developers. In this essay, we will use chess as a proxy for exploring how these paradigms can also support those who have an intuitive understanding of the program state and its connection with textual code. We will consider the visual programming language Algot and recent user studies conducted on the language to uncover insights into how direct manipulation and programming by demonstration can benefit everyone.


title: Use Site Checking Considered Harmful

authors:
Dimi Racordon
Benjamin Chung

abstract: Static type checking aims to detect nonsensical operations based on their domains at compile time. While its benefits no longer need to be argued, it comes with expressiveness limitations that can only be lifted at the expense of complexity. This problem is particularly antithetical to generic programming, where algorithms and data structures are designed in the most general setting possible. In response, some systems have adopted a form of static duck typing: generic definitions are written against assumed interfaces that are only type checked with concrete types at their ultimate use sites. This essay claims that such an approach, which we refer to as use site checking, is harmful to user experience. We study four main problems caused by use site checking and show how they relate to similar well-known issues in dynamically typed languages. We then look at existing language constructs to discuss how statically typed languages may address these shortcomings.


title: Discovering Your Software Umwelt

authors:
Rebecca Wirfs-Brock
Allen Wirfs-Brock
Jordan Wirfs-Brock

abstract: We apply the biological-behavioral concept of an umwelt, which is how an organism perceives and acts within its environment, to the practice of software development. By writing narrative descriptions of our own software umwelts and iteratively discussing and analyzing them, we develop prompts that can elicit reflection on how and why we relate to software in the ways that we do.


title: tl;dr: Chill, y’all: AI Will Not Devour SE

authors:
Eunsuk Kang
Mary Shaw

abstract: Social media provide a steady diet of dire warnings that artificial intelligence (AI) will make software engineering (SE) irrelevant or obsolete. To the contrary, the engineering discipline of software is rich and robust; it encompasses the full scope of software design, development, deployment, and practical use; and it has regularly assimilated radical new offerings from AI. Current AI innovations such as machine learning, large language models (LLMs) and generative AI will offer new opportunities to extend the models and methods of SE. They may automate some routine development processes, and they will bring new kinds of components and architectures. If we're fortunate they may force SE to rethink what we mean by correctness and reliability. They will not, however, render SE irrelevant.


title: Moldable Exceptions

authors:
Andrei Chiş
Tudor Gîrba
Oscar Nierstrasz

abstract: Debugging is hard. Interactive debuggers are mostly the same. They show you a stack, a way to sample the state of the stack, and, if the debugger is live, a way to step through execution. The standard interactive debugger for a general-purpose programming language provided by a mainstream IDE mostly offers a low-level interface in terms of generic language constructs to track down and fix bugs. A custom debugger, such as those developed for specific application domains, offers alternative interfaces more suitable to the specific execution context of the program being debugged. Custom debuggers offering contextual debugging views and actions can greatly improve our ability to reason about the current problem. Implementing such custom debuggers, however, is non-trivial, and poses a barrier to improving the debugging experience. In this paper we introduce moldable exceptions, a lightweight mechanism to adapt a debugger’s interface based on contextual information provided by a raised exception. We present, through a series of examples, how moldable exceptions can enhance a live programming environment.


title: Reclaiming the Unexplored in Hybrid Visual Programming

abstract: Programming languages have been trapped in a world of linear textual representations fundamentally unchanged for half a century. Even systems pushing beyond these forms — visual languages, projectional language workbenches, and end-user programming tools — largely ape the strictures of stream-of-bytes compilers and confine themselves to the popular paradigms of conventional textual systems. Instead of recreating what succeeded in textual paradigms, new programming systems should also be exploring what did not — the confounding, confusing, convoluted approaches that fell by the wayside — with the sorts of direct manipulation, spatial connection, and change over time that textual languages could never match; and they should use their control of presentation to let the user choose the right representation for a piece of code in the moment — and change it. We argue that these two points unlock new frontiers for programming systems, and present preliminary explorations to highlight how multiple-representation environments can lower the pressure on more speculative visual paradigms, to encourage more investigation of this underexamined space.


title: Active DSU: Dynamic Software Updates for Active Functions

authors:
Filip Strömbäck
Dániel Varró

abstract: Dynamic Software Updating (DSU) is a technique for updating programs without restarting them. It is useful in systems that provide live programming or in system with high availability needs. As a common limitation, existing DSU systems cannot update active functions. Hence, they are unable to update long-running functions, such as the main loop in a web server, or a state machine in an embedded system implemented as a loop. Updating active functions is challenging as it requires updating local variables and control flow to create a consistent state in the new version of the function. In this paper, we propose Active DSU, which updates the call stack to migrate data and control flow of active functions without the need to wait for the program to reach a particular state beforehand. This is achieved by replacing return addresses with stubs to avoid moving other stack frames on the call stack. Active DSU can migrate control flow automatically without input from the programmer in most cases.


title: Source-Level Debugging of Compiler-Optimised Code: Ill-Posed, but Not Impossible

authors:
Stephen Kell
J. Ryan Stinnett

abstract: Debuggability and optimisation are traditionally regarded as in fundamental tension. This paper disputes that idea, arguing instead that it is possible to compile programs such that they are both fully source-level-debuggable and fully optimised, and that the essential problem to be solved is loss of state. Although these two properties are usually not achievable at the same time, it argues the feasibility of providing the desired one 'on demand', and that metadata-based approaches extended with residual state can do so in a manner that generalises beyond dynamic deoptimisation. Correctness of debugging metadata is introduced as an ill-posed problem, a partial correctness criterion is proposed, and further approaches are discussed.


title: The Meerkat Vision: Language Support for Live, Scalable, Reactive Web Apps

authors:
João Costa Seco
Jonathan Aldrich

abstract: The reactive programming paradigm has become ubiquitous for modern web and mobile app development. But despite its many benefits, today reactive programming is limited to data updates within the client, leaving to the programmer the tedious and error-prone tasks of managing updates to code and synchronizing data updates between reactive clients and a server database. In this paper, we lay out the vision for Meerkat, a tierless, reactive, and live programming language designed to scale to the needs of modern applications. We introduce the language through a chat application which runs on our prototype implementation. We then describe approaches for modularizing and scaling Meerkat programs, customizing tradeoffs between properties such as consistency and availability, supporting local-first software and rich data models, and scaling live updates to full DevOps in software organizations. The Meerkat research program will enable a new era of developing apps that are more responsive, reliable, and evolvable than ever before.


title: Talking to Objects in Natural Language: Toward Semantic Tools for Exploratory Programming

authors:
Christoph Thiede
Marcel Taeumel
Lukas Böhme
Robert Hirschfeld

abstract: In exploratory programming, programmers often face a semantic gap between their high-level understanding and the low-level interfaces available for interacting with objects in a system. That is, technical object structure and behavior need to be interpreted as abstract domain concepts, which then increases cognitive load and thus impedes exploration progress. We propose semantic object interfaces that bridge this gap by enabling contextual, natural-language conversations with objects. Our approach leverages an exploratory programming agent powered by a large language model (LLM) to translate natural-language questions into low-level experiments and provide high-level answers. We describe a framework for integrating semantic object interfaces into existing exploratory programming systems, including a prototype implementation in Squeak/Smalltalk using GPT-4o. We showcase the potential of semantic object interfaces through case studies and discuss their feasibility, limitations, and impact on the programming experience. While challenges remain, our approach promises to reduce mental effort and empower programmers to explore and understand systems at a higher level of abstraction for a better programming experience.


title: Software Engineering Methods for AI-Driven Deductive Legal Reasoning

abstract: The recent proliferation of generative artificial intelligence (AI) technologies such as pre-trained large language models (LLMs) has opened up new frontiers in computational law. An exciting area of development is the use of AI to automate the deductive rule-based reasoning inherent in statutory and contract law. This paper argues that such automated deductive legal reasoning can now be viewed from the lens of software engineering, treating LLMs as interpreters of natural-language programs with natural-language inputs. We show how it is possible to apply principled software engineering techniques to enhance AI-driven legal reasoning of complex statutes and to unlock new applications in automated meta-reasoning such as mutation-guided example generation and metamorphic property-based testing.


title: Scimitar: Functional Programs as Optimization Problems

authors:
Nate F. F. Bragg
Jeffrey S. Foster
Philip Zucker

abstract: Mixed integer linear programming is a powerful and widely used approach to solving optimization problems, but its expressiveness is limited. In this paper we introduce the optimization-aided language Scimitar, which encodes optimization problems using an expressive functional language, with a compiler that targets a mixed integer linear program solver. Scimitar provides easy access to encoding techniques that normally require expert knowledge, enabling solve-time conditional constraints, inlining, loop unrolling, and many other high-level language constructs. We give operational semantics for Scimitar and constraint encodings of various features. To demonstrate Scimitar, we present a number of examples and benchmarks including classic optimization domains and more complex problems. Our results indicate that Scimitar's use of a dedicated MILP solver is effective for expressively modeling optimization problems embedded within functional programs.


title: Beyond Procedure Calls as Component Glue: Connectors Deserve Metaclass Status

authors:
Marcel Weiher
Marcel Taeumel
Robert Hirschfeld

abstract: We present the architecture-oriented programming language Objective-S, which goes beyond procedure calls for expressing inter-component connectors (so-called glue code) in order to directly express a wide range of architectural patterns directly in the implementation. Previous approaches for encoding architecture require either indirection, maintaining separate architectural descriptions, or both. Expressing the architecture directly in the implementation instead of indirectly avoids the problems associated with creating and maintaining duplicate representations. Objective-S introduces syntactic elements that let us express many architectural connections directly using a simple surface syntax. These surface elements are supported by a metaobject protocol of polymorphic connectors. The key insight of our approach is that while so-called general-purpose programming languages do lack the ability to express most architectural concerns directly, as shown by previous research, this is not an inherent limitation. With Objective-S, we take connectors that already exist in implementation languages, such as data access or procedure calls and make them polymorphic using a metaobject protocol. This metaobject protocol enables polymorphic connection using glue code at the metaobject level that is both generic and mostly hidden from the surface language.


title: Abstract Debuggers: Exploring Program Behaviors using Static Analysis Results

authors:
Karoliine Holter
Juhan Oskar Hennoste
Patrick Lam
Simmo Saan
Vesal Vojdani

abstract: Traditional, or concrete, debuggers allow developers to step through programs and explore the corresponding concrete program states—developers can query current values of program variables. This exploration enables developers to formulate and refine hypotheses about program behaviors. We propose the novel notion of abstract debuggers, which allow developers to explore abstract program states, as computed by sound static analyzers. Giving developers the ability to interactively explore abstract states empowers them to work with hypotheses that are true for all program executions: they can examine and rule out false positives, or better understand a static analysis’s declaration that some code is indeed safe. Abstract debuggers’ interfaces, reminiscent of conventional debuggers, aim to make navigating and interpreting static analysis results more straightforward. We have formalized the concept, applied it by implementing a tool that leverages the static analyzer Goblint, and illustrate its usefulness through case studies.


title: A Programming Language for Data and Configuration!

abstract: A day in the life of a developer often involves more time working with schemas, configurations, and data description systems than writing code and logic in a classical programming language. As more systems move into distributed worlds, e.g. cloud and microservices, and developers make increasing use of libraries and frameworks, the need to interact with a range of data formats and configuration mechanisms is only increasing. This is a treacherous world, where a misspelled property name or missing field can render an entire service inoperable, a mistake that a number in an API represents seconds instead of milli-seconds can lead to a message being set for delivery in several months instead of in an hour, misconfigured schema can lead to public exposure of sensitive data, and corrupt or erroneous results from a misunderstood data format could result in massive financial and/or reputational damage. To address these challenges this paper casts the problems of data and configuration descriptions, not as a problem of data representation, but as a type system problem, that can be addressed with well understood and highly effective programming language techniques! The novel challenge is that data representation and configuration are universal concerns in a system and, particularly in modern cloud or micro-service systems, these systems may involve many programming languages. In the past this has led to specification systems that use a least-common-denominator set of data types, often little more than strings and numbers, and then rely on conventions or (out-of-date) documentation to ensure that the data is interpreted correctly. This paper shows that, with careful design, it is possible to create a rich universal system that can be used to express data and configuration specifications in a way that is human readable/writable and that can be produced/consumed, much like JSON, by a wide range of programming languages and systems.


title: Synchronous Programming for Kids: A Manifesto

abstract: Many primary school age children find developing games and interactive animations very motivating, and this has been successfully leveraged by several educational programming environments. However, most of these environments, like Scratch and Microsoft MakeCode, are fundamentally based on imperative, Pascal-style programming languages with ad-hoc support for concurrency and events. I argue that this style of programming language, and the burden of encoding state machines that it imposes, does not match the children's intuitions, and is therefore discouraging. Instead, I propose re-founding these tools around synchronous programming languages like Esterel, which, by being centered around the concepts of time, sequential composition, concurrency, signalling, and preemption, match the children's intuitions. I describe a prototype implementation, and argue how using such a programming language would enable schoolchildren to express their intuitions more directly.


title: Semantics-Preserving Transformation of Context-Free Grammars into LL(1) Form

abstract: Transformation of context-free grammars into LL(1) form enables construction of simple and efficient parsers. However, if semantics are overlooked, the transformation is likely to result in a complex grammar that needs to be manually aligned with the original semantics. This work presents a method of semantics-preserving grammar transformation into LL(1) form using a representation based on trees. Grammar rules and their semantics are modelled as typed tree nodes, which enables elimination of LL(1) conflicts while retaining the original semantics. Transformed grammars can be used to construct continuation-passing style parsers that produce parse trees matching the original grammar. It is shown how this approach can be applied to the design of domain-specific languages in Java, resulting in size and type complexity linear in the size of the transformed grammar.


title: ScooPy: Enhancing Program Synthesis with Nested Example Specifications

authors:
Tomer Katz
Hila Peleg

abstract: Current IDE-integrated program synthesis leaves no indication of what code was auto-generated, let alone an explanation of why. This makes both identifying and understanding machine-generated code hard. We therefore add example scopes, comments enclosing synthesized code that document the input-output examples that created it. This also allows programmers to manually edit examples and re-launch the synthesizer without tediously re-entering the examples. Scopes are simply text, and so can be created anywhere, including inside other scopes. However, synthesizers can only reason about one flat example set. To address this, we introduce ScooPy, IDE-integrated program synthesis for nested example specifications. ScooPy lets programmers edit example scopes, see live information based on the examples, and call the synthesizer on nested scopes. In two user studies with 6 and 16 participants we see that example scopes increase users’ engagement with the code and that ScooPy improves users’ ability to synthesize for some types of tasks.


title: Foundational Design Principles and Patterns for Building Robust and Adaptive GenAI-Native Systems

abstract:
Generative AI (GenAI) has emerged as a transformative technology, demonstrating remarkable capabilities across diverse application domains. However, GenAI faces several major challenges in developing reliable and efficient GenAI-empowered systems due to its unpredictability and inefficiency. This paper advocates for a paradigm shift: future GenAI-native systems should integrate GenAI's cognitive capabilities with traditional software engineering principles to create robust, adaptive, and efficient systems.

We introduce foundational GenAI-native design principles centered around five key pillars---reliability, excellence, evolvability, self-reliance, and assurance---and propose architectural patterns such as GenAI-native cells, organic substrates, and programmable routers to guide the creation of resilient and self-evolving systems. Additionally, we outline the key ingredients of a GenAI-native software stack and discuss the impact of these systems from technical, user adoption, economic, and legal perspectives, underscoring the need for further validation and experimentation. Our work aims to inspire future research and encourage relevant communities to implement and refine this conceptual framework.


title: Sharing Is Scaring: Linking Cloud File-Sharing to Programming Language Semantics

authors:
Skyler Austen
Shriram Krishnamurthi
Kathi Fisler

abstract:
Users often struggle with cloud file-sharing applications. Problems appear to arise not only from interface flaws, but also from misunderstanding the underlying semantics of operations like linking, attaching, downloading, and editing. We argue that these difficulties echo long-standing challenges in understanding concepts in programming languages like aliasing, copying, and mutation.

We begin to examine this connection through a formative user study investigating general users’ understanding of file sharing. Our study casts known misconceptions from the programming-education literature into semantically-similar cloud file-sharing tasks. It also uses tasks that echo two kinds of analyses used in programming-education: tracing and programming. Our findings reveal widespread misunderstandings across several tasks.

We also develop a formal semantics of cloud file-sharing operations, reflecting copying, referencing, and mutating shared content. By explicating the semantics, we aim to provide a formal foundation for improving mental models, educational tools, and automated assistance. This semantics can support applications including trace checking, workflow synthesis, and interactive feedback.


title: An Argument for the Practicality of Entity Component Systems as the Primary Data Structure for an Interpreter or Compiler

authors:
Joshua Dahl
Frederick C. Harris

abstract: In this paper, we examine how Entity Component Systems, a data structure that has been gaining popularity in game engines, can benefit compiler and interpreter design. ECS does not consistently provide the same performance benefits that games utilize it for; however, it does make writing optimization passes easier. Additionally, its dogmatic focus on simple Plain-Old-Data structures makes serialization much easier. These benefits do come at a memory cost, the severity of which we still need to compare against more mature language implementations.


title: X-by-Construction: Towards Ensuring Non-functional Properties in by-Construction Engineering

authors:
Maximilian Kodetzki
Tabea Bordis
Alex Potanin
Ina Schaefer

abstract: Correctness-by-Construction engineering (CbC) is a refinement-based approach to develop functionally correct programs based on a formal specification. By correctly applying refinement rules during development, CbC enables detection of bugs during program construction, unlike post-hoc verification, which proves correctness only after implementation. Support for CbC engineering for non-functional properties is summarized under the term X-by-Construction (XbC). However, current XbC approaches are limited to information flow properties, leaving other non-functional properties of software quality, such as performance or reliability, unsupported. To address this gap, we present our vision for generalizing XbC to integrate non-functional properties into by-Construction engineering. In this way, we leverage the development of high-quality software through a refinement-based approach for future software engineering. With that, it will become possible to develop software ensuring that it not only exhibits functional correctness, but also non-functional guarantees by construction. Further, we propose ideas for ensuring energy efficiency in by-Construction engineering. We assess what it needs to integrate non-functional properties into by-Construction engineering and discuss arising challenges.


title: On Collective Control over User Interfaces in the Face of Network Effects

authors:
Caleb Malchik
Joan Feigenbaum

abstract: User interfaces for accessing modern Internet services are increasingly defined by the services themselves, leaving users with little control over the interfaces they use on a daily basis. This architecture and the economic drive to monetize users’ activity has lead to a status quo that falls short in key areas of user concern, with interfaces exhibiting undesirable features such as dark patterns, distracting ads, and pop-ups. The Platform for Content-Structure Inference (PCSI, pronounced “pixie”) supports new applications that resist these features by giving users control over their interfaces and allows new applications to overcome network effects by integrating existing web content. This strategy of client-driven interoperability is demonstrated in the news reader application PCSINews. In concert with user organizations such as data co-ops, PCSI could enable evolutionary advancement toward a better Internet characterized by a fairer balance of power between users and service providers.


title: Exploring the Design Space for Runtime Enforcement of Dynamic Capabilities

authors:
Andrew Fawcet
James Noble
Michael Homer

abstract:
Dala is an "as simple as possible" concurrent object-oriented language designed to avoid data races. Dala objects come in three safe flavours: immutable, isolated, and local, plus a fourth unsafe flavour. The objects are organised into an hierarchy so that e.g. immutable objects can be accessed from anywhere but never mutated, while thread local objects can be mutated but cannot be accessed outside their containing thread.

Dala's flavours are intended to be enforced at runtime: unfortunately it is not clear when and how best to undertake that enforcement.

In this paper we present six axes of variation for the dynamic enforcement of Dala flavours: when each safe flavour is enforced, how isolated objects are moved, how new objects are assigned a flavour, and whether objects' flavours can change over time. These six axes embody 2,880 different combinations: we present five exemplary designs and discuss how they are placed on those those axes. Programming language designers can use our analysis to inform the design of dynamic capabilities in their languages, while the analysis may also help programmers understand what language designers have done.


title: Literate Tracing

abstract: As computer systems grow ever larger and more complex, a crucial task in software development is for one person (the system expert) to communicate to another (the system novice) how a certain program works. This paper reports on the author’s experiences with a paradigm for program documentation that we call literate tracing. A literate trace explains a software system using annotated, concrete execution traces of the system. Literate traces complement both in-code comments (which often lack global context) and out-of-band design docs (which often lack a concrete connection to the code). We also describe TReX, our tool for making literate traces that are interactive, visual, and guaranteed by construction to be faithful to the program semantics. We have used TReX to write literate traces explaining components of large systems software including the Linux kernel, Git source control system, and GCC compiler.


title: TideScript: A Domain Specific Language for Peptide Chemistry

authors:
Nicholas Morris
Blair Archibald
S. Hessam M. Mehr

abstract: Synthetic peptides are becoming increasingly important in industry and academia, including applications in peptide-based therapeutics. While Solid Phase Peptide Synthesis (SPPS) is largely automated, current software options for describing this process are instrument-specific, with no unifying standard protocol specification. Post-synthesis modification of peptides in the solution phase is also performed manually. As a result, discovery and process optimisation remains an iterative and manual process, requiring large amounts of human intervention and labour. Here we introduce TideScript: a domain specific language for peptide chemistry. TideScript aims to provide a programming language to standardize protocol descriptions, allowing unambiguous specification, increased automation, and autonomous optimization. At present, TideScript is a formal specification language, with scope to expand into full execution on hardware. We give a full description of TideScript, including its syntax and a small-step operational semantics, and show how TideScript can encode three common peptide protocols: peptide chain assembly by SPPS, peptide cleavage and thiol-maleimide conjugation. We compare this approach to existing non-peptide-specific chemical protocol languages, χDL and BioScript.


title: What You See Is What It Does: A Structural Pattern for Legible Software

authors:
Eagon Meng
Daniel Jackson

abstract:
The opportunities offered by LLM coders (and their current limitations) demand a reevaluation of how software is structured. Software today is often “illegible”—lacking a direct correspondence between code and observed behavior—and insufficiently modular, leading to a failure of three key requirements of robust coding: incrementality (the ability to deliver small increments by making localized changes), integrity (avoiding breaking prior increments) and transparency (making clear what has changed at build time, and what actions have happened at runtime).

A new structural pattern offers improved legibility and modularity. Its elements are concepts and synchronizations: fully independent services and event-based rules that mediate between them. A domain-specific language for synchronizations allows behavioral features to be expressed in a granular and declarative way (and thus readily generated by an LLM). A case study of the RealWorld benchmark is used to illustrate and evaluate the approach.


title: Carving Text at Its Joints: A New Perspective on Writing and Computers

abstract: Multilingual computer text handling appears at present unapproachably difficult. Despite considerable progress made over the past three decades, major open problems remain in encoding, interactively editing, programmatically transforming, and displaying text in many of the world's writing systems. These challenges are especially pronounced with regard to ancient and minority or minoritized writing systems and are exacerbated by antiquated, retrofitted software and standards. In this paper, I offer a genealogical critique of how computer scientists have approached human writing hitherto, a new, clarifying perspective on writing as it relates to computers, and a sketch of how the problems I identify herein could be addressed.


title: Gauguin, Descartes, Bayes: A Diurnal Golem’s Brain

authors:
Kartik Chandra
Amanda Liu
Jonathan Ragan-Kelley
Joshua B. Tenenbaum

abstract: A "quine" is a deterministic program that prints itself. In this essay, I will show you a "gauguine": a probabilistic program that infers itself. A gauguine is repeatedly asked to guess its own source code. Initially, its chances of guessing correctly are of course minuscule. But as the gauguine observes more and more of its own previous guesses, it detects patterns of behavior and gains information about its inner workings. This information allows it to bootstrap self-knowledge, and ultimately discover its own source code. We will discuss how—and why—we might write a gauguine, and what we stand to learn by constructing one.


title: Let’s Take Esoteric Programming Languages Seriously

authors:
Jeremy Singer
Steve Draper

abstract: Esoteric programming languages are challenging to learn, but their unusual features and constraints may serve to improve programming ability. From languages designed to be intentionally obtuse (e.g. INTERCAL) to others targeting artistic expression (e.g. Piet) or exploring the nature of computation (e.g. Fractan), there is rich variety in the realm of esoteric programming languages. This essay examines the counterintuitive appeal of esoteric languages and seeks to analyse reasons for this popularity. We will explore why people are attracted to esoteric languages in terms of (a) program comprehension and construction, as well as (b) language design and implementation. Our assertion is that esoteric languages can improve general PL awareness, at the same time as enabling the esoteric programmer to impress their peers with obscure knowledge. We will also consider pedagogic principles and the use of AI, in relation to esoteric languages. Emerging from the specific discussion, we identify a general set of 'good' reasons for designing new programming languages. It may not be possible for anyone to be exhaustive on this topic, and it is certain we have not achieved that goal here. However we believe our most important contribution is to draw more attention to the varied and often implicit motivations involved in programming language design.


title: The Unix Executable as a Smalltalk Method: And Its Implications for Unix-Smalltalk Unification

abstract: Unix and Smalltalk are very different in the details, but bear curious similarities in their broad outlines. Prior work has made these comparisons at a high level and sketched a path for retrofitting Smalltalk's advantages onto Unix (without compromising the advantages of the latter). Everybody seems to agree on identifying the Unix file with the Smalltalk object, but this still leaves much unspecified. I argue that we should identify the Unix executable with the Smalltalk method. A Smalltalk VM implementation via the filesystem falls out quite easily from this premise; however, the severe overhead associated with Unix processes casts doubt on its practical realisation. Nevertheless, we can see several ways around this problem. The connection shows promise for realising the benefits of Smalltalk within Unix without sequestering the former in a hermetically sealed image and VM.


title: The Proof Must Go On: Formal Methods in the Theater of Secure Software Development of the Future

abstract:
Formal Methods (FM) will not arrive with fanfare. It will spread quietly, not as a revolution, but as a patch: reviewed, merged, and dismissed. In the coming century, the decades-old practice of simply testing code will collapse under the weight of cyberattacks and development complexity.

It is succeeded by a slower, more methodical approach as FM becomes infrastructure. Verified C libraries thread their way into the systems that run the internet. Model checkers embed themselves in CI pipelines. Modern type systems reach the masses. AI and IO remain stubbornly unverifiable and insecure, forcing industry to work towards a deeper form of trust. Meanwhile, a generation of developers learns to write specifications not as a niche academic exercise, but as a matter of professional survival.

This paper tells a fictional, yet historically-grounded, story of how formal verification goes from lofty fantasy to invisible standard throughout the century, and how, without anyone noticing, the proof goes on.


venue: oopsla

title: A Smalltalk System for Algebraic Manipulation

authors:
S. Kamal Abdali
Guy W. Cherry
Neil Soiffer

abstract: This paper describes the design of an algebra system Views implemented in Smalltalk. Views contains facilities for dynamic creation and manipulation of computational domains, for viewing these domains as various categories such as groups, rings, or fields, and for expressing algorithms generically at the level of categories. The design of Views has resulted in the addition of some new abstractions to Smalltalk that are quite useful in their own right. Parameterized classes provide a means for run-time creation of new classes that exhibit generally very similar behavior, differing only in minor ways that can be described by different instantiations of certain parameters. Categories allow the abstraction of the common behavior of classes that derives from the class objects and operations satisfying certain laws independently of the implementation of those objects and operations. Views allow the run-time association of classes with categories (and of categories with other categories), facilitating the use of code written for categories with quite different interpretations of operations. Together, categories and views provide an additional mechanism for code sharing that is richer than both single and multiple inheritance. The paper gives algebraic as well as non-algebraic examples of the above-mentioned features.


title: Experience with Flamingo: A Distributed, Object-Oriented User Interface System

abstract: The Flamingo Window Management System is based on a remote method invocation mechanism that provides separate processes running in a heterogeneous, distributed computing environment with complete access to Flamingo's objects and methods. This object-oriented interface has made Flamingo a kernel window manager into which device drivers, graphics libraries, window managers and user interfaces can be dynamically loaded. This paper discusses the strengths and weaknesses of Flamingo's system architecture, and introduces a new architecture which will provide a network-wide object space with object protection, migration, and garbage collection.


title: The Future of Object-Oriented Languages - Panel

authors:
Jim Anderson
Nori Suzuki
Alan Borning
Mark Stefik
Dave A. Thomas
Henry Lieberman


title: Hurricane: An Optimizing Compiler for Smalltalk

abstract: We discuss a recent attempt at providing a more efficient compilation system for the Smalltalk-80™ language than currently exists. The approach is unique in that it attempts to work within the existing semantics of the language. A type declaration and inference mechanism is developed in order to make the problem tractable. Details concerning the compiler implemented to date are given, as well as preliminary speed tests of compiled object code.


title: Quicktalk: A Smalltalk-80 Dialect for Defining Primitive Methods

authors:
Mark B. Ballard
David Maier
Allen Wirfs-Brock

abstract: QUICKTALK is a dialect of Smalltalk-80 that can be compiled directly into native machine code, instead of virtual machine bytecodes. The dialect includes “hints” on the class of method arguments, instance variables, and class variables. We designed the dialect to describe primitive Smalltalk methods. QUICKTALK achieves improved performance over bytecodes by eliminating the interpreter loop on bytecode execution, by reducing the number of message send/returns via binding some target methods at compilation, and by eliminating redundant class checking. We identify changes to the Smalltalk-80 system and compiler to support the dialect, and give performance measurements.


title: Virtual Instruments: Object-Oriented Program Synthesis

authors:
K. S. Bhaskar
J. K. Pecol
James L. Beug

abstract: Virtual Instruments1 is an experimental programming environment for developing electronic test and measurement (T&M) applications. Intended users are test engineers, who are not programmers, but computer literate domain specialists. Unlike traditional programming environments, that provide weak support for a broad range of applications, virtual instruments provides strong support for a specific application. The programming paradigm is bottom-up synthesis of layers of virtual machines — called virtual instruments — using human interface models from the application domain, so that software development occurs without writing code. The object-oriented view of the world has proven a natural fit. Implementation was in Berkeley Smalltalk on a SUN workstation.


title: Object Structure in the Emerald System

authors:
Andrew P. Black
Norman C. Hutchinson
Eric Jul
Henry M. Levy

abstract: Emerald is an object-based language for the construction of distributed applications. The principal features of Emerald include a uniform object model appropriate for programming both private local objects and shared remote objects, and a type system that permits multiple user-defined and compiler-defined implementations. Emerald objects are fully mobile and can move from node to node within the network, even during an invocation. This paper discusses the structure, programming, and implementation of Emerald objects, and Emerald's use of abstract types.


title: CommonLoops: Merging Lisp and Object-Oriented Programming

authors:
Daniel G. Bobrow
Kenneth M. Kahn
Gregor Kiczales
Larry Masinter
Mark Stefik
Frank Zdybel


title: An Object-Oriented Architecture for Intelligent Tutoring Systems

authors:
Jeffrey Bonar
Robert K. Cunningham
Jamie Schultz

abstract: We describe an object-oriented architecture for intelligent tutoring systems. The architecture is oriented around objects that represent the various knowledge elements that are to be taught by the tutor. Each of these knowledge elements, called bites, inherits both a knowledge organization describing the kind of knowledge represented and tutoring components that provide the functionality to accomplish standard tutoring tasks like diagnosis, student modeling, and task selection. We illustrate the approach with several tutors implemented in our lab.


title: Object-Oriented Programming without an Object-Oriented Language - Panel

authors:
Grady Booch
Ed Seidewitz
Mike Start
Donald Firesmith


title: Petri Net-Based Object-Oriented Modeling of Distributed Systems

authors:
Giorgio Bruno
Alessandro Balsamo

abstract: This paper presents an object-oriented approach for building distributed systems. An example taken from the field of computer integrated manufacturing systems is taken as a guideline. According to this approach a system is built up through three steps: control and synchronization aspects for each class of objects are treated first using PROT nets, which are a high-level extension to Petri nets; then data are introduced specifying the internal states of the objects as well as the messages they send each other; finally the connections between the objects are introduced by means of a data flow diagram between classes. The implementation uses ADA as the target language, exploiting its tasking and structuring mechanisms. The flexibility of the approach and the possibility of using a knowledge-based user interface promote rapid prototyping and reusability.


title: Pi: A Case Study in Object-Oriented Programming

abstract: Pi is a debugger written in C + +. This paper explains how object-oriented programming in C + + has influenced Pi's evolution. The motivation for object-oriented programming was to experiment with a browser-like graphical user interface. The first unforeseen benefit was in the symbol table: lazy construction of an abstract syntax-based tree gave a clean interface to the remainder of Pi, with an efficient and robust implementation. Next, though not in the original design, Pi was easily modified to control multiple processes simultaneously. Finally, Pi was extended to control processes executing across multiple heterogeneous target processors.


title: A Third Generation Smalltalk-80 Implementation

authors:
Patrick J. Caudill
Allen Wirfs-Brock


title: Architectural Support for Object-Oriented Programming - Panel


title: User Interface Frameworks - Panel

authors:
Brad Cox
L. Peter Deutsch
Lawrence G. Tesler
Marilyn Setlzner
Ron Duisberg


title: A Diagram for Object-Oriented Programs

authors:
Ward Cunningham
Kent L. Beck

abstract: We introduce a notation for diagramming the message sending dialogue that takes place between objects participating in an object-oriented computation. Our representation takes a global point of view which emphasizes the collaboration between objects implementing the behavior of individuals. We illustrate the diagram's usage with examples drawn from the Smalltalk-80™ virtual image. We also describe a mechanism for automatic construction of diagrams from Smalltalk code.


title: A Probe-Based Monitoring Scheme for an Object-Oriented Distributed Operating System

abstract: article Free Access Share on A probe-based monitoring scheme for an object-oriented distributed operating system Author: Partha Dasgupta Georgia Tech Georgia TechView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 21Issue 11Nov. 1986 pp 57–66https://doi.org/10.1145/960112.28704Online:01 June 1986Publication History 13citation436DownloadsMetricsTotal Citations13Total Downloads436Last 12 Months9Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF


title: Design of a Distributed Object Manager for the Smalltalk-80 System

abstract: This paper describes the design of a distributed object manager which allows several Smalltalk-80 systems to share objects over a local-area network. This object manager is based on the following principles: location transparency and uniform object naming, unique object representation and use of symbolic links for remote access, possibility of object migration and distributed garbage collection. A version of the object manager has been implemented and is currently being integrated on a two nodes configuration.


title: An Object-Oriented Operating System Interface

abstract: This paper discusses an object-oriented interface from the Smalltalk-80™ programming environment to a Unix-like operating system. This interface imposes an object-oriented paradigm on operating system facilities. We discuss some of the higher order abstractions that were created to make use of these facilities, and discuss difficulties we encountered implementing this interface. Several examples of cooperating Smalltalk and operating system processes are presented.


title: An Experience with a Prolog-based Object-Oriented Language

authors:
Koichi Fukunaga
Shin'ichi Hirose

abstract: This paper presents an experience with a programming language SPOOL which is based on the combination of object-oriented programming and logic programming. This language inherits the capability of knowledge base organization from object-oriented programming and its expressive power from logic programming.


title: Building a Timeline Editor from Prefab Parts: The Architecture of an Object-Oriented Application

authors:
L. Nancy Garrett
Karen E. Smith


title: A Simple Technique for Handling Multiple Polymorphism

abstract: Certain situations arise in programming that lead to multiply polymorphic expressions, that is, expressions in which several terms may each be of variable type. In such situations, conventional object-oriented programming practice breaks down, leading to code which is not properly modular. This paper describes a simple approach to such problems which preserves all the benefits of good object-oriented programming style in the face of any degree of polymorphism. An example is given in Smalltalk-80 syntax, but the technique is relevant to all object-oriented languages.


title: A Concurrent Object-Oriented Knowledge Representation Language Orient84/K: Its Features and Implementation

authors:
Yutaka Ishikawa
Mario Tokoro

abstract: Orient84/K is an object oriented concurrent programming language for describing knowledge systems. In Orient84/K, an object is composed of the behavior part, the knowledge-base part, and the monitor part, in order to provide object-oriented, logic-based, demon-oriented, and concurrent-programming paradigms in the object framework. Every object is capable of concurrent execution in Orient84/K.


title: An Object-Oriented Approach to a Large Scientific Application

authors:
Jonathan Jacky
Ira Kalet

abstract: We used an object-oriented design to build a large scientific application: simulation of radiation therapy treatments for cancer. We provide features familiar in the graphics workstation world, including graphic editing of the proposed treatment, multiple views of the treatment in different windows, and computations which proceed concurrently as the input data are being edited. To make our system practical for the typical clinic we used a popular minicomputer and the vendor's operating system and compiler. This paper describes how we implemented objects, inheritance, message passing, windows, and concurrency in (almost) standard Pascal on a VAX under VMS.


title: Language Support for Changeable Large Real Time Systems

abstract: A set of concepts for modeling large real time systems is discussed informally. The concepts support the design of centralized as well as distributed systems. They are object oriented in that they correspond to entities of the 'real world', and they are 'change oriented' in that they support not only the first development stage of a system but also its continuous change and evolution. In particularly, the concepts give a promising solution to 'on the fly' changes of existing, active entities.


title: Type-Checking Smalltalk

abstract: Although most attempts to speed-up Smalltalk have focused on providing more efficient interpreters, code optimization is probably necessary for further increases in speed. A type-system for Smalltalk is a prerequisite for building an optimizing compiler. Unfortunately, none of the type-systems so far proposed for Smalltalk are adequate; they either cause nearly all Smalltalk programs to be type incorrect, allow run-time type errors, or do not provide enough information for optimization. This paper presents a type-system for Smalltalk that is suitable for code optimization.


title: Mach and Matchmaker: Kernel and Language Support for Object-Oriented Distributed Systems

authors:
Michael B. Jones
Richard F. Rashid

abstract: Mach, a multiprocessor operating system kernel providing capability-based interprocess communication, and Matchmaker, a language for specifying and automating the generation of multi-lingual interprocess communication interfaces, are presented. Their usage together providing a heterogeneous, distributed, object-oriented programming environment is described. Performance and usage statistics are presented. Comparisons are made between the Mach/Matchmaker environment and other related systems. Possible future directions are examined.


title: Virtual Memory on a Narrow Machine for an Object-Oriented Language

abstract: LOOM (Large Object-Oriented Memory) is a virtual memory implemented in software that supports the Smalltalk-80(™) programming language and environment on the Xerox Dorado computer. LOOM provides 8 billion bytes of secondary memory address space and is specifically designed to run on computers with a narrow word size (16-bit wide words). All storage is viewed as objects that contain fields. Objects may have an average size as small as 10 fields. LOOM swaps objects between primary and secondary memory, and addresses each of the two memories with a different sized object pointer. When objects are cached in primary memory, they are known only by their short pointers. On a narrow word size machine, the narrow object pointers in primary memory allow a program such as the Smalltalk-80 interpreter to enjoy a substantial speed advantage. Interesting design problems and solutions arise from the mapping between the two address spaces and the temporary nature of an object's short address. The paper explains why the unusual design choices in LOOM were made, and provides an interesting example of the process of designing an integrated virtual memory and storage management system.


title: Objects in Concurrent Logic Programming Languages

authors:
Kenneth M. Kahn
Eric Dean Tribble
Mark S. Miller
Daniel G. Bobrow

abstract: Concurrent Prolog supports object-oriented programming with a clean semantics and additional programming constructs such as incomplete messages, unification, direct broadcasting, and concurrency synchronization [Shapiro 1983a]. While it provides excellent computational support, we claim it does not provide good notation for expressing the abstractions of object-oriented programming. We describe a preprocessor that remedies this problem. The resulting language, Vulcan, is then used as a behicle for exploring new variants of object-oriented programming which become possible in this framework.


title: Object Identity

authors:
Setrag Khoshafian
George P. Copeland

abstract: Identity is that property of an object which distinguishes each object from all others. Identity has been investigated almost independently in general-purpose programming languages and database languages. Its importance is growing as these two environments evolve and merge.


title: An Exemplar Based Smalltalk

authors:
Wilf R. LaLonde
Dave A. Thomas
John R. Pugh


title: Oaklisp: an Object-Oriented Scheme with First Class Types

authors:
Kevin J. Lang
Barak A. Pearlmutter

abstract: The Scheme papers demonstrated that lisp could be made simpler and more expressive by elevating functions to the level of first class objects. Oaklisp shows that a message based language can derive similar benefits from having first class types.


title: Swamp: A Fast Processor for Smalltalk-80

authors:
David M. Lewis
David R. Galloway
Robert J. Francis
Brian W. Thomson

abstract: A processor for the Smalltalk-80↑ programming language is described. This machine is implemented using a standard bit slice ALU and sequencer, TTL MSI, and NMOS LSI RAMS. It executes an instruction set similar to the Smalltalk-80 virtual machine instruction set. The data paths of the machine are optimized for rapid Smalltalk-80 execution by the inclusion of a context cache, tag checking, and a hardware method cache. Each context is only partly initialized when created, and has no memory allocated for it until a possibly non-LIFO reference to it is created. The machine is microprogrammed, and uses a simple next micro-address prediction strategy to obtain most of the performance of pipelining without the attendant complexity. The machine can execute simple instructions at over 7M bytecodes per second and has a predicted average throughput of 1.9M bytecodes per second.


title: Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems


title: Development of an Object-Oriented DBMS

authors:
David Maier
Jacob Stein
Allen Otis
Alan Purdy

abstract: We describe the results of developing the GemStone object-oriented database server, which supports a model of objects similar to that of Smalltalk-80. We begin with a summary of the goals and requirements for the system: an extensible data model that captures behavioral semantics, no artificial bounds on the number or size of database objects, database amenities (concurrency, transactions, recovery, associative access, authorization) and an interactive development environment. Object-oriented languages, Smalltalk in particular, answer some of these requirements. We discuss satisfying the remaining requirements in an object oriented context, and report briefly on the status of the development efforts. This paper is directed at an audience familiar with object-oriented languages and their implementation, but perhaps unacquainted with the difficulties and techniques of database system development. It updates the original report on the project [CM], and expands upon a more recent article [MDP].


title: Boolean Classes

authors:
David A. McAllester
Ramin Zabih

abstract: We extend the notion of class so that any Boolean combinations of classes is also a class. Boolean classes allow greater precision and conciseness in naming the class of objects governed a particular method. A class can be viewed as a predicate which is either true or false of any given object. Unlike predicates however classes have an inheritance hierarchy which is known at compile time. Boolean classes extend the notion of class, making classes more like predicates, while preserving the compile time computable inheritance hierarchy.


title: Genericity versus Inheritance

abstract: Genericity, as in Ada or ML, and inheritance, as in object-oriented languages, are two alternative techniques for ensuring better extendibility, reusability, and compatibility of software components.This article is a comparative analysis of these two methods.It studies their similarities and differences and assesses to what extent each may be simulated in a language offering only the other.It shows what features are needed to successfully combine the two approaches in an object-oriented language that also features strong type checking.The discussion introduces the principal aspects of the language EiffePM whose design, resulting in part from this study, includes multiple inheritance and a limited form of genericity under full static typing. OVERVIEWDespite its name, today's software is usually not soft enough: adapting it to new uses turns out in most cases to be a harder endeavor than should be.It is thus essential to find ways of enhancing such software quality factors as extendibility (the ease


title: Intermedia: The Architecture and Construction of an Object-Oriented Hypermedia System and Applications Framework

abstract: This article presents a case study of the development of the Intermedia system, a large, object-oriented hypermedia system and associated applications development framework providing sophisticated document linkages. First it presents the educational and technological objectives underlying the project. Subsequent sections capture the process of developing the Intermedia product and detail its architecture and construction, concentrating on the areas in which object-oriented technology has had a significant role. Finally, the successes and failures of the development approach are examined, and several areas of standardization and research that would enhance the process are proposed.


title: The Application Accelerator Illustration System

authors:
Michael S. Miller
Howard Cunningham
Chan Lee
Steven R. Vegdahl


title: Virtual Copies - At the Boundary Between Classes and Instances

authors:
Sanjay Mittal
Daniel G. Bobrow
Kenneth M. Kahn

abstract: Knowledge bases built in object-oriented systems use networks of interconnected objects in their representations. The mechanism described here provides a way to use such a network as a prototype by making virtual copies of it. The virtual copy is created incrementally. Values of instance variables in the virtual copy are inherited from the prototype until locally overridden in the copy, similar to inheritance of defaults between instances and classes in Loops. A virtual copy preserves the topology of the original network. Virtual copies can be made from virtual copies. Alternative implementations of virtual copies allow different tradeoffs in space and lookup time. Virtual copies can be used for building knowledge bases for design, for representing contexts in a problem solving system, and have other uses in ordinary programming.


title: Object-Oriented Programming with Flavors

abstract: This paper describes Symbolics' newly redesigned object-oriented programming system, Flavors. Flavors encourages program modularity, eases the development of large, complex programs, and provides high efficiency at run time. Flavors is integrated into Lisp and the Symbolics program development environment. This paper describes the philosophy and some of the major characteristics of Symbolics' Flavors and shows how the above goals are addressed. Full details of Flavors are left to the programmers' manual, Reference Guide to Symbolics Common Lisp. (5)


title: The Learnability of Object-Oriented Programming Systems - Panel

authors:
Tim O'Shea
Jent Beck
Dan Halbert
Kurt J. Schmucker


title: Augmentation of Object-Oriented Programming by Concepts of Abstract Data Type Theory: The ModPascal Experience

abstract: Object-oriented programming and abstract data type (ADT) theory have emerged from the same origin of computer science: the inability to deal efficiently with 'programming in the large' during the early seventies. Each of the approaches has led to significant practical and theoretical results resp. Nevertheless it is still unsatisfactory that up to now the mutual influence seems to be limited to more or less syntactical issues (e.g. the provision of packages, clusters, forms).


title: Encapsulators: A New Software Paradigm in Smalltalk-80

abstract: Certain situations arise in programming that lead to multiply polymorphic expressions, that is, expressions in which several terms may each be of variable type. In such situations, conventional object-oriented programming practice breaks down, leading to code which is not properly modular. This paper describes a simple approach to such problems which preserves all the benefits of good object-oriented programming style in the face of any degree of polymorphism. An example is given in Smalltalk-80 syntax, but the technique is relevant to all object-oriented languages.


title: Object Oriented Spreadsheets: The Analytic Spreadsheet Package

abstract: The ASP package, a spreadsheet implemented in Smalltalk-80, is discussed. A description of the unique data manipulation features of ASP is given. A discussion of how these features arise from the Smalltalk-80 environment is included, with emphasis on features not common to all object oriented languages.


title: SOAR: Smalltalk Without Bytecodes

authors:
A. Dain Samples
David M. Ungar
Paul N. Hilfinger

abstract: We have implemented Smalltalk-80 on an instruction-level simulator for a RISC microcomputer called SOAR. Measurements suggest that even a conventional computer can provide high performance for Smalltalk-80 by abandoning the 'Smalltalk Virtual Machine' in favor of compiling Smalltalk directly to SOAR machine code, linearizing the activation records on the machine stack, eliminating the object table, and replacing reference counting with a new technique called Generation Scavenging. In order to implement these techniques, we had to find new ways of hashing objects, accessing often-used objects, invoking blocks, referencing activation records, managing activation record stacks, and converting the virtual machine images.


title: An Alternative to Subclassing

abstract: Smalltalk-80 obtains some of its expressive power from arranging classes in a hierarchy. Inheritance is an important aspect of this hierarchy. An alternative organization of classes is proposed that emphasizes description instead of inheritance. This alternative can be used with compile-time type checking and retains the important characteristics of Smalltalk's hierarchy.


title: An Introduction to Trellis/Owl

authors:
Craig Schaffert
Topher Cooper
Bruce Bullis
Mike Killian
Carrie Wilpolt


title: The Management of Changing Types in an Object-Oriented Database

authors:
Andrea H. Skarra
Stanley B. Zdonik

abstract: We examine the problem of type evolution in an objectoriented database environment.Type definitions are persistent objects in the database and as such may be modified and shared.The effeets of changing a type extend to objects of the type and to programs that use objeets of the type.We propese a solution to the problem through an extension of the semantic data model.A ehange in the interfaee defined by a type may result in errors when programs use new or old objects of the type.Through the use of an abstraction of the type over time, timestamping and error handling mechanisms provide support for the type designer in creating compatible versions of the type.The mechanisms are incorporated Into the behavior defined by the type and are inherited via the type-lattice.


title: Impulse-86: A Substrate for Object-Oriented Interface Design

authors:
Reid G. Smith
Rick Dinitz
Paul Barth

abstract: Impulse-86 provides a general and extensible substrate upon which to construct a wide variety of interactive user interfaces for developing, maintaining, and using knowledge-based systems. The system is based on five major building blocks: Editor, Editor Window, PropertyDisplay, Menu, and Operations. These building blocks are interconnected via a uniform framework and each has a well-defined set of responsibilities in an interface.


title: Encapsulation and Inheritance in Object-Oriented Programming Languages

abstract: Object-oriented programming is a practical and useful programming methodology that encourages modular design and software reuse. Most object-oriented programming languages support data abstraction by preventing an object from being manipulated except via its defined external operations. In most languages, however, the introduction of inheritance severely compromises the benefits of this encapsulation. Furthermore, the use of inheritance itself is globally visible in most languages, so that changes to the inheritance hierarchy cannot be made safely. This paper examines the relationship between inheritance and encapsulation and develops requirements for full support of encapsulation with inheritance.


title: Moving Structures between Smalltalk Images

abstract: There are a number of reasons why a user might want to move data structures between Smalltalk images. Unfortunately, the facilities for doing this in the standard Smalltalk image are inadequate: they do not handle circular structures properly, for example. We have implemented a collection of Smalltalk methods that handles circular structures; in addition, these methods have a number of other advantages over those provided in the standard image. This paper is largely a discussion of the issues that arose during their design, implementation, and use.


title: A Distributed Repository for Immutable Persistent Objects

abstract: Jasmine is an object-oriented system for programming-in-the-large. Jasmine describes software using system model objects. These objects are persistent (they have lifetimes of days or decades) and immutable (since system models act as historical records). This paper describes JStore, a distributed, replicated repository for system model objects. JStore provides robust, transactional, write-once storage.


title: Object-Oriented Programming for Product Development - Panel

authors:
Bob Wilhelm
Peggy Poggio
Evelyn Van Orden
Richard Jones
Hamid Eghbalnia
Tom Love


title: The Design and Implementation of ConcurrentSmalltalk

authors:
Yasuhiko Yokote
Mario Tokoro

abstract: ConcurrentSmalltalk is a programming language/system which incorporates the facilities of concurrent programming in Smalltalk-801. Such facilities are realized by providing concurrent constructs and atomic objects. This paper first gives an outline of ConcurrentSmalltalk. Then, the design of ConcurrentSmalltalk is described. The implementation of ConcurrentSmalltalk is presented in detail.


title: Object-Oriented Concurrent Programming in ABCL/1

authors:
Akinori Yonezawa
Jean-Pierre Briot
Etsuya Shibayama

abstract: An object-oriented computation model is presented which is designed for modelling and describing a wide variety of concurrent systems. In this model, three types of message passing are incorporated. An overview of a programming language called ABCL/1, whose semantics faithfully reflects this computation model, is also presented. Using ABCL/1, a simple scheme of distributed problem solving is illustrated. Furthermore, we discuss the reply destination mechanism and its applications. A distributed “same fringe” algorithm is presented as an illustration of both the reply destination mechanism and the future type message passing which is one of the three message passing types in our computation model.


title: Painless Panes for Smalltalk Windows

abstract: Current windowing systems (i.e., Macintosh, Smalltalk) give the user flexibility in the layout of their computer display, but tend to discourage construction of new window types. Glazier is a knowledge-based tool that allows users to construct and test novel or special purpose windows for Smalltalk applications.


title: Combining Language and Database Advances in an Object-Oriented Development Environment

authors:
Tim Andrews
Craig Harris

abstract: Object-oriented languages generally lack support for persistent objects—that is objects that survive the process or programming session. On the other hand, database systems lack the expressibility of object-oriented languages. Both persistence and expressibility are necessary for production application development.This paper presents a brief overview of VBASE, an object-oriented development environment that combines a procedural object language and persistent objects into one integrated system. Language aspects of VBASE include strong datatyping, a block structured schema definition language, and parameterization, or the ability to type members of aggregate objects. Database aspects include system support for one-to-one, one-to-many, and many-to-many relationships between objects, an inverse mechanism, user control of object clustering in storage for space and retrieval efficiency, and support for trigger methods.Unique aspects of the system are its mechanisms for custom implementations of storage allocation and access methods of properties and types, and free operations, that is operations that are not dispatched according to any defined type.During the last several years, both languages and database systems have begun to incorporate object features. There are now many object-oriented programming languages. [Gol1983, Tes1985, Mey 1987, Cox 1986, Str 1986]. Object-oriented database management systems are not as prevalent yet, and sometimes tend to use different terms (Entity-Relationship, Semantic Data Model), but they are beginning to appear on the horizon [Cat1983, Cop1984, Ston1986, Mylo1980]. However, we are not aware of any system which combines both language and database features in a single object-oriented development platform. This is essential since a system must provide both complex data management and advanced programming language features if it is to be used to develop significant production software systems. Providing only one or the other is somewhat akin to providing half a bridge: it might be made structurally sound, perhaps, but it is not particularly useful to one interested in getting across the river safely.Object-oriented languages have been available for many years. The productivity increases achievable through the use of such languages are well recognized. However, few serious applications have been developed using them. One reason has been performance, though this drawback is being eliminated through the development of compiled object languages. The remaining major negative factor, in our view, is the lack of support for persistence; the lack of objects that survive the processing session and provide object sharing among multiple users of an application.Database management systems, in contrast, suffer from precisely the opposite problem. While having excellent facilities for managing large amounts of data stored on mass media, they generally support only limited expression capabilities, and no structuring facilities.Both language and database systems usually solve this problem by providing bridges between the systems. Thus the proliferation of 'embedded languages', allowing language systems to access database managers. These bridges are usually awkward, and still provide only restricted functionality. Both performance and safety can be enhanced through a tighter coupling between the data management and programming language facilities.It is this lack of a truly integrated system which provided our inspiration at Ontologic, Inc. This paper reviews Ontologic's VBASE Integrated Object System and describes how it combines language and database functionality.


title: Using Objects To Design and Build Radar ESM Systems

authors:
Brian M. Barry
John R. Altoft
Dave A. Thomas
Mike Wilson

abstract: This paper describes the application of object-oriented programming to the design of a multiprocessor ESM testbed. The ESM testbed uses an object-oriented development environment which integrates Smalltalk and C language tools with the Harmony real-time operating system in a shared memory multiprocessor. All development for an application is done using personal computers which are themselves processors in the real-time testbed. We first discuss two aspects of the ESM testbed: a framework for investigating ESM signal processing algorithms based on an object-oriented emitter database and blackboard objects which implement probabilistic reasoning; and an object-oriented ESM simulation environment which illustrates the use of object-oriented techniques for the development of complex real-time systems. In the second part of the paper we describe our software engineering approach and tools. Throughout the paper, the role played by object-oriented programming in the design of hybrid multiprocessors is highlighted.


title: The Design and Implementation of Distributed Smalltalk

abstract: Distributed Smalltalk (DS) is an implementation of Smalltalk that allows objects on different machines to send and respond to messages. It also provides some capability for sharing objects among users. The distributed aspects of the system are largely user transparent and preserve the reactive quality of Smalltalk objects. Distributed Smalltalk is currently operational on a network of Sun workstations. The implementation includes an incremental distributed garbage collector and support for remote debugging, access control, and object mobility. This paper concentrates on the important design issues encountered and some of the more interesting implementation details. Performance measurements of the current implementation are included.


title: Some Experiments In Object-Oriented Simulation

abstract: Discrete event simulation has been a constant source of inspiration for language designers. The present interest in Object-Oriented Programming (O.O.P.) can be traced back to the Simula 67 language. In return, simulation languages are currently getting back many advantages from the ongoing research in O.O.P. One of the main present research trends is the possibility of concurrently executing a simulation program composed of a set of interacting and communicating objects. Conditions which will make this possible are discussed together with some induced problems. More precisely this paper presents some experiments in object-oriented simulation that reveal the great flexibility of the Smalltalk-801 programming system for building evaluation environments.


title: Issues in the Design of Object-Oriented Database Programming Languages

authors:
Toby Bloom
Stanley B. Zdonik

abstract: We see a trend toward extending object-oriented languages in the direction of databases, and, at the same time, toward extending database systems with object-oriented ideas. On the surface, these two activities seem to be moving in a consistent direction. However, at a deeper level, we see difficulties that may inhibit their ending up at the same point. We feel that many of these difficulties are a result of the underlying assumptions that are inherent in the fields of programming language and database systems research. Many of these assumptions are historical and contribute to a set of cultural biases that often prevent the two communities from interacting as effectively as possible.


title: Constraint Hierarchies

authors:
Alan Borning
Robert Duisberg
Bjørn N. Freeman-Benson
Axel Kramer
Michael Woolf

abstract: Constraints describe relations that must be maintained, and provide a useful tool for such applications as interactive simulations, algorithm animation, and graphical user interface construction. We describe a major overhaul and extension to the constraint satisfaction mechanism in ThingLab, a constraint-oriented simulation laboratory written in the Smalltalk-80 language. First, a specification is presented of constraint hierarchies. Such hierarchies include both required constraints and default constraints of differing strengths, thus adding considerable expressive power to the system. Second, an algorithm for satisfying constraint hierarchies is described. The new satisfier is substantially faster than the previous version, even though it also includes new functionality.


title: CLAM - an Open System for Graphical User Interfaces

authors:
Lisa A. Call
David L. Cohrs
Barton P. Miller

abstract: CLAM is an object-oriented system designed to support the building of extensible graphical user interfaces. CLAM provides a basic windowing environment with the ability to extend its functions using dynamically loaded C++ classes. The dynamically loaded classes allow for performance tuning (by transparently loading the class in either the client or the CLAM server) and for sharing of new functions.


title: An Information System Based on Distributed Objects

abstract: The Telesophy system is intended to provide transparent access to all of a community's online information. The scale of the system requires that it be distributed across many machines via a network; the multiple types and formats of the information require that it be a multimedia system. We describe a prototype that uses objects to represent, query, display, and edit information. A two-level storage system is used to store the objects on multiple servers; queries are processed by indexing servers layered on top of the storage system. New media types and new indexing schemes can be added simply by defining new classes within the existing framework.


title: Metaclasses are First Class: the ObjVlisp Model

abstract: This paper shows how an attempt at a uniform and re-flective definition resulted in an open-ended system sup-porting ObjVlisp, which we use to simulate object-oriented language extensions. We propose to unify Smalltalk classes and their terminal instances. This unification allows us to treat a class as a “first class citizen”, to give a circular definition of the first metaclass, to access to the metaclass level and finally to control the instantiation link. Because each object is an instance of another one and because a metaclass is a real class inheriting from another one, the metaclass links can be created indefinitely. This uniformity allows us to define the class variables at the metalevel thus suppressing the Smalltalk- ambiguity between class variables and instance variables: in our model the instance variables of a class are the class variables of its instances.


title: Producer: A Tool for Translating Smalltalk-80 to Objective-C

authors:
Brad J. Cox
Kurt J. Schmucker

abstract: Source to source translation tools provide a way of integrating the strengths of production programming environments like C/UNIX™ with rapid prototyping environments like Smalltalk-80™ into a comprehensive hybrid environment that spans more of the software development life-spiral than ever before. This paper describes a tool-assisted process for translating Smalltalk-80 programs into Objective-C™, and shows how the tool, called Producer, is used in practice. To assist others in using this translation tool, we have made Producer publicly available without charge on USENET.


title: An Object-Oriented Design System Shell

authors:
Jim Diederich
Jack Milton

abstract: We present a design system shell which can be used to experiment with principles of design and be used as a design tool where complex layers of information need to be specified about objects, such as in database design. The shell can be tailored to a variety of application areas. It is object-oriented in its implementation and structure. Objects and messages are used as the specification language. The basic ingredients of a rule-based production system are provided, with rules treated as objects and defined independently of the classes to which they are applied.


title: Retrofitting Objects

abstract: I present the results of an experiment in retrofitting objects into an existing system. I describe a technology, based on automatic redefinition of existing functions, that allowed alternative implementations of the fundamental data types of the KEE™ knowledge-based system building tool. This technology is applicable in environments where the system's procedures can be subject to programmatic manipulation. It allows the retrofitting of objects into the implementations of other existing systems. The experience of retrofitting objects into KEE provides insight into the issues of the interaction of semantic classes and data representation and granularity in object-based systems.1


title: RAPID: Prototyping Control Panel Interfaces

abstract: RAPID is a design environment to support human factors specialists in designing user interfaces for small control panels. RAPID permits modeling of both the appearance and behavior of operator interfaces. Its main goal is to allow exploration of a greater number of design alternatives by decreasing the time and effort required to generate and evaluate those alternatives. It is a graphically-based system intended to be used by non-programmers. RAPID is implemented in Smalltalk-80.


title: Mentat: An Object-Oriented Macro Data Flow System

authors:
Andrew S. Grimshaw
Jane W.-S. Liu

abstract: Mentat, an object-oriented macro data flow system designed to facilitate parallelism in distributed systems, is presented.The macro data flow model is a model of computation similar to the data flow model with two principle differences: the computational complexity of the actors is much greater than in traditional data flow systems, and there are persistent actors that maintain state information between executions.Mentat is a system that combines the object-oriented programming paradigm and the macro data flow model of computation.Mentat programs use a dynamic structure called a future list to represent the future of computations.


title: Logical Composition of Object-Oriented Interfaces

authors:
Mark Grossman
Raimund K. Ege

abstract: This paper describes an approach to object-oriented interface design that goes beyond mere object decomposition. In our user interface management system we use logic and filters to declaratively specify and control a space of ways that objects may be composed to create interfaces. A filter is a package of constraints and associated typed objects that express the relationship of data and representation objects.Conceptually our system is completely based on constraints. Filters provide the high bandwidth constraints to maintain the components of the direct-manipulation interface while the logic forms the low bandwidth constraints to combine and provide communication between these components. The use of Horn-clause logic to compose separate interface objects facilitates both the distribution of computation onto multiple processors and the generation of multiple views of data. Intelligent backtracking implemented in the logic allows for user- and system-initiated undo operations to correct errors and/or try alternative approaches to a problem. We illustrate the power and flexibility of this approach by describing a floor layout and design system.


title: ManiplIcons in ThinkerToy

abstract: ThinkerToy is a graphical environment for modeling decision support problems. It provides a tableau on which such problems as landscape planning, service scheduling, and statistical analysis can be modeled and analyzed. Normally, complex mathematical and statistical modeling techniques are needed to perform meaningful analysis. ThinkerToy uses graphical icons with concrete physical properties to replace mathematical relationships and properties. The key construct in this methodology is the ManiplIcon: an icon which is not just a pictorial representation, but also a semantic tool for building models which homorphically represent semi-structured problems.


title: OTM: Applying Objects to Tasks

authors:
John Hogg
Steven Weiser

abstract: OTM is a concurrent object language presently being implemented at the University of Toronto. It provides a novel, simple and powerful way of structuring tasks or collections of operations. This paper describes the concurrency control features of OTM, which include external termination of tasks. An example demonstrates how the language can be used to cleanly and concisely control cooperating objects.


title: Object Oriented Development in an Industrial Environment

abstract: Object-oriented programming is a promising approach to the industrialization of the software development process. However, it has not yet been incorporated in a development method for large systems. The approaches taken are merely extensions of well-known techniques when 'programming in the small' and do not stand on the firm experience of existing developments methods for large systems. One such technique called block design has been used within the telecommunication industry and relies on a similar paradigm as object-oriented programming. The two techniques together with a third technique, conceptual modeling used for requirement modeling of information systems, have been unified into a method for the development of large systems.


title: MELDing Data Flow and Object-Oriented Programming

authors:
Gail E. Kaiser
David Garlan

abstract: MELD combines concepts from data flow and object-oriented programming languages in a unique approach to tool reusability. MELD provides three units of abstraction — equations, classes and features — that together allow sufficient options for granularity and encapsulation to support the implementation of reusable tools and the composition of existing tools in parallel (i.e., interleaved) as well as in series.


title: Experience with CommonLoops

authors:
James Kempf
Warren Harris
Roy D'Souza
Alan Snyder

abstract: CommonLoops is an object-oriented language embedded in Common Lisp. It is one of two such languages selected as starting points for the Common Lisp Object System (CLOS) which is currently being designed as a standard object-oriented extension to Common Lisp. This paper reports on experiences using the existing Portable CommonLoops (PCL) implementation of CommonLoops. The paper is divided into two parts: a report on the development of a window system application using the CommonLoops programming language, and a description of the implementation of another object-oriented language (CommonObjects) on top of the CommonLoops metaclass kernel, paralleling the two aspects of CommonLoops: the programming language and the metaclass kernel. Usage of the novel features in CommonLoops is measured quantitatively, and performance figures comparing CommonLoops, CommonObjects on CommonLoops, and the native Lisp implementation of CommonObjects are presented. The paper concludes with a discussion about the importance of quantitative assessment for programming language development.


title: Teaching Object-Oriented Programming with the KEE System

authors:
Renate Kempf
Marilyn Stelzner

abstract: Successful learning of an object-oriented programming style is greatly facilitated by a flexible, window-oriented interface and a “step-by-step” instructional methodology. Specifically, students can benefit from a learning sequence moving from working with object hierarchies to working with objects with behavior to more complex problems (conditional or sequential message passing, automation of behavior). Within each area in turn, a step-by-step approach of learning by conceptualization, learning by analogy, learning by experience, and learning by reinforcement is suggested. This is demonstrated using examples from the training of the KEE® Knowledge Engineering Environment™.


title: Use of Object-Oriented Programming in a Time Series Analysis System

authors:
R. K. Kerr
Donald B. Percival

abstract: We describe the use of object-oriented programming (OOP) in the design and implementation of TSA, a system for interactive time series and spectral analysis. We show how such features of OOP as inheritance, generic messages, and decomposition of the programming problem in terms of objects have contributed to our goal of providing an extensible data analysis system. We discuss the strengths and limitations of both OOP and the particular implementation we used (Flavors on a Symbolics Lisp Machine) for our particular problem.


title: Composite Object Support in an Object-Oriented Database System

authors:
Won Kim
Jay Banerjee
Hong-Tai Chou
Jorge F. Garza
Darrell Woelk

abstract: Many applications in such domains as computer-aided design require the capability to define, store and retrieve as a single unit a collection of related objects known as a composite object. A composite object explicitly captures and enforces the IS-PART-OF integrity constraint between child and parent pairs of objects in a hierarchical collection of objects. Further, it can be used as a unit of storage and retrieval to enhance the performance of a database system.


title: Opus: A Smalltalk Production System

authors:
Jane Laursen
Robert G. Atkinson

abstract: Opus is a tool for rule-based programming which integrates a production system paradigm with the Smalltalk-80 environment. Opus currently provides a data-driven production system that allows the programmer considerable freedom, including access to the full functionality of the Smalltalk-80 language, and the ability to match rules with arbitrary objects in the environment. We present the goals for the design, a description of the system and its implementation, and discuss issues raised by this approach.


title: Parallel Programming in a Virtual Object Space

abstract: Sloop is a parallel language and environment that employs an object-oriented model for explicit parallel programming of MIMD multiprocessors. The Sloop runtime system transforms a network of processors into a virtual object space. A virtual object space contains a collection of objects that cooperate to solve a problem. Sloop encapsulates virtual object space semantics within the object type domain. This system-defined type provides an associative, asynchronous method by which one object gains access to another. It also provides an operation for specifying groups of objects that should, for efficiency, reside on the same physical processor, and supports exploitation of the topology of the underlying parallel machine. Domains also support the creation of indivisible objects, which provide implicit concurrency control. The encapsulation of these semantics within an object gives the programmer the power to construct an arbitrary hierarchy of virtual object spaces, facilitating debugging and program modularity. Sloop implementations are running on a bus-based multiprocessor, a hypercube multiprocessor, and on a heterogeneous network of workstations. The runtime system uses object relocation heuristics and coroutine scheduling to attain high performance.


title: Concepts and Experiments in Computational Reflection

abstract: This paper brings some perspective to various concepts in computational reflection. A definition of computational reflection is presented, the importance of computational reflection is discussed and the architecture of languages that support reflection is studied. Further, this paper presents a survey of some experiments in reflection which have been performed. Examples of existing procedural, logic-based and rule-based languages with an architecture for reflection are briefly presented. The main part of the paper describes an original experiment to introduce a reflective architecture in an object-oriented language. It stresses the contributions of this language to the field of object-oriented programming and illustrates the new programming style made possible. The examples show that a lot of programming problems that were previously handled on an ad hoc basis, can in a reflective architecture be solved more elegantly.

awards: Most Influential OOPSLA Paper (1986-1996 retrospective)


title: Transparent Forwarding: First Steps

abstract: Traditional object-oriented systems tend to be single-user. As we move from personal to interpersonal computing, we must look for ways to extend our programming paradigms. This research extends the Smalltalk-80 system to send messages transparently to objects residing on remote machines. We discuss two models for remote message sends, describe our current implementation, and suggest areas for future research.


title: A Pragmatic System for Shared Persistent Objects

authors:
Thomas Merrow
Jane Laursen

abstract: This paper describes a system for sharing information in the form of objects among users of the Smalltalk-80 programming environment. The system, called Coral3, is pragmatic in that it was developed to meet the needs of specific applications. This paper describes the expectations for the system, presents factors influencing the design, outlines the implementation of Coral3, and raises questions about object-oriented database systems in general.


title: INSIST: Interactive Simulation in Smalltalk

abstract: A functional simulator/editor for VLSI design has been implemented in the Smalltalk-801 system. Users can explore their designs in an highly interactive and graphical manner with “close-to-reality” tools. The traditional sequence of editing, compiling and simulating the circuit is avoided. During editing, functional Modules can immediately respond to new connections. The simulator, called INSIST, strongly supports hierarchical simulation and design up to gate level. Hardware descriptions of the design can be generated for other CAD systems. From these descriptions layout has been generated. A RISC chip was entered and simulated at three hierarchical levels containing more than 50 Modules.


title: A Law-Based Approach to Object-Oriented Programming

authors:
Naftaly H. Minsky
David Rozenshtein

abstract: The central idea behind this paper is that the discipline governing the exchange of messages between objects should be specifiable by the programmer in the form of an explicit law of the system. We show how, starting from a very primitive foundation, which presumes neither encapsulation nor inheritance, one can establish various forms of both, as well as other useful disciplines, simply by means of appropriate laws.


title: BrouHaHa - A Portable Smalltalk Interpreter

abstract: BrouHaHa is a portable implementation of the Smalltalk-80 virtual machine interpreter. It is a more efficient redesign of the standard Smalltalk specification, and is tailored to suit conventional 32 bit microprocessors. This paper presents the major design changes and optimization techniques used in the BrouHaHa interpreter. The interpreter runs at 30% of the speed of the Dorado on a Sun 3/160 workstation. The implementation is portable because it is written in C.


title: Active Objects in Hybrid

abstract: Most object-oriented languages are strong on reusability or on strong-typing, but weak on concurrency. In response to this gap, we are developing Hybrid, an object-oriented language in which objects are the active entities. Objects in Hybrid are organized into domains, and concurrent executions into activities. All object communications are based on remote procedure-calls. Unstructured sends and accepts are forbidden. To this the mechanisms of delegation and delay queues are added to enable switching and triggering of activities. Concurrent subactivities and atomic actions provided for compactness and simplicity. We show how solutions to many important concurrent problems, such a pipelining, constraint management and “administration” can be compactly expressed using these mechanisms.


title: The Trellis Programming Environment

authors:
Patrick D. O'Brien
Daniel C. Halbert
Michael F. Kilian

abstract: The Trellis programming environment supports programming in Trellis/Owl, an object-based language with multiple inheritance and compile-time type-checking. Trellis is composed of a number of integrated tools that share a common programming environment database. It is a highly interactive, easy-to-use programming environment, providing various programming aids, incremental compilation, and good debugging support. Trellis is both integrated and open-ended.


title: Class Modification in the GemStone Object-Oriented DBMS

authors:
D. Jason Penney
Jacob Stein

abstract: We are currently designing a class modification methodology for GemStone. We describe the current status of the design. We choose from two basic approaches and then introduce those aspects of GemStone necessary for an understanding of the paper. After defining a set of invariants for GemStone databases, we discuss specific class modification operations in terms of maintaining these invariants. We next discuss several issues that impact class modification. These issues include concurrency and authorization, and lead to difficult choices.