Data abstraction, information hiding, inheritance, and dynamic binding are four basic elements used in designing object-oriented (OO) programs. These four mechanisms enable programmers to write object-oriented program...
详细信息
Data abstraction, information hiding, inheritance, and dynamic binding are four basic elements used in designing object-oriented (OO) programs. These four mechanisms enable programmers to write object-oriented programs that are easily extended, reused and maintained. Software implemented by OO methodologies has increased software quality and productivity. However, this cannot be guaranteed without an appropriate software testing approach. Traditional testing approaches cannot be applied directly to the testing of OO programs due to the OO characteristics used in these programs. OO program testing strategies and methods are proposed continually, but fewer OO testing tools with flexibility are discussed.
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.
Cascade is a generic pattern for layering and ordering the parts of a complex whole. Each layer is itself a Composite pattern that composes objects into tree structures to represent whole-part hierarchies. Composite l...
详细信息
Cascade is a generic pattern for layering and ordering the parts of a complex whole. Each layer is itself a Composite pattern that composes objects into tree structures to represent whole-part hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly. Cascade makes the layering and ordering of objects and their compositions explicit. Cascade has the ability to treat one Composite layer as a primitive component of its parent layer and hence allows us to express the relationship between parts and wholes naturally: A whole for one particular layer is simply a part for the next layer up. In our modeling of transport systems, we have observed frequent recurrence of the Cascade pattern. We believe that many real-world problems exhibit the features of Cascade. In this article, we illustrate Cascade with more examples from transport systems.
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 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.
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.
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.
We present LOCAL++, an object-oriented framework to be used as a general tool for the development and the implementation of local search algorithms in C++. The framework comprises a hierarchy of abstract template clas...
详细信息
We present LOCAL++, an object-oriented framework to be used as a general tool for the development and the implementation of local search algorithms in C++. The framework comprises a hierarchy of abstract template classes, one for each local search technique taken into account (i.e., hill-climbing, simulated annealing, and tabu search). Each class specifies and implements the invariant part of the algorithm built according to the technique, and is supposed to be specialized by a concrete class which implements the problem-dependent part of the algorithm. LOCAL++ comprises also a set of abstract classes for creating new techniques by combining different search techniques and different neighborhood relations. The architecture of LOCAL++ provides a principled modularization for the solution of combinatorial search problems, and helps the designer deriving a neat conceptual scheme of the application, thus facilitating the development and debugging phases. LOCAL++ proved to be flexible enough for the implementation of the algorithms solving various scheduling problems.
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.
暂无评论