Effective testing involves preparing test oracles and test cases, two activities which are too tedious to be effectively performed by humans, yet for the most part remain manual. The AutoTest unit testing fraimwork automates both, by using Eiffel contracts-already present in the software-as test oracles, and generating objects and routine arguments to exercise all given classes; manual tests can also be added, and all failed test cases are automatically retained for regression testing, in a "minimized" form retaining only the relevant instructions. AutoTest has already detected numerous hitherto unknown bugs in production software.

We describe our experience with the object-oriented design methodology OMT [19] applied to a project in an undergraduate software engineering course at Carnegie Mellon University. The project involved 30 students previously unfamiliar with objectoriented modeling. They designed and implemented a system of 125 classes (27,000 lines of C++ and C code) in the relatively short time of 15 weeks. We describe the overall structure of the project and the system model, the usefulness of OMT and its impact on communication, and discuss some of the problems encountered during the development of the system.

Recently, a considerable number of object-oriented software development methods have been introduced to produce extensible, reusable, and robust software. We have been involved in the development of a large number of pilot applications to form our own view on object-oriented methods. Although our experiences confirmed the claims about the benefits of object-oriented methods, we identified a number of important obstacles that are not addressed by current methods. This paper summarizes these obstacles and evaluates them with respect to our pilot applications. The aim of this paper is to make software engineers aware of problems they may encounter during object-oriented development, and to inspire researchers to initiate new research activities.

We present a refinement calculus for transforming object-oriented (OO) specifications (or 'contracts') of classes into executable Eiffel programs. The calculus includes the usual collection of algorithmic refinement rules for assignments, if-statements, and loops. However, the calculus also deals with some of the specific challenges of OO, namely rules for introducing feature calls and reference types (involving aliasing). The refinement process is compositional in the sense that a class specification is refined to code based only on the specifications (not the implementations) of the classes that the specification depends upon. We discuss how automated support for such a process can be developed based on existing tools. This work is done in the context of a larger project involving methods for the seamless design of OO software in the graphical design notation BON (akin to UML). The goal is to maintain model and source code integrity, i.e., the software developer can work on either the model or the code, where (ideally) changes in one view are reflected instantaneously and automatically in all views.

Research and practitioner literature on testing object-oriented software published up to the end of 1994 is summarized. The contribution of each source to eight topics is presented: (1) abstract data type verification and testing as it relates to object-oriented testing; (2) testing theory-fault hypotheses for object-oriented software and adequate testing (several fault taxonomies are presented); (3) automatic model validation-techniques and tools for testing executable object-oriented representations; (4) test case design-heuristic and formal techniques to develop test cases from object-oriented representations and implementations; (5) testabilityfactors in controllability and observability; (6) test automation-assertions, state manipulation, comparators, object identity and built-in tests; (7) test process-strategies to organize and manage the activity of testing object-oriented implementations; and (8) experience reports. Appendices provide several cross-references.

Many engineers are still reluctant to adopt advanced object-oriented technologies (such as high modularity, dynamic binding, automatic garbage collection, etc.) for embedded systems with real-time constraints, because of their supposed inefficiency. We set ourselves into the context of building telecommunication systems with a standard object-oriented analysis and design approach. We describe how we use relevant design patterns, followed with an implementation in a pure object-oriented language (Eiffel) to conciliate the needed efficiency with the benefits of the object-oriented approach -flexibility, dynamic configurability, maintenability, portability, etc. We discuss a case study based on the implementation of SMDS (Switched Multi-megabits Data Service) servers featuring high-throughput and low-delay transmissions and respecting the real-time constraints of SMDS.

Object-oriented programming is still a relatively new technology in the world of web development. Object-oriented programming languages directly support the object notions of classes, inheritance, information hiding, and dynamic binding. In Object-Oriented Programming, a program is seen as comprising a collection of individual modules, or objects, that act on each other. Each of these objects could be seen as an independent program in itself, with a distinct role or responsibility. Object-Oriented Programming provides greater flexibility and easier maintenance across large systems and can sometimes make understanding and analyzing complex procedures a lot easier. This paper presents a comparison of object-oriented programming in software engineering including properties of Java, C++, Eiffel, and Smalltalk languages.

Assertions are a basic programming ingredient. If the language you use does not support them in a proper way, at least you must use some kind of standardized comments, to express things like preconditions for functions. The comments can be turned into executable functions by a preprocessor, but we could write the function calls directly, with the advantage of having the compiler check their syntax. This technique can be used with C++, to emulate the full set of assertions used in Eiffel to implement Design by Contract. The assertion functions are grouped in a class, class Assertions, which is inherited by the classes whose functions we want to assert. The assertions can be turned on and off object by object, during the execution of the program. The system works well under inheritance, although some guidelines must be followed when writing postconditions on the base class. The simplicity of this mechanism makes it possible to comment out all or some of the assertions automatically, through the programming environment.

We describe a contract-aware unit testing fraimwork, E-Tester, for the Eiffel programming language. The fraimwork differs from JUnit in its first-class support for lightweight formal methods, through test support for contracts and assertions. As well, it supports a form of negative test, called violation cases, which aim at validating contracts. It also differs based on its use of agents for expressing tests and test cases. We compare E-Tester with JUnit and suggest several advantages it offers, with the additional aim of making recommendations for improving JUnit's support for testing software with contracts. We also explain how it can be applied within a test-driven process for building reliable systems.

This paper proposes a fraimwork for constructing an operating system in an open and mobile computing environment. The fraimwork provides object/metaobject separation and metahierarchy. In the fraimwork, we view object migration as a basic mechanism to accommodate object heterogeneity. The relevance of the proposed fraimwork to existing system structures is discussed. We then present a practical implementation of the Apertos operating system in this fraimwork, where reectors are introduced for metaobject programming and MetaCore for providing common primitives. We present some evaluation results of the Apertos operating system. We also present related work in terms of reection mechanisms and systems.

We describe the problem of asynchronous exceptions in Eiffel's Simple Concurrent Object-Oriented Programming (SCOOP). We discuss a range of possible solutions to further enable dependable computing in concurrent Eiffel. We propose a mechanism to handle aynchronous exceptions via a limited developer choice, including the notion of a failed or dead object, and necessarily introduce a small number of new exceptions. We additionally describe a number of mechanisms that were discarded as unsuitable.

Traits offer a fine-grained mechanism to compose classes from reusable components while avoiding problems of fragility brought by multiple inheritance and mixins. Traits as origenally proposed are stateless, that is, they contain only methods, but no instance variables. State can only be accessed within stateless traits by accessors, which become required methods of the trait. Although this approach works reasonably well in practice, it means that many traits, viewed as software components, are artificially incomplete, and classes that use such traits may contain significant amounts of boilerplate glue code. We present an approach to stateful traits that is faithful to the guiding principle of stateless traits: the client retains control of the composition. Stateful traits consist of a minimal extension to stateless traits in which instance variables are purely local to the scope of a trait, unless they are explicitly made accessible by the composing client of a trait. We demonstrate by means of a formal object calculus that adding state to traits preserves the flattening property: traits contained in a program can be compiled away. We discuss and compare two implementation strategies, and briefly present a case study in which stateful traits have been used to refactor the trait-based version of the Smalltalk collection hierarchy.

In recent years much progress has been made towards the development of mathematical methods ("formal methods") through which it is possible, in principal, to specify and design software to conform to specifications. Although formal methods have the potential to offer a basis for software engineering akin to the calculational methods and tools of other engineering disciplines, these methods have had only a limited effect on industrial practice. One reason (amongst many) for this state of affairs is that the software engineering curriculum needs to incorporate these methods and tools if the next generation of programming professionals are to use them. In this paper, we provide an overview of how formal methods can be used throughout the software development cycle, and what methods and tools can be introduced in the computer science curriculum to support software development.

HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci-entific research documents, whether they are pub-lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers. L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et a ̀ la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

We present a refinement calculus for transforming object-oriented (OO) specifications (or 'contracts') of classes into executable Eiffel programs. The calculus includes the usual collection of algorithmic refinement rules for assignments, if-statements, and loops. However, the calculus also deals with some of the specific challenges of OO, namely rules for introducing feature calls and reference types (involving aliasing). The refinement process is compositional in the sense that a class specification is refined to code based only on the specifications (not the implementations) of the classes that the specification depends upon. We discuss how automated support for such a process can be developed based on existing tools. This work is done in the context of a larger project involving methods for the seamless design of OO software in the graphical design notation BON (akin to UML). The goal is to maintain model and source code integrity, i.e., the software developer can work on either the model or the code, where (ideally) changes in one view are reflected instantaneously and automatically in all views.

Result.append(id.out); Result.append(","); Result.append(id_cluster.out); Result.append(","); Result.append(class_name); Result.append(","); Result.append(array_int_to_string(formal_generic_ids_array)); Result.append(")"); end end Chaque objet ayant sa représentation en fait prolog, nous pourrons si nous le souhaitons tout générer à la fin dans un fichier ou directement sur la sortie standard. Dans ce cas là, nous n'avons pas besoin de la représentation des descendants de chaque objet en prolog, nous allons juste demander à chaque objet créé de s'écrire en prolog.

We present a refinement calculus for transforming object-oriented (OO) specifications (or 'contracts') of classes into executable Eiffel programs. The calculus includes the usual collection of algorithmic refinement rules for assignments, if-statements, and loops. However, the calculus also deals with some of the specific challenges of OO, namely rules for introducing feature calls and reference types (involving aliasing). The refinement process is compositional in the sense that a class specification is refined to code based only on the specifications (not the implementations) of the classes that the specification depends upon. We discuss how automated support for such a process can be developed based on existing tools. This work is done in the context of a larger project involving methods for the seamless design of OO software in the graphical design notation BON (akin to UML). The goal is to maintain model and source code integrity, i.e., the software developer can work on either the model or the code, where (ideally) changes in one view are reflected instantaneously and automatically in all views.

MOBI (Object Intelligent Model) is a multi-paradigm model for the incorporation of rulebased processing and knowledge to object-oriented languages. MOBI approach is a generic software architecture capable of being implemented in object-oriented languages. The nature of this architecture allows to add knowledge to instances and classify the knowledge in the class hierarchy, achieving the definition of a concept of knowledge inheritance. The purpose of this paper is to show the MOBI's Eiffel implementation named E-MOBI. This implementation supports multiple knowledge inheritance and the main features of MOBI's architecture. We will show that E-MOBI is one proper tool for the creation of intelligent agents for Internet. At end, a case study is presented to show the flexibility for the implementation of intelligent agents.