Reusing software improves quality as well as productivity. In practice, it is hard to achieve significant levels of reuse in commercial applications beyond generic support software. This tutorial will present programm...
详细信息
Reusing software improves quality as well as productivity. In practice, it is hard to achieve significant levels of reuse in commercial applications beyond generic support software. This tutorial will present programming and design techniques for achieving more reuse. The first session will examine the obstacles to reuse in commercial data processing, and illustrate the potential benefits. The main session will: consider design reuse, source code reuse and routine libraries;review the principles of modular design, cohesion, coupling and information hiding;and show how inheritance and dynamic binding extend and enhance these established techniques. The final session addresses organizational aspects of reuse, an alternative project lifecycle, metrics and developer motivation. The tutorial is intended for developers and their managers regardless of language, method or platform.
Static Single Assignment (SSA) is an effective intermediate representation in optimizing compilers. However, traditional SSA form and optimizations are not applicable to programs represented as native machine instruct...
详细信息
Static Single Assignment (SSA) is an effective intermediate representation in optimizing compilers. However, traditional SSA form and optimizations are not applicable to programs represented as native machine instructions because the use of dedicated registers imposed by calling conventions, the runtime system, and target architecture must be made explicit. We present a simple scheme for converting between programs in machine code and in SSA, such that references to dedicated physical registers in machine code are preserved. Our scheme ignores all output- and anti-dependences imposed by physical registers while a program is in SSA form, but inserts compensation code during machine code reconstruction if any naming requirements have been violated. By resolving all mismatches between the two representations in separate phases, we are able to utilize existing SSA algorithms unaltered to perform machine code optimizations.
Runtime systems are critical to the implementation of concurrent object-orientedprogramming languages. This paper describes a concurrent object-orientedprogramming language - Balinda C++, running on a distributed me...
详细信息
Runtime systems are critical to the implementation of concurrent object-orientedprogramming languages. This paper describes a concurrent object-orientedprogramming language - Balinda C++, running on a distributed memory system and its runtime implementation. The runtime system is built on the top of the Nexus communication library. The tuplespace is the key of Balinda C++. A distributed tuplespace model is presented to improve data locality. Some experiments have been done to verify our model. The results indicate that our model is effective to improve system performance.
The most distinctive requirement of modern complex heterogeneous real-time systems is the need to dynamically adapt to dynamically changing conditions. The TAFT (Time-Aware, Fault-Tolerant) scheduling approach address...
详细信息
The most distinctive requirement of modern complex heterogeneous real-time systems is the need to dynamically adapt to dynamically changing conditions. The TAFT (Time-Aware, Fault-Tolerant) scheduling approach addresses this class of real-time systems. It trades functionality of the task for its timeliness. TAFT scheduling uses the concept of the expected case execution time (ECET) of a task in order to achieve adaptivity. The authors describe an integrated on-line monitoring and execution time prediction infrastructure that is able to compute the ECETs efficiently during runtime. Especially, we will explain how object orientation can be utilized to achieve more fine-grained and thus often more precise execution time predictions.
In this talk, we present a series of C++ programming design idioms for writing efficient C++ programs, briefly review the underlying C++ object model, and turn to design alternatives when the idioms themselves become ...
详细信息
In this talk, we present a series of C++ programming design idioms for writing efficient C++ programs, briefly review the underlying C++ object model, and turn to design alternatives when the idioms themselves become overwhelmed with, say, large-scale object creation and copy. We look at object-based and object-oriented design, use of the STL container classes and generic algorithms, and the design alternatives of inheritance versus parameterization through use of the C++ template facility. This is a particularly effective area of program efficiency because (a) the idioms generally make for more readable programs, and (b) once the idioms and implementation (or object) model is internalized, these gains in efficiency come mostly for free - I like to think of them as low-hanging fruit. In the course of the tutorial, I'll point out areas where experienced C programmers tend to write correct but frightfully sluggish C++ code by contrasting C and C++ programming idioms.
The modeling of behavior in object-oriented systems usually relies on control flow diagrams and (extended) state automatas. These basic techniques do not well support the design in a declarative style. This style is u...
详细信息
The modeling of behavior in object-oriented systems usually relies on control flow diagrams and (extended) state automatas. These basic techniques do not well support the design in a declarative style. This style is useful for modeling integrity constraints, especially active constraints, on the data model, to perform event handling, to derived new attribute values and associations and to model strategies in business and engineering. In this contribution, rules are added as a declarative modeling technique for behavior. Roughly speaking, a rule consists of a condition and an action. If the condition is true, the action is performed. The concept of rules is integrated into an existing object-oriented modeling technique by formulating rules on object diagrams. A rule application may test and change a certain object structure. The application may be triggered automatically by a relevant change of this object structure, periodically or by an event occurring in some behavior diagram. This rule concept has an underlying formal semantics on the basis of graph transformation which may be exploited for analyzing a designed rule set concerning e.g. conflicts, dependencies, etc. The graphical notation of the rules follows the UML-notations as far as possible.
OPEN is the premier third-generation, process-focussed, public domain OO methodology. It is documented in a number of professional-level texts. In this tutorial, a beginner's level presentation, OPEN is introduced...
详细信息
OPEN is the premier third-generation, process-focussed, public domain OO methodology. It is documented in a number of professional-level texts. In this tutorial, a beginner's level presentation, OPEN is introduced through a number of case studies using UML as the notation.
In this paper we analyze statistically the efforts for C++ program modification which is needed by a given requirement change during the prototyping development of a certain GUI application. In the analysis we conside...
详细信息
In this paper we analyze statistically the efforts for C++ program modification which is needed by a given requirement change during the prototyping development of a certain GUI application. In the analysis we consider both C++ program P to be updated and the resultant C++ program P′, and discuss the correlation between the values M(P) of the object-oriented metrics obtained from P and the efforts E(P′) needed to produce P′. According to the definitions of M(P) and E(P′), we present two approaches in this paper. In the first approach, we take M(P) as the value obtained by applying the metrics to the whole source code P and E(P′) as the lines of codes(LOC) that are actually modified or created, respectively. However, the experimental result cannot show strong correlation between M(P) and E(P′). Based on the analysis results of the first approach, we propose the second approach to consider the object-oriented properties more directly. The analysis process consists of following three steps: 1) take only the classes in P, classify them according to the MVC paradigm originally for Smalltalk their functions, and then evaluate M(P) for the classified classes, 2) in order to evaluate the efforts for code modification, define E(P′) as the heuristic value which is calculated empirically from the numbers of methods and members created or modified, and 3) analyze the relationship between the values of M(P) on the classified classes in P and the values of E(P′) on the source codes in P′. From the experimental result, we can prove there exists a high correlation between them.
A cornerstone in the object-oriented paradigm is the abstraction mechanisms transcending analysis, design, and implementation. The notions of class, object, behaviour, and inheritance are supported in both design nota...
详细信息
A cornerstone in the object-oriented paradigm is the abstraction mechanisms transcending analysis, design, and implementation. The notions of class, object, behaviour, and inheritance are supported in both design notations and through programming language constructs in object-oriented languages. An association is a declarative mechanism to associate objects, and it is well known from analysis and design notations. However, associations are not matched by a programming language construct. This paper eliminates the semantic gap between design and implementation by proposing a programming language construct to support associations directly. An important issue in designing such a language construct is to make it as efficient and flexible as a manual translation to pointers and containers, and that it gives added benefits compared to a manual translation. Our association compiler can generate code that is as efficient as hand produced code, and it is our experience that it is easier to make changes to program structure and implementation when using language supported associations.
In this Tutorial I provide a number of Principles for using PBC to rigorously document class interfaces in a way that is accessible to technically oriented software developers. With each Principle I present an example...
详细信息
In this Tutorial I provide a number of Principles for using PBC to rigorously document class interfaces in a way that is accessible to technically oriented software developers. With each Principle I present an example, a justification, and advice about when it might be appropriate to violate the Principle (and how to document such violations). The complexity of the Principles vary. Some are simple enough that we can use them to improve the documentation of almost any class. Others are sufficiently complex and time-consuming to use that they may only be appropriate in designing class libraries. Indeed, I will use examples from ELKS, the Eiffel Library Kernel Standard to illustrate the power of the Principles.
暂无评论