The class concept is central in OO programming (OOP) to implement abstract data types and enforce encapsulation. Type hierarchy has been regarded as a useful technique for consistency during extension. Yet, the import...
详细信息
ISBN:
(纸本)9780909925888
The class concept is central in OO programming (OOP) to implement abstract data types and enforce encapsulation. Type hierarchy has been regarded as a useful technique for consistency during extension. Yet, the importance of class and type hierarchy extends beyond their technical merits. Specifically, a class classifies objects and a type hierarchy classifies classes. Classification is fundamental to design, and its place in program evolution and programming language structure can be elucidated through formal symmetry models. Symmetry is the interplay between an invariant and the possibility of change. This paper discusses the importance of classification in OOP and shows the connection between classification and symmetry in class and type hierarchies.
Many systems are constructed without the use of modeling and visualization artifacts, due to constraints imposed by deadlines or a shortage of manpower. Nevertheless, such systems might profit from the visualization p...
详细信息
ISBN:
(纸本)9780909925888
Many systems are constructed without the use of modeling and visualization artifacts, due to constraints imposed by deadlines or a shortage of manpower. Nevertheless, such systems might profit from the visualization provided by diagrams to facilitate maintenance of the constructed system. In this paper, we present a tool, Reveal, to reverse engineer a class diagram from the C + + source code representation of the software. In Reveal, we remain faithful to the UML standard definition of a class diagram wherever possible. However, to accommodate the vagaries of the C + + language, we offer some extensions to the standard notation to include representations for namespaces, stand-alone functions and friend functions. We compare our representation to three other tools that reverse-engineer class diagrams, for both compliance to the UML standard and for their ability to faithfully represent the software system under study.
The growing popularity of wired and wireless Internet requires distributed systems to be more flexible, adaptive and easily extensible. Dynamic reconfiguration of component-based distributed systems is one possible so...
详细信息
ISBN:
(纸本)0769517366
The growing popularity of wired and wireless Internet requires distributed systems to be more flexible, adaptive and easily extensible. Dynamic reconfiguration of component-based distributed systems is one possible solution to meet these demands. However, there are some challenges for building dynamically reconfigurable distributed systems. Managing dependencies among components is one of the most crucial problems we have to solve before a system can be dynamically reconfigured at runtime. This paper describes a dependence management for dynamic reconfiguration of distributed systems. The dependence management analyzes not only the static dependencies among components, but also the dynamic dependencies that take place at runtime, in order to support an efficient consistent reconfiguration of distributed systems. In addition, the dependence management can deal with nested dependencies during a dynamic reconfiguration.
The design of software applications largely amounts to capturing constraints, representing the domain under study. Current case-tools do not provide an unambiguous way to represent constraints and ignore most of the c...
详细信息
ISBN:
(纸本)9780909925888
The design of software applications largely amounts to capturing constraints, representing the domain under study. Current case-tools do not provide an unambiguous way to represent constraints and ignore most of the constraints when moving to code. In this article constraints are expressed in the object Constraint Language (OCL) on class diagrams of the Unified Modelling Language (UML). We present a framework assisting the developer in making the transition from constraints on detailed design level to implementation. This framework defines a structure representing the issues related to turning declarative constraints into operational code. Our approach exploits the object-oriented paradigm by representing constraints as explicit classes in the implementation. The points in the code where the constraints must be checked are automatically deduced using the model and by performing path analysis on declarative constraint expressions. An improved code generator is built and integrated in the Argo/UML case-tool. This framework enables developers to exploit the high levels of information that are available in UML/OCL models.
As object-oriented paradigm becomes the mainstreamparadigm on software development, due to its attractivefeatures that can effectively divide a complex softwareproblem into several independent modules, one of theobjec...
详细信息
As object-oriented paradigm becomes the mainstreamparadigm on software development, due to its attractivefeatures that can effectively divide a complex softwareproblem into several independent modules, one of theobject-oriented languages - Java, becomes popular inrecent years because it is widely used in the rapidlygrowing Internet computing. However, similar to otherobject-oriented languages, Java has a big drawback of poorperformance. One of the main causes of the performance deficiencyis the extensive use of dynamic memory allocations anddeallocations during object or array creations anddestructions. Even a simple Othello applet game easilyrequires half a million of memory allocations for only onegame play. After analysis on the memory allocation behavior ofJava programs, it is concluded that about 99% of theallocations are of sizes less than 1024 bytes. The analysisalso shows that most of the allocated chunks in small sizewill survive only a very short period of time and after theyare garbage collected, they can be reused in the very nearfuture. This implies the memory allocation / deallocationpattern in Java is bounded to a certain kind of locality. The information presented in this paper is a referencefor designing an efficient hardware memory allocation /deallocation unit.
We present a novel approach to dynamic datarace detection for multithreaded object-oriented programs. Past techniques for on-the-fly datarace detection either sacrificed precision for performance, leading to many fals...
详细信息
ISBN:
(纸本)9781581134636
We present a novel approach to dynamic datarace detection for multithreaded object-oriented programs. Past techniques for on-the-fly datarace detection either sacrificed precision for performance, leading to many false positive datarace reports, or maintained precision but incurred significant overheads in the range of 3x to 30x. In contrast, our approach results in very few false positives and runtime overhead in the 13% to 42% range, making it both efficient and precise. This performance improvement is the result of a unique combination of complementary static and dynamic optimization techniques.
One of the techniques employed by programmers during the development process is the use of code and design conventions. These are rules-of-thumb or best practices that improve the maintainability of software applicati...
详细信息
To integrate a software component into a system, it must interactproperly with the system's other components. Unfortunately, thedecisions about how a component is to interact with other components aretypically com...
详细信息
To integrate a software component into a system, it must interactproperly with the system's other components. Unfortunately, thedecisions about how a component is to interact with other components aretypically committed long before the moment of integration and aredifficult to change. This paper introduces the flexible packagingmethod, which allows a component developer to defer some decisions aboutcomponent interaction until system integration time. The method dividesthe component's source into two pieces: the ware, which encapsulates thecomponent's functionality; and the packager, which encapsulates thedetails of interaction. Both the ware and the packager are independentlyreusable. A ware, as a reusable part, allows a given piece offunctionality to be employed in systems in different architecturalstyles. A packager, as a reusable part, encapsulates conformance to acomponent standard, like an ActiveX control or an ODBC databaseaccessor. Because the packager's source code is often formulaic, a toolis provided to generate the packager's source from a high-leveldescription of the intended interaction, a description written in thearchitectural description language UniCon. The method and tools areevaluated with a series of experiments in which three wares and ninetypes of packaging are combined to form thirteen components
We propose to use modal logic as a logic for coalgebras and discuss it in view of the work done on coalgebras as a semantics of object-oriented programming. Two approaches are taken: First, standard concepts of modal ...
详细信息
We propose to use modal logic as a logic for coalgebras and discuss it in view of the work done on coalgebras as a semantics of object-oriented programming. Two approaches are taken: First, standard concepts of modal logic are applied to coalgebras. For a certain kind of functor it is shown that the logic exactly captures the notion of bisimulation and a complete calculus is given. Examples of verifications of object properties are given. Second, we discuss the relationship of this approach with the coalgebraic logic of Moss (Coalgebraic logic, Ann. pure Appl. Logic 96 (1999) 277-317.). (C) 2001 Elsevier Science B.V. All rights reserved.
Modern object-oriented systems have to cope with an increasing number of exceptional conditions and incorporate fault tolerance into systems' activities in order to meet dependability-related requirements. An exce...
详细信息
Modern object-oriented systems have to cope with an increasing number of exceptional conditions and incorporate fault tolerance into systems' activities in order to meet dependability-related requirements. An exception handling mechanism is one of the most important schemes for detecting and recovering errors, and for structuring fault-tolerant activities in a system. The mechanisms that were ill designed can make an application unreliable and difficult to understand, maintain and reuse in the presence of faults. This paper surveys various exception mechanisms implemented in different object-oriented languages, evaluates and compares different designs. A taxonomy is developed to help address 10 basic technical aspects for a given exception handling proposal, including exception representation, external exceptions in signatures, separation between internal and external exceptions, attachment of handlers, handier binding, propagation of exceptions, continuation of the control flow, clean-up actions, reliability checks, and concurrent exception handling. Practical issues and difficulties are summarized., major trends in actual languages are identified, and directions for future work are suggested. (C) 2001 Elsevier Science Inc. All rights reserved.
暂无评论