21 research outputs found
ETHOM: An Evolutionary Algorithm for Optimized Feature Models Generation (v. 1.2): Technical Report ISA-2012-TR-05
A feature model defines the valid combinations of features in a domain.
The automated extraction of information from feature models is a thriving
topic involving numerous analysis operations, techniques and tools.
The progress of this discipline is leading to an increasing concern to test
and compare the performance of analysis solutions using tough input models
that show the behaviour of the tools in extreme situations (e.g. those
producing longest execution times or highest memory consumption). Currently,
these feature models are generated randomly ignoring the internal
aspects of the tools under tests. As a result, these only provide a rough idea
of the behaviour of the tools with average problems and are not sufficient
to reveal their real strengths and weaknesses.
In this technical report, we model the problem of finding computationally–
hard feature models as an optimization problem and we solve it using a
novel evolutionary algorithm. Given a tool and an analysis operation, our
algorithm generates input models of a predefined size maximizing aspects
as the execution time or the memory consumption of the tool when performing
the operation over the model. This allows users and developers to
know the behaviour of tools in pessimistic cases providing a better idea of
their real power. Experiments using our evolutionary algorithm on a number
of analysis operations and tools have successfully identified input models
causing much longer executions times and higher memory consumption
than random models of identical or even larger size. Our solution is generic
and applicable to a variety of optimization problems on feature models, not
only those involving analysis operations. In view of the positive results, we
expect this work to be the seed for a new wave of research contributions
exploiting the benefit of evolutionary programming in the field of feature
modelling
System Engineering and Evolution Decision Support Interim Progress Report (01/01/2000-09/30/2000)
The objective of our effort is to develop a scientific basis for system engineering automation and decision support. This objective addresses the long term goals of increasing the quality of service provided complex systems while reducing development risks, costs, and time. Our work focused on decision support for designing operations of complex modular systems that can include embedded software. Emphasis areas included engineering automation capabilities in the areas of design modifications, design records, reuse, and automatic generation of design representations such as real-time schedules and software
Purely top-down software rebuilding
Software rebuilding is the process of deriving a deployable software system from its primitive source objects. A build tool helps maintain consistency between the derived objects and source objects by ensuring that all necessary build steps are re-executed in the correct order after a set of changes is made to the source objects. It is imperative that derived objects accurately represent the source objects from which they were supposedly constructed; otherwise, subsequent testing and quality assurance is invalidated.
This thesis aims to advance the state-of-the-art in tool support for automated software rebuilding. It surveys the body of background work, lays out a set of design considerations for build tools, and examines areas where current tools are limited. It examines the properties of a next-generation tool concept, redo, conceived by D. J. Bernstein; redo is novel because it employs a purely top-down approach to software rebuilding that promises to be simpler, more flexible, and more reliable than current approaches. The details of a redo prototype written by the author of this thesis are explained including the central algorithms and data structures. Lastly,
the redo prototype is evaluated on some sample software systems with respect to migration effort between build tools as well as size, complexity, and performances aspects of the resulting build systems
Pattern-based refactoring in model-driven engineering
L’ingénierie dirigée par les modèles (IDM) est un paradigme du génie logiciel qui utilise les
modèles comme concepts de premier ordre à partir desquels la validation, le code, les tests
et la documentation sont dérivés. Ce paradigme met en jeu divers artefacts tels que les
modèles, les méta-modèles ou les programmes de transformation des modèles. Dans un
contexte industriel, ces artefacts sont de plus en plus complexes. En particulier, leur
maintenance demande beaucoup de temps et de ressources. Afin de réduire la complexité
des artefacts et le coût de leur maintenance, de nombreux chercheurs se sont intéressés au
refactoring de ces artefacts pour améliorer leur qualité.
Dans cette thèse, nous proposons d’étudier le refactoring dans l’IDM dans sa
globalité, par son application à ces différents artefacts. Dans un premier temps, nous
utilisons des patrons de conception spécifiques, comme une connaissance a priori, appliqués
aux transformations de modèles comme un véhicule pour le refactoring. Nous procédons
d’abord par une phase de détection des patrons de conception avec différentes formes et
différents niveaux de complétude. Les occurrences détectées forment ainsi des opportunités
de refactoring qui seront exploitées pour aboutir à des formes plus souhaitables et/ou plus
complètes de ces patrons de conceptions.
Dans le cas d’absence de connaissance a priori, comme les patrons de conception,
nous proposons une approche basée sur la programmation génétique, pour apprendre des
règles de transformations, capables de détecter des opportunités de refactoring et de les
corriger. Comme alternative à la connaissance disponible a priori, l’approche utilise des
exemples de paires d’artefacts d’avant et d’après le refactoring, pour ainsi apprendre les
règles de refactoring. Nous illustrons cette approche sur le refactoring de modèles.Model-Driven Engineering (MDE) is a software engineering paradigm that uses models as
first-class concepts from which validation, code, testing, and documentation are derived.
This paradigm involves various artifacts such as models, meta-models, or model
transformation programs. In an industrial context, these artifacts are increasingly complex.
In particular, their maintenance is time and resources consuming. In order to reduce the
complexity of artifacts and the cost of their maintenance, many researchers have been
interested in refactoring these artifacts to improve their quality.
In this thesis, we propose to study refactoring in MDE holistically, by its application
to these different artifacts. First, we use specific design patterns, as an example of prior
knowledge, applied to model transformations to enable refactoring. We first proceed with a
detecting phase of design patterns, with different forms and levels of completeness. The
detected occurrences thus form refactoring opportunities that will be exploited to implement
more desirable and/or more complete forms of these design patterns.
In the absence of prior knowledge, such as design patterns, we propose an approach
based on genetic programming, to learn transformation rules, capable of detecting
refactoring opportunities and correcting them. As an alternative to prior knowledge, our
approach uses examples of pairs of artifacts before and after refactoring, in order to learn
refactoring rules. We illustrate this approach on model refactoring
Systematic construction of goal-oriented COTS taxonomies
El proceso de construir software a partir del ensamblaje e integraciĂłn de soluciones de software pre-fabricadas, conocidas como componentes COTS (Comercial-Off-The-Shelf) se ha convertido en una necesidad estratĂ©gica en una amplia variedad de áreas de aplicaciĂłn. En general, los componentes COTS son componentes de software que proveen una funcionalidad especĂfica, que están disponibles en el mercado para ser adquiridos e integrados dentro de otros sistemas de software. Los beneficios potenciales de esta tecnologĂa son principalmente la reducciĂłn de costes y el acortamiento del tiempo de desarrollo, a la vez que fomenta la calidad. Sin embargo, numerosos retos que van desde problemas tĂ©cnicos y legales deben ser afrontados para adaptar las actividades tradicionales de ingenierĂa de software para explotar los beneficios del uso de COTS para el desarrollo de sistemas.Actualmente, existe un incrementalmente enorme mercado de componentes COTS; asĂ, una de las actividades más crĂticas en el desarrollo de sistemas basados en COTS es la selecciĂłn de componentes que deben ser integrados en el sistema a desarrollar. La selecciĂłn está básicamente compuesta de dos procesos principales: La bĂşsqueda de componentes candidatos en el mercado y su posterior evaluaciĂłn con respecto a los requisitos del sistema. Desafortunadamente, la mayorĂa de los mĂ©todos existentes para seleccionar COTS, se enfocan en el proceso de evaluaciĂłn, dejando de lado el problema de buscar los componentes en el mercado. La bĂşsqueda de componentes en el mercado no es una tarea trivial, teniendo que afrontar varias caracterĂsticas del mercado de COTS, tales como su naturaleza dispersa y siempre creciente, cambio y evoluciĂłn constante; en este contexto, la obtenciĂłn de informaciĂłn de calidad acerca de los componentes no es una tarea fácil. Como consecuencia, el proceso de selecciĂłn de COTS se ve seriamente dañado. Además, las alternativas tradicionales de reuso tambiĂ©n carecen de soluciones apropiadas para reusar componentes COTS y el conocimiento adquirido en cada proceso de selecciĂłn. Esta carencia de propuestas es un problema muy serio que incrementa los riesgos de los proyectos de selecciĂłn de COTS, además de hacerlos ineficientes y altamente costosos. Esta disertaciĂłn presenta el mĂ©todo GOThIC (Goal- Oriented Taxonomy and reuse Infrastructure Construction) enfocado a la construcciĂłn de infraestructuras de reuso para facilitar la bĂşsqueda y reuso de componentes COTS. El mĂ©todo está basado en el uso de objetivos para construir taxonomĂas abstractas, bien fundamentadas y estables para lidiar con las caracterĂsticas del mercado de COTS. Los nodos de las taxonomĂas son caracterizados por objetivos, sus relaciones son declaradas como dependencias y varios artefactos son construidos y gestionados para promover la reusabilidad y lidiar con la evoluciĂłn constante.El mĂ©todo GOThIC ha sido elaborado a travĂ©s de un proceso iterativo de investigaciĂłn-acciĂłn para identificar los retos reales relacionados con el proceso de bĂşsqueda de COTS. Posteriormente, las soluciones posibles fueron evaluadas e implementadas en varios casos de estudio en el ámbito industrial y acadĂ©mico en diversos dominios. Los resultados más relevantes fueron registrados y articulados en el mĂ©todo GOThIC. La evaluaciĂłn industrial preliminar del mĂ©todo se ha llevado a cabo en algunas compañĂas en Noruega.The process of building software systems by assembling and integrating pre-packaged solutions in the form of Commercial-Off-The-Shelf (COTS) software components has become a strategic need in a wide variety of application areas. In general, COTS components are software components that provide a specific functionality, available in the market to be purchased, interfaced and integrated into other software systems. The potential benefits of this technology are mainly its reduced costs and shorter development time, while maintaining the quality. Nevertheless, many challenges ranging form technical to legal issues must be faced for adapting the traditional software engineering activities in order to exploit these benefits.Nowadays there is an increasingly huge marketplace of COTS components; therefore, one of the most critical activities in COTS-based development is the selection of the components to be integrated into the system under development. Selection is basically composed of two main processes, namely: searching of candidates from the marketplace and their evaluation with respect to the system requirements. Unfortunately, most of the different existing methods for COTS selection focus their efforts on evaluation, letting aside the problem of searching components in the marketplace. Searching candidate COTS is not an easy task, having to cope with some challenging marketplace characteristics related to its widespread, evolvable and growing nature; and the lack of available and well-suited information to obtain a quality-assured search. Indeed, traditional reuse approaches also lack of appropriate solutions to reuse COTS components and the knowledge gained in each selection process. This lack of proposals is a serious drawback that makes the whole selection process highly risky, and often expensive and inefficient. This dissertation introduces the GOThIC (Goal- Oriented Taxonomy and reuse Infrastructure Construction) method aimed at building a domain reuse infrastructure for facilitating COTS components searching and reuse. It is based on goal-oriented approaches for building abstract, well-founded and stable taxonomies capable of dealing with the COTS marketplace characteristics. Thus, the nodes of these taxonomies are characterized by means of goals, their relationships declared as dependencies among them and several artifacts are constructed and managed for reusability and evolution purposes. The GOThIC method has been elaborated following an iterative process based on action research premises to identify the actual challenges related to COTS components searching. Then, possible solutions were envisaged and implemented by several industrial and academic case studies in different domains. Successful results were recorded to articulate the synergic GOThIC method solution, followed by its preliminary industrial evaluation in some Norwegian companies
Combining SOA and BPM Technologies for Cross-System Process Automation
This paper summarizes the results of an industry case study that introduced a cross-system business process automation solution based on a combination of SOA and BPM standard technologies (i.e., BPMN, BPEL, WSDL). Besides discussing major weaknesses of the existing, custom-built, solution and comparing them against experiences with the developed prototype, the paper presents a course of action for transforming the current solution into the proposed solution. This includes a general approach, consisting of four distinct steps, as well as specific action items that are to be performed for every step. The discussion also covers language and tool support and challenges arising from the transformation
SERVICE-BASED AUTOMATION OF SOFTWARE CONSTRUCTION ACTIVITIES
The reuse of software units, such as classes, components and services require professional
knowledge to be performed. Today a multiplicity of different software unit technologies,
supporting tools, and related activities used in reuse processes exist. Each of these relevant
reuse elements may also include a high number of variations and may differ in the level and
quality of necessary reuse knowledge. In such an environment of increasing variations and,
therefore, an increasing need for knowledge, software engineers must obtain such knowledge
to be able to perform software unit reuse activities. Today many different reuse activities exist
for a software unit. Some typical knowledge intensive activities are: transformation,
integration, and deployment. In addition to the problem of the amount of knowledge required
for such activities, other difficulties also exist. The global industrial environment makes it
challenging to identify sources of, and access to, knowledge. Typically, such sources (e.g.,
repositories) are made to search and retrieve information about software unitsand not about
the required reuse activity knowledge for a special unit. Additionally, the knowledge has to be
learned by inexperienced software engineers and, therefore, to be interpreted. This
interpretation may lead to variations in the reuse result and can differ from the estimated result
of the knowledge creator. This makes it difficult to exchange knowledge between software
engineers or global teams. Additionally, the reuse results of reuse activities have to be
repeatable and sustainable. In such a scenario, the knowledge about software reuse activities
has to be exchanged without the above mentioned problems by an inexperienced software
engineer. The literature shows a lack of techniques to store and subsequently distribute
relevant reuse activity knowledge among software engineers. The central aim of this thesis is
to enable inexperienced software engineers to use knowledge required to perform reuse
activities without experiencing the aforementioned problems. The reuse activities:
transformation, integration, and deployment, have been selected as the foundation for the
research. Based on the construction level of handling a software unit, these activities are
called Software Construction Activities (SCAcs) throughout the research. To achieve the aim,
specialised software construction activity models have been created and combined with an
abstract software unit model. As a result, different SCAc knowledge is described and
combined with different software unit artefacts needed by the SCAcs. Additionally, the
management (e.g., the execution of an SCAc) will be provided in a service-oriented
environment. Because of the focus on reuse activities, an approach which avoids changing the
knowledge level of software engineers and the abstraction view on software units and
activities, the object of the investigation differs from other approaches which aim to solve the
insufficient reuse activity knowledge problem. The research devised novel abstraction models
to describe SCAcs as knowledge models related to the relevant information of software units.
The models and the focused environment have been created using standard technologies. As a
result, these were realised easily in a real world environment. Softwareengineers were able to
perform single SCAcs without having previously acquired the necessary knowledge. The risk
of failing reuse decreases because single activities can be performed. The analysis of the
research results is based on a case study. An example of a reuse environmenthas been created
and tested in a case study to prove the operational capability of the approach. The main result
of the research is a proven concept enabling inexperienced software engineers to reuse
software units by reusing SCAcs. The research shows the reduction in time for reuse and a
decrease of learning effort is significant
Specification And Mechanical Verification Of Performance Profiles Of Software Components
Software performance predictability is vital to a system design and unpredictable performance is a leading cause of software failure. The emphasis of this dissertation is on verification that component-based software performs as specified. Performance profiles (specifications) depend on functional specifications and are necessary for all components for modular verification. Modular verification process is scalable because it uses profiles as contracts and allows verification of a single component in isolation with the assumption that any underlying component would have already been verified or will be verified to meet its specifications independently. This dissertation presents an integration of performance specification (profiles) with functional specifications within a single language. It contains a mechanizable and modular proof system to verify the performance bounds of reusable software components built reusing other components. The proof system forms the basis for a prototype verification condition (VC) generator. Experimentation with the VC generator illustrates that software component performance can be formally specified and verified. This dissertation discusses only duration (timing) aspect of performance, but the results can be extended to include space constraints
SAVCBS 2003: Specification and Verification of Component-Based Systems
These are the proceedings for the SAVCBS 2003 workshop. This workshop was held at ESEC/FSE 2003 in Helsinki Finland in September 2003
Representing Variability in Software Architecture
Software Architecture is a high level description of a software intensive system that enables architects to have a better intellectual control over the complete system. It is also used as a communication vehicle among the various system stakeholders. Variability in software-intensive systems is the ability of a software artefact (e.g., a system, subsystem, or component) to be extended, customised, or configured for deployment in a specific context. Although variability in software architecture is recognised as a challenge in multiple domains, there has been no formal consensus on how variability should be captured or represented.
In this research, we addressed the problem of representing variability in software architecture through a three phase approach. First, we examined existing literature using the Systematic Literature Review (SLR) methodology, which helped us identify the gaps and challenges within the current body of knowledge. Equipped with the findings from the SLR, a set of design principles have been formulated that are used to introduce variability management capabilities to an existing Architecture Description Language (ADL). The chosen ADL was developed within our research group (ALI) and to which we have had complete access. Finally, we evaluated the new version of the ADL produced using two distinct case studies: one from the Information Systems domain, an Asset Management System (AMS); and another from the embedded systems domain, a Wheel Brake System (WBS).
This thesis presents the main findings from the three phases of the research work, including a comprehensive study of the state-of-the-art; the complete specification of an ADL that is focused on managing variability; and the lessons learnt from the evaluation work of two distinct real-life case studies