title: Relations as Semantic Constructs in an Object-Oriented Language

abstract: The relation as a semantic construct in an object-oriented language clearly expresses associations and constraints among objects which would otherwise be buried in implementation code. The externalization of references between objects permits a symmetric, non-redundant conceptual model which merits its own special notation and predefined operations. The object-relation model, which combines the object-oriented model with the entity-relationship model from data base theory, is particularly useful for designing and partitioning systems of interrelated objects. Relations can be implemented efficiently using hash tables. The model proposed here has been fully implemented in an object-oriented language written by the author which has been used to implement several production applications.


venue: oopsla

title: Object-Oriented Programming in Smalltalk and ADA

abstract: Though Ada and Modula-2 are not object-oriented languages, an object-oriented viewpoint is crucial for effective use of their module facilities. It is therefore instructive to compare the capabilities of a modular language such as Ada with an archetypal object-oriented language such as Smalltalk. The comparison in this paper is in terms of the basic properties of encapsulation, inheritance and binding, with examples given in both languages. This comparison highlights the strengths and weaknesses of both types of languages from an object-oriented perspective. It also provides a basis for the application of experience from Smalltalk and other object-oriented languages to increasingly widely used modular languages such as Ada and Modula-2.


title: Intermedia: A Case Study of the Differences Between Relational and Object-Oriented Database Systems

authors:
Karen E. Smith
Stanley B. Zdonik

abstract: This paper compares two approaches to meeting the data handling requirements of Intermedia, a hypermedia sysfem developed at fhe institute for Research in information and Scholarship at Brown Universify. Intermedia, though wriffen using an object-oriented programming language, relies on a traditional relafional database management system for data storage and retrieval. We examine the ramifications of replacing the relational database with an object-oriented database. We begin by describing the important characteristics each database system. We then describe Intermedia and give an overview of its architecture and its dafa handling requirements. We explain why and how we used a relational database management system and the problems that we encountered with this system. We then present the design of art objectodenfed database schema for Intermedia and compare the relational and object-oriented dafabase management system approaches. 1. lNTRODUCTlON The Institute for Research in Information and


title: Delegation Is Inheritance

abstract: Inheritance and delegation are alternate methods for incremental definition and sharing. It has commonly been believed that delegation provides a more powerful model. This paper demonstrates that there is a “natural” model of inheritance which captures all of the properties of delegation. Independently, certain constraints on the ability of delegation to capture inheritance are demonstrated. Finally, a new framework which fully captures both delegation and inheritance is outlined, and some of the ramifications of this hybrid model are explored.


title: Modules and Type Checking in PL/LL

abstract: The type system of a programming language system PL/LL is described. PL is a simple object oriented programming language and LL is a language for composing PL modules into programs. The goals of the PL/LL system are to enable the programming of efficient object-oriented computations and to provide the powerful linking language LL for facilitating the construction of large programs. The goal of the type system is to ensure efficient and secure object handling through a combination of static and dynamic type checking, and to preserve this property across module boundaries. The solution is based on (i) the module and linking concepts of LL, (ii) a language construct in PL for the safe creation of linked data structures, and (iii) a limited form of type polymorphism and type unification.


title: Self: The Power of Simplicity

authors:
David M. Ungar
Randall B. Smith

abstract: Self is a new object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables and procedures into a single construct. This permits the inheritance hierarchy to take over the function of lexical scoping in conventional languages. Finally, because Self does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures. Self's simplicity and expressiveness offer new insights into object-oriented computation.

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


title: Dimensions of Object-Based Language Design

abstract: The design space of object-based languages is characterized in terms of objects, classes, inheritance, data abstraction, strong typing, concurrency, and persistence. Language classes (paradigms) associated with interesting subsets of these features are identified and language design issues for selected paradigms are examined. Orthogonal dimensions that span the object-oriented design space are related to non-orthogonal features of real languages. The self-referential application of object-oriented methodology to the development of object-based language paradigms is demonstrated.


title: Experience and Evolution of ConcurrentSmalltalk

authors:
Yasuhiko Yokote
Mario Tokoro

abstract: ConcurrentSmalltalk is an object-oriented concurrent programming language/system which has been running since late 1985. ConcurrentSmalltalk has the following features:


title: An Object-Oriented Framework for Interactive Data Graphics

abstract: Ida is an object-oriented framework for interactive data graphics. It can be used for independent data examination or integrated into application user interfaces. Ida's model of graphics is composed of five basic elements: Presentations, Assemblies, Data Sources, Data Displays, and Scales. Presentations and assemblies address display layout. A sharp distinction is maintained between drawing and the management of already drawn images. Data sources are responsible for drawing while data displays are image managers. Data displays are complex structures consisting of multiple layers that may be larger than the visible regions they underlie. Scales represent coordinate transformations. An object-oriented architecture proves valuable in supporting taxonomic hierarchies with inheritance, part-whole structures for composition, message passing implementation of graphic operations and late attribute binding.


title: Data Abstraction Mechanisms in SINA/ST

authors:
Mehmet Aksit
Anand R. Tripathi

abstract: This paper describes a new data abstraction mechanism in an object-oriented model of computing. The data abstraction mechanism described here has been devised in the context of the design of Sina/st language. In Sina/st no language constructs have been adopted for specifying inheritance or delegation, but rather, we introduce simpler mechanisms that can support a wide range of code sharing strategies without selecting one among them as a language feature. Sina/st also provides a stronger data encapsulation than most of the existing object-oriented languages. This language has been implemented on the SUN 3 workstation using Smalltalk.


title: Transformation of Data Flow Analysis Models to Object-Oriented Design

abstract: This paper describes a strategy to transform Data Flow Analysis into Object Oriented Design. This transformation is performed by extracting information from the Data Flow Model, by enriching with Design decision and by finally producing an Object Oriented Design Model. Semiformal transformation rules are described. Also a special notation is introduced to describe the Object Oriented Design Model. The Model used to represent Data Flow Analysis is the one originally proposed by Yourdon, complemented with Ward-Mellor's Real Time extensions (the “Essential Model”).


title: Panel: Experiences with Reusability

authors:
Kent L. Beck
Raghu Raghavan
Wilf R. LaLonde
Daniel Weinreb


title: Intensional Concepts in an Object Database Model

abstract: There is a requirement for a stronger treatment of intentional concepts and more general inferential ability within database systems. A framework for achieving this will be described in terms of extensions to an object data model.


title: An Execution Model for Distributed Object-Oriented Computation

authors:
Edward H. Bensley
Thomas J. Brando
Myra Jean Prelle

abstract: This paper describes an execution model being developed for distributed object-oriented in a message-passing multiple-instruction/multiple-data-stream (MIMD) environment. The objective is to execute an object-oriented program as concurrently as possible. Some opportunities for concurrency can be identified explicitly by the programmer. Others can be identified at compile time. There are some opportunities for concurrency, however, that can only be discovered at runtime because they are data-dependent. The model of execution we describe attempts to discover and exploit the data-dependent concurrency that exists in a given program execution.


title: AVANCE: An Object Management System

authors:
Anders Björnerstedt
Stefan Britts

abstract: AVANCE1 is an integrated application development and run-time system. It provides facilities for programming with shared and persistent objects, transactions and processes. The architecture is designed with decentralization in mind by having a large object identifier space and a remote procedure call interface to objects. Emphasis in this paper is on the programming language PAL and its relation with the underlying virtual machine.


title: A Performance Comparison of Object and Relational Databases Using the Sun Benchmark

authors:
Joshua Duhl
Craig Damon

abstract: A general concern about object-oriented systems has been whether or not they are able to meet the performance demands required to be useful for the development of significant production software systems. Attempts to evaluate this assertion have been hampered by a lack of meaningful performance benchmarks that compare database operations across different kinds of databases.


title: A Smalltalk Window System Based on Constraints

authors:
Danny Epstein
Wilf R. LaLonde

abstract: We describe the design of a constraint-based window system for Smalltalk. This window system uses constraints to specify attributes of windows and relationships between them. Three classes of constraints are supported, one of which is implicit and not available for general use. The system extends the current Smalltalk system, providing support for both fixed-size and fixed-scale windows. It also provides the capability to dynamically reorganize the layout of a window. A goal of the design is to produce a system with real-time response that is fast enough to be substituted for the existing system. A prototype with response times of approximately 1/4 second has been implemented to demonstrate the feasibility of the design as well as to point out several important optimizations.


title: Fabrik: A Visual Programming Environment

authors:
Dan Ingalls
Scott Wallace
Yu-Ying Chow
Frank Ludolph
Ken Doyle

abstract: Fabrik is a visual programming environment - a kit of computational and user-interface components that can be “wired” together to build new components and useful applications. Fabrik diagrams utilize bidirectional dataflow connections as a shorthand for multiple paths of flow. Built on object-oriented foundations. Fabrik components can compute arbitrary objects as outputs. Music and animation can be programmed in this way and the user interface can even be extended by generating graphical structures that depend on other data. An interactive type system guards against meaningless connections. As with simple dataflow, each Fabrik component can be compiled into an object with access methods corresponding to each of the possible paths of data propagation.


title: TS: An Optimizing Compiler for Smalltalk

authors:
Ralph E. Johnson
Justin O. Graver
Lawrence W. Zurawski

abstract: TS (Typed Smalltalk) is a portable optimizing compiler that produces native machine code for a typed variant of Smalltalk, making Smalltalk programs much faster. This paper describes the structure of TS, the kinds of optimizations that it performs, the constraints that it places upon Smalltalk, the constraints placed upon it by an interactive programming environment, and its performance.


title: Integrating an Object-Oriented Programming System with a Database System

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

abstract: There are two major issues to address to achieve integration of an object-oriented programming system with a database system. One is the language issue: an object-oriented programming language must be augmented with semantic data modeling concepts to provide a robust set of data modeling concepts to allow modeling of entities for important real-world applications. Another is the computational-model issue: application programmers should be able to access and manipulate objects as though the objects are in an infinite virtual memory; in other words, they should not have to be aware of the existence of a database system in their computations with the data structures the programming language allows. This paper discusses these issues and presents the solutions which we have incorporated into the ORION object-oriented database system at MCC.


title: GraphTrace - Understanding Object-Oriented Systems Using Concurrently Animated Views

authors:
Michael F. Kleyn
Paul C. Gingrich

abstract: Object-Oriented programming is a powerful means of developing large complex systems. In this paper we address the need to understand the behavior of objects in order to facilitate code sharing and reusability. We describe GraphTrace, a tool we have developed that has allowed us to experiment with new ways of visualizing the dynamic behavior of object-oriented programs. Based on our experience with the GraphTrace tool we suggest that being able to present many different views of an object-oriented system and then animating these views concurrently represents a powerful means for understanding such systems.


title: Building a Backtracking Facility in Smalltalk Without Kernel Support

authors:
Wilf R. LaLonde
Mark Van Gulik

abstract: Languages like Snobol, Prolog, and Icon were designed with backtracking facilities from the outset and these facilities are deeply intertwined with the implementation. Retrofitting a backtracking facility in a language that wasn't designed for it has never been achieved. We report on an experiment to retrofit Smalltalk with a backtracking facility. The facility is provided through a small number of primitives written in the language (no modifications to the kernel were made). The ability to do this is a direct result of the power provided by the objectification of contexts.


title: Object-Oriented Programming: An Objective Sense of Style

authors:
Karl J. Lieberherr
Ian M. Holland
Arthur J. Riel

abstract: We introduce a simple, programming language independent rule (known in-house as the Law of Demeter™) which encodes the ideas of encapsulation and modularity in an easy to follow form for the object-oriented programmer. You tend to get the following related benefits when you follow the Law of Demeter while minimizing simultaneously code duplication, the number of method arguments and the number of methods per class: Easier software maintenance, less coupling between your methods, better information hiding, narrower interfaces, methods which are easier to reuse, and easier correctness proofs using structural induction. We discuss two important interpretations of the Law (strong and weak) and we prove that any object-oriented program can be transformed to satisfy the Law. We express the Law in several languages which support object-oriented programming, including Flavors, Smalltalk-80, CLOS, C++ and Eiffel.


title: Using Tuple Space Communication in Distributed Object-Oriented Languages

authors:
Satoshi Matsuoka
Satoru Kawai

abstract: When Object-Oriented languages are applied to distributed problem solving, the form of communication restricted to direct message sending is not flexible enough to naturally express complex interactions among the objects. We transformed the Tuple Space Communication Model[29] for better affinity with Object-Oriented computation, and integrated it as an alternative method of communication among the distributed objects. To avoid the danger of potential bottleneck, we formulated an algorithm that makes concurrent pattern matching activities within the Tuple Space possible.


title: Panel: OOP in Business

authors:
Jeff McKenna
Jim Anderson
Rae Conrad
Karen Norby
Gregory Powell
Roy Smith


title: Panel: Object-Oriented Knowledge-Based Software Maintenance

authors:
Rao V. Mikkilineni
W. T. Tsai
Gordon Kotik
Mohammad A. Ketabchi
Gerhard Fischer


title: Fast Dispatch Mechanisms for Stock Hardware

abstract: Article Fast dispatch mechanisms for stock hardware Share on Author: John R. Rose Sun Microsystems, Inc., 2550 Garcia Avenue, Mountain View, CA Sun Microsystems, Inc., 2550 Garcia Avenue, Mountain View, CAView Profile Authors Info & Claims OOPSLA '88: Conference proceedings on Object-oriented programming systems, languages and applicationsJanuary 1988 Pages 27–35https://doi.org/10.1145/62083.62087Online:01 January 1988Publication History 31citation346DownloadsMetricsTotal Citations31Total Downloads346Last 12 Months7Last 6 weeks0 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 SiteGet Access


title: A Smalltalk Implementation of an Intelligent Operator's Associate

authors:
Kenneth S. Rubin
Patricia M. Jones
Christine M. Mitchell
Theodore C. Goldstein

abstract: This paper describes the use of Smalltalk in the design and implementation of OFMspert. OFMspert is an architecture for an intelligent operator's associate. In order to verify the architecture, an OFMspert was implemented to act as an assistant to an operator of a NASA satellite ground control system. OFMspert is a large system that utilizes a Smalltalk implementation of a knowledge-based problem solving method known as the blackboard architecture. The entire system was designed and implemented in Smalltalk/V™ and later ported to the Smalltalk-80™ system. The object-oriented paradigm in general, and Smalltalk‡ in particular, greatly facilitated the rapid design and implementation of this system. This paper summarizes the OFMspert architecture, emphasizing its implementation in an object-oriented paradigm.


title: Controlling Propagation of Operations Using Attributes on Relations

abstract: Controlling the propagation of operations through a collection of objects connected by various relationships has been a problem both for the object-oriented and the data base communities. Operations such as copy, destroy, print, and save must propagate to some, but not all, of the objects in a collection. Such operations can be implemented using ad hoc methods on objects, at the cost of extra work and loss of clarity. The use of propagation attributes on the relationships between objects permits a concise, intuitive specification of the manner in which operations should propagate from one object to another. These concepts have been implemented in the object-oriented language DSM and have been used to write applications.


title: Process Management and Exception Handling in Multiprocessor Operating Systems

authors:
Vincent F. Russo
Gary Johnston
Roy H. Campbell

abstract: The programming of the interrupt handling mechanisms, process switching primitives, scheduling mechanism, and synchronization primitives of an operating system for a multiprocessor require both efficient code in order to support the needs of high- performance or real-time applications and careful organization to facilitate maintenance. Although many advantages have been claimed for object-oriented class hierarchical languages and their corresponding design methodologies, the application of these techniques to the design of the primitives within an operating system has not been widely demonstrated. To investigate the role of class hierarchical design in systems programming, the authors have constructed the Choices multiprocessor operating system architecture the C++ programming language. During the implementation, it was found that many operating system design concerns can be represented advantageously using a class hierarchical approach, including: the separation of mechanism and policy; the organization of an operating system into layers, each of which represents an abstract machine; and the notions of process and exception management. In this paper, we discuss an implementation of the low-level primitives of this system and outline the strategy by which we developed our solution.


title: An Interactive Environment for Object-Oriented Music Composition and Sound Synthesis

authors:
Carla A. Scaletti
Ralph E. Johnson

abstract: Kyma is an object-oriented environment for music composition written in Smalltalk-80, which, in conjunction with a microprogrammable digital signal processor called the Platypus, provides the composer with a means for creating and manipulating Sound objects graphically with real-time sonic feedback via software synthesis. Kyma draws no distinctions between the materials and the structure of a composition; both are Sound objects. When a Sound object receives a message to play, it transforms itself into a microSound object, i.e. an object representation of itself in the microcode of the Platypus. Thus an object paradigm is used not only in the representation of Sound objects in Smalltalk-80 but also in the microcode representation of those Sound objects on the Platypus.


title: Panel: Teaching OOP

authors:
Dan Shafer
David A. Wilson
Jeff McKenna
John R. Pugh
Adele Goldberg


title: How To Invent Distributed Implementation Schemes of an Object-Based Concurrent Language: A Transformational Approach

abstract: A design and verification technique for implementation schemes of distributed software is presented. In this technique, first, the specification is modelled by a concurrent object system, that is, one which is constituted of computational agents with capability of concurrent execution and message passing. Then, such a concurrent object system is transformed into another concurrent object system, which models a sophisticated implementation scheme.


title: Configuring Stand-Alone Smalltalk-80 Applications

abstract: The Smalltalk-80™ programming environment, though powerful for prototyping applications, does not have any mechanisms for constructing a stand-alone version of an application. Traditionally, the application is bundled with an image including the entire development environment. Production applications frequently require that the only interface visible to the end user be that of the application. A common misperception among Smalltalk-80 application developers is that it is impossible to: develop and deliver applications containing proprietary algorithms,prevent inspection and modification of the application,separate the development environment from the delivered application,provide annotation of the application classes and methods without actually revealing the source code to the end user.In this paper, we introduce various techniques and mechanisms for meeting these requirements.


title: Transportable Applications Environment (TAE) Plus Experiences in "Object"-ively Modernizing a User Interface Environment

authors:
Martha R. Szczur
Philip Miller

abstract: This paper describes the evolution of the Transportable Applications Executive (TAE) (developed at NASA/Goddard Space Flight Center) from a traditional procedural menu and command-oriented system to an object-oriented, modeless user interface management system, known as TAE Plus. The impetus for developing this environment and early experiments which led to its current implementation are addressed. The current version of TAE Plus provides design and prototyping functions, working in tandem with a mature application management system. The main components are (1) a user interface designers' WorkBench that allows an application developer to interactively layout an application screen and define the static and/or dynamic areas of the screen; (2) an application programmer subroutine package that provides runtime services used to display and control WorkBench-designed “interaction objects” on the screen; and (3) an extension to the existing TAE command language that provides commands for displaying and manipulating interaction objects, thus providing a means to quickly prototype an application's user interface. During TAE Plus development, many design and implementation decisions were based on the state-of-the-art within graphics workstations, windowing systems and object-oriented programming languages, and this paper shares some of the problems and issues experienced during implementation. Some of the topics discussed include: lessons learned in using the Smalltalk™ language to prototype the initial WorkBench; why C++ was selected (over other languages) to build the WorkBench; and experiences in using X Window System™ and Stanford's InterViews object library. The paper concludes with open issues and a description of the next steps involved in implementing the “totally modern” TAE.


title: A User Interface Toolkit Based on Graphical Objects and Constraints

authors:
Pedro A. Szekely
Brad A. Myers

abstract: One of the most difficult aspects of creating graphical, direct manipulation user interfaces is managing the relationships between the graphical objects on the screen and the application data structures that they represent. Coral (Constraint-based Object-oriented Relations And Language) is a new user interface toolkit under development that uses efficiently-implemented constraints to support these relationships. Using Coral, user interface designers can construct interaction techniques such as menus and scroll bars. More importantly, Coral makes it easy to construct direct-manipulation user interfaces specialized to particular applications. Unlike previous constraint-based toolkits, Coral supports defining constraints in the abstract, and then applying them to different object instances. In addition, it provides iteration constructs where lists of items (such as those used in menus) can be constrained as a group. Coral has two interfaces: a declarative interface that provides a convenient way to specify the desired constraints, and a procedural interface that will allow a graphical user interface management system (UIMS) to automatically create Coral calls.


title: Orwell - A Configuration Management System for Team Programming

authors:
Dave A. Thomas
Kent Johnson

abstract: In this paper, we describe the design and implementation of Orwell, a configuration management tool for multiperson Smalltalk projects. Although the system described has been implemented for Smalltalk, the design is applicable to other languages such as C++, Objective-C or ADA. Smalltalk is well recognized as a productive programming environment for an individual programmer, but its lack of team support is currently a major obstacle in using Smalltalk for a large software project. To support multiperson Smalltalk programming, Orwell provides both source and object code sharing as well as version control on a network of personal workstations. Class ownership is used as the primary means for dividing work among programmers during the lifecycle of a project. Orwell also supports groups of programmers not physically connected to a common file server. We describe our implementation which preserves the productive exploratory environment of Smalltalk. Seamless integration and performance are essential for Orwell to be accepted and used by Smalltalk programmers.


title: Tenuring Policies for Generation-Based Storage Reclamation

authors:
David M. Ungar
Frank Jackson

abstract: One of the most promising automatic storage reclamation techniques, generation-based storage reclamation, suffers poor performance if many objects live for a fairly long time and then die. We have investigated the severity of this problem by simulating Generation Scavenging automatic storage reclamation from traces of actual four-hour sessions. There was a wide variation in the sample runs, with garbage-collection overhead ranging from insignificant, during the interactive runs, to severe, during a single non-interactive run. All runs demonstrated that performance could be improved with two techniques: segregating large bitmaps and strings, and mediating tenuring with demographic feedback. These two improvements deserve consideration for any generation-based storage reclamation strategy.


title: Panel: Treaty of Orlando Revisited

authors:
David M. Ungar
Henry Lieberman
Lynn Andrea Stein
Daniel Halbert


title: Reflection in an Object-Oriented Concurrent Language

authors:
Takuo Watanabe
Akinori Yonezawa

abstract: Our work is along the line of the work of B. Smith and P. Maes. We first discuss our notion of reflection in object-oriented concurrent computation and then present a reflective object-oriented concurrent language ABCL/R. We give several illustrative examples of reflective programming such as (1) dynamic concurrent acquisition of “methods” from other objects, (2) monitoring the behavior of concurrently running objects, and (3) augmentation of the time warp mechanism to a concurrent system. Also the definition of a meta-circular interpreter of this language is given as the definition of a meta-object. The language ABCL/R has been implemented. All the examples given in this paper are running on our ABCL/R system.


title: ET++ - An Object-Oriented Application Framework in C++

authors:
André Weinand
Erich Gamma
Rudolph Marty

abstract: ET++ is an object-oriented application framework implemented in C++ for a UNIX† environment and a conventional window system. The architecture of ET++ is based on MacApp and integrates a rich collection of user interface building blocks as well as basic data structures to form a homogeneous and extensible system. The paper describes the graphic model and its underlying abstract window system interface, shows composite objects as a substrate for declarative layout specification of complex dialogs, and presents a model for editable text allowing the integration of arbitrary interaction objects.


title: An Integrated Color Smalltalk-80 System

abstract: The Smalltalk-80™ user interface and graphics model are based on monochromatic graphics. One natural step in the evolution of the Smalltalk-80 system is the addition of color. This paper describes an implementation of color Smalltalk. Classes have been defined to manipulate visual color models and colored graphics objects. The extensive collaboration between classes which describe color, classes which perform basic graphics operations, and classes in the user interface is explored. Issues in the design and implementation are examined. Potential future directions for object-oriented color systems are discussed.


title: An Overview of Modular Smalltalk

authors:
Allen Wirfs-Brock
Brian Wilkerson

abstract: This paper introduces the programming language Modular Smalltalk, a descendant of the Smalltalk-80 programming language. Modular Smalltalk was designed to support teams of software engineers developing production application programs that can run independently of the environment in which they are developed. We first discuss our motivation for designing Modular Smalltalk. Specifically, we examine the properties of Smalltalk-80 that make it inappropriate for our purposes. We then present an overview of the design of Modular Smalltalk, with an emphasis on how it overcomes these weaknesses.


title: An Object-Oriented Framework of Pattern Recognition Systems

authors:
Norihiko Yoshida
Kouji Hino

abstract: In this paper, we describe a purely object-oriented framework of pattern recognition systems. Its aim is in dealing with knowledge representation issues in pattern recognition. In our approach, everything works in an entirely autonomous and decentralized manner. Even a search procedure for sample-concept matching is distributed onto every concept object itself by being implemented in what we introduced as the recursive agent-blackboard model. We developed an experimental prototype of character recognition systems in Smalltalk-80, which proved the ability of the object-oriented framework and the cooperative search procedure.


title: Neural Agents - A Frame of Mind

authors:
Sam S. Adams
Abdul K. Nabi

abstract: Several recent theories have been advanced to model complex heuristic behavior. From Minsky's Society of Mind to neural networks, these theories all share a common architecture consisting of many highly connected elements that together exhibit sophisticated macro behavior. This paper describes NeuralAgents, a framework developed in Smalltalk-80 that combines the high level interaction and collaboration of rule-based agents with the topological connectivity of neural nets. The Client-Facilitator-Consultant model for agencies will be presented, along with the object oriented design and implementation of the NeuralAgents system. PetWorld, an animated environment for the simulation of animal behavior is presented as an example application.


title: Rule-Based Delegation for Prototypes

abstract: Arguments have been given recently for providing the functionality of prototypes in object-oriented languages. Prototypes allow more flexible sharing of code and data by delegating messages to parent objects without the rigid structure of a class hierarchy. Prototypes can implement classes, and delegation can be used to model both single and multiple inheritance. However, one drawback with delegation is the difficulty in enforcing the semantics that delegation is used to model. This paper proposes a novel mechanism to control the delegation of messages with rules. In this system, the delegation of messages is governed by a set of rules possessed by each object. Rules can be used to implement classical single inheritance and can implement various solutions to multiple inheritance. In addition, rules can be created dynamically to model application-specific semantics. This paper describes how rule-based delegation works and illustrates various rules for rule-based delegation that have been implemented.


title: Panel: From Prototype to Product?

authors:
Ken Auer
Theodore C. Goldstein
S. Sridhar
Tom Love
Dave A. Thomas


title: Prototyping a Real-Time Embedded System in Smalltalk

abstract: This paper presents a case study of AMEP, a prototype ESM signal processor which has been implemented in Smalltalk using an actor-based design methodology, Arguments for choosing an OOPS for implementing such applications are reviewed. AMEP is a large system which includes both hard real-time and knowledge-based subsystems. Extensive software metrics are presented for each subsystem and used to compare the characteristics of code designed for different purposes. For example, analysis of this data suggests that knowledge-based applications may be more difficult to port to an object-based language such as Ada than hard real-time systems. Team programming, productivity, documentation standards and other software engineering issues are also addressed.


title: A Laboratory for Teaching Object-Oriented Thinking

authors:
Kent L. Beck
Ward Cunningham

abstract: It is difficult to introduce both novice and experienced procedural programmers to the anthropomorphic perspective necessary for object-oriented design. We introduce CRC cards, which characterize objects by class name, responsibilities, and collaborators, as a way of giving learners a direct experience of objects. We have found this approach successful in teaching novice programmers the concepts of objects, and in introducing experienced programmers to complicated existing designs.


title: An Extended Frame Language

authors:
F. P. Block
N. C. Chan

abstract: This paper describes several extensions to the traditional frame based programming semantics. We generalize the treatment of slots to include frame-like semantics; in addition we allow slots to be referenced by complex terms, whereas previously described frame based systems typically allow only scalar slot references. The resulting frame system naturally accommodates complex data structures and provides an extremely powerful mechanism for specifying complex relationships between objects represented by frames.


title: Panel: Object-Oriented Languages: Premises and Promises

authors:
Daniel G. Bobrow
L. Peter Deutsch
Gregor Kiczales
Bjarne Stroustrup


title: PROCOL - A Parallel Object Language with Protocols

authors:
Jan van den Bos
Chris Laffra

abstract: PROCOL is a parallel C-based object-oriented language with communication based on one-way synchronous messages. Objects execute in parallel unless engaged in communication. Communication partners are defined by object instance identifiers, or by type. Therefore send-receive mappings may be 1-1, n-1, or 1-n, though only 1 message is transferred. PROCOL controls object access by a novel concept: an explicit per-object protocol. This protocol is a specification of the occurrence and sequencing of the communication between the object and its partners. Thus protocols support structured, safer and potentially verifiable information exchange between objects. Protocols also act as a composition rule over client objects, thereby offering a 'part-of' hierarchy of these cooperating objects.


title: Programming with Explicit Metaclasses in Smalltalk-80

authors:
Jean-Pierre Briot
Pierre Cointe

abstract: This paper discusses the introduction of explicit metaclasses á la ObjVlisp into the Smalltalk-80 language. The rigidity of Smalltalk metaclass architecture motivated this work. We decided to implement the ObjVlisp model into the standard Smalltalk-80 system. The resulting combination defines the Classtalk platform. This platform provides a full-size environment to experiment with class-oriented programming by combining implicit metaclasses á la Smalltalk and explicit metaclasses á la ObjVlisp. Obviously, these experiments are not limited to the Smalltalk world and will be useful to understand and practice the metaclass concept advocated by modern object-oriented languages such as ObjVlisp and CLOS.


title: Interfaces for Strongly-Typed Object-Oriented Programming

authors:
Peter S. Canning
William R. Cook
Walter L. Hill
Walter G. Olthoff

abstract: This paper develops a system of explicit interfaces for object-oriented programming. The system provides the benefits of module interfaces found in languages like Ada and Modula-2 while preserving the expressiveness that gives untyped object-oriented languages like Smalltalk their flexibility. Interfaces are interpreted as polymorphic types to make the system sufficiently powerful. We use interfaces to analyze the properties of inheritance, and identify three distinct kinds of inheritance in object-oriented programming, corresponding to objects, classes, and interfaces, respectively. Object interfaces clarify the distinction between interface containment and inheritance and give insight into limitations caused by equating the notions of type and class in many typed object-oriented programming languages. Interfaces also have practical consequences for design, specification, and maintenance of object-oriented systems.


title: An Efficient Implementation of SELF - a Dynamically-Typed Object-Oriented Language Based on Prototypes

authors:
Craig Chambers
David M. Ungar
Elgin Lee

abstract: We have developed and implemented techniques that double the performance of dynamically-typed object-oriented languages. Our SELF implementation runs twice as fast as the fastest Smalltalk implementation, despite SELF's lack of classes and explicit variables.


title: An Object Addressing Mechanism for Statically Types Languages with Multiple Inheritance

authors:
Richard C. H. Connor
Alan Dearle
Ronald Morrison
Alfred L. Brown

abstract: In this paper we are concerned with addressing techniques for statically typed languages with multiple inheritance. The addressing techniques are responsible for the efficient implementation of record field selection. In object-oriented languages, this record selection is equivalent to the access of methods. Thus, the efficiency of these techniques greatly affects the overall performance of an object-oriented language. We will demonstrate that addresses, in such systems, cannot always be calculated statically and show how symbol tables have been used as address maps at run time. The essence of the paper is a new addressing technique that can statically calculate either the address of a field or the address of the address of the field. This technique is powerful enough to support an efficient implementation of multiple inheritance with implicit subtyping as described by Cardelli.


title: A Denotational Semantics of Inheritance and its Correctness

authors:
William R. Cook
Jens Palsberg

abstract: This paper presents a denotational model of inheritance. The model is based on an intuitive motivation of the purpose of inheritance. The correctness of the model is demonstrated by proving it equivalent to an operational semantics of inheritance based upon the method-lookup algorithm of object-oriented languages. Although it was originally developed to explain inheritance in object-oriented languages, the model shows that inheritance is a general mechanism that may be applied to any form of recursive definition.


title: Panel: Object-Oriented Technologies and the Software Industrial Revolution - Necessary But Not Sufficient

authors:
Brad Cox
Bruce Martin
Nate Edwards
John Morrison
Ried Philips


title: Saving a Legacy With Objects

authors:
Walter C. Dietrich Jr.
Lee R. Nackman
Franklin Gracer

abstract: Developers of application software must often work with “legacy systems.” These are systems that have evolved over many years and are considered irreplaceable, either because it is thought that duplicating their function would be too expensive, or because they are trusted by users. Because of their age, such systems are likely to have been implemented in a conventional language with limited use of data abstraction or encapsulation. The lack of abstraction complicates adding new applications to such systems and the lack of encapsulation impedes modifying the system because applications depend on system internals. We describe our experience providing and using an object-oriented interface to a legacy system.


title: A Fast Method Dispatcher for Compiled Languages with Multiple Inheritance

authors:
R. Dixon
T. McKee
Paul Schweizer
M. Vaughan

abstract: This paper addresses the problem of an efficient dispatch mechanism in an object-oriented system with multiple inheritance. The solution suggested is a direct table indexed branch such as is used in C++. The table slot assignments are made using a coloring algorithm. The method is applicable to strongly typed languages such as C++ (with multiple inheritance added) and Eiffel, and in a slightly slower form to less strongly typed languages like Objective C.


title: TICLOS: An Implementation of CLOS for the Explorer Family

abstract: article Free Access Share on TICLOS: an implementation of CLOS for the explorer family Author: P. H. Dussud Lucid Inc. Lucid Inc.View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 24Issue 10Oct. 1989 pp 215–219https://doi.org/10.1145/74878.74901Published:01 September 1989Publication History 17citation311DownloadsMetricsTotal Citations17Total Downloads311Last 12 Months19Last 6 weeks1 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: Objects in their Eyes (Panel)

authors:
Esther Dyson
Bertrand Meyer
Daniel Weinreb
William N. Joy


title: Playground: An Object-Oriented Simulation System With Agent Rules for Children of All Ages

authors:
Jay Fenton
Kent L. Beck

abstract: Programming languages for children have been limited by primitive control and data structures, indirect user interfaces, and artificial syntax. Playground is a child-oriented programming language that uses objects to structure data and has a modular control structure, a direct-manipulation user interface, and an English-like syntax. Integrating Playground into the curriculum of a classroom of 9- to 10-year-olds has given us valuable insights from the programs intended users, and confirmed many of our design decisions.


title: Computational Reflection in Class-Based Object-Oriented Languages

abstract: This paper describes various models of computational reflection in class based object oriented language. Two different approaches are covered: the meta-object approach which supposes that every object can have a meta-object describing and monitoring its behavior, and the message reification approach which describes a message as an object. The meta-object approach is discussed more fully showing that it is important to differentiate between structural reflection and computational reflection. We will see that, whereas classes and metaclasses are very important for the former, they cannot cope adequately with the later. Therefore we introduce a model of computational reflection where meta-objects are instances of a class META-OBJECT or of one of its subclasses.


title: Vamp: The Aldus Application Framework

authors:
Patrick J. Ferrel
Robert F. Meyer

abstract: This paper describes an application framework, called Vamp, which supports Interactive Compound Documents and applications as collections of Interactive Objects. Aldus developed Vamp as a practical experiment in solving several software engineering and project management problems including software reusability, portability, and management of large program teams. Vamp is written in C ++ to run on the Macintosh and Microsoft Windows. This paper discusses the decisions that led to the architecture of Vamp and what Aldus stands to gain by its use.


title: Reflective Facilities in Smalltalk-80

authors:
Brian Foote
Ralph E. Johnson

abstract: Computational reflection makes it easy to solve problems that are otherwise difficult to address in Smalltalk-80, such as the construction of monitors, distributed objects, and futures, and can allow experimentation with new inheritance, delegation, and protection schemes. Full reflection is expensive to implement. However, the ability to override method lookup can bring much of the power of reflection to languages like Smalltalk-80 at no cost in efficiency.


title: A Module Mechanism for Constraints in Smalltalk

abstract: ThingLab II, a rewrite of ThingLab, provides two representations of objects: fully-exposed and interpreted Things, or hidden and compiled Modules. Both representations provide the full power of the ThingLab II constraint hierarchy (an ordering of constraint preferences), and both can be manipulated by the graphical user-interface. This paper briefly describes Modules and their environmental support in ThingLab II. It also describes the process by which the ModuleCompiler translates a collection of objects (a ThingLab II Thing) into a single object with compiled and optimized Smalltalk-80 methods (a Module).


title: Metaclass Compatibility

abstract: Metaclasses provide control of object description, method compilation and more generally class behaviour. Consequently, they have been widely used in languages such as Smalltalk-80 or more recently CLOS by both users and implementers. Due to their powerful control of instances, careless inheritance of classes with different metaclasses can lead to unsound or inefficient implementations of instance methods. Using examples, we will pin-point these problems. Then we will introduce compatibility rules which need to be fulfilled by metaclasses of inherited classes in order to allow reasonable instance method description.


title: Good News, Bad News: Experience Building a Software Development Environment Using the Object-Oriented Paradigm

authors:
William H. Harrison
John J. Shilling
Peter F. Sweeney

abstract: This paper presents our experience building an extendible software development environment using the object-oriented paradigm. We have found that object instances provide a natural way to model program constructs, and to capture complex relationships between different aspects of a software system. The object-oriented paradigm can be efficiently implemented on standard hardware and software, and provides some degree of extendibility without requiring major modifications to the existing implementation.


title: Function Minimization and Automatic Differentiation Using C++

abstract: Function minimization techniques often require values for the first partial derivatives of the function at a point. Certain techniques, such as Newton's method, require the values of the second partial derivatives as well. The methods commonly used to obtain these values have certain drawbacks which can be eliminated using a technique known as automatic differentiation. When this technique is implemented in an object oriented language with operator overloading capabilities, the problem of differentiation and minimization can be mapped into a code which fits well with the problem space.


title: Contributions to Teaching Object Oriented Design and Programming

authors:
Karl J. Lieberherr
Arthur J. Riel

abstract: We provide a formal agenda for teaching the object-oriented paradigm in a programming language independent manner, and a tool which supports our teaching approach. Our proposal for a comprehensive study of the subject includes an ordered set of objectives designed to guide the uninitiated user from zero knowledge about object-oriented programming through class definitions, inheritance, subtyping, and the parameterization of classes. This set of graded objectives provides both a useful metric for gauging a student's progress, and a facility through which users can begin their studies at a level commensurate with their experience.


title: Virtual Classes: A Powerful Mechanism in Object-Oriented Programming

authors:
Ole Lehrmann Madsen
Birger Møller-Pedersen

abstract: The notions of class, subclass and virtual procedure are fairly well understood and recognized as some of the key concepts in object-oriented programming. The possibility of modifying a virtual procedure in a subclass is a powerful technique for specializing the general properties of the superclass.


title: Constraint Technology fur User-Interface Construction in ThingLab II

authors:
John Maloney
Alan Borning
Bjørn N. Freeman-Benson

abstract: ThingLab II is an object-oriented constraint programming system designed specifically for interactive user interface construction and implemented in Smalltalk-80 For constraints to be effective in building user interfaces, they must not impede the responsiveness of the user interface either at run time or during construction. The necessary speed is attained in ThingLab II by making judicious tradeoffs between compilation and interpretation, and by using a fast, incremental algorithm for constraint satisfaction. The resulting system allows user interface components to be assembled, tested, and modified expediently while maintaining interactive responsiveness.


title: Extending the Operating System to Support an Object-Oriented Environment

authors:
José Alves Marques
Paulo Guedes

abstract: Comandos is a project within the European Strategic Programme for Research on Information Technology - ESPRIT and it stems from the identified need of providing simpler and more integrated environments for application development in large distributed systems.


title: Object-Oriented Programming for Linear Algebra

abstract: Many numerical analysts and Lisp/Smalltalk programmers share the assumption that languages like Fortran are more appropriate for traditional, quantitative scientific programming than object-oriented languages. To show how straightforward application of object-oriented design to standard algorithms in numerical linear algebra improves clarity and expressiveness, without sacrificing speed or accuracy, I describe parts of Cactus, a system for numerical linear algebra and constrained optimization, implemented in Common Lisp and CLOS.


title: Controllable Delegation: An Exercise in Law-Governed Systems

authors:
Naftaly H. Minsky
David Rozenshtein

abstract: We believe that the regime governing the patterns of sharing between objects, and of exchange of messages between them, should not be “hard-wired” into a programming language, but should be specifiable by the builders of a system to fit its particular requirements. This thesis has been the primary motivation behind our general concept of law-governed system, which serves as the foundation for this paper.


title: Panel: Inheritance: Can We Have Our Cake and Eat it, Too?

authors:
J. Eliot B. Moss
Ralf Johnson
Alan Snyder
David W. Stemple
David M. Ungar


title: The Use of Multimethods and Method Combination in a CLOS Based Window System Interface

authors:
Hans Muller
John R. Rose
James Kempf
Tayloe Stansbury

abstract: Solo is a portable window interface written in the Common Lisp Object System (CLOS) object-oriented programming language. Solo provides a virtual window machine which is targeted to a host window system by implementing a set of host window system specific classes and methods for Solo's host window system driver protocol. The interface presented by Solo to an application insulates it from differences in the host window system, facilitating application portability. Solo distinguishes itself from other object-oriented window systems by exploiting certain features of CLOS. CLOS method combination simplifies initialization of windows while preserving easy extensibility of the basic classes. Generic dispatch on multiple arguments, a feature unique to CLOS, allows a simpler and more flexible input event dispatching protocol. A powerful event description language simplifies the specification of keyboard and mouse events. A prototype implementation runs on the server based XII and NeWS host systems, and on the frame buffer based Lucid Window Toolkit.


title: Panel: Using Ada within an Object-Oriented Software Development Paradigm

authors:
Steve Nies
Grady Booch
Richard P. Simonian
Ed Harris


title: Static Type Inference for Parametric Classes

authors:
Atsushi Ohori
Peter Buneman

abstract: Central features of object-oriented programming are method inheritance and data abstraction attained through hierarchical organization of classes. Recent studies show that method inheritance can be nicely supported by ML style type inference when extended to labeled records. This is based on the fact that a function that selects a field ƒ of a record can be given a polymorphic type that enables it to be applied to any record which contains a field ƒ. Several type systems also provide data abstraction through abstract type declarations. However, these two features have not yet been properly integrated in a statically checked polymorphic type system. This paper proposes a static type system that achieves this integration in an ML-like polymorphic language by adding a class construct that allows the programmer to build a hierarchy of classes connected by multiple inheritance declarations. Moreover, classes can be parameterized by types allowing “generic” definitions. The type correctness of class declarations is statically checked by the type system. The type system also infers a principal scheme for any type correct program containing methods and objects defined in classes.


title: PCLOS: A Critical Review

abstract: This paper uses the persistent object system PCLOS to survey some problems and benefits of object persistence. The system is analyzed along several relevant dimensions. PCLOS provides object persistence for an object-oriented language. The insights gained on desirable and detrimental components of the system are presented. The intent is to outline some of the expected and unexpected problems encountered in the construction of support for object persistence.


title: An Object-Oriented Modeling Environment

authors:
Thomas W. Page Jr.
Steven Berson
William C. Cheng
Richard R. Muntz

abstract: Many tools and techniques exist for the modeling and analysis of computer and communication systems. These tools are often complex and tailored to a narrow range of problems. The system analysis task often requires coordinated use of multiple tools and techniques which is not supported by currently available systems. The Tangram project goal is to develop an environment which makes a large set of tools and techniques readily accessible and is easily tailored to specialized applications.


title: Extending Ordinary Inheritance Schemes to Include Generalization

abstract: The arrangement of classes in a specialization hierarchy has proved to be a useful abstraction mechanism in class-based object oriented programming languages. The success of the mechanism is based on the high degree of code reuse that is offered, along with simple type conformance rules.


title: Panel: Architectural Alternatives for Object-Oriented Database Management

authors:
Alan Purdy
Jeff Sutherland
Mike Caruso
Tom Atwood
Tim Andrews
Jacob Stein


title: An Environment for Literate Smalltalk Programming

authors:
Trygve Reenskaug
Anna Lise Skaar

abstract: The programming environment described in this paper is an adaptation of Donald Knuth's concept of literate programming, applied to Smalltalk programs. The environment provides a multi-media document production system including media for Smalltalk class and method definitions.


title: OROS: Toward a Type Model for Software Development Environments

authors:
William R. Rosenblatt
Jack C. Wileden
Alexander L. Wolf

abstract: Three important goals of next generation software development environments (SDEs) are extensibility, integration and broad scope. Our work on OROS is predicated on the hypothesis that a type model, incorporated into an environment's object manager, can contribute to achieving those goals. This paper reports on an attempt at applying object-oriented typing concepts in the domain of software development environments. We believe that the result is a type model that has properties of interest both to software environment builders and also to builders and users of object-oriented systems in general.


title: Problem-Solution Mapping in Object-Oriented Design

authors:
Mary Beth Rosson
Eric Gold

abstract: Six expert Smalltalk programmers and three expert procedural programmers were observed as they worked on a gourmet shopping design problem; they were asked to think aloud about what was going through their minds as they worked. These verbal protocols were recorded and examined for ways in which the programmers' understanding of the problem domain affected the design process; most of our examples are from the three Smalltalk programmers who focussed most on the mapping from problem to solution. We characterize the problem entities that did appear as solution objects, the active nature of the mapping process, and ways in which the resultant objects went beyond their problem analogs.


title: Virtual Memory and Backing Storage Management in Multiprocessor Operating Systems Using Object-Oriented Design Techniques

authors:
Vincent F. Russo
Roy H. Campbell

abstract: The Choices operating system architecture [?, ?, ?] uses class hierarchies and object-oriented programming to facilitate the construction of customized operating systems for shared memory and networked multiprocessors. The software is being used in the Tapestry Parallel Computing Laboratory at the University of Illinois to study the performance of algorithms, mechanisms, and policies for parallel systems. This paper describes the architectural design and class hierarchy of the Choices memory and secondary storage management system. The mechanisms and policies of a virtual memory system implement a memory hierarchy that exploits the trade-offs between response times and storage capacities. In Choices, the notion of a memory hierarchy is represented by layers in which abstract classes define interfaces between and internal to the layers. Concrete subclasses implement new algorithms or data structures or specializations of existing ones. This paper describes the motivation for an objecto...


title: Incremental Distribution of Timestamp Packets: A New Approach to Distributed Garbage Collection

abstract: A new algorithm for distributed garbage collection is presented. This algorithm collects distributed garbage incrementally and concurrently with user activity. It is the first incremental algorithm that is capable of collecting cyclic distributed garbage. Computational and network communication overhead are acceptable. Hosts may be temporarily inaccessible and synchronization between hosts is not necessary. The algorithm is based on asynchronous distribution of timestamp packets each containing a list of last-access times of some relevant remotely referenced objects. Finally, the correctness and time complexity of the algorithm are discussed.


title: DSM: An Object-Relationship Modeling Language

authors:
Ashwin V. Shah
James E. Rumbaugh
Jung H. Hamel
Renee E. Borsari

abstract: The Data Structure Manager (DSM) combines object-oriented programming with semantic data modeling concepts in the context of the C language. DSM is a full-featured object-oriented language which includes single and multiple inheritance, class descriptor objects, metaclasses, choice of method binding time, error handling, persistent objects, modularity, and an interactive interpreter in an efficient manner. In addition, DSM supports the association and aggregation relationships as part of the Object Modeling Technique (OMT) used for conceptual design. DSM has been used since 1986 to build a variety of research and production-quality software such as an advanced CAF/CAD system.


title: An Event-Driven Model-View-Controller Framework for Smalltalk

abstract: The Smalltalk Model-View-Controller (MVC) user interface paradigm uses polling for its input control. The polling loops consume CPU cycles even when the user is not interacting with the interface. Applications using Smalltalk as their front-end often suffer unnecessary performance loss. This paper presents a prototype event-driven MVC framework to solve these problems. A solution to the compatibility problem is also provided to allow interface objects built under both polling and event-driven mechanisms to be used by each other with no modification and no performance penalty.


title: Three Steps to Views: Extending the Object-Oriented Paradigm

authors:
John J. Shilling
Peter F. Sweeney

abstract: At the core of any sophisticated software development and maintenance environment is a large mass of complex data. The data (the central data of the environment) is composed of smaller sets of data that can be related in complicated and often subtle ways. The user or developer of the environment will be more effective if they are able to deal with conceptual slices, or views, of the large, complex structure. This paper presents an architectural building block for object-based software environments based on the views concept. The building block allows the construction of global abstractions that describe unified behavior of large sets of objects. The basis of the architecture relies on extending the object-oriented paradigm in three steps: (1) defining multiple interfaces in object classes; (2) controlling visibility of instance variables; and (3) allowing multiple copies of an instance variable to occur within an object instance. This paper focuses on the technical aspects of the views approach.


title: Mandatory Security in Object-Oriented Database Systems

abstract: A multilevel secure object-oriented data model (using the ORION data model) is proposed for which mandatory security issues in the context of a database system is discussed. In particular the following issues are dealt with: (1) the security policy for the system, (2) handling polyinstantiation, and (3) handling the inference problem.


title: Inheritance and Synchronization with Enabled Sets

authors:
Chris Tomlinson
Vineet Singh

abstract: We discuss several issues related to the integration of inheritance and concurrency in an object-oriented language to support fine-grain parallel algorithms. We present a reflective extension of the actor model to implement inheritance mechanisms within the actor model. We demonstrate that a particularly expressive and inheritable synchronization mechanism must support local reasoning, be composable, be first-class, and allow parameterization based on message content. We present such a mechanism based on the concept of enabled-sets, and illustrate each property. We have implemented enabled-sets in the Rosette prototyping testbed.


title: Strategies for Scientific Prototyping in Smalltalk

authors:
Sandra S. Walther
Richard L. Peskin

abstract: This paper describes the design of a scientific prototyping environment in Smalltalk and discusses implementation strategies to achieve high performance interactive modeling of computationally intensive physical problems. Classes for scientific visualization, including contour plotting and 3D surface representations which incorporate the model-view-controller paradigm are presented. Techniques for inclusion of user primitives written in C to support computationally intense methods are described in detail in their current implementation on advanced Smalltalk workstations (SUN4, Ardent Titan, Tektronix 4317).


title: Design of the Opportunistic Garbage Collector

authors:
Paul R. Wilson
Thomas G. Moher

abstract: The Opportunistic Garbage Collector (OGC) is a generational garbage collector for stock hardware and operating systems. While incorporating important features of previous systems, the OGC includes several innovations. A new bucket brigade heap organization supports advancement thresholds between one and two scavenges, using only two or three spaces per generation, and without requiring per-object counts. Opportunistic scavenging decouples scavenging from the filling of available memory, in order to hide potentially disruptive scavenge pauses and improve efficiency. Card marking efficiently records which small areas of the heap may contain pointers into younger generations, and is supported by a refinement of the crossing map technique, to enable scanning of arbitrary cards.


title: Object-Oriented Design: A Responsibility-Driven Approach

authors:
Rebecca Wirfs-Brock
Brian Wilkerson

abstract: Object-oriented programming languages support encapsulation, thereby improving the ability of software to be reused, refined, tested, maintained, and extended. The full benefit of this support can only be realized if encapsulation is maximized during the design process.We argue that design practices which take a data-driven approach fail to maximize encapsulation because they focus too quickly on the implementation of objects. We propose an alternative object-oriented design method which takes a responsibility-driven approach. We show how such an approach can increase the encapsulation by deferring implementation issues until a later stage.


title: Panel on Transactions in Object-Oriented Systems

authors:
Stanley B. Zdonik
Toby Bloom
David W. Stemple
Jeannette M. Wing


title: Foundations of Concurrent Object-Oriented Programming (Panel)

authors:
Gul Agha
Samson Abramsky
Carl Hewitt
Robin Milner
Peter Wegner
Akinori Yonezawa


title: A Parallel Object-Oriented Language with Inheritance and Subtyping

authors:
Pierre America
Frank van der Linden

abstract: This paper shows that inheritance and subtyping can be introduced advantageously into a parallel object-oriented language, POOL-I. These concepts are clearly distinguished, because they deal with different aspects of programming. In this way several problems traditionally adhering to inheritance can be solved. The language POOL-I is a parallel object-oriented language with a strong typing scheme which includes genericity and dynamic binding. A novel and particularly powerful mechanism offers the possibility to manipulate and analyse types dynamically.


title: LO and Behold! Concurrent Structured Processes

authors:
Jean-Marc Andreoli
Remo Pareschi

abstract: We introduce a novel concurrent logic programming language, which we call LO, based on an extension of Horn logic. This language enhances the process view of objects implementable in Horn-based concurrent logic programming languages with powerful capabilities for knowledge structuring, leading to a flexible form of variable-structure inheritance. The main novelty about LO is a new kind of OR-concurrency which is dual to the usual AND-concurrency and provides us with the notion of structured process. Such OR-concurrency can be nicely characterized with a sociological metaphor as modelling the internal distribution of tasks inside a complex organization; this complements the external cooperation among different entities accounted for by AND-concurrency.


title: Graphical Specification of Object-Oriented Systems

authors:
Stephen Bear
Phillip Allen
Derek Coleman
Fiona Hayes

abstract: The graphical notation Objectcharts, introduced in this paper, allows a developer to precisely specify the behaviour of object classes and to reason about the behaviour of particular configurations of objects.


title: When Objects Collide: Experiences with Reusing Multiple Class Hierarchies

abstract: Well-designed reusable class libraries are often incompatible due to architectural mismatches such as error-handling and composition conventions. We identify five pragmatic dimensions along which combinations of subsystems must match, and present detailed examples of conflicts resulting from mismatches. Examples are drawn from our experiences of integrating five subsystem-level class hierarchies into an object-oriented hypertext platform. We submit that effective reuse will require that these pragmatic decisions be explicitly identified in descriptions of reusable software. Such descriptions will enable developers to identify and combine subsystems whose architectures are compatible.


title: What Tracers Are Made Of

authors:
Hans-Dieter Böcker
Jürgen Herczeg


title: The Design of the C++ Booch Components

authors:
Grady Booch
Michael Vilot

abstract: This paper describes design issues encountered developing a reusable component library. The design applied encapsulation, inheritance, composition and type parameterization. The implementation uses various C++ mechanisms, including: virtual and static member functions, templates, and exceptions.The resulting library contains about 500 components (mostly template classes and functions) and an optional utility for instantiating templates. The components provide variations of basic collection/container abstractions with various time and space complexities.A key insight gained from this project: the design process centered on developing a “template for the templates” — designing a component framework and orderly process for generating the template classes.


title: Mixin-based Inheritance

authors:
Gilad Bracha
William R. Cook

abstract: The diverse inheritance mechanisms provided by Smalltalk, Beta, and CLOS are interpreted as different uses of a single underlying construct. Smalltalk and Beta differ primarily in the direction of class hierarchy growth. These inheritance mechanisms are subsumed in a new inheritance model based on composition of mixins, or abstract subclasses. This form of inheritance can also encode a CLOS multiple-inheritance hierarchy, although changes to the encoded hierarchy that would violate encapsulation are difficult. Practical application of mixin-based inheritance is illustrated in a sketch of an extension to Modula-3.


title: The Point of View Notion for Multiple Inheritance

authors:
Bernard Carré
Jean-Marc Geib

abstract: We examine several problems related to the preservation of the Independence Principle inheritance. This principle states that all the characteristics of independent superclasses must be inherited by subclasses, even if there are name conflicts. In this context, a conventional approach is to use explicit class selection. We show that this mechanism suffers from serious limitations, and leads to inhibition of refinement and genericity. Our experimental object-oriented language ROME introduces the “Point of View” notion (using an “as-expressions” mechanism) which solves these problems.


title: Structured Analysis and Object Oriented Analysis (Panel)

authors:
Dennis de Champeaux
Larry L. Constantine
Ivar Jacobson
Stephen J. Mellor
Paul Ward
Edward Yourdon

abstract: The object-oriented paradigm still faces an open challenge: Delivering huge software systems routinely and cost effectively. To quote Ed Yourdon: “A system composed of 100,000 lines of C++ is not be sneezed at, but we don't have that much trouble developing 100,000 lines of COBOL today. The real test of OOP will come when systems of 1 to 10 million lines of code are developed.”


title: OOP in the Real World (Panel)

authors:
Rick DeNatale
Charles H. Irby
John LaLonde
Burton Leathers
Reed Phillips

abstract: Some advocates of OOP have promised that it will make all code reusable, shorten development cycles, remove the applications backlog, cure the common cold and plug the hole in the ozone layer.


title: Exception Handling and Object-Oriented Programming: Towards a Synthesis

abstract: The paper presents a discussion and a specification of an exception handling system dedicated to object-oriented programming. We show how a full object-oriented representation of exceptions and of protocols to handle them, using meta-classes, makes the system powerful as well as extendible and solves many classical exception handling issues. We explain the interest for object-oriented programming of handlers attached to classes and to expressions. We propose an original algorithm for propagating exceptions along the invocation chain which takes into account, at each stack level, both kind of handlers. Any class can control which exceptions will be propagated out of its methods; any method can provide context-dependant answers to exceptional events. The whole specification and some keys of our Smalltalk implementation are presented in the paper.


title: The Performance of an Object-Oriented Threads Package

authors:
John E. Faust
Henry M. Levy

abstract: Presto is an object-oriented threads package for writing parallel programs on a shared-memory multiprocessor. The system adds thread objects and synchronization objects to C++ to allow programmers to create and control parallelism. Presto's object-oriented structure, along with its user-level thread implementation, simplifies customization of thread management primitives to meet application-specific needs.The performance of thread primitives is crucial for parallel programs with fine-grained structure; therefore, the principal objective of this effort was to substantially improve Presto's performance under heavy loads without sacrificing the benefits of its object-oriented interface. We discuss design and implementation issues for shared-memory multiprocessors, and the performance impact of various designs is shown through measurements on a 20-processor Sequent Symmetry multiprocessor.


title: Kaleidoscope: Mixing Objects, Constraints and Imperative Programming

abstract: Kaleidoscope is an object-oriented language being designed to integrate the traditional imperative object-oriented paradigm with the less traditional declarative constraint paradigm. Imperative state changes provide sequencing while declarative constraints provide object relations. A variables as streams semantics enables the declarative-imperative integration. A running example is used to illustrate the language concepts—a reimplementation of the MacDraw II dashed-lines dialog box. The example is in three parts: the input channel, using imperative code to sequence through modes; the output channel, using constraints to update the display; and the internal relations, using constraints to maintain the data objects' consistency requirements. The last sections of the paper discuss views as a natural result of combining objects with constraints, as well as related and future work.


title: An Iterative-Design Model for Reusable Object-Oriented Software

authors:
Sanjiv Gossain
Bruce Anderson

abstract: We present an iterative-design approach for reusable object-oriented software that augments existing design methods by incorporating iteration into the design methodology and focuses on the set of problems within the domain, encouraging reuse of existing design information. The model has five separate stages which are described, before an example design is outlined using the model with sample code constructs in C++. Our results have shown a high degree of code reuse when using the model, directly attributable to two distinct design stages. An analysis of these results is also presented.


title: A Framework for Visualizing Object-Oriented Systems

authors:
Volker Haarslev
Ralf Möller

abstract: This paper describes a new approach to visualizing program systems within the object-oriented paradigm. This approach is based on a T E X-like notation which has been extended and generalized for specifying graphical layout of arbitrary objects. The CLOS meta-level architecture is used to associate visualization and application objects. We propose several useful techniques such as indirect values, slot and method demons, and instance-specific metaobjects. Our techniques require no modifications to the systems which are selected for visualization. We demonstrate the feasibility of our approach using application domains such as CLOS debugging and constraint systems. 1 Introduction Although programming has mostly been done in textual terms users have always had a notion of visualizing their programs. Programs have been entered as lines of text but soon users started to indent their programs and also used comments for separating or emphasizing particular program parts. Tools were develop...


title: COOL: Kernel Support for Object-Oriented Environments

authors:
Sabine Habert
Vadim Abrossimov

abstract: The Chorus Object-Oriented Layer (COOL) is an extension of the facilities provided by the Chorus distributed operating system with additional functionality for the support of object-oriented environments. This functionality is realized by a layer built on top of the Chorus V3 Nucleus, which extends the Chorus interface with generic functions for object management: creation, deletion, storage, remote invocation and migration. One major goal of this approach was to explore the feasibility of general object management at the kernel level, with support of multiple object models at a higher level. We present the implementation of COOL and a first evaluation of this approach with a C++ environment using the COOL mechanisms.


title: Contracts: Specifying Behavioural Compositions in Object-Oriented Systems

authors:
Richard Helm
Ian M. Holland
Dipayan Gangopadhyay

abstract: Behavioral compositions, groups of interdependent objects cooperating to accomplish tasks, are an important feature of object-oriented systems. This paper introduces Contracts, a new technique for specifying behavioral compositions and the obligations on participating objects. Refinement and composition of contracts allows for the creation of large grain abstractions based on behavior, orthogonal to those provided by existing class constructs. Using contracts thus provides a basis and vocabulary for Interaction-Oriented design which greatly facilitates the early identification, abstraction and reuse of patterns of behavior in programs. Contracts differ from previous work in that they capture explicitly and abstractly the behavioral dependencies amongst cooperating objects. By explicitly stating these dependencies, contract also provide an effective aid for program understanding and reuse.


title: Object-Oriented Real-Time Language Design: Constructs for Timing Constraints

authors:
Yutaka Ishikawa
Hideyuki Tokuda
Clifford W. Mercer

abstract: We propose a new object-oriented programming language called RTC++ for programming real-time applications. RTC++ is an extension of C++ and its features are to specify i) a real-time object which is an active entity, ii) timing constraints in an operation as well as in statements, and iii) a periodic task with rigid timing constraints.In this paper, we first discuss real-time programming issues and what language support should be provided for building real-time applications. Then, the key features of RTC++ are described. Some programming examples are shown to demonstrate RTC++'s expressive power. A comparison to other programming languages are also discussed.


title: Garbage Collection of Actors

authors:
Dennis G. Kafura
Douglas Washabaugh
Jeff Nelson

abstract: This paper considers the garbage collection of concurrent objects for which it is necessary to know not only “reachability,” the usual criterion for reclaiming data, but also the “state” (active or blocked) of the object. For the actor model, a more comprehensive definition than previously available is given for reclaimable actors. Two garbage collection algorithms, implementing a set of “coloring” rules, are presented and their computational complexity is analyzed. Extensions are briefly described to allow incremental, concurrent, distributed and real-time collection. It is argued that the techniques used for the actor model applies to other object-based concurrent models.


title: Actors as a Special Case of Concurrent Constraint Programming

authors:
Kenneth M. Kahn
Vijay A. Saraswat

abstract: Saraswat recently introduced the framework of concurrent constraint programming [14]. The essence of the framework is that computations consist of concurrent agents interacting by communicating constraints. Several concurrent constraint programming languages have been defined. They differ in the kinds of constraints that can be used as well as the kinds of operations on constraints which are available. In this paper we introduce a very simple concurrent constraint language we call Lucy, designed to closely mimic the actor model of computation. Agents can communicate only by the posting of constraints upon bags (un-ordered collections possibly with duplicate elements). This very impoverished concurrent constraint language is a syntactic subset of Janus, a concurrent constraint language which closely resembles concurrent logic programming languages such as Guarded Horn Clauses [21], Strand [5], Parlog [2] and Flat Concurrent Prolog [13]. By identifying the subset of Janus which is an actor language, we elucidate the relationship between actors and concurrent logic programming (and its generalization as concurrent constraint programming). Lucy is best not thought of as a unification of logic and constraint programming with actor and object-oriented programming, but as the missing link between these programming language genera.


title: Reasoning about Object-Oriented Programs that Use Subtypes

authors:
Gary T. Leavens
William E. Weihl

abstract: Programmers informally reason about object-oriented programs by using subtype relationships to classify the behavior of objects of different types and by letting supertypes stand for all their subtypes. We describe formal specification and verification techniques for such programs that mimic these informal ideas. Our techniques are modular and extend standard techniques for reasoning about programs that use abstract data types. Semantic restrictions on subtype relationships guarantee the soundness of these techniques.


title: Beyond Schema Evolution to Database Reorganization

authors:
Barbara Staudt Lerner
A. Nico Habermann

abstract: While the contents of databases can be easily changed, their organization is typically extremely rigid. Some databases relax the rigidity of database organization somewhat by supporting simple changes to individual schemas. As described in this paper, OTGen supports not only more complex schema changes, but also database reorganization. A database administrator uses a declarative notation to describe mappings between objects created with old versions of schemas and their corresponding representations using new versions. OTGen generates a transformer that applies the mappings to update the database to the new definitions, thus facilitating improvements in performance, functionality, and usability of the database.1


title: Strong Typing of Object-Oriented Languages Revisited

authors:
Ole Lehrmann Madsen
Boris Magnusson
Birger Møller-Pedersen

abstract: This papei is concerned with the relation between sub-typing and subclassing and their influence on programming language design. Traditionally subclassing as introduced by Simula has also been used for defining a hierarchical type system. The type system of a language can be characterized as strong or weak and the type checking mechanism as static or dynamic. Parameterized classes in combination with a hierarchical type-system is an example of a language construct that is known to create complicated type checking situations. In this paper these situations are analyzed and several different solutions are found. It is argued that an approach with a combination of static and dynamic type checking gives a reasonable balance also here. It is also concluded that this approach makes it possible to base the type system on the class/subclass mechanism.


title: Painting Multiple Views of Complex Objects

authors:
John Alan McDonald
Werner Stuetzle
Andreas Buja

abstract: This paper reviews and illustrates a direct manipulation approach to visualization of complex objects called painting multiple views. We describe a programming model for direct manipulation in general and for painting in particular, based on simple constraints between entities in an the underlying scientific database and the components of displays used to examine the data. With this model, the original notion of “brushing scatterplots” is easily extended.


title: A Logical Theory of Concurrent Objects

abstract: A new theory of concurrent objects is presented. The theory has the important advantage of being based directly on a logic called rewriting logic in which concurrent object-oriented computation exactly corresponds to logical deduction. This deduction is performed by concurrent rewriting modulo structural axioms of associativity, commutativity and identity that capture abstractly the essential aspects of communication in a distributed object-oriented configuration made up of concurrent objects and messages. Thanks to this axiomatization, it becomes possible to study the behavior of concurrent objects by formal methods in a logic intrinsic to their computation. The relationship with Actors and with other models of concurrent computation is also discussed. A direct fruit of this theory is a new language, called Maude, to program concurrent object-oriented modules in an entirely declarative way using rewriting logic; modules written in this language are used to illustrate the main ideas with examples. Maude contains OBJ3 as a functional sublanguage and provides a simple and semantically rigorous integration of functional programming and concurrent object-oriented programming.


title: Viewing Objects as Patterns of Communicating Agents

authors:
Oscar Nierstrasz
Michael Papathomas

abstract: Following our own experience developing a concurrent object-oriented language as well of that of other researchers, we have identified several key problems in the design of a concurrency model compatible with the mechanisms of object-oriented programming. We propose an approach to language design in which an executable notation describing the behaviour of communicating agents is extended by syntactic patterns that encapsulate language constructs. We indicate how various language models can be accommodated, and how mechanisms such as inheritance can be modeled. Finally, we introduce a new notion of types that characterizes concurrent objects in terms of their externally visible behaviour.


title: PCLOS: Stress Testing CLOS Experiencing the Metaobject Protocol

abstract: This paper demonstrates that the CLOS metaobject protocol approach to defining and implementing an object model is very powerful. CLOS is an object-oriented language that is based on Common Lisp and is in the process of being standardized. Implementations of CLOS are themselves object-oriented with all major building blocks of the language being instances of system classes. A metaobject protocol provides a framework for CLOS implementations by specifying the hierarchy of these classes and the order and contents of the communication among their instances. This design has made CLOS both flexible and portable, two design goals that traditionally conflict. In support of this suggestion we present a detailed account of how we added object persistence to CLOS without modifying any of the language's implementation code.


title: Type Substitution for Object-Oriented Programming

authors:
Jens Palsberg
Michael I. Schwartzbach

abstract: Genericity allows the substitution of types in a class. This is usually obtained through parameterized classes, although they are inflexible since any class can be inherited but is not in itself parameterized. We suggest a new genericity mechanism, type substitution, which is a subclassing concept that complements inheritance: any class is generic, can be “instantiated” gradually without planning, and has all of its generic instances as subclasses.


title: Message Pattern Specifications: A New Technique for Handling Errors in Parallel Object Oriented Systems

authors:
Jan A. Purchase
Russel L. Winder

abstract: As object oriented techniques enable the fabrication of ever more sophisticated systems, the need grows for a mechanism to ensure the consistent and 'correct' behaviour of each object at run-time. We describe a new, in-source specification mechanism, Message Pattern Specifications (MPS), to directly satisfy this need in a succinct, orthogonal and disciplined manner. Targeted for use in parallel object oriented systems, MPS allows programmers to enunciate the 'legal' patterns of run-time behaviour in which their objects may engage. Furthermore, it supports the definition of methods for object recovery or graceful failure in case these specifications are violated during execution.


title: OOPSLA Distributed Object Management (Panel)

authors:
John R. Rymer
Richard Mark Soley
William Stephen Andreas
Ian Fuller
Neal Jacobson
Richard A. Demers

abstract: article Free Access Share on OOPSLA distributed object management Authors: John R. Rymer Seybold Office Computing Group, Moderator Seybold Office Computing Group, ModeratorView Profile , Richard Mark Soley Vice President, Object Management Group Vice President, Object Management GroupView Profile , William Stephen Andreas Staff Software Engineer, Distributed Applications Architecture, Data General Staff Software Engineer, Distributed Applications Architecture, Data GeneralView Profile , Ian Fuller Project Manager, Distributed New Wave Application Architecture, Hewlett-Packard Project Manager, Distributed New Wave Application Architecture, Hewlett-PackardView Profile , Neal Jacobson Principal Engineer, Distributed Information Systems, Digital Equipment Corp. Principal Engineer, Distributed Information Systems, Digital Equipment Corp.View Profile , Richard A. Demers Distributed Data Management Architecture, IBM Distributed Data Management Architecture, IBMView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 25Issue 10Oct. 1990 pp 331–333https://doi.org/10.1145/97946.97985Published:01 September 1990Publication History 0citation229DownloadsMetricsTotal Citations0Total Downloads229Last 12 Months10Last 6 weeks0 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: MoDE: A UIMS for Smalltalk

abstract: While the Model-View-Controller (MVC) framework has contributed to many aspects of user interface development in Smalltalk, interfaces produced with MVC often have highly coupled model, view, and controller classes. This coupling and the effort required to use MVC make user interface creation a less effective aspect of Smalltalk.


title: Issues in Object Database Management

authors:
Jacob Stein
Tim Andrews
Bill Kent
Kate Rotzell
Daniel Weinreb

abstract: While the availability of commercial systems from several vendors indicates maturity in object database management technology, there are numerous issues which remain. This panel will attempt to expose and discuss several of these issues.


title: Type Consistency of Queries in an Object-Oriented Database System

authors:
Dave D. Straube
M. Tamer Özsu

abstract: Queries in object-oriented databases can return non-homogeneous sets of objects when no type restrictions are placed on the inputs to the query. The tradition has been to force homogeneity on the result by restricting the types of the inputs. This restricts the range of permissible, and possibly useful, queries. We propose a type consistency theory for queries in object-oriented databases which supports the existence of multiple types in the query result. The technique is illustrated by developing type inference rules for an object algebra. The main result is that the loss of type information associated with a query operation is reduced in most cases. We also show how type information is increased when queries are qualified by conjunctive predicates.


title: Designing Reusable Designs - Experiences Designing Object-Oriented Frameworks (Panel)

authors:
Allen Wirfs-Brock
Ralph E. Johnson
Ward Cunningham
Mark A. Linton


title: Static Type Checking of Multi-Methods

authors:
Rakesh Agrawal
Linda G. DeMichiel
Bruce G. Lindsay

abstract: Multi-methods allow method selection to be based on the types of any number of arguments.Languages that currently support multi-methods do not support static type checking.We show how multi-methods can be statically type checked and how information collected at the time of program compilation can be used to make the run-time dispatch of multi-methods more efficient.The results presented can provide the basis for introducing multi-methods in languages with static type checking and for designing new object-oriented paradigms based on multi-methods. 'The exact syntax is different in C++;we have taken liberty with the syntax to clarify the point.


title: Communication as Fair Distribution of Knowledge

authors:
Jean-Marc Andreoli
Remo Pareschi

abstract: Ve introduce an abstract form of interobject communication for object-oriented concurrent programming based on the proof theory of Linear Logic, a logic introduced to provide a theoretical basis for the study of concurrency.Such a form of communication, which we call forumbased communication, can be seen as a refinement of blackboard-based communication in terms of a more local notion of resource consumption.Forumbased communication is introduced as part of a new computational model for the object-oriented concurrent programming language LO, presented at last year OOPSLA/ECOOP (1990), which exploits the proof-theory of Linear Logic also to achieve a powerful form of knowledge-sharing.


title: Can Structured Methods be Objectified? (Panel)

authors:
Kent L. Beck
Grady Booch
Peter Coad
Meilir Page-Jones
Paul Ward


title: Symbolic and Spatial Database for Structural Biology

authors:
Dan Benson
Greg Zick

abstract: article Free AccessSymbolic and spatial database for structural biology Share on Authors: Dan Benson Department of Electrical Engineering, FT-10, University of Washington/Seattle, WA Department of Electrical Engineering, FT-10, University of Washington/Seattle, WAView Profile , Greg Zick Department of Electrical Engineering, FT-10, University of Washington/Seattle, WA Department of Electrical Engineering, FT-10, University of Washington/Seattle, WAView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 26Issue 11Nov. 1991 pp 329–339https://doi.org/10.1145/118014.117979Online:01 November 1991Publication History 3citation349DownloadsMetricsTotal Citations3Total Downloads349Last 12 Months3Last 6 weeks0 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