bluuebunny/crossref_metadata_2025 huggingface dataset:
A typed interface for garbage collection
Authors: Vanderwaart Joseph C. , Crary Karl
Published: November 2005

An important consideration for certified code systems is the interaction of the untrusted program with the runtime system, most notably the garbage collector. Most certified code systems that treat the garbage collector as part of the trusted computing base dispense with this issue by using a collector whose interface with the program is simple enough that it does not pose any certification challenges. However, this approach rules out the use of many sophisticated high-performance garbage collectors. We present the language LGC, whose type system is capable of expressing the interface of a modern high-performance garbage collector. We use LGC to describe the interface to one such collector, which involves a substantial amount of programming at the type constructor level of the language.
Garbage collection safety for region-based memory management
Authors: Elsman Martin
Published: November 2005

In this paper, we prove the safety of integrating region-based memory management and Cheney-style copying garbage collection. The safety property relies on a refinement of the region typing rules that forbids dangling pointers during evaluation.To accommodate the triggering of garbage collection at any step in the evaluation process, we base our type-safety result for the region-based system on a small-step contextual semantics and show that whenever a well-typed expression reduces to another expression, possibly by deallocating a region, then no dangling pointer is introduced. Because there are no dangling pointers in the initial heap, no dangling pointers appear during evaluation.Although in principle, the refinement of the region typing rules leads to less flexibility and can cause worse memory behavior than when dangling pointers are permitted, experiments show that, for a range of benchmark programs, the refinement has little effect on overall memory behavior.
Object database support for a software project management environment
Authors: Liu Lung-Chun , Horowitz Ellis
Published: November 2005

The recent development of object-oriented database models, which combine the power of object programming and the efficient management of data, provides a feasible solution for the construction of a computer-aided software engineering environment or CASE. However, an object oriented database provides only a kernel set of capabilities. This paper identifies the data management requirements related to software project management and shows how they are represented in the model called Design-Net. Then it is shown how the concepts of the work breakdown structure, project history, event monitoring, and re-initiation of tasks are realized in a specific object-oriented system. Limitations of existing object oriented database systems are identified, with respect to implementing these concepts. Based upon an actual prototype, recommendations are made for enhancing future object-oriented systems.
Foundations for the Arcadia environment architecture
Authors: Taylor Richard N. , Belz Frank C. , Clarke Lori A. , Osterweil Leon , Selby Richard W. , Wileden Jack C. , Wolf Alexander L. , Young Michal
Published: November 2005

Early software environments have supported a narrow range of activities (
programming
environments) or else been restricted to a single “hard-wired” software development process. The Arcadia research project is investigating the construction of software environments that are tightly integrated, yet flexible and extensible enough to support experimentation with alternative software processes and tools. This has led us to view an environment as being composed of two distinct, cooperating parts. One is the
variant
part, consisting of process programs and the tools and objects used and defined by those programs. The other is the fixed part, or
infrastructure
, supporting creation, execution, and change to the constituents of the variant part. The major components of the infrastructure are a process programming language and interpreter, object management system, and user interface management system. Process programming facilitates precise definition and automated support of software development and maintenance activities. The object management system provides typing, relationships, persistence, distribution and concurrency control capabilities. The user interface management system mediates communication between human users and executing processes, providing pleasant and uniform access to all facilities of the environment. Research in each of these areas and the interaction among them is described.
The Software Life Cycle Support Environment (SLCSE): a computer based framework for developing software systems
Authors: Strelich Tom
Published: November 2005

The Software Life Cycle Support Environment (SLCSE) is a VAX/VMS-based software development environment framework which presents a common and consistent user interface accessing a comprehensive set of software development tools supporting the full spectrum of DOD-STD-2 167A software life cycle activities from Requirements Analysis to Maintenance. These tools utilize a Project Database which maintains information relevant not only to the software under development (e.g., requirements allocation, software interfaces, etc.), but also information relating to the project as a whole (e.g., schedules, milestones, Quality Assurance, Configuration Management, etc.). The Project Database supports the DOD-STD-2167A life cycle model and associated Data Item Descriptions (DIDs). SLCSE's framework approach supports the integration of new tools into the environment and permits the SLCSE to evolve over time and adapt to advances in software engineering technology.
(ISEF): an integrated industrial-strength software engineering framework
Authors: Koenig Shaye
Published: November 2005

ISEF is an environment for programming-in-the-large that integrates disparate software engineering principles, methods and tools into an industrial-strength, automated software development framework. Projects using ISEF have reported increased software quality, improved software manageability and decreased software production costs. This paper presents the basic principles and mechanisms that enable ISEF to achieve environment/process integration as well as integration within the environment itself, describes the ISEF approach to software development, provides comparisons with related work, and reports on experience in using ISEF.
The workshop system: a practical knowledge-based software environment
Authors: Clemm Geoffrey M.
Published: November 2005

The Workshop System is a programming environment designed to support teams of programmers working concurrently on large software projects. An essential feature of the Workshop System is the storage of all information from the software project as fine grained objects in a shared database. In order to allow effective usage of this potentially overwhelming amount of information, the Workshop System provides a rule-based language called SE-KRL for specifying both the software objects and the software process for a given domain. SE-KRL programs can then be written to automate mechanical aspects of the software development process as well as to guide the essential creative activity of a software engineer.
Interacting with an active, integrated environment
Authors: Rodden Thomas , Sawyer Pete , Sommerville Ian
Published: November 2005

Software engineering environments are intended to provide a cohesive and integrated set of tools to support the process of software engineering with much current research into environment design focussed on maximising the degree to which these tools can be integrated. This paper describes the architecture of a prototype environment which attempts to achieve a high degree of integration using techniques drawn from artificial intelligence, office automation and object-oriented programming. This environment is implemented as a federation of intelligent, co-operating agents which communicate, with each other and with users, by message passing. This paper is particularly concerned with user interface integration including the mechanisms employed to permit inter-agent and agent-user communications.
The relationship between software development environments and the software process
Authors: Notkin David
Published: November 2005

The program committee originally planned for this panel session (and this introduction) to provide a summary of the 4th International Workshop on the Software Process. I have taken the liberty of covering a slightly more general view of the relationship between software development environments and the software process.
Pgraphite: an experiment in persistent typed object management
Authors: Wileden Jack C. , Wolf Alexander L. , Fisher Charles D. , Tarr Peri L.
Published: November 2005

Defining, creating, and manipulating
persistent typed objects
will be central activities in future software environments. PGRAPHITE is a working prototype through which we are exploring the requirements for the persistent object capability of an object management system in the Arcadia software environment.

PGRAPHITE represents both a set of abstractions that define a model for dealing with persistent objects in an environment and a set of implementation strategies for realizing that model. PGRAPHITE currently provides a type definition mechanism for one important class of types, namely directed graphs, and the automatic generation of Ada implementations for the defined types, including their persistence capabilities.

We present PGRAPHITE, describe and motivate its model of persistence, outline the implementation strategies that it embodies, and discuss some of our experience with the current version of the system.
Extended programming in the large in a software development environment
Authors: Lewerentz Claus
Published: November 2005

This paper deals with the programming in the large part and the integration with related activities (programming in the small, variant control, support of technical documentation, responsibility and access control) of the software development and maintenance process. It is pointed out how these tasks are supported with an integrated and incremental software project support environment (IPSEN).

Snapshots of a working session are used to demonstrate the user interface and the functionality of the tools for the above mentioned topics. The main concern of this paper is to show how an incremental and integrated tool set, regarding the consistency of software documents can support software development.
Version management in Gypsy
Authors: Cohen Ellis S. , Soni Dilip A. , Gluecker Raimund , Hasling William M. , Schwanke Robert W. , Wagner Michael E.
Published: November 2005

This paper describes the Version Manager of the Gypsy programming support environment, and its integration with the object-oriented extension of Unix
1
on which it is built.
Formalization of the control stack
Authors: Velazques Iturbide J. A.
Published: November 2005

The main aim of the article is to show a simple explanation of how variables are accessed in block-structured programming languages. For such a purpose, the run-time devices generically known as control stacks are modelled as an abstract data type.
Process oriented programming
Authors: Magnusson B.
Published: November 2005

This paper argues that co-routines are related to concurrent processes. By adding interrupt mechanisms languages containing co-routine mechanisms can be used for concurrency. It is also the intention to bring some of the terminology used in Simula constructs to the attention of others dealing with concurrency in object oriented languages. The use of processes to avoid global states in user interfaces are shortly commented upon.
From objects to actors: study of a limited symbiosis in smalltalk-80
Authors: Briot J.-P.
Published: November 2005

In this paper we describe an implementation of actors in Smalltalk-80, named Actalk. This attempt is designed as a minimal extension preserving the Smalltalk-80 language.Actors are active and autonomous objects, as opposed to standard passive Smalltalk-80 objects. An actor is built from a standard Smalltalk-80 object by associating a process with it and by serializing the messages it could receive into a queue.We will study the cohabitation and synergy between the two models of computation: transfer of active messages (message and thread of activity) between passive objects, and exchange of passive messages between active objects. We propose a sketch of methodology in order to have a safe combination between these two programming paradigms.We show how to extend the Actalk kernel into various extensions to define the basic Actor model of computation, higher level programming constructs such as the 3 types of message passing (asynchronous, synchronous, and eager) proposed in the ABCL/1 programming language, and distributed architectures. All these examples are constructed as simple extensions (by using inheritance) of our kernel model.
Message driven computing and its relationship to actors
Authors: Christopher T. W.
Published: November 2005

We define Message Driven Computation as a style of computing with two characteristics: 1) Messages, not sequential processes, convey both control and data. Indeed, there are no sequential processes unless they are programmed explicitly in terms of messages. 2) Computation is invoked by the presence of a collection of messages at the same location. MDC may be viewed as a generalization of Actors [AGHA86].

MDC - Message Driven Computing

MDC is based on message passing to named locations at which both data storage and computation is performed.

Messages are sent to labeled message queues called portals. A locus is a named collection of portals.

Messages are not sent or received by processes; rather, a collection of messages at a locus that match a pattern will trigger the execution of a procedure. These pattern-invoked procedures are called behaviors. The execution of a behavior can send further messages.

There are two kinds of patterns currently provided for triggering behaviors. 1) A specified number of messages at each of several specified portals at the same locus can trigger a behavior. 2) A message arriving at a specified portal of a locus can trigger a behavior if that locus has no other messages at any of its portals. The contents of the messages are not examined in either pattern match.

A locus is named by an arbitrary tuple of information. The first component is required to be a symbol, an internally generated value used somewhat like a pointer. All loci whose names begin with the same symbol are typically considered to be components of the same distributed object. Moreover, a garbage collector can collect all loci whose names cannot be generated again because no active computation has access to their initial symbol.

A locus will occupy one node of a multi-computer. The node number may be calculated from the locus name by a user specified formula or by hashing if no other method is specified. A locus is created when a message arrives at it and vanishes when no further messages are present or the garbage collector discovers it can no longer be active.

Similarly, portals are created at loci when messages arrive at them. A portal name is constructed out of a locus name and a portal label.
A general model for concurrent and distributed object-oriented programming
Authors: Caromel D.
Published: November 2005

This summary presents a general model supporting object-oriented programming in concurrent as well as distributed environments.The model combines the advantages of remote procedure calls with those of message passing.It relies on the following concepts:• All objects are not active but the active entities are objects.• Asynchronous Message Passing with Data-driven synchronization.• Service mechanism allowing an explicit thread of control.
Extensions to the object paradigm for the development of distributed applications
Authors: Heuser L. , Schill A. , Mühlhäuser M.
Published: November 2005

Current distributed object oriented languages and systems hide distribution in general while retaining the ability to control object locations explicitly. These approaches seem adequate but are exclusively focussing on the implementation stage of a distributed application. We present a new foundation for the development of distributed object oriented applications focussing on the design stage. Its main characteristics are:

all aspects of linguistic support can be introduced,

special issues, especially mobility and cooperation, can be integrated,

tight integration of linguistic and CASE (Computer Aided Software Engineering) support can be achieved,

only one formalism is used throughout

all of the above can be expressed at design level as opposed to source code level.

In the paper, we will focus on two important aspects of distributed object oriented systems requiring special design support:
mobility
and
cooperation
(see below).
Objects for distributed systems
Authors: Jazayeri M.
Published: November 2005

By examining the structure of distributed programs, we derive some requirements for the object paradigm to support the design and development distributed systems.
Modeling the semantics of smalltalk-80 with Petri nets
Authors: Christodoulakis D. N.
Published: November 2005

Over the last ten years, as the use of concurrent programming languages increased with a corresponding increase in the effort spent for building parallel machines, the importance of Petri nets grow. During this period Petri nets have been widely used for the specification, design and verification of nonsequential systems, and lots of effort has been spent for the development of software tools supporting Petri nets. Examples include the GRASPIN software engineering environment which supports Petri nets for graphical representation and formal specification of nonsequential systems [5], different net editors, etc.Since about one year we have started to use Petri nets in order to describe the semantics of object oriented languages (O-O for short), and in particular as a semantic model of the most representative O-O language, namely Smalltalk-80 [1]. Recent attempts towards possible extensions of Smalltalk-80 with concurrency have shown that semantic models of Smalltalk-80 like the above presented here, are not only useful for compiler writers, but their aid also towards identification and control of concurrency in the existing Smalltalk-80 systems; to specify possible computational models for a "concurrent" Smalltalk-80; and to indicate a possible semantic model for O-O distributed databases. Finally, since Petri nets provide the necessary theory for verification purposes, such a semantic model can be utilised for the verification of Smalltalk-80 programs as well.Main objective of this paper is to give an outline of the semantic function, described in next section. Subsequentialy, we discuss very short how the semantic function can be used for concurrency identiffication and control, and program verification.For the ongoing discussion we suppose that the reader is familiar with basic notions from Petri net theory [2, 3, 4].
Transformation of concurrent object systems
Authors: Shibayama E.
Published: November 2005

Rapid progress of hardware technology makes it feasible to construct a network system consisting of hundreds of small computers. Today, such a system can offer more computing power than a single large computer in a cheaper way. Moreover, a network computer system is much more flexible and, even when some of the processors fall in trouble, the other processors can possibly continue their work. Widely use of network computer systems is expected in near future.

In order to utilize distributed computing systems, we need distributed software. However, the progress of software technology is relatively slow. The design and development of distributed software is a difficult task at least under today's technologies. We need more sophisticated methodologies for design and development of distributed software.
A distributed debugger for Amoeba
Authors: Elshoff I. J. P.
Published: November 2005

We describe a debugger that is being developed for distributed programs in Amoeba. A major goal in our work is to make the debugger independent of the Amoeba kernel. Our design integrates many facilities found in other debuggers, such as execution replay, breakpointing, and an event-based view of the execution of the target program. This paper discusses the influence of Amoeba's architecture on the attainability of our goals and the desired functionality of the debugger. We also consider such problems as how to deal with timeouts and interactions between the target program and its environment.
Debugging distributed C programs by real time reply
Authors: Wittie Larry D.
Published: November 2005

Bugnet is a portable Unix system designed to debug C programs distributed within a local area network. A graphics interface allows the user of a Sun workstation to manage process groups and monitor process interactions very conveniently. Bugnet gives information about interprocess communication, I/O events, and execution traces for each component process. It allows the user to detect an error visually, to roll global program state back to a time before the error, and to replay events almost exactly as they previously occurred. Current work on Bugnet is making the implementation easier to port, seeing if replay accuracy can be improved by minor adjustments in the Unix process scheduler, linking it with Unix
dbx
to control individual processes, and determining useful tools for filtering of long event strings and for detecting errors. The Bugnet project is testing how well existing multiprocess C programs can be debugged without special hardware features that make porting difficult. An initial version is running on a network of Suns. It currently reproduces real time execution sequences with an accuracy of 0.01 to 0.10 seconds.
A real-time monitor for a distributed real-time operating system
Authors: Tokuda Hideyuki , Kotera Makoto , Mercer Clifford
Published: November 2005

Monitoring and debugging for a distributed real-time system is a complicated problem due to the lack of a set of advanced tools and adequate operating system capability. Software tools can cover the wide range of the software development life cycle from the requirement analysis phase to debugging and maintenance phases. However, many of these modern tools are not effective for building or analyzing complex real-time systems. Real-time software tools and effective kernel support are essential to reduce the complexity of real-time software. In this paper, we first address the issues in real-time monitoring and debugging, such as capturing the timing error, the monitor's invasive nature and visualization of system behavior. We then describe the architecture of the ART Real-Time Monitor which is being built for a distributed real-time OS, called ARTS. The built-in monitoring/debugging kernel primitives are also mentioned.
Supporting reverse execution for parallel programs
Authors: Pan Douglas Z. , Linton Mark A.
Published: November 2005

Parallel programs are difficult to debug because they run for a, long time and two executions may yield different results.
Reverse execution
, is a simple and powerful concept that solves both these problems. We are designing a tool for debugging parallel programs, called Recap, that provides the illusion of reverse execution using checkpoints and event recording and playback. During normal execution, Recap logs the results of system calls and shared memory reads: as well as the times that asynchronous events (signals) occur. Recap periodically checkpoints the state of a process by forking and suspending a new process. To reverse execute to a certain point in time, Recap continues the nearest checkpoint process forward in a self-contained environment, simulating all events using the log. We are implementing Recap as part of a larger environment for parallel program development.
Debugging of heterogeneous parallel systems
Authors: Forin Alessandro
Published: November 2005

The Agora system supports the development of
heterogeneous parallel programs
, e.g. programs written in multiple languages and running on heterogeneous machines. Agora has been used since September 1986 in a large distributed system [1]: Two versions of the application have been demonstrated in one year, contrary to the expectation of two years per one version. The simplicity in debugging is one of the reasons of the productivity speedup gained. This simplicity is due both to the deeper understanding that the debugger has of parallel systems, and to a novel feature: the ability to replay the execution of parallel systems built with Agora. A user is able to exactly repeat for any number of times and at a slower pace an execution that failed. This makes it easy to identify time-dependent errors, which are peculiar to parallel and distributed systems. The debugger can also be customized to support user defined synchronization primitives, which are built on top of the system provided ones. The Agora debugger tackles three set of problems that no parallel debugger in the past has simultaneously addressed: dealing with programming-in-the-large, multiple processes in different languages, and multiple machine architectures.
A program debugger for a systolic array: design and implementation
Authors: Bruegge Bernd , Gross Thomas
Published: November 2005

The Warp machine consists of a programmable linear systolic array connected to a general-purpose workstation host. Warp can be accessed either locally from this host or remotely from a large number of workstations connected to a local area network. Since the linear arrangement of the cells in the array restricts direct input and output with the host to the boundary cells, a source language debugger is important for program development. The Warp debugger is integrated into the Warp Programming Environment (WPE) which provides a uniform interface to the Warp machine. The debugger presents a conventional debugging model that includes breakpoints for individual cells as well as the inspection of the local state of each of the cells in the array. Although this user model is fairly simple, the implementation had to overcome several problems resulting from the parallel architecture of the machine and the distributed architecture of the programming environment.
Interactive blackbox debugging for concurrent languages
Authors: Goldszmidt G. , Katz S. , Yemini S.
Published: November 2005

We describe a novel approach to the design of portable integrated debugging tools for concurrent languages. Our design partitions the tools set into two categories. The
language specific tools
take into account the particular features of a programming language for on-line experimenting with and monitoring of distributed programs. The
language independent tools
support off-line presentation and analysis of the monitored information. The separation of the language independent tools from the language specific tools allows adapting the tools to support debugging for a broad category of concurrent programming languages. The separation of interactive experimentation from off-line analysis provides for efficient exploitation of both user time and machine resources. We present an overview of our design and describe the implementation of a prototype debugging facility for OCCAM.
Managing C++ libraries
Authors: Coggins J. M. , Bollella G.
Published: November 2005

This paper describes a scheme we have used to manage a large library written in the C++ language. The scheme imposes a directory structure, and represents dependency hierarchy in a globally accessible file we call the 'prelude' file. We also discuss the structure of the description files (makefiles) used with the UNIX options we have found to be useful in reducing the size of the library, and how to minimize recompilation time after trivial changes to the source code of the library.
Bugfind: a tool for debugging optimizing compilers
Authors: Caron J. M. , Darnell P. A.
Published: November 2005

This paper describes a tool for isolating modules that are compiled incorrectly when optimization is invoked. This tool benefits application developers by automatically compiling each module to its highest level of correct optimization. It benefits compiler writers by pinpointing failing modules.
Parallel compilation for a parallel machine
Authors: Gross T. , Sobel A. , Zolg M.
Published: November 2005

An application for a parallel computer with multiple, independent processors often includes different programs (functions) for the individual processors; compilation of such functions can proceed independently. We implemented a compiler that exploits this parallelism by partitioning the input program for parallel translation. The host system for the parallel compiler is an Ethernet-based network of workstations, and different functions of the application program are compiled in parallel on different workstations. For typical programs in our environment, we observe a speedup ranging from 3 to 6 using not more than 9 processors. The paper includes detailed measurements for this parallel compiler; we report the system overhead, implementation overhead, as well as the speedup obtained when compared with sequential compilation.
A VHDL compiler based on attribute grammar methodology
Authors: Farrow R. , Stanculescu A. G.
Published: November 2005

This paper presents aspects of a compiler for a new hardware description language (VHDL) written using attribute grammar techniques. VHDL is introduced, along with the new compiler challenges brought by a language that extends an Ada subset for the purpose of describing hardware. Attribute grammar programming solutions are presented for some of the language challenges.

The organization of the compiler and of the target virtual machine represented by the simulation kernel are discussed, and performance and code-size figures are presented.

The paper concludes that attribute grammars can be used for large commercial compilers with excellent results in terms of rapid development time and enhanced maintainability, and without paying any substantial penalty in terms of either the complexity of the language that can be handled or the resulting compilation speed.
Type reconstruction with first-class polymorphic values
Authors: O'Toole J. W. , Gifford D. K.
Published: November 2005

We present the first type reconstruction system which combines the implicit typing of ML with the full power of the explicitly typed second-order polymorphic lambda calculus. The system will accept ML-style programs, explicitly typed programs, and programs that use explicit types for all first-class polymorphic values. We accomplish this flexibility by providing both generic and explicitly-quantified polymorphic types, as well as operators which convert between these two forms of polymorphism. This type reconstruction system is an integral part of the FX-89 programming language. We present a type reconstruction algorithm for the system. The type reconstruction algorithm is proven sound and complete with respect to the formal typing rules.
Reasoning about continuations with control effects
Authors: Jouvelot P. , Gifford D. K.
Published: November 2005

We present a new static analysis method for first-class continuations that uses an
effect system
to classify the control domain behavior of expressions in a typed polymorphic language. We introduce two new control effects, goto and comefrom, that describe the control flow properties of expressions. An expression that does not have a goto effect is said to be
continuation following
because it will always call its passed return continuation. An expression that does not have a comefrom effect is said to be
continuation discarding
because it will never preserve its return continuation for later use. Unobservable control effects can be
masked
by the effect system. Control effect soundness theorems guarantee that the effects computed statically by the effect system are a conservative approximation of the dynamic behavior of an expression.

The effect system that we describe performs certain kinds of control flow analysis that were not previously feasible. We discuss how this analysis can enable a variety of compiler optimizations, including parallel expression scheduling in the presence of complex control structures, and stack allocation of continuations. The effect system we describe has been implemented as an extension to the FX-87 programming language.
BEG: a generator for efficient back ends
Authors: Emmelmann H. , Schröer F.-W. , Landwehr Rudolf
Published: November 2005

This paper describes a system that generates compiler back ends from a strictly declarative specification of the code generation process. The generated back ends use tree pattern matching for code selection. Two methods for register allocation supporting a wide range of target architectures are provided. A general bottom-up pattern matching method avoids problems that occurred with previous systems using LR-parsing. The performance of compilers using generated back ends is comparable to very fast production compilers. Some figures are given about the results of using the system to generate the back end of a Modula-2 compiler.
Inline function expansion for compiling C programs
Authors: Chang P. P. , Hwu W.-W.
Published: November 2005

Inline function expansion replaces a function call with the function body. With automatic inline function expansion, programs can be constructed with many small functions to handle complexity and then rely on the compilation to eliminate most of the function calls. Therefore, inline expansion serves a tool for satisfying two conflicting goals: minizing the complexity of the program development and minimizing the function call overhead of program execution. A simple inline expansion procedure is presented which uses profile information to address three critical issues: code expansion, stack expansion, and unavailable function bodies. Experiments show that a large percentage of function calls/returns (about 59%) can be eliminated with a modest code expansion cost (about 17%) for twelve UNIX
*
programs.
Problem-solution mapping in object-oriented design
Authors: Rosson M. B. , Gold E.
Published: November 2005

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.
Incremental distribution of timestamp packets: a new approach to distributed garbage collection
Authors: Schelvis M.
Published: November 2005

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.
Saving legacy with objects
Authors: Dietrich W. C. , Nackman L. R. , Gracer F.
Published: November 2005

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.
Good news, bad news: experience building software development environment using the object-oriented paradigm
Authors: Harrison W. H. , Sweeney P. F. , Shilling J. J.
Published: November 2005

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.

Unfortunately, we have also found that some natural extensions that we would like to make to the environment are not easily incorporated. We argue that the lack of extendibility is due to the object-oriented paradigm's lack of support for providing modifications and extensions to the object-oriented paradigm itself.
PROCOL: a parallel object language with protocols
Authors: Van Den Bos J. , Laffra C.
Published: November 2005

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.
Inheritance and synchronization with enabled-sets
Authors: Tomlinson C. , Singh V.
Published: November 2005

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.
Virtual memory and backing storage management in multiprocessor operating systems using object-oriented design techniques
Authors: Russo V. F. , Campbell R. H.
Published: November 2005

The
Choices
operating system architecture [3, 4, 15] 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 object-oriented, class-hierarchical approach to virtual memory system design, and describes the overall architecture of such an approach, as it has been applied to the
Choices
system. Special attention is paid to the advantages in both design and implementation that have resulted from using object-oriented techniques.
Computational reflection in class based object-oriented languages
Authors: Ferber J.
Published: November 2005

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.
Reflective facilities in Smalltalk-80
Authors: Foote B. , Johnson R. E.
Published: November 2005

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.
Three steps to views: extending the object-oriented paradigm
Authors: Shiling J. J. , Sweeney P. F.
Published: November 2005

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.
Rule-based delegation for prototypes
Authors: Almarode J.
Published: November 2005

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.
A module mechanism for constraints in Smalltalk
Authors: Freeman-Benson B. N.
Published: November 2005

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
).
Virtual classes: a powerful mechanism in object-oriented programming
Authors: Madsen O. L. , Moller-Pedersen B.
Published: November 2005

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.

In most object-oriented languages, the attributes of an object may be references to objects and (virtual) procedures. In Simula and BETA it is also possible to have class attributes. The power of class attributes has not yet been widely recognized. In BETA a class may also have
virtual class attributes
. This makes it possible to defer part of the specification of a class attribute to a subclass. In this sense virtual classes are analogous to virtual procedures. Virtual classes are mainly interesting within strongly typed languages where they provide a mechanism for defining general parameterized classes such as set, vector and list. In this sense they provide an alternative to generics.

Although the notion of virtual class originates from BETA, it is presented as a general language mechanism.
A denotational semantics of inheritance and its correctness
Authors: Cook W. , Palsberg J.
Published: November 2005

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.
Static type inference for parametric classes
Authors: Ohori A. , Buneman P.
Published: November 2005

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.