The tutorial will present an integrated set of techniques for performing competent and comprehensive Business Process Modeling. Concepts have been drawn from a number of sources, including Stakeholder modeling Enterpr...
详细信息
The tutorial will present an integrated set of techniques for performing competent and comprehensive Business Process Modeling. Concepts have been drawn from a number of sources, including Stakeholder modeling Enterprise modeling based upon value chains and objects developed at the GMD in Germany Event models from James Odell and the corresponding UML activity diagrams Simulation techniques for multi-server queuing network analysis. These have been synthesized and integrated in a manner which is comprehensive, non-redundant and practical for commercial developers. The dynamic models reflecting the business process are built against the background of a static business object model represented using a standard UML Class Diagram. The approach is architecture and repository based. Resultant models can be easily expanded into system level event models reflecting the full impact of operations on the underlying business objects. If desired, this can extend to model technical events, such as user interaction with a GUI. The resultant models are easily mapped to technical design architectures which are GUI, Client Server and Internet capable. The tutorial will cover the concepts, but not the detail involved in this mapping. A paper will be issued to attendees which covers the mapping in detail.
As the demand for virtual reality systems increases, a new approach is needed to satisfy the following requirements: 1) A world consists of a large number of objects;2) A camera is allowed to move and a world should b...
详细信息
As the demand for virtual reality systems increases, a new approach is needed to satisfy the following requirements: 1) A world consists of a large number of objects;2) A camera is allowed to move and a world should be displayed in near real-time depending on the position of the camera as well as the angle of its lens;and 3) Minimum effort should be needed when objects are moving. We satisfy these requirements with the following: 1) An object-oriented rendering approach is developed and 2) An approach based on region trees and spatial indexing (specifically R+-tree) is developed to manage operations to objects (i.e., retrieval, insertion, and deletion) effectively.
Because the relational database (RDB) does not support OO features like inheritance and polymorphism, persistent objects whose data are stored in an RDB cannot usually make full use of these features. A solution to th...
详细信息
Because the relational database (RDB) does not support OO features like inheritance and polymorphism, persistent objects whose data are stored in an RDB cannot usually make full use of these features. A solution to this problem is presented in the form of a design and C++ implementation pattern in this article. In this pattern, the mapping of the persistent objects to RDB tables is addressed. A surrogate concept is used for the design of the persistent objects. The use of surrogates allows persistent objects to be extended through inheritance. Polymorphism is supported even though the structure of the persistent objects is fixed according to their storage in the RDB tables.
This article traces the unstable semantics of use cases from Jacobson to UML 1.3. The UML 1.1 metamodel formally defined the 'uses' and 'extends' use case relationships as stereotypes of generalization...
详细信息
This article traces the unstable semantics of use cases from Jacobson to UML 1.3. The UML 1.1 metamodel formally defined the 'uses' and 'extends' use case relationships as stereotypes of generalization, yet both received interpretations that varied between inheritance and composition, reflecting a large degree of confusion among developers. The recently revised UML 1.3 has quietly dropped these in favour of new 'include' and 'extend' relationships, which are styled instead as kinds of dependency. Despite this change, the deployment of use case diagrams encourages analysts to conceptualize and develop models which conceal arbitrary jumps in the flow of control, corresponding to goto and comefrom statements, and in which unpleasant non-local dependencies exist across modules. A discussion of examples reveals how a conscientious designer must disassemble use case models completely to produce properly-structured code. A radical solution is proposed.
Testing is a key aspect of software development, because of its cost and impact on final product reliability. Classical views on testing and their associated testing models, based on the waterfall model, are not well-...
详细信息
Testing is a key aspect of software development, because of its cost and impact on final product reliability. Classical views on testing and their associated testing models, based on the waterfall model, are not well-suited to an OO development process. The standardization of semi-formal modeling methods, such as UML, reveals this trend: testing can no longer be separated from specification/design/code stages. A test approach integrated with the OO process must be defined with an associated testing philosophy. The approach presented in this paper aims at providing a consistent framework for building trust into components. By measuring the quality of test cases, we seek to build trust in a component passing those test cases. We present a pragmatic approach for linking design and test of classes, seen as basic unit test components. Components are self-testable by enhancing them with embedded test sequences and test oracles. Self-testable components serve as building blocks for performing systematic integration and non-regression testing. The main contribution presented in this paper consists of using component self-tests to systematically exercise main system structural dependencies. This approach has been implemented in the Eiffel, Java, Perl and C++ languages. Since it is simpler, due to the direct support for Design-by-ContractTM in the language, the Eiffel implementation is detailed here.
In parallel with the rise to prominence of the OO paradigm has come the acceptance that conventional software metrics are not adequate to measure object-oriented systems. This has inspired a number of software practit...
详细信息
In parallel with the rise to prominence of the OO paradigm has come the acceptance that conventional software metrics are not adequate to measure object-oriented systems. This has inspired a number of software practitioners and academics to develop new metrics that are suited to the OO paradigm. Arguably, the most thorough treatment of the subject is that of the MOOD team, under the leadership of Abreau. The MOOD metrics have been subjected to much empirical evaluation, with claims made regarding the usefulness of the metrics to assess external attributes such as quality and maintainability. We evaluate the MOOD metrics on a theoretical level and show that any empirical validation is premature due to the majority of the MOOD metrics being fundamentally flawed. The metrics either fail to meet the MOOD team's own criteria or are founded on an imprecise, and in certain cases inaccurate, view of the OO paradigm. We propose our own solutions to some of these anomalies and clarify some important aspects of OO design, in particular those aspects that may cause difficulties when attempting to define accurate and meaningful metrics. The suggestions we make are not limited to the MOOD metrics but are intended to have a wider applicability in the field of OO metrics.
The goal of this paper is to obtain a one-to-one correspondence between state machines as e.g. used in UML and object-orientedprogramming languages. A proposal is made for a language mechanism that makes it possible ...
详细信息
The goal of this paper is to obtain a one-to-one correspondence between state machines as e.g. used in UML and object-orientedprogramming languages. A proposal is made for a language mechanism that makes it possible for an object to change its virtual bindings at run-time. A state of an object may then be represented as a set of virtual bindings. One advantage of object-orientation is that it provides an integrating perspective on many phases of software development, including analysis, design and implementation. For the static set of OO language constructs there is almost a one-to-one correspondence between analysis/design notations and OO programming languages. No such correspondence exists for the dynamic aspects, but the proposed state-mechanism is a contribution to a better correspondence. The proposal is based on previous work by Antero Taivalsaari and compared to the more complex features for changing object behavior as found in CLOS, Smalltalk, and Predicate Classes, it is simple and efficient to implement.
Use case analysis is a requirements capture technique that is most often used in the early stages of OO and component development projects. A requirements/service/interface (RSI) approach to use case analysis is descr...
详细信息
Use case analysis is a requirements capture technique that is most often used in the early stages of OO and component development projects. A requirements/service/interface (RSI) approach to use case analysis is described. This approach provides a framework for analyzing and understanding potential use case delivering and their interrelationships. The RSI approach also aims to assist in maximizing software re-use, by partitioning functionality into those aspects which are concerned with `managing the interface' to an actor, and those areas which make up the re-usable core of the system.
In this paper some effort estimation methods for objectoriented systems proposed in recent years are summarized. Moreover, we propose a general technique of effort estimation that is applicable to any paradigm of com...
详细信息
ISBN:
(纸本)9608052122
In this paper some effort estimation methods for objectoriented systems proposed in recent years are summarized. Moreover, we propose a general technique of effort estimation that is applicable to any paradigm of computer systems. Along these lines the huge importance of good estimation in the first stages of the computer systems life cycle is justified.
In the development of distributed programs two different concepts have to be considered, each being quite complex even on its own: concurrency and distribution. For both similar problems like synchronization and commu...
详细信息
In the development of distributed programs two different concepts have to be considered, each being quite complex even on its own: concurrency and distribution. For both similar problems like synchronization and communication need to be addressed, yet are treated with completely different mechanisms. This paper presents Dejay, a programming language based on Java that unifies concurrency and distribution into the single mechanism of virtual processors. This allows a considerable simplification for the development of distributed or concurrent programs and makes the transition from a local to a distributed environment seamless.
暂无评论