Results 1 - 10
of
83
OpenJava: A Class-based Macro System for Java
- in Reflection and Software Engineering
, 2000
"... This paper presents OpenJava, which is a macro system that we have developed for Java. With traditional macro systems designed for non object-oriented languages, it is difficult to write a number of macros typical in object-oriented programming since they require the ability to access a logical stru ..."
Abstract
-
Cited by 105 (6 self)
- Add to MetaCart
(Show Context)
This paper presents OpenJava, which is a macro system that we have developed for Java. With traditional macro systems designed for non object-oriented languages, it is difficult to write a number of macros typical in object-oriented programming since they require the ability to access a logical structure of programs. One of the drawbacks of traditional macro systems is that abstract syntax trees are used for representing source programs. This paper first points out this problem and then shows how OpenJava addresses this problem. A key idea of OpenJava is to use metaobjects, which was originally developed for reflective computing, for representing source programs.
Superimposition: A Component Adaptation Technique
- INFORMATION AND SOFTWARE TECHNOLOGY
"... Several authors have identified that the only feasible way to increase productivity in software construction is to reuse existing software. To achieve this, component-based software development is one of the more promising approaches. However, traditional research in component-oriented programming ..."
Abstract
-
Cited by 103 (9 self)
- Add to MetaCart
Several authors have identified that the only feasible way to increase productivity in software construction is to reuse existing software. To achieve this, component-based software development is one of the more promising approaches. However, traditional research in component-oriented programming often assumes that components are reused "as-is". Practitioners have found that "as-is" reuse seldomly occurs and that reusable components generally need to be adapted to match the system requirements. Existing component object models provide only limited support for component adaptation, i.e. white-box techniques such as copy-paste and inheritance and black-box approaches such as aggregation and wrapping. These techniques suffer from problems related to reusability, efficiency, implementation overhead or the self problem. To address these problems, this paper proposes superimposition, a novel black-box adaptation technique that allows one to impose predefined, but configurable types ...
Evolving Object-Oriented Designs with Refactorings
, 2001
"... Refactorings are behavior-preserving program transformations that automate design evolution in object-oriented applications. Three kinds of design evolution are: schema transformations, design pattern microarchitectures, and the hot-spot-driven-approach. This research shows that all three are automa ..."
Abstract
-
Cited by 100 (2 self)
- Add to MetaCart
Refactorings are behavior-preserving program transformations that automate design evolution in object-oriented applications. Three kinds of design evolution are: schema transformations, design pattern microarchitectures, and the hot-spot-driven-approach. This research shows that all three are automatable with refactorings. A comprehensive list of refactorings for design evolution is provided and an analysis of supported schema transformations, design patterns, and hot-spot meta patterns is presented. Further, we evaluate whether refactoring technology can be transferred to the mainstream by restructuring non-trivial C++ applications. The applications that we examine were evolved manually by software engineers. We show that an equivalent evolution could be reproduced significantly faster and cheaper by applying a handful of general-purpose refactorings. In one application, over 14K lines of code were transformed automatically that otherwise would have been coded by hand. Our experiments identify benefits, limitations, and topics of further research related to the transfer of refactoring technology to a production environment.
Product-Line Architectures in Industry: A Case Study
- Pages 544 - 554. The 21st International Conference on Software Engineering. IEEE
, 1998
"... In this paper, a case study investigating the experiences from using product-line architectures is presented involving two Swedish companies, Axis Communications AB and Securitas Larm AB. Key persons in these organizations have been interviewed and information has been collected from documents and o ..."
Abstract
-
Cited by 60 (12 self)
- Add to MetaCart
In this paper, a case study investigating the experiences from using product-line architectures is presented involving two Swedish companies, Axis Communications AB and Securitas Larm AB. Key persons in these organizations have been interviewed and information has been collected from documents and other sources. The study identified a collection of problems and issues. The identified problems include the amount of required background knowledge, information distribution, the need for multiple versions of assets, dependencies between assets, use of assets in new contexts, documentation, tool support, management support and effort estimation. Issues collected from the case study are the questioned necessity of domain engineering units, business units versus development departments, timetomarket versus asset quality and common features versus feature superset. For each problem, a problem description, an example, underlying causes, available solutions and research issues are identified whereas for each issue the advantages and disadvantages of each side are discussed.
Integrating independent components with on-demand remodularization
, 2002
"... This paper proposes language concepts that facilitate the separation of an application into independent reusable building blocks and the integration of pre-build generic software components into applications that have been developed by third party vendors. A key element of our approach are ondemand ..."
Abstract
-
Cited by 54 (9 self)
- Add to MetaCart
(Show Context)
This paper proposes language concepts that facilitate the separation of an application into independent reusable building blocks and the integration of pre-build generic software components into applications that have been developed by third party vendors. A key element of our approach are ondemand remodularizations, meaning that the abstractions and vocabulary of an existing code base are translated into the vocabulary understood by a set of components that are connected by a common collaboration interface. This general concept allows us to mix-and-match remodularizations and components on demand.
SPQR: Flexible Automated Design Pattern Extraction From Source Code
- IN 18TH IEEE INTL CONF ON AUTOMATED SOFTWARE ENGINEERING
, 2003
"... Previous automated approaches to discovering design patterns in source code have suffered from a need to enumerate static descriptions of structural and behavioural relationships, resulting in a finite library of variations on pattern implementation. Our approach, System for Pattern Query and Recogn ..."
Abstract
-
Cited by 48 (10 self)
- Add to MetaCart
(Show Context)
Previous automated approaches to discovering design patterns in source code have suffered from a need to enumerate static descriptions of structural and behavioural relationships, resulting in a finite library of variations on pattern implementation. Our approach, System for Pattern Query and Recognition, or SPQR, differs in that we do not seek statically to encode each pattern and each variant that we wish to find. Our system finds patterns that were not explicitly defined, but instead are inferred dynamically during code analysis by a theorem prover, providing practical tool support for software construction, comprehension, maintenance, and refactoring. We use a logical inference system to reveal large numbers of patterns and their variations from a small number of definitions by encoding in a formal denotational semantics a small number of fundamental OO concepts (elemental design patterns), encode the rules by which these concepts are combined to form patterns (reliance operators) , and encode the structural/behavioral relationships among components of objects and classes (rho-calculus). A chain of fully automated tools provides a path from source code to revealed patterns. We describe our approach in this paper with a concrete example to drive the discussion, accompanied by formal treatment of the foundational topics.
XOTcl -- an Object-Oriented Scripting Language
- IN PROCEEDINGS OF TCL2K: THE 7TH USENIX TCL/TK CONFERENCE
, 2000
"... This paper describes the object-oriented scripting language XOTcl (Extended OTcl), which is a value added replacement of OTcl. OTcl implements dynamic and introspective language support for objectorientation on top of Tcl. XOTcl includes the functionality of OTcl but focuses on the construction, man ..."
Abstract
-
Cited by 47 (33 self)
- Add to MetaCart
This paper describes the object-oriented scripting language XOTcl (Extended OTcl), which is a value added replacement of OTcl. OTcl implements dynamic and introspective language support for objectorientation on top of Tcl. XOTcl includes the functionality of OTcl but focuses on the construction, management, and adaptation of complex systems. In order to
Component Integration with Pluggable Composite Adapters
- Software Architectures and Component Technology: The State of the Art in Research and Practice
, 1999
"... . In this paper we deal with object-oriented component integration issues. We argue that traditional framework customization techniques are inappropriate for componentbased programming since they lack support for non-invasive, encapsulated, dynamic customization. We propose a new language construct, ..."
Abstract
-
Cited by 46 (8 self)
- Add to MetaCart
(Show Context)
. In this paper we deal with object-oriented component integration issues. We argue that traditional framework customization techniques are inappropriate for componentbased programming since they lack support for non-invasive, encapsulated, dynamic customization. We propose a new language construct, called a pluggable composite adapter, for expressing component gluing. A pluggable composite adapter allows the separation of customization code from component implementation, resulting in better modularity, flexible extensibility, and improved maintenance and understandability. We also discuss alternative realizations of the construct. 1. Introduction Component software, i.e., software that is an assembly of individual, independently developed parts, is becoming the predominant architecture. We consider two factors as the driving force behind this development. First, as indicated in [22] component software represents a middle path between the two extremes that predominate traditional sof...
Using Generative Design Patterns to Generate Parallel Code for a Distributed Memory Environment
, 2003
"... A design pattern is a mechanism for encapsulating the knowledge of experienced designers into a re-usable artifact. Parallel design patterns reflect commonly occurring parallel communication and synchronization structures. Our tools, CO 2 P 3 S (Correct Object-Oriented Pattern-based Parallel Program ..."
Abstract
-
Cited by 33 (11 self)
- Add to MetaCart
(Show Context)
A design pattern is a mechanism for encapsulating the knowledge of experienced designers into a re-usable artifact. Parallel design patterns reflect commonly occurring parallel communication and synchronization structures. Our tools, CO 2 P 3 S (Correct Object-Oriented Pattern-based Parallel Programming System) and MetaCO 2 P 3 S, use generative design patterns. A programmer selects the parallel design patterns that are appropriate for an application, and then adapts the patterns for that specific application by selecting from a small set of code-configuration options. CO 2 P 3 S then generates a custom framework for the application that includes all of the structural code necessary for the application to run in parallel. The programmer is only required to write simple code that launches the application and to fill in some applicationspecific sequential hook routines. We use generative design patterns to take an application specification (parallel design patterns + sequential user code) and use it to generate parallel application code that achieves good performance in shared memory and distributed memory environments. Although our implementations are for Java, the approach we describe is tool and language independent. This paper describes generalizing CO 2 P 3 S to generate distributed-memory parallel solutions.
ScriptEase: Generative Design Patterns for Computer Role-Playing Games
- in 19 th International Conference on Automated Software Engineering
, 2004
"... Recently, some researchers have argued that generative design patterns (GDPs) can leverage the obvious design re-use that characterizes traditional design patterns into code re-use. This paper provides additional evidence that GDPs are both useful and productive. Specifically, the current state-of-t ..."
Abstract
-
Cited by 32 (13 self)
- Add to MetaCart
Recently, some researchers have argued that generative design patterns (GDPs) can leverage the obvious design re-use that characterizes traditional design patterns into code re-use. This paper provides additional evidence that GDPs are both useful and productive. Specifically, the current state-of-the-art in the domain of computer games is to script individual game objects to provide the desired interactions for each game adventure. We use BioWare Corp.’s popular Neverwinter Nights computer role-playing game to show how GDPs can be used to generate game scripts. This is a particularly good domain for GDPs, since game designers often have little or no programming skills. We demonstrate our approach using a new GDP tool called ScriptEase.
