Achieving extensibility through product-lines and domain-specific languages: a case study

@inproceedings{Batory2002AchievingET,
  title={Achieving extensibility through product-lines and domain-specific languages: a case study},
  author={Don S. Batory and Clay Johnson and Bob MacDonald and Dale von Heeder},
  booktitle={TSEM},
  year={2002}
}
This is a case study in the use of product-line architectures (PLAs) and domain-specific languages (DSLs) to design an extensible command-and-control simulator for Army fire support. The reusable components of our PLA are layers or "aspects" whose addition or removal simultaneously impacts the source code of multiple objects in multiple, distributed programs. The complexity of our component specifications is substantially reduced by using a DSL for defining and refining state machines… 
View on ACM
cs.utexas.edu
133 Citations
Highly Influential Citations
3
Background Citations
39
Methods Citations
14
Results Citations
2

Figures and Tables from this paper

133 Citations

ExCIS: An Integration of Domain-Specific Languages and Feature-Oriented Programming1
TLDR
ExCIS is a methodology and tool suite that integrates the technologies of domain-specific languages (DSLs) and feature-oriented programming (FOP) and is being developed for STRICOM to create next-generation simulators for the U.S. Army.
A tutorial on feature oriented programming and product-lines
  • D. Batory
  • Computer Science
    25th International Conference on Software Engineering, 2003. Proceedings.
  • 2003
TLDR
Feature Oriented Programming is a design methodology and tools for program synthesis that has been used to develop product-lines in disparate domains, including compilers for extensible Java dialects and fire support simulators for the U.S. Army.
C-PLAD-SM: Extending Component Requirements with Use Cases and State Machines
TLDR
This paper describes an extension to the C- PLAD approach, dubbed C-PLAD-SM, which addresses the gaps in earlier work, and includes the inclusion of state machines to drive the architectural specifications beyond component interfaces and into component states.
Mixin layers: an object-oriented implementation technique for refinements and collaboration-based designs
TLDR
This paper examines large-scale refinements in terms of a fundamental object-oriented technique called collaboration-based design and presents a specific expression of large- scale refinements called mixin layers, and demonstrates how it overcomes the scalability difficulties that plagued prior work.
From Crosscutting Concerns to Product Lines : A Function Composition Approach
TLDR
A way to emulate function composition using AspectJ for the synthesis of a non-trivial product line is described, a general mechanism to support it is presented and its potential reuse benefits are highlighted.
Aspect Refinement
TLDR
A set of concrete mechanisms for refining all kinds of structural elements of aspects in a uniform way (methods, pointcuts, advice) are proposed and applied to a non-trivial case study and derive several programming guidelines.
Improving maintenance by creating a DSL for configuring a fieldbus
TLDR
A DSL for creating configuration files that describe the topology of a fieldbus and a second DSL which allows a concise description of system configurations and the generation of topologies to improve the maintainability and extensibility of a legacy component.
Implementing feature variability for models and code with projectional language workbenches
TLDR
This paper describes an approach for product line engineering using projectional language workbenches, which makes the tight integration between several domain-specific languages possible and simple and illustrates the benefits using a small product line for embedded systems.
Feature Oriented Model Driven Development: A Case Study for Portlets
TLDR
A case study of FOMDD on a product line of portlets, which are components of web portals, is presented and mathematical properties of portlet synthesis are revealed that helped to validate the correctness of the abstractions, tools, and specifications, as well as optimize portlets synthesis.
mTurnpike: a Model-driven Framework for Domain Specific Software Development
This paper describes and empirically evaluates a new model-driven framework, called Modeling Turnpike (or mTurnpike), which allows developers to effectively model and program domain concepts (ideas…
...
...

References

SHOWING 1-10 OF 173 REFERENCES
Mixin layers: an object-oriented implementation technique for refinements and collaboration-based designs
TLDR
This paper examines large-scale refinements in terms of a fundamental object-oriented technique called collaboration-based design and presents a specific expression of large- scale refinements called mixin layers, and demonstrates how it overcomes the scalability difficulties that plagued prior work.
Evolving object-oriented designs with refactorings
  • Lance Tokuda, D. Batory
  • Computer Science
    14th IEEE International Conference on Automated Software Engineering
  • 1999
TLDR
This research evaluates whether refactoring technology can be transferred to the mainstream by restructuring non-trivial C++ applications by applying a handful of general-purpose refactorings.
Product-Line Architectures
TLDR
It is argued that future software development will be very different and will center around product-line architectures, refinements, and software plug-and-pla y (a codeless form of programming).
Comparing frameworks and layered refinement
  • Richard Cardone, Calvin Lin
  • Computer Science
    Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001
  • 2001
TLDR
It is demonstrated that JL scales better than frameworks as the number of possible application features increases and how constrained parametric polymorphism and a small number of language features can support JL's model of loosely coupled components and stepwise program refinement is described.
Modular object-oriented programming with units and mixins
TLDR
This paper demonstrates the synergy of a particular form of modules and classes---called units and mixins, respectively---for solving complex reuse problems in a natural manner.
Executable object modeling with statecharts
  • D. Harel, Eran Gery
  • Computer Science
    Proceedings of IEEE 18th International Conference on Software Engineering
  • 1996
TLDR
An effort to develop an integrated set of diagrammatic languages for modeling object-oriented systems to be intuitive and well-structured, yet fully executable and analyzable, enabling automatic synthesis of usable and efficient code in object- oriented languages such as C++.
The design and implementation of hierarchical software systems with reusable components
TLDR
A domain-independent model of hierarchical software system design and construction that is based on interchangeable software components and large-scale reuse that is a blueprint for achieving software component technologies in many domains is presented.
Implementing Product-Line Features By Composing Component Aspects
TLDR
This paper outlines a practical development process that structures a set of common and variable features supporting a product-line, to produce reusable elements that can be combined into customized components and frameworks to support the product- line.
Scoping Constructs for Program Generators
TLDR
This paper presents generation scoping: a mechanism for specifying interdependencies among code fragments that solves the variable binding problem in program generation.
Components and Generative Programming
TLDR
This paper argues that the current OO technology does not support reuse and configurability in an effective way, and shows how a system family approach can aid in defining reusable components.
...
...