The confluence of component based development, model driven development and software product lines forms an approach to application development based on the concept of software factories. This approach promises greate...
详细信息
ISBN:
(纸本)1581137516
The confluence of component based development, model driven development and software product lines forms an approach to application development based on the concept of software factories. This approach promises greater gains in productivity and predictability than those produced by incremental improvements to the current paradigm of object orientation, which have not kept pace with innovation in platform technology. Software factories promise to make application assembly more cost effective through systematic reuse, enabling the formation of supply chains and opening the door to mass customization.
Static analysis of object-orientedapplications has become widespread over the last decade, mainly in the context of compile-time optimizations. The paper describes how static analysis of virtual method calls can be e...
详细信息
ISBN:
(纸本)1581137516
Static analysis of object-orientedapplications has become widespread over the last decade, mainly in the context of compile-time optimizations. The paper describes how static analysis of virtual method calls can be employed to provide a high-level view of Java applications. The result is a method call graph that can be built from either source or bytecode, and a graphical browser that enables the user to analyze control flow and the coupling between classes and packages in an intuitive fashion, thereby supporting application design as well as refactoring and debugging. In order to achieve the necessary bijection between source and bytecode representations of classes, we implement a new approach based on source code pre-processing.
In theory, requirements engineering solves many of software engineering's fundamental problems. The stakeholders know what the developers are building, why they are building it, when they are building it, and even...
详细信息
ISBN:
(纸本)1581137516
In theory, requirements engineering solves many of software engineering's fundamental problems. The stakeholders know what the developers are building, why they are building it, when they are building it, and even to some degree, how they are building it. If requirements engineering resolves some of the basic communication issues between IT and the business, why aren't more companies actively practicing this discipline? In practice, requirements engineering is almost impractical without a commercial automation tool. The critics argue that the current automation tools do not convincingly demonstrate its value proposition, or fulfill the longstanding promises of the leading requirements engineering experts. This paper describes how the enterprise software development lifecycle management solution, Visual SDLC, addresses some of the outstanding issues of the present requirements engineering tools.
This panel brings together coaches to discuss all aspects of the practice - how to become a coach, choosing a coach, and describing what is to be an (in) effective coach. A coach watches, provides feedback, and sugges...
详细信息
ISBN:
(纸本)1581137516
This panel brings together coaches to discuss all aspects of the practice - how to become a coach, choosing a coach, and describing what is to be an (in) effective coach. A coach watches, provides feedback, and suggests subtle direction. The coach may be more - for example - an architect or team lead. The panelists will describe their positions and offer feedback. Panelists were asked to offer responses to three questions: • How did YOU become a coach? • What's the toughest thing you've had to do as a coach? • What's your advice for teams looking for a coach?
作者:
Agrawal, Aditya
Vanderbilt University Nashville TN 37235 United States
The Model Driven Architecture (MDA) can have a greater impact by expanding its scope to Domain Specific MDA (DSMDA). This helps developers to represent their systems using familiar domain concepts. For each DSMDA, a t...
详细信息
ISBN:
(纸本)1581137516
The Model Driven Architecture (MDA) can have a greater impact by expanding its scope to Domain Specific MDA (DSMDA). This helps developers to represent their systems using familiar domain concepts. For each DSMDA, a transformer is needed to convert Domain Specific Platform Independent Models (DSPIM-s) to Domain Specific Platform Specific Models (DSPDM-s). Such model transformers are time consuming and error prone to develop and maintain. A high-level specification language to formally specify the behavior of model transformers is required. The language must also have an efficient execution framework. This research proposes to develop such a language and execution framework.
object-orientedprogramminglanguages provide effective means to achieve better reuse and extensibility levels, which increases development productivity. However, the object-oriented paradigm has several limitations, ...
详细信息
ISBN:
(纸本)1581137516
object-orientedprogramminglanguages provide effective means to achieve better reuse and extensibility levels, which increases development productivity. However, the object-oriented paradigm has several limitations, sometimes leading to tangled code and spread code. For example, business code tangled with presentation code or data access code, and distribution, concurrency control, and exception handling code spread over several classes. This decreases readability, and therefore, system maintainability. Some extensions of the object-oriented paradigm try to correct those limitations allowing reuse and maintenance in practical situations where the original paradigm does not offer an adequate support. However, in order to guarantee that those benefits will be achieved by those techniques it is necessary to use them together with an implementation method. Our objective is to adapt and to analyze an object-oriented implementation method to use aspect-orientedprogramming in order to implement several concerns to a family of object-oriented system. In particular, we are interested in implementing persistence, distribution, and concurrency control aspects. At the moment we are particularly interested to present some results and get feed back about a performed experiment to identify if and when a progressive approach is better than a non-progressive one. In a progressive approach, persistence, distribution, and concurrency control are not initially considered in the implementation activities, but are gradually introduced, preserving the application's functional requirements. This approach helps in dealing with the inherent complexity of the modern applications, through the support to gradual implementations and tests of the intermediate versions of the application.
作者:
DeLesley, HutchinsCISA
School of Informatics University of Edinburgh 11 Crichton Street Edinburgh EH8 9LE United Kingdom
I present the Ohmu language, a unified object model which allows a number of "advanced" techniques such as aspects, mixin layers, parametric polymorphism, and generative components to be implemented cleanly ...
详细信息
ISBN:
(纸本)1581137516
I present the Ohmu language, a unified object model which allows a number of "advanced" techniques such as aspects, mixin layers, parametric polymorphism, and generative components to be implemented cleanly using two basic concepts: block structure and inheritance. I argue that conventional ways of defining classes and objects have created artificial distinctions which limit their expressiveness. The Ohmu model unifies functions, classes, instances, templates, and even aspects into a single construct - the structure. Function calls, instantiation, aspect-weaving, and inheritance are likewise unified into a single operation - the structure transformation. This simplification eliminates the distinction between classes and instances, and between compiletime and run-time code. Instead of being compiled, programs are reduced using partial evaluation, during which the interpreter is invoked at compile-time. Within this architecture, standard OO inheritance becomes a natural vehicle for creating meta-programs and automatic code generators - the key to a number of recent domain-driven programming methodologies.
The term aspect-orientedprogramming (AOP) has come to describe the set of programming mechanisms developed specifically to express crosscutting concerns. Since crosscutting concerns cannot be properly modularized wit...
详细信息
The term aspect-orientedprogramming (AOP) has come to describe the set of programming mechanisms developed specifically to express crosscutting concerns. Since crosscutting concerns cannot be properly modularized within object-orientedprogramming, they are expressed as aspects and are composed, or woven, with traditionally encapsulated functionality referred to as components. Many AOP models exist, but their implementations are typically coupled with a single language. To allow weaving of existing components with aspects written in the language of choice, AOP requires a language-independent tool. This paper presents ***, a load-time weaver that allows aspects and components to be written in a variety of languages and freely intermixed. *** relies on XML to specify aspect bindings and standardized Common Language Infrastructure to avoid coupling aspects or components with a particular language. By demonstrating language-independence, *** provides a migration path to the AOP paradigm by preserving existing developer knowledge, tools, and software components. The tool's capabilities are demonstrated with logging aspects written in and applied to Visual Basic and C# components.
JPie is a tightly integrated development environment supporting live object-oriented software construction in Java. JPie embodies the notion of a dynamic class whose signature and implementation can be modified at run...
详细信息
ISBN:
(纸本)1581137516
JPie is a tightly integrated development environment supporting live object-oriented software construction in Java. JPie embodies the notion of a dynamic class whose signature and implementation can be modified at run time, with changes taking effect immediately upon existing instances of the class. The result is complete elimination of the edit-compile-test cycle. JPie users create and modify class definitions through direct manipulation of visual representations of program abstractions. This support is provided without modification of the language or run-time system. In this demonstration, we illustrate central features of JPie through the construction of a sample application. These include dynamic declaration of instance variables and methods, dynamic modification of method bodies and threads, dynamic user interface construction and event handling, and on-the-fly exception handling in JPie's integrated thread-oriented debugger.
Separation of concerns and modularity are key elements of software engineering. The work described here presents a combination of two proven techniques that help improve both of these elements: the Eclipse Core Runtim...
详细信息
ISBN:
(纸本)1581137516
Separation of concerns and modularity are key elements of software engineering. The work described here presents a combination of two proven techniques that help improve both of these elements: the Eclipse Core Runtime Platform, which introduces plugins to Java programming as a kind of module concept on top of packages, and aspect-orientedprogramming using AspectJ, which aims to improve the modularity of crosscutting concerns. The work presents a combination of these two technologies in an AspectJ-enabled version of the Eclipse Core Runtime Platform. Unlike the standard implementation of the Eclipse Core Runtime Platform, the AspectJ-enabled implementation allows aspects to modularize crosscutting concerns beyond the boundaries of plugins (without the need for recompilation across plugins). It allows crosscutting concerns to be modularized by means of aspects and plugins while using the enhanced but compatible version of the Eclipse Core Runtime Platform as promoted by the Eclipse project.
暂无评论