|
WOON Abstractsof 27 papers selected for the Proceedings of both the First (WOON'96) and the Second (WOON'97) international conferences on object-oriented technology. |
Authors: Oleg T. Balovnev, Armin B. Cremers,
Wolfgang Reddig
University of Bonn, Germany
Institute of Computer Science III
Integrating large software systems with object-oriented databases should be supported by mechanisms for schema customization according to application specific needs. Customized schemas reflect the differing structure and behavior of objects modeling identical entities. Viewing objects in different schemas, however, raises the problem of maintaining consistency when these objects are modified by a particular application.
Recently, object-preserving view concepts have become popular as a means of describing objects that are direct instances of multiple classes. Consequently, different applications using different schemas are enabled to work on the same objects. However, special care has to be taken when updating an object that is direct instance of more than one class. If an application solely executes its specific update operation, the object will in general become inconsistent in the other applications since attributes not known in the updating application will be left unchanged. We propose a mechanism that attacks this problem hence facilitating the independent description of the various facets of multiply instantiated objects.
Author: Mark J. Bilger
IBM Corporation, NY, USA
Business dynamics in the global marketplace are driving network centric business transactions. These major changes require a new generation of technology such as distributed object computing provides. These changes are driving the invention of new tools that foster libraries of business components. These technologies in tandem provide the information processing prerequisite for the dominant paradigm of business competition during the later 1990's: mass customization.
Authors: Bart Childs
Department of Computer Science
Texas A&M University, USA
Johannes Sametinger
Department of Computer Science
Brown University, USA
Object-oriented programming has resulted in the reuse of class libraries and application frameworks. This can considerably improve the productivity in software development. Black-box reuse boosts productivity a lot more than white-box reuse. However, white-box reuse is the usual means of dealing with common parts in different applications, assuming that the same developers are building these applications or they somehow know about these commonalties.
With a case study we will demonstrate that both code and documentation can and have to be reused systematically and that there is a need for methods and tools for doing so. Literate programming and software reuse are not in contradiction. Current literate programming systems do not explicitly support software reuse, even though, as the study will show, there is a high demand for doing so.
We will also present an outline for systematic reuse of documentation. The same object-oriented techniques, i.e., inheritance and information hiding, that ease reusing software, will be applied to literate programs and thus, enable its reuse.
Keywords: object-oriented programming, object-oriented documentation,
literate programming, software reuse, software documentation
Authors: Philippe Collet & Roger Rousseau
UNSA (University of Nice - Sophia Antipolis)
I3S -- CNRS (French National Scientific Research Centre)
Sophia Antipolis, France
Half-way between mathematical notation and programming languages, assertions still have not found the place they deserve. This paper proposes regarding assertions as what they are: *computer objects* having a life cycle (as their definitions evolve) and many relations with their associated objects.
An object model is derived from two models developed to integrate persistency in Eiffel (FLOO) and to manage classes evolution (IREC)(~~).
Using this model, assertions are compared to logical formulas such as queries criteria, consistency constraints, specifications, conditions, etc. The most suitable times to check assertions are then discussed. Entities they act on are distinguished, in particular several kinds of collections and extents, volatile or persistent. Finally, different checking techniques are studied in order to choose the most appropriate one: full or sampled tests on real or generated objects, etc.
Keywords: Assertion, Eiffel, Mathematical Objects vs. Computer Objects,
Reification, Object Model, Object Life Cycle, Persistency,
Collection, Extent, Lazy Evaluation, Test.
-----------------------------
(~~) FLOO and IREC are parts of the ESPRIT~II (european) project No. 5311
"Business Class".
Authors: A. Frick, R. Neumann and W. Zimmermann
Universitaet Karlsruhe, Germany
This paper introduces a method for the construction of robust class hierarchies. This is an extension of our earlier work on the kind of inheritance relationships possible under robustness constraints, which resulted in conditions for the correct use of polymorphism under inheritance.
Here, we analyse constrained and unconstrained genericity in addition to inheritance. The combined robustness analysis of both OO concepts leads to conditions for the construction of robust class hierarchies. The principles can be applied constructively, resulting in a methodology.
Author: Lisa Florence
IBM Corporation, NY, USA
Reuse is the ability to leverage system components in multiple problem domains. This simple yet elusive concept has captured the hearts and minds of most IT shops as well as the product and service vendors who support them. For the technology enthusiast the IT industry is an exciting place to work. For a development manager faced with an enormous backlog of system requirements and a proliferation of technology, products and services, the choices to be made and the risk involved may be daunting.
This paper explores why reuse is a key focus for IT shops world-wide, why success is difficult to achieve in most organizations and outlines the characteristics of a successful reuse program. This paper draws on the experiences and lessons learned over my career as a developer, manager and most recently as the director of an Enterprise Reuse Program for a large financial services company. It also draws upon the research, advice and lessons learned from industry experts, consultants and other end user organizations striving for reuse and the benefits it can provide.
Reuse can drastically improve an IT shops ability to respond to new system requirements and therefore support the business in its efforts to respond to new business requirements. It does however, require planning and focus in order to invest in the proper organizational and technical infrastructure required to build, manage and reuse system assets. That statement seems to be in direct conflict with most of the popular literature which promotes ad-hoc reuse as the antidote for business and systems planning. This paper examines some of the key facets of the required infrastructure in order to build a case for architected, managed or systematic reuse as opposed to ad-hoc or opportunistic reuse.
Lastly, this paper explores the key organizational issues which present barriers to reuse. The solutions proposed draw upon key principles of disciplines such as business reengineering, quality, business architecture development and strategic systems planning - all of which require significant organizational change. Systematic reuse must be planned, focused, technically feasible, managed and supported.
Authors: Dr. Ivan Futo
ML Consulting and Computing Ltd., Hungary
Gyorgy Strausz
Technical University of Budapest, Hungary
Prof. Igor V.Vel'bitsky
International Scientific Centre of Software Engineering TECHNOSOFT
Ukrainian National Academy of Sciences, Ukraine
Sergey V. Yershov
International Scientific Centre of Software Engineering TECHNOSOFT
Ukrainian National Academy of Sciences, Ukraine
Sergey V. Golub
International Scientific Centre of Software Engineering TECHNOSOFT
Ukrainian National Academy of Sciences, Ukraine
Communication Design and Control System (CSCS) provides computer assistance for the communication aspects of a distributed program in network environment. The CDCS supports the static definition of kind of structure of shared objects, exchanged messages, remotely called procedures and remotely invoked methods. It identifies client and server processing units together with the involved services and puts boilerplate C++ code into prerequisite program units. Automatically generated header files program skeletons containing C++ definitions for the communication ease object-oriented programming and improve the program reliability. Similar tools set is delivered for UNIX and MS-Windows.
Authors: Thomas Gerth, Roland Schachtschabel,
Reinhold Schönefeld
Technische Universitat of Ilmenau, Germany
In software development, as well as in other areas of life and science, there are encountered recurring themes and structures. By explicitely describing them together with the underlying considerations and decisions in an abstract manner, i.e. in a pattern form, the knowledge and experience of developers can be recorded in a structured and systematic way. Such patterns then may be used by other developers to reuse that recorded experience. Furthermore, patterns help to improve the quality of software documentation.
This paper first gives an introduction to the pattern subject. Then the authors discuss their experiences of using patterns, where much attention is paid to the problems thereby arising.
Authors: Peter Hartmann, Moritz Frisch
Fachgebiet Mikroprogrammierung and Fachgebiet Programmiersprachen
und Übersetzer Fachbereich Informatik
Fachbereich Informatik
Darmstadt, Germany
We report about the Smalltalk implementation of a simulator for dynamic cellular structures. The structures of interest are represented by a graph which is decorated with a multitude of intensively interacting objects called the cells. Cellular structures have applications in fields of natural sciences and engineering sciences where complex systems need to be simulated.
The simulator is based on the theory of parallel replacement systems for cellular hypergraphs. One part of the project deals with design patterns and a class library for constructing replacement systems. This eases the usage of the simulator by non computer scientists, i.e. biologists or scientists from mechanical engineering.
A further aspect of the project is related to improving the performance of the simulator, because up to several thousand cells shall be simulated. The performance of the simulator can be enhanced using OO technology since it allows us to describe how objects send messages to productions which shall be applied (rather than to test repeatedly at which locations of the graph each of the productions may be applied).
Author: Wolfgang Hesse
FB Mathematik/Informatik, Philipps-Universitaet
Marburg, Germany
Software development goals, guidelines and techniques have considerably changed during the last decade. New paradigms and ideas such as object orientation and software evolution have found extraordinary attention and have lead to new system architectures, development strategies, methods and tools. Software process models, however, have not yet sufficiently been further developed to meet the changed managerial requirements originating from the technical and methodical changes. This has also been confirmed by an empirical interdisciplinary study which was recently carried out by computer scientists, work psychologists and sociologists. It is even true for many so-called object-oriented methodologies such as OOA by Shlaer & Mellor, OOAD by G. Booch, OMT by J. Rumbaugh et al. and OOSE by I. Jacobson which stick more or less to traditional, phase-oriented concepts and process structures. Thus there is still a considerable gap left between modern development techniques and conventional process models and management techniques.
A new software process model for evolutionary, object-oriented software development (short: EOS) is being presented to fill this gap and to support modern software development by adequate process structures and management techniques. Ultimately giving up the traditional phase structure, the EOS model is based on development cycles and activities which are associated with the ,objects" of software construction: systems, subsystems, components and classes. Management procedures build upon this framework and allow for multi-level, adapted, differentiated planning and control. This implies new challenges for project managers but it also enables them to plan and to act in a more adequate, dynamic and situative manner.
Author: Dipl.-Inform. Peter E. H. Hofmann
University of Stuttgart, Germany
The design of integrated circuits requires massive computer support. Therfore in recent years a variety of different CAE tools has been developed, which support almost all tasks within the design process. CAE systems, which integrate a set of CAE tools, are extremely large and complex software systems typically containing several hundred thousand lines of code. The developement of such systems often requires hundreds of man years.
Using the object-oriented techniques for the developement of CAE-tools solves only the software engineering problems. There is, whoever, a number of additional problems to solve, especially the optimisation of computation expensive algorithms. Concurrent programming is one way to optimize such NP-complete algorithms. Another goal of the CoDO project is to take advantage of object-oriented programming techniques and their potential for software reusability for the construction of concurrent object-oriented software systems. The problem is that issues of concurrency are not orthogonal to object-oriented concepts, makes it necessary to integrate concurrent and object-oriented features in one language.
The paper describes an environment for designing and implementing concurrent object-oriented CAE tools based on the EIFFEL language. The paper contains also a detailed report about our experience how object-oriented techniques can be applied to implement large and complex software systems
Author: Pekka Kahkipuro
University of Helsinki, Finland
This paper presents a pattern language that documents the fundamental solutions for distributed object-oriented computing. The patterns are divided into three categories. The technology patterns cover the basic solutions found in most distributed systems. The middleware patterns explain the role of the object-oriented middleware and document their functionality. Finally, the exploitation patterns show how middleware can be used in some difficult cases.
The contribution of this paper is threefold. First, the technology and middleware patterns provide a concise introduction to the state-of-the-art distributed computing. Second, the exploitation patterns show some modern ways for overcoming traditional problems of distributed computing. Finally, the paper can be used as a basis for more extensive pattern languages for distributed application design.
Authors: Jens Knoop
University of Passau, Germany
Wolfgang Golubski
University of Siegen, Germany
Type analysis is the key for improving the efficiency of untyped object-oriented programs with dynamic method binding by replacing costly `late' by the more efficient `early' binding. Classical optimization is concerned with improving the efficiency of programs of `conventional' procedural languages. In this paper we adapt the framework of abstract interpretation to the object-oriented setting, and demonstrate that it uniformly supports type analysis and classical optimization. We illustrate this by presenting a new abstract interpretation based type analysis which is exceptional for treating program branches almost deterministically, and by developing an algorithm for the computationally optimal placement of primitive method calls in a program, which directly evolves from its interprocedural code motion counterpart. We show that type analysis is not a prerequisite of classical optimization, but in general it enhances its power.
Keywords: (Untyped) object-oriented languages, type analysis,
abstract interpretation, data flow analysis,
(classical) program optimization, MOP-Solution,
MFP-Solution, (object-oriented) Coincidence Theorem,
code motion, partial redundancy elimination, Smalltalk.
Author: Thomas Kühne
Department of Computer Science, TU Darmstadt, Germany
Object references in object-oriented languages suffer from their pointer heritage. We discourage the use of a single magic value, shared among all reference types, to denote a non-referencing state. The advantages of void values, which include uniform treatment of empty and non-empty structures, provision of default-behavior, termination of recursive definitions, and gracefully dealing with error situations are presented in pattern form. We then investigate the impact of the void value pattern for language design, extending the applications to implicit creation, abstract method execution, and simplified module usage. Finally we point out related mechanisms like pattern matching in functional programming languages and compare void values to UFO's so-called nullcases.
Authors: H. Maurer, N. Scherbakov
Institute for Information Processing and
Computer Supported New Media,
Graz University of Technology, Austria
Although the object-oriented paradigm is well suited for modeling self-contained independent objects, it is not suited for modeling relations (or static links) between abstract data objects. At the same time, the concept of computer-navigable links is an integral part of the hypermedia paradigm. In contrast to multimedia, where the object-oriented paradigm plays a leading role, this "link deficiency" considerably reduces the application of object-oriented methods in hypermedia.
In this paper, we present a new hypermedia data model (the HM data model) which incorporates the well-known principles of object-oriented data modeling into the management of large-scale, multi-user hypermedia databases. The model is based on the notion of abstract hypermedia data objects called S-collections. Computer-navigable links are encapsulated within a particular S-collection and are also bound between S-collections. This approach overcomes the link deficiency in the object-oriented paradigm
Author: Dr. Alexander A. Podelko
Rodnik Software
Moscow, Russia
Widely used for application development, relational DBMSs (RDBMSs) have several important limitations. One of the means to overcome these limitations is implementation of object-oriented DBMSs.
Possessing a great potential for development, ODBMSs could become a major player in DBMS development arena soon.
Right selection of suitable ODBMS is rather complicated task. In order not to make a mistake special investigation should be done.
As a result of investigation, aimed at selection of right ODBMS for development of serious business applications for complex objects in Russia, POET ODBMS was selected as most suitable, if C++ interface is used and there is no requirement for distributed data base support.
Author: Dirk Riehle
UBILAB, Union Bank of Switzerland
Design patterns are patterns of classes and objects that present a solution to a recurring design problem. They are usually described using a class diagram. Class diagrams, however, often intertwine the actual solution with efficient ways of implementing it. This paper uses role diagrams to describe and compose patterns. Role diagrams helps designers focus on the collaborations and distribution of responsibilities between objects. Role diagrams are also a better starting point for composing patterns. This paper presents several examples and reports on first experiences with using role diagrams for composing patterns which have been very promising.
Authors: Dr. Michael Rohloff
Danet GmbH Munchen, Germany
This paper introduces an object oriented approach to business process modeling. The approach integrates decisions on the organisational design with the information systems development. Based on the understanding of business processes as a customer-supplier relationship a general process model is introduced which summarizes fundamental characteristics of business processes. These characteristics are the ground for an object oriented approach which extends the OO modeling-technique OMT with features for business process modeling. An example illustrates the principal approach, the main modeling steps and the methodical support. It is based on an outside (macro) and an inside (micro) view on business processes.
Author: Richard K. Runyan
IBM Corporation
Research Triangle Park, NC, USA
Object oriented technology is giving every indication that it will deliver on the promise of reuse. If so, this will be looked back on as the most significant advance in software programming technology since the advent of the compiler some 35 years ago. But just as significant as the technological advance will be the dramatic economic restructuring of the software industry. Real reuse will precipitate a "parts economy" for software. Parts will provide a "make or buy" alternative for developers and their management, and as "make" gives way to "buy", the age of software as a craft will end.
Parts and reuse technology give the software industry the opportunity to apply the discipline of engineering science to the design and construction of software applications. Competitive pressures have been demanding these advances for years. Only now are we seeing the confluence of hardware and software technologies that finally hold the promise of unleashing a response to those pressures in the form of object oriented systems.
Yet to be generally and unequivocally proven in widespread application and at industrial strength scale, there are many enterprise prototype projects going on and a generous sprinkling of successful scaled-up full production applications that are pointing the way. The quantitative benefits from reusing parts are in the process of being proven.
Author: Dr. rer. nat. Michael Ryba
Stuttgart University
IPVR/ISE, Germany
This paper describes the results of the project PLASMA (PLAnning and Scheduling of Methodology-based Activities). The main goal of this project was the development of tools supporting administrative tasks bound up with the computer-aided design of integrated circuits, such as project planning, workflow management, etc. Within this project object-oriented principles have been used in two ways:
Author: Alois Stritzinger
Institut f. Wirtschaftsinformatik
C. Doppler Laboratory f. Software Engineering
J. Kepler University of Linz, Austria
This paper starts with a consolidated description of widely applied reuse techniques and discusses their drawbacks. As one of the most promising techniques, component-based software development is presented in more detail. Our modeling approach defines three representation techniques for capturing and documenting the essence of component systems. Each one can be represented in two forms, graphically or textually. To further ease modeling complex software systems, we present a general architecture model which structures a system in layers with well-defined tasks. Last, we discuss our view on the task of modeling in contrast to designing and present a list of modeling process activities which can be performed in any order.
Keywords: analysis, design, modeling, components, software architecture
Authors: Marlon Erthal Righi Vieira, Guilherme Horta Travassos
Federal University of Rio de Janeiro, Brazil
This paper describes some facilities for supporting Integrated Software Engineering Environment (ISEE) testing activities for object-oriented software development with emphasis on a scenario based test. A key element in this approach is the integration development/testing process utilising a group of facilities to verify and validate any development product. In our point of view software testing activity includes the verification and validation of any product of software process development and not just the execution of code. The benefit of this approach, using test tools in ISEE is to reduce the extra test effort in the development process when the test activity is performed, which is the reason why it becomes a relevant research that has the objective of identifying the testing facilities that should be available during the development of a ISEE
Authors: Holger Vogelsang, Uwe Brinkschulte
Institute for Microcomputer and Automation
University of Karlsruhe, Germany
This paper describes the design and implementation of persistent objects for given relational database system. This is the solution of a problem that raised in a larger aplication at the institute. To build a reusable man machine service for distributed systems wihin the object oriented language C++ there is a need to save and restore to contents of objets together with their relations. This is necessary to keep a prebuild user interface in a datbase and to allow permanent runtime modifications. On the other hand old style applications usig the man machine system must be able to use the same database or at least the same datbase server. Furthermore, this solution is usable in realtime requirements.
Author: Dipl.-Ing. Dipl.-Wirt.Ing. Holger Winklbauer
Research Institute for Operations Management
at Aachen University of Technology (RWTH),
Aachen, Germany
Today's enterprises have to compete in a highly dynamic market. The flexibility of companies on customer demands and production technology has become the most important success factor to compete. Recent studies have shown that information technology has a major impact on the companies flexibility and consequently on the organisation strategy. Today's information technology restricts the organisational potential of enterprises. Within this paper the negative aspects of this impact are shown and a different approach towards organisation strategy is introduced. Therefore the human-machine interface and the treatment of information like infrastructure are focused on. The resulting concept is that users are working interactively with a concrete information system using cognition.
Authors: Jens Knoop, Falk Schreiber
University of Passau, Germany
Object-oriented programming is going to replace the imperative programming paradigm as the state-of-the-art paradigm for large industrial software projects. The benefits offered, however, come at the price of intricate new problems for optimizing compilers. In contrast to the imperative paradigm, where abstract interpretation is well-established as a uniform and theoretically well-founded framework for analysis and optimization, for the object-oriented paradigm the situation is still characterized by approaches being quite specific or ad-hoc. Here, we show how to enhance the framework of abstract interpretation to the object-oriented setting considering an Oberon-2- like language for illustration. We arrive at a generic framework, whose generality and flexibility is demonstrated by a hierarchy of type analysis algorithms of different power and precision. Their results can directly be used for various optimizations like inlining type-bound procedure calls or eliminating unnecessary type tests and assertions. Moreover, we show how a previously proposed approach for type analysis by Corney and Gough, which is restricted to the intraprocedural setting, can be modeled in our approach, and even interprocedurally be enhanced, underlining thus the generality and flexibility of our approach.
Authors: Alexander Kogtenkov, Andrew Tischenko, Alexei Shestialtynov
Object Tools (Moscow), Russia
Visual Eiffel programming system is targeted to effective development of programs in object-oriented programming (OOP) language Eiffel. Being most methodologically completed Eiffel includes the features of well-known OOP languages such as C++, Smalltalk, Java and extends them. Among them: multiple inheritance; fully implemented polymorphism; encapsulation with detailed description of visibility rules; delayed methods implementation; parametric template description; exception handling mechanism; once-calculated methods; automatic garbage collection; connection with features implemented in other programming languages. Eiffel supports a "programming by contract" technology at the source language level. This allows to develop large programming systems efficiently. It is provided due to built-in mechanism of assertions, including preconditions, postconditions, invariants, variants, etc. This opportunity permits to apply program verification up to proofs of program correctness. Automatic dynamic memory management ensures the lack of "hanging pointers" while automatic object initialization eliminates the problems of non-initialized variables. Summarizing the above, Eiffel may be considered as a general-purpose OOP language targeted for both large systems design and their implementation.
Authors: Alexander V. Smolyaninov, Vitaly A. Kalmychkov
Saint Petersburg Electrotechnical University, Russia
The main purpose of a research is to develope a visual programming environment for teaching and learning OOP using C++. The paper describes how graphical patterns for visual object-oriented programming in C++ was designed. As a result, the set of patterns is proposed. The set reflects the main principles of OOP concept and emphasizes peculiarities introduced from the C++ language. An overview of CLaD, a visual tool for class design and implementation in C++, is also presented. CLaD is complete programming environment - that is, it is possible to write and maintain an entire program in C++.