Search

During the past few years in our laboratory we have had many experiences with various software engineering technologies and sophisticated computer aids for software development. In general, we felt that they usually try to solve too much but do indeed practically very few. In this paper we intentionally avoided proposing too much (e.g. by over-formulating those aspects which could well have been formalized strictly if we had wanted). The way outlined in this paper concentrates on the process of development, emphasises the discipline and not the formalities. [ABSTRACT FROM AUTHOR]

Very few of the existing software analysis and design methodologies provide a facility for developing and specifying system components containing cooperating parallel processes. In this paper we develop a general specification technique which allows to precisely describe processes, process-classes, events and messages. The proposed methodology is based on Petri Nets which have been extended with higher level concepts to allow the straight forward specification of processes and their cooperation and to avoid the principle problem of Petri Nets, i.e. the large complexity of such nets when specifying even simple mechanisms. Care has been taken to provide for the adaption of the many formal analysis principles available for Petri Nets to the proposed technique. The development, design and specification technique is then used to extend four of the most popular design methodologies — Jackson, SADT, HIPO and Nassi Shneiderman — with process and event/message specification facilities. [ABSTRACT FROM AUTHOR]

LDM (Logic based Development Method) is a method, a language, and a support system for designing software objects on different levels of abstraction. It is based on the ideas of logic programming (PROLOG) and the Vienna Development Method (VDM). The paper gives an overview of the method, the language, the first experimental support system, and the experiences from its usage. It gives an example of the development process in LDM, and further plans are summarised. [ABSTRACT FROM AUTHOR]

This paper outlines ESPRESO, a specification system for process control software, which was developed at Nuclear Research Center, Karlsruhe, Federal Republic of Germany. ESPRESO is based on some new ideas, which are combined with elements taken from other systems. ESPRESO consists of a set of concepts, a specification language, a tool for the management, evaluation and validation of specifications, and the method how to use the system. Language, tool, and method are carefully adapted to the concepts. The aim was to demonstrate some ideas not found in the specification systems currently available, rather than to provide another product for the software market. The concepts of ESPRESO where abstracted from the most common tasks in real time programming, focusing on process communication. All operations are precisely defined. The concept of modules allows for the definition of static units which hide their internal structure from the outside. An attribute grammar was used, which describes not only the context sensitive syntax of the language, but also the effect of operations on the stored specification. The tool-component was partially coded in PASCAL, and installated on IBM-OS and VAX-VMS. While ESPRESSO is already being used for the specification of a nuclear reactor safety system, more components are being implemented in order to provide means for validation and documentation. [ABSTRACT FROM AUTHOR]

There is an increasing wealth of experience with abstract data types. This experience encompasses informal discussion of abstract data types, their formal specification, programming language constructs to facilitate their implementation, and the formal verification of implementations. This paper shows how abstract data types may be used as the basis of a top-down method of program design which leads to programs with a high degree of information hinding. [ABSTRACT FROM AUTHOR]

This paper presents two examples of implementing shared abstract data types in EDISON and Ada®. The solutions are based on Laventhal's algorythm for implementing synchronization specification. The presented two examples illustrate how shared abstract data types can be implemented using different language constructs. [ABSTRACT FROM AUTHOR]

There are many tricks of the software trade; this paper has sampled just a few. The science and management techniques underlying software are essential to any career in software engineering, but these tricks are sometimes useful. Careful use of the tricks has catapulted more than one competent young programmer into software superstardom. I don't think that these tricks should be given a one-hour lecture in a software engineering course. Some might deserve a ten-minute lecture here or a five-minute story there. But for the most part, tricks are learned through osmosis: your students will learn them as you apply them in lectures and as your teaching assistants apply them in software laboratories. And if they do learn these tricks, both your students and their employers will be grateful to you. [ABSTRACT FROM AUTHOR]

The need to educate computer professionals about the process, methods and tools used to create and maintain software systems is being met by The Johns Hopkins University at three levels. In the graduate program, which offers an M.S. in computer science to part-time students, a course in software engineering recently has been established as a degree requirement. At a second level, students in the program with an interest in software engineering may choose from a relatively comprehensive group of courses. Finally, at a third level, a short course program makes much of the same material available to non-matriculating professionals in a two to five full-day format. This paper describes the program, details the offerings, provides measures of the size and impact of the software engineering effort, and makes some general observations about the teaching of software engineering to practicing professionals. [ABSTRACT FROM AUTHOR]

Much has been written about software engineering programs from the view-point of the academician, but do these programs really reflect the needs of industry? This paper provides some insight into the needs of practicing software engineers at Texas Instruments who are developing software according to military specifications and requirements for embedded real-time systems. The needs of our environment are compared to the entering skills of a typical new-hire, with the differences noted. These differences can be satisfied by internal training that covers all aspects of software engineering, from communicating with co-workers to understanding the system life cycle. [ABSTRACT FROM AUTHOR]

This paper has presented plans for software engineering programs in the School of Information Technology and Engineering at George Mason University. Those plans include a Masters program in Software Systems Engineering, cross-listing of core courses in software engineering with Computer Science and Systems Engineering, a post-Masters Certificate program, development of doctoral level courses for the existing Ph.D. program in information technology, and evolution of the Center for Software and Systems Engineering into an industrially supported center for research and technology transfer in software engineering methods, tools, and techniques. The Masters core courses, the Certificate program, and some of the Ph.D. courses will be introduced during the 1988-89 academic year. Several additional courses in software engineering will be introduced during the next one to three years. Approval of the Masters degree program is anticipated by Fall Semester of 1989. Industrial support for the Center for Software and Systems Engineering is expected to reach steady state within five years. The overall goal for these plans is to evolve a center of excellence in software engineering within the School of Information Technology and Engineering at George Mason University that can serve the needs of high technology industries, governmental agencies, and educational institutions within the Commonwealth of Virginia and throughout the region. [ABSTRACT FROM AUTHOR]

IAI, Israel Aircraft Industries, has developed an industrial course to train its engineers in the analysis and specification of embedded computer systems (ESC) and their software. The course, based on a method which has been developed at IAI over the last eight years, blends known methods with original IAI developments. The approach stresses a total systems engineering view which considers the analysis of all systems aspects, not only the software. It discourages analysis of software alone without considering the entire system viewpoint. STATEMATE, a tool specially developed to support the method, is also introduced in the course. The paper describes briefly the IAI method and the tool, the objectives of the course, its structure, contents and organization. That is followed by the lessons learned, future developments in the method and courses. [ABSTRACT FROM AUTHOR]

This paper describes a graduate level course that covers concepts, techniques and tools for the specification, design, coding, and validation of concurrent software. This course is intended to transfer practical software engineering technology for the production of reliable concurrent software systems. One unique aspect of this course is the use of a collection of tools developed at NCSU for testing and debugging concurrent software. [ABSTRACT FROM AUTHOR]

Software engineering education is a difficult venture at very best but the difficulty of teaching software engineering ideas at the undergraduate level is even more problematic. The most significant problem in undergraduate software engineering education is, not surprisingly, lack of maturity. From our experience over the last six years this immaturity manifests itself in three different areas: computer science, academics in general, and social and personal relations. Each of the these manifestations of the undergraduate's lack of development has a significant impact on their ability to understand software engineering concepts. The results of our study on the unique pitfalls of undergraduate software engineering education are detailed in the first of the two papers that follow. We feel that software engineering should be an equal partner in our undergraduate computer science major with the more traditional hardware and software topics. Based on our experiences, we have developed an approach for teching software engineering which considers the immaturity of undergraduates and attempts to avoid the problems it imposes. The second paper briefly outlines our approach, which is based upon the sound educational principle of iteration of basic concepts and the eventual synthesis of those concepts into second and third level relationships. [ABSTRACT FROM AUTHOR]

The Ada programming language was designed to inherently support advanced software engineering. Thus, Ada is more than a language to the educator — Ada provides a framework in which to teach software engineering and computer science in ways not previously possible. However, most of the current emphasis in Ada development is involved with tools for the experienced programmer. These environments are usually too complex and bulky to be presented to novices in an early computer science course (based on the ACM CS1 curriculum). In addition, they usually require hardware that is too expensive to provide for large numbers of students. Therefore, in this paper we discuss a plan to construct an Ada environment for novices based on the MacGNOME environments already developed at Carnegie Mellon and being used on the Apple Macintosh. Through cooperation between the Software Engineering Institute, the Computer Science Department, Apple Computer, and Incremental Systems, Inc., we hope to put together a complete package including curricula, software (including support libraries), and a textbook to be used in teaching with Ada at the introductory level. [ABSTRACT FROM AUTHOR]

Software engineering education has traditionally focussed on the development phase of the software life cycle. It is recognised that maintenance is the most expensive phase of the life cycle, yet it receives very little direct attention in the software engineering curriculum. This paper contrasts a development based approach with a maintenance based approach to project work in software engineering education. [ABSTRACT FROM AUTHOR]

Software maintenance activities consume the majority of software life cycle costs in organizations which support a software product over an extended interval of time. These maintenance activities include error corrections as well as enhancements to the software. In addition to being extremely costly, software maintenance activities are very error prone. As a result, if an organization is to improve its productivity and quality, improvements in software maintenance skills would provide an effective return on investment. This paper describes a two-fold approach to improving software maintenance skills which entails a practical "hands-on" training course coupled with performance management focusing on positive reinforcement for new skills. [ABSTRACT FROM AUTHOR]

Traditionally, students in undergraduate computer science curricula have to wait until their third or fourth year until they are confronted with the problems which arise in the design of large programs. The rationale behind this is that programming-in-the-small has to be mastered before programming-in-the-large. In this paper we will argue that the elements of software engineering must be present at all levels and in all computer science courses and that it is feasible, with the proper tools and precautions, to assign large and complex programming assignments even at the introductory level. An experiment to this effect has been carried out in a data structures and algorithms course given at the University of Lund. A non-trivial program (a make-utility for Modula-2) was specified and partially modularized by the instructor and assigned piecewise to the students. The assignments trained the students in the implementation of data structures and algorithms as well as software tool design, modularization, information hiding, reuse, and large system design. [ABSTRACT FROM AUTHOR]

An often-cited problem in software engineering education is that many of the relevant topics are difficult to address in a university setting. Though project work is a useful supplement to the lectures, it is very difficult to make the project truly realistic. In our environment therefore, we decided not to try to mimic all aspects of reality. Rather, we try to concentrate on a few aspects which can be realistically dealt with in a university environment. In this paper we describe a project which concentrates on maintenance activities. Independent evaluations by both students and project instructors reveal that these maintenance activities were most seriously hampered by inappropriate documentation at the component level. [ABSTRACT FROM AUTHOR]

The award of the Combat Submarine (BSY-2) contract to GE has challenged the Government Electronic Systems Division (GESD) in terms of involvement in the single largest Ada oriented project development to date in the world. The total project is faced with a development effort exceeding 2,200,000 lines of Ada code to be implemented by a community of software engineers totaling 900. The Government Electronic Systems Division at Moorestown, NJ, with its current staff of approximately 200 software engineers involved with on-going projects, is faced with significant numbers of additional engineers to hire that need to be integrated into the existing software engineering staff. The combined new staff is challenged with new methodologies, design, standards and Ada. The training campaign is critical as a strategic element in the successful Ada software engineering effort of this fixed price contract. This paper will detail a fundamentally different approach in the training of engineers and engineering managers into a significantly new environment. [ABSTRACT FROM AUTHOR]

In July of 1987, the Rockwell International Avionics Group initiated a Software Engineering Training Program to increase our personnel's knowledge of software engineering, particularly with respect to real-time, embedded systems development. The program's design and development took place from July 1987 through January 1988. The program has been offered to engineers and managers since March of 1988. During the March to September 1988 period there have been 530 participants. The program has been very successful so far and participation has been higher than anticipated. Plans are to continue the training program at a controlled pace, with periodic program evaluations used to continually steer the program in the right direction. This paper highlights some of the efforts and "lessons learned" in developing and administering the Software Engineering Training Program. [ABSTRACT FROM AUTHOR]

Computer science courses, including those at the introductory level, require students to be capable of demonstrating that the programs they write satisfy the problem specifications. This demonstration of correctness is nearly always done via testing. Yet these courses tend to offer little or no guidance to the students in selecting appropriate test data. This paper analyzes the characteristics of test data used by novice programmers in the absence of such guidance. Test data generated by over 100 students in introductory courses at two large public institutions were analyzed for feature, statement, and validity coverage as described in the IEEE standard for unit testing. The student test data were often found inadequate to cover all but the most high-level features described in the problem specifications. Statement coverage was frequently not achieved, and most of the students did not include invalid inputs in their test suites, even if they wrote their programs to check for such invalid inputs. Students tended to do a better job in achieving these levels of coverage when testing someone else's program than they did when testing their own program. About 2/3 of the defective programs found in the study were tested well enough by the student to reveal a defect, but in many cases the defects were not recognized even when revealed. Simple systematic testing strategies, based only on information contained in the specifications, were found capable of revealing defects in most of the defective programs, including most of those for which the student's own data were inadequate to reveal a defect. [ABSTRACT FROM AUTHOR]

This position paper proposes questions to consider in planning curricula for undergraduate software engineering education. We should specify the audience for such curricula, plan a process for deciding what material to incorporate and how to keep it up to date, plan for flexible packaging of curriculum materials, and begin to think about how we might deal with political issues in establishing such curricula. [ABSTRACT FROM AUTHOR]

This paper proposes an evolutionary approach for developing an undergraduate software engineering program within an existing computer science program. The proposed approach is evolutionary because of the fairly common university requirement that a new program must already have some identifiable courses, students, faculty, and other resources before it is formally approved. The approach consists of five steps and has two main goals: a gradual establishment of an undergraduate software engineering program and the introduction of key software engineering concepts within an undergraduate computer science program which now exists and will continue to exist. [ABSTRACT FROM AUTHOR]

This position paper outlines the rationale for and the approach used at the University of Hawaii at Hilo to further augment the ACM/IEEE computer science curriculum for software engineering considerations. [ABSTRACT FROM AUTHOR]

We are developing an abstract model to provide a framework for comparing the object models of various systems, ranging from object-oriented programming languages to distributed object architectures. Our purpose is to facilitate communication among researchers and developers, improve the general understanding of object systems, and suggest opportunities for technological convergence. This paper describes the application of the abstract object model to the C++ programming language. We give an overview of the abstract object model and illustrate its use in modeling C++ objects. Several modeling alternatives are discussed and evaluated, which reveal anomalies in the C++ language. We conclude by characterizing those aspects of the C++ object model that distinguish C++ from other object systems. [ABSTRACT FROM AUTHOR]

This paper addresses the issue of schema evolution in LISPO2, a persistent object-oriented language. It introduces the schema modifications supported by the LISPO2 programming environment and presents the potential inconsistencies resulting from these modifications at the schema, method and object levels. Furthermore, it describes how the environment efficiently detects such inconsistencies using a database representing the schema definition. Moreover for correct modifications, it presents how this database is used to update the schema, to trigger method recompilations and to restructure objects using a semi-lazy evolution policy. [ABSTRACT FROM AUTHOR]

This paper presents a formal system based on the notion of objects and asynchronous communication. Built on Milner's work on π-calculus, the communication primitive of the formal system is purely based on asynchronous communication, which makes it unique among various concurrency formalisms. Computationally this results in a consistent reduction of Milner's calculus, while retaining the same expressive power. Seen semantically asynchronous communication induces a surprisingly different framework where bisimulation is strictly more general than its synchronous counterpart. This paper shows basic construction of the formal system along with several illustrative examples. [ABSTRACT FROM AUTHOR]

The Z notation for the formal specification of software and systems is based on set-theory and first-order predicate calculus and is widely used and understood. Recent research has demonstrated that by extending the notation to include the idea of a class schema grouping together a state schema and the operation schemas referring to it, an object oriented specification style can be supported. This paper introduces the concept of inheritance into object oriented Z in two ways. First of all, it defines derivation, an incremental inheritance technique for expressing new class schemas in terms of old ones. Secondly, it characterises subtyping inheritance as a technique for the hierarchical classification of objects. Thus derivation in Z is a basis for reusing existing specification modules. Subtyping inheritance is the basis for considering the substitutability of one class for another. [ABSTRACT FROM AUTHOR]

This paper has discussed some of the issues that were addressed in the first release of the GS Designer. We have shown how the order of class modifications can lead to problems unless performed in the correct order, and given an algorithm of how the GS Designer performs multiple class modifications in the database. We have also shown how references to classes external to the schema can lead to problems when multiple designers are updating the database, and discussed the import operations to support incomplete definitions in the schema. Finally, we have illustrated problems with locking and optimistic concurrency control when subclasses are created by multiple users in different database sessions. The emphasis throughout the design and implementation of the tool has been on providing intuitive, consistent operations for the user without limiting other users of the database. The tool is intended to aid in the sharing of class definitions as well as in their creation and modification. To this end, we expect to add a number of additional features in the next release. We expect to integrate the GS Designer with a database administration tool that will allow the user to set authorizations and to easily move objects to different name spaces. In the future, we also expect to couple the GS Designer with a forms package and a query tool, so that users will be able to specify indices and query the database graphically. With the increased complexity of inheritance, behavior, and complex objects in the database, building such tools for an object-oriented database management system will provide a challenge to all database researchers and implementors. [ABSTRACT FROM AUTHOR]

Integrity maintenance in object-oriented systems has so far received little attention. This paper is an attempt to fill this gap. It describes a mechanism for maintaining integrity in an object-oriented database, implemented for the O2 system, and which uses the production rule approach to constraint maintenance. Object integrity is ensured by objects themselves — the rules which are activated when selected events take place. The approach presented is original, in the sense that it takes full advantage of the object-oriented paradigm, considering constraints as first-class citizens which can be inherited, and defined independently of any application. Furthermore, we support maintenance of not only static but also some types of dynamic constraints, as well as constraints on object behavior. [ABSTRACT FROM AUTHOR]

The value of computational reflection has been explored in a number of programming language efforts. The major claim of this paper is that an ostensibly broader view of reflection, which we call implementational reflection, can be applied to the design of other kinds of systems, accruing the same benefits that arise in the programming language case. The domain of window systems in general, and the Silica window system in particular are used to illustrate how reflection can be applied more broadly. Silica is a CLOS-based window system that is a part of the Common Lisp Interface Manager, an emerging user interface programming standard for Common Lisp. [ABSTRACT FROM AUTHOR]

This paper describes the design of an exception handling mechanism for Guide, an object-oriented language based on a distributed system. We confront the usual exception techniques to the object formalism, and we propose conformance rules and an original association scheme. A specific tool to maintain the consistency of objects in the face of exceptions is provided. System and hardware exceptions are integrated to the mechanism, and parallelism is handled in an original manner. Some details of the implementation are given. [ABSTRACT FROM AUTHOR]

Subclassing is reuse of class definitions. It is usually tied to the use of class names, thus relying on the order in which the particular classes in a program are created. This is a burden, however, both when programming and in theoretical studies. This paper presents a structural notion of subclassing for typed languages. It is a direct abstraction of the Smalltalk interpreter and the separate compilation technique of Modula. We argue that it is the most general mechanism which can be supported by the implementation while relying on the type-correctness of superclasses. In short, it captures type-safe code reuse. [ABSTRACT FROM AUTHOR]

Version management services have traditionally focussed on versioning individual objects, and especially text files. This approach ignores the fact that (versions of) different objects are not independent from each other, and introduces the problem of finding consistent version combinations. One way to alleviate these problems is by expanding the unit of versioning, i.e. by applying integral version management to collections of objects. This paper describes implementation techniques for integral version control. The techniques are applied to an object model which is characteristic for modern (engineering) object management systems, i.e. a model in which data is represented through objects and relationships. The techniques we propose support for both linear development and general, branching history. Furthermore, the techniques are incremental: they only store the difference with respect to the previous version. [ABSTRACT FROM AUTHOR]

In this paper, we address the issue of how to provide an analyst that uses the object-oriented paradigm with a top-down approach. An analyst gets this approach for free when working within the structured paradigm. Ensembles are introduced that differ from objects in that they connote entities with internal parallelism. Preliminary experimentation suggests that ensembles allow for information hiding. [ABSTRACT FROM AUTHOR]

We have previously shown how the discovery of classes from objects can be automated, and how the resulting class organization can be efficiently optimized in the case where the optimum is a single inheritance class hierarchy. This paper extends our previous work by showing how an optimal class dictionary can be learned incrementally. The ability to expand a class organization incrementally as new object examples are presented is an important consideration in software engineering. [ABSTRACT FROM AUTHOR]

The design of many popular object-oriented languages like Smalltalk, Eiffel, or Sather follows a certain trend: The class is the only structuring form. In this paper, the need for having modules besides classes is claimed. Modules stem from a different language family and at first glance it seems that they can easily be unified with classes. Among other things, unifying modules and classes carries the danger of unifying the import and inheritance relationships. Constructs in several languages are discussed that indicate that modules and classes should indeed be kept separate. [ABSTRACT FROM AUTHOR]

This paper describes a formal object-oriented specification language, Z++, and identifies proof rules and associated specification structuring and development styles for the facilitation of validation and verification of implementations against specifications in this language. We give inference rules for showing that certain forms of inheritance lead to refinement, and for showing that refinements are preserved by constructs such as promotion of an operation from a supplier class to a client class. Extension of these rules to other languages is also discussed. [ABSTRACT FROM AUTHOR]

In this paper, a number of existing solutions and suggestions towards combining the object-oriented (OO) and logic programming paradigms have been briefly studied and categorized, and a sketch of a new solution has been proposed which tries to capture the essence of OO in terms of modal logic, and which could be implemented as a modal logic programming system. The proposal is based on the belief that two orthogonal dimensions — object hierarchy and time — are involved in OO that in many respects are similar. For the one-dimensional (static) case, three logics — MU, MU′, and MU″ — have been designed, each allowing a different variety of inheritance modes. The two-dimensional (dynamic) case has been treated in a logic 2MU and its corresponding variants. Under certain OO-motivated definitions of Horn clause, the resolution calculi of these logics turn out to be complete. [ABSTRACT FROM AUTHOR]

This paper describes the outline of an object-oriented design technique denoted role modeling, emphasizing the ability to compose parts of a design. The purpose of role modeling is to achieve separation of concerns, allowing the designer to consider different aspects, or the same aspect at different levels of detail, more or less independent of other aspects of the overall design. A role model represents the concept of a structure of communicating objects; each object being represented by a role to be ‘played' in the context of this role model. Each role model is considered a design of a separate aspect of some overall design. Composition of designs is achieved by synthesizing roles in several role models, constructing more aggregated and specialized roles and role models. [ABSTRACT FROM AUTHOR]

This paper presents SIROCO, a research on user interface design and development support in an object-oriented programming environment. User interface (UI) design in SIROCO focuses on conceptual modeling; a fully object-oriented conceptual representation model and language is proposed, distinguishing the function dimension from the use dimension in an interactive system. Interaction style and presentation aspects are dealt with as generic parameters. SIROCO promotes a continuous object-oriented approach from UI design to UI implementation. Transition from conceptual design to implementation is achieved through an extended object-oriented software architecture model. Effective UI development is supported by an object factory that produces the object code needed to implement the specified user interface. [ABSTRACT FROM AUTHOR]

This paper describes an original object communication protocol, named ACS (Apply, Call, Send), that we adopted in KAROS (Kernel of an Action-based Reliable Object System) to deal with concurrency control and failure recovery in distributed applications. The basic idea in ACS is to associate each request message to an atomic action. ACS allows to build atomic action trees representing the logical nesting of services. Moreover, it gives to the programmer full control on the granularity of atomicity and provides a fairly natural model for grouping objects inside actions to ensure the system's global consistency. By using ACS, objects may be seen as reliable elements that can be composed to build up reliable distributed applications. [ABSTRACT FROM AUTHOR]

This paper describes the use of the object-oriented programming language BETA for modelling and implementing a simple prototype of an ISDN D-channel layer 3 (I.451) entity. In particular, the implementation of ISDN supplementary services on top of the I.451 entity is considered using an object-oriented language, whereby several advantages are gained in comparison with other types of implementation languages. Aquaintance with the BETA programming language is assumed although the most vital constructs for use in this paper are explained. [ABSTRACT FROM AUTHOR]

Applications requiring sophisticated modeling techniques raise challenging issues to software designers. CAD/CAM and genetics are example of applications that call for powerful modeling techniques. Existing approaches seem limited in their ability to support their demands. Relational database systems for example support only simple tables. The need to enhance their capabilities led to non-normalized relational data models. Object-oriented programming languages and databases propose new solutions to the problems of complex and composite object modeling and manipulation. Yet, severe shortcomings impede their practicability, e.g., their inability to model multiple object representations and complex semantic relationships. This paper is an informal overview of a data model called SHOOD based on object-oriented concepts and frame-based knowledge representation. SHOOD implements sophisticated features, such as: · object persistence, multi-methods along a specific specialization hierarchy (which is independent of the class hierarchy), · sophisticated semantic relationships, e.g., dependency relationships between objects (which are totally independent of the composition relationship), · multiple object representations, allowing the users to manipulate the objects from several points of views simultaneously, · the systematic use of a powerful meta-object kernel, which is used to implement a reflexive architecture. The paper focuses on the last two issues. [ABSTRACT FROM AUTHOR]

Constraints are declarative statements of relations among elements of the language's computational domain, e.g., integers, booleans, strings, and other objects. Orthogonally, the tools of object-oriented programming, including encapsulation, inheritance, and dynamic message binding, provide important mechanisms for extending a language's domain. Although the integration of constraints and objects seems obvious and natural, one basic obstacle stands in the way: objects provide a new, larger, computational domain, which the language's embedded constraint solver must accommodate. In this paper we list some goals and non-goals for an integration of constraints and object oriented language features, outline previous approaches to this integration, and describe the scheme we use in Kaleidoscope'91, our object-oriented constraint imperative programming language. Kaleidoscope'91 uses a class-based object model, multi-methods, and constraint constructors to integrate cleanly the encapsulation and abstraction of a state-of-the-art object-oriented language with the declarative aspects of constraints. [ABSTRACT FROM AUTHOR]

Contracts were introduced by Helm et al. as a high level construct for explicitly specifying interactions among groups of objects. This paper describes further developments and application of the Contract construct. We show how Contracts can be used to represent classic algorithms as large grained reusable object oriented abstractions, how these algorithms can be customized through Contract refinement and how they are reused through Contract conformance. The example algorithm used throughout is the classic graph depth first traversal algorithm. This algorithm is represented as a Contract which is then refined to specify algorithms which number connected regions of graphs and which check graphs for cycles. Changes to the Contract language are introduced and we discuss some new problems resulting from the simultaneous reuse of related contracts. [ABSTRACT FROM AUTHOR]

The inheritance mechanism facilitates incremental modification and is the basis for the many advantages and popularity of the object oriented paradigm. The overloading of inheritance to describe different relationship requires a semantic model to facilitate "safe" redefinition between classes. Current approaches use type systems to ensure "safe" redefinitions, and are not capable of handling all the different uses of inheritance naturally. This paper develops a uniform type system built on a hierarchy which distinguishes between abstract and concrete classes. We show how such a structure on the hierarchy can be exploited to describe all common uses of inheritance in a natural way. Finally, we develop the formalism to define abstract and concrete classes and their relationships; and the type system along with the static type checker and the semantic model to interpret type safety. [ABSTRACT FROM AUTHOR]

This paper introduces a new model, based on so-called object-composition filters, that uniformly integrates database-like features into an object-oriented language. The focus is on providing persistent dynamic data structures, data sharing, transactions, multiple views and associative access, integrated with the object-oriented paradigm. The main contribution is that the database-like features are part of this new object-oriented model, and therefore, are uniformly integrated with object-oriented features such as data abstraction, encapsulation, message passing and inheritance. This approach eliminates the problems associated with existing systems such as lack of reusability and extensibility for database operations, the violation of encapsulation, the need to define specific types such as sets, and the incapability to support multiple views. The model is illustrated through the object-oriented language Sina. [ABSTRACT FROM AUTHOR]

An approach for supporting physical independence in Object Database Servers is proposed in this paper. While in current implementations the strategy for storing data objects reflects the logical object definitions, a certain degree of independence in the physical database organization would be essential to meet specific performance requirements. In this paper, a canonical object data model and a storage object data model are presented. In the first, the objects are organized in classes; in the second, physical objects with similar structures are grouped in collections. Mechanisms for mapping data structures and operations from the logical level to the physical level are discussed, and a comprehensive example is given. [ABSTRACT FROM AUTHOR]

This paper describes the development of a class hierarchy to support distributed transaction processing. Inheritance and polymorphism, key features of the object oriented programming model, have been used to develop a hierarchy of classes which convey to their subclasses the behaviours of persistence, concurrency-control, recoverability and identity necessary for distributed transaction processing. The development is traced from the requirements of distributed transaction processing to the definition of classes supporting these key properties. The system is interesting in both its development and its results. The development, not based on any rigourous design methodology, illustrates some of the design decisions unique to object-oriented systems. The resulting class hierarchy provides a flexible, object-oriented interface for reliable distributed programming. The paper includes a step-by-step description of the design of the classes and the class hierarchy. [ABSTRACT FROM AUTHOR]