A domain-specific language based approach to component composition, error-detection, and fault prediction

Current methods of software production are resource-intensive and often require a number of highly skilled professionals. To develop a well-designed and effectively implemented system requires a large investment of resources, often numbering into millions of pounds. The time required may also prove to be prohibitive. However, many parts of the new systems being currently developed already exist, either in the form of whole or parts of existing systems. It is therefore attractive to reuseexisting code when developing new software, in order to reduce the time andresources required. This thesis proposes the application of a domain-specific language (DSL) to automatic component composition, testing and fault-prediction. The DSL ISinherently based on a domain-model which should aid users of the system m knowing how the system is structured and what responsibilities the system fulfils. The DSL structure proposed in this thesis uses a type system and grammar hence enabling the early detection of syntactically incorrect system usage. Each DSL construct's behaviour can also be defined in a testing DSL, described here as DSL-test. This can take the form of input and output parameters, which should suffice for specifying stateless components, or may necessitate the use of a special method call, described here as a White-Box Test (WBT), which allows the external observer to view the abstract state of a component. Each DSL-construct can be mapped to its implementing components i.e. the component, or amalgamation of components, that implement(s) the behaviour as prescribed by the DSL-construct. User-requirements are described using the DS Land appropriate implementing components (if sufficient exist) are automatically located and integrated. That is to say, given a requirement described in terms of the DSL and sufficient components, the architecture (which was named Hydra) will be able to generate an executable which should behave as desired. The DSL-construct behaviour description language (DSL-test) is designed in such a way that it can be translated into a computer programming language, and so code can be inserted between the system automatically to verify that the implementing component is acting in a way consistent with the model of its expected behaviour. Upon detection of an error, the system examines available data (i.e. where the error occurred, what sort of error was it, and what was the structure of the executable), to attempt to predict the location of the fault and, where possible, make remedialaction. A number of case studies have been investigated and it was found that, if applied to the appropriate problem domain, the approach proposed in this thesis shows promise in terms of full automation and integration of black-box or grey-box software. However, further work is required before it can be claimed that this approach should be used in real scale systems

A generative-oriented model-driven design environment for customizable video surveillance systems

To tackle the growing complexity and huge demand for tailored domestic video surveillance systems along with a high demanding time-to-market expectation, engineers at IVV Automação, LDAa are exploiting video surveillance domain as families of systems that can be developed following a pay-as-you-go fashion rather than developing an ex-nihilo new product. Several and different new functionalities are required for each new product’s hardware platforms (e.g., ranging from mobile phone, PDA to desktop PC) and operating systems (e.g., flavors of Linux, Windows and MAC OS X). Some of these functionalities have special economical constraints of development time and memory footprint. To better accommodate all the above listing requirements, a model-driven generative software development paradigm supported by mainstream tools is proposed to offer a significant leverage in hiding commonalities and configuring variabilities across families of video surveillance products while maintaining the new product quality.This work was funded through the Competitive Factors Operational Program COMPETE and through national funds though the Science and Technology Foundation - FCT, within the project: FCOMP-01-0124-FEDER-022674. This work was developed in cooperation with IVV Automation; all support and means provided by the company is acknowledged

The Feature-Architecture Mapping Method for Feature-Oriented Development of Software Product Lines

Software Produktlinien sind die Antwort von Software Engineering auf die zu-nehmende Komplexität und kürzerenProdukteinführungszeiten von heutigen Softwaresystemen. Nichtsdestotrotz erfordern Software Produktlinien einefortgeschrittene Wartbarkeit und hohe Flexibilität. Das kann durch die angemessene Trennung der Belange erreicht werden.Merkmale stellen die Hauptbelange im Kontext von Software Produktlinien dar. Demzufolge sollte ein Merkmal idealerweise ingenau einer Architekturkomponente implementiert werden. In der Praxis ist das jedoch nicht immer machbar. Deshalb solltezumindest ein starkes Mapping zwischen Merkmalen und der Architektur bestehen. Die Methoden zur Entwicklung von SoftwareProduktlinien, die dem Stand der Technik entsprechen, führen zu bedeutender Verstreutheit und Vermischung von Merkmalen. Indieser Arbeit wird die Feature-Architecture Mapping (FArM) Methode entwickelt, um ein stärkeres Mapping zwischen Merkmalenund der Produktlinien-Architektur zu erzielen. Der Input für FArM besteht in einem initialen Merkmalmodell, das anhand einerMethode zur Domänenanalyse erstellt wurde. Dieses initiale Merkmalmodell wird einer Serie von Transformationen unterzogen.Die Transformationen streben danach, ein Gleichgewicht zwischen der Sichtweise von Kunden und Softwarearchitekteneinzustellen. Die Merkmalinteraktionen werden während der Transformationen ausdrücklich optimiert. Von jedem Merkmal destransformierten Merkmalmodells wird eine Architekturkomponente abgeleitet. Die Architekturkomponenten implementieren dieApplikationslogik der entsprechenden Merkmale. Die Kommunikation zwischen den Komponenten spiegelt die Interaktion zwischenden Merkmalen wider. Dieser Ansatz führt im Vergleich zu den Produktlinien-Entwicklungsmethoden des Stands der Technik zueinem stärkeren Mapping zwischen Merkmalen und der Architektur und zu einer höheren Variabilität auf Merkmalebene. DieseEigenschaften haben eine bessere Wartbarkeit und eine vereinfachte generative Produktinstanzierung zur Folge, was wiederumdie Flexibilität der Produktlinien steigert. FArM wurde durch ihre Anwendung in einigen Domänen evaluiert, z.B. in denDomänen von Mobiltelefonen und Integrierten Entwicklungsumgebungen (IDEs). Diese Arbeit wird FArM anhand einer Fallstudie inder Domäne von Künstlichen Neuronalen Netzwerken präsentieren.Software product lines are the answer of software engineering to the increasing complexity and shorter time-to-market ofcontemporary software systems. Nonetheless, software product lines demand for advanced maintainability and high flexibility.The latter can be achieved through the proper separation of concerns. Features pose the main concerns in the context ofsoftware product lines. Consequently, one feature should ideally be implemented into exactly one architectural component. Inpractice, this is not always feasible. Therefore, at least a strong mapping between features and the architecture mustexist. The state of the art product line development methodologies introduce significant scattering and tangling offeatures. In this work, the Feature-Architecture Mapping (FArM) method is developed, to provide a stronger mapping betweenfeatures and the product line architecture. FArM receives as input an initial feature model created by a domain analysismethod. The initial feature model undergoes a series of transformations. The transformations strive to achieve a balancebetween the customer and architectural perspectives. Feature interaction is explicitly optimized during the feature modeltransformations. For each feature of the transformed feature model, one architectural component is derived. Thearchitectural components implement the application logic of the respective features. The component communication reflectsthe feature interaction. This approach, compared to the state of the art product line methodologies, allows a strongerfeature-architecture mapping and for higher variability on the feature level. These attributes provide highermaintainability and an improved generative approach to product instantiation, which in turn enhances product lineflexibility. FArM has been evaluated through its application in a number of domains, e.g in the mobile phone domain and theIntegrated Development Environment (IDE) domain. This work will present FArM on the basis of a case study in the domain ofartificial Neural Networks

Supporting fine-grained generative model-driven evolution

In the standard generative Model-driven Architecture (MDA), adapting the models of an existing system requires re-generation and restarting of that system. This is due to a strong separation between the modeling environment and the runtime environment. Certain current approaches remove this separation, allowing a system to be changed smoothly when the model changes. These approaches are, however, based on interpretation of modeling information rather than on generation, as in MDA. This paper describes an architecture that supports fine-grained evolution combined with generative model-driven development. Fine-grained changes are applied in a generative model-driven way to a system that has itself been developed in this way. To achieve this, model changes must be propagated correctly toward impacted elements. The impact of a model change flows along three dimensions: implementation, data (instances), and modeled dependencies. These three dimensions are explicitly represented in an integrated modeling-runtime environment to enable traceability. This implies a fundamental rethinking of MDA

Modelling large-scale information systems using ADLs – An industrial experience report

An organisation that had developed a large information system wanted to embark on a programme that would involve large-scale evolution of it. As a precursor to this, it was decided to create a comprehensive architectural description to capture and understand the system’s design. This undertaking faced a number of challenges, including a low general awareness of software modelling and software architecture practices. The approach taken by the software architects tasked with this project included the definition of a simple, very specific, architecture description language. This paper reports our experience of the project and a simple ADL that we created as part of it. 

E valuating Support for Features in Advance d Modu larization Technologies

Abstract. A software product-line is a family of related programs. Each program is defined by a unique combination of features, where a feature is an increment in program functionality. Modularizing features is difficult, as feature-specific code often cuts across class boundaries. New modularization technologies have been proposed in recent years, but their support for feature modules has not been thoroughly examined. In this paper, we propose a variant of the expression problem as a canonical problem in product-line design. The problem reveals a set of technology-independent properties that feature modules should exhibit. We use these properties to evaluate five technologies: AspectJ, Hyper/J, Jiazzi, Scala, and AHEAD. The results suggest an abstract model of feature composition that is technology-independent and that relates compositional reasoning with algebraic reasoning 1

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow

Engineering Automation for Reliable Software Interim Progress Report (10/01/2000 - 09/30/2001)

Prepared for: U.S. Army Research Office P.O. Box 12211 Research Triangle Park, NC 27709-2211The objective of our effort is to develop a scientific basis for producing reliable software that is also flexible and cost effective for the DoD distributed software domain. This objective addresses the long term goals of increasing the quality of service provided by complex systems while reducing development risks, costs, and time. Our work focuses on "wrap and glue" technology based on a domain specific distributed prototype model. The key to making the proposed approach reliable, flexible, and cost-effective is the automatic generation of glue and wrappers based on a designer's specification. The "wrap and glue" approach allows system designers to concentrate on the difficult interoperability problems and defines solutions in terms of deeper and more difficult interoperability issues, while freeing designers from implementation details. Specific research areas for the proposed effort include technology enabling rapid prototyping, inference for design checking, automatic program generation, distributed real-time scheduling, wrapper and glue technology, and reliability assessment and improvement. The proposed technology will be integrated with past research results to enable a quantum leap forward in the state of the art for rapid prototyping.U. S. Army Research Office P.O. Box 12211 Research Triangle Park, NC 27709-22110473-MA-SPApproved for public release; distribution is unlimited