Miguel Goulão

KAOS is one of the most well-known goal-oriented requirements engineering approaches. Nevertheless, building large KAOS models sometimes results in incomplete and/or complex requirements models that are difficult to understand and maintain. These shortcomings often lead to an increase in costs of product development and evolution. Therefore, for large-scale systems, the ability to manage the complexity and completeness of KAOS models is essential. In this paper, we propose a metrics suite for supporting the quantitative assessment of KAOS models complexity and completeness, in order to support their early identification. We apply the metrics to an example taken from a health club system specification.

Scenario modeling can be realized through different perspectives. In UML, scenarios are often modeled with activity models, in an early stage of development. Later, sequence diagrams are used to detail object interactions. The migration from activity diagrams to sequence diagrams is a repetitive and error-prone task. Model-Driven Development (MDD) can help streamlining this process, through transformation rules. Since the information in the activity model is insufficient to generate the corresponding complete sequence model, manual refinements are required. Our goal is to compare the relative effort of building the sequence diagrams manually with that of building them semi-automatically. Our results show a decrease in the number of operations required to build and refine the sequence model of approximately 64% when using MDD, when compared to the manual approach.

Domain Specific Languages (DSLs) are claimed to increase productivity, while reducing the required maintenance and programming expertise. In this context, DSL usability by domain experts is a key factor for its successful adoption. Evidence that support those improvement claims is mostly anecdotal. Our systematic literature review showed that a usability evaluation was often skipped, relaxed, or at least omitted from papers reporting the development of DSLs. The few exceptions mostly take place at the end of the development process where fixing problems identified is too expensive. We argue that a systematic approach based on User Interface experimental validation techniques should be used to assess the impact of the new DSLs. The rationale is that assessing important and specially tailored usability attributes for DSLs early in language construction will ultimately foster a higher productivity of the DSL users. This paper, besides discussing the quality criteria, proposes a development and evaluation process that can be used to achieve usable DSLs in a better way.

Domain Specific Languages (DSLs) are claimed to increment productivity, while reducing the required maintenance and programming expertise. In this context, DSLs usability is a key factor for its successful adoption.

In this paper, we propose a systematic approach based on User Interfaces Experimental validation techniques to assess the impact of the introduction of DSLs on the productivity of domain experts. To illustrate this evaluation approach we present a case study of a DSL for High Energy Physics (HEP).

The DSL on this case study, called Pheasant (PHysicist’s EAsy Analysis Tool), is assessed in contrast with a pre-existing baseline, using General Purpose Languages (GPLs) such as C++. The comparison combines quantitative and qualitative data, collected with users from a real-world setting. Our assessment includes Physicists with programming experience with two profiles; ones with no experience with the previous framework used in the project and other experienced.

This work’s contribution highlights the problem of the absence of systematic approaches for experimental validation of DSLs. It also illustrates how an experimental approach can be used in the context of a DSL evaluation during the Software Languages Engineering activity, with respect to its impact on effectiveness and efficiency.

Models, with different levels of detail, share similar abstractions that can be reused by means of model-driven techniques such as transformations. For example, scenarios are a well-known technique in requirements engineering to represent behavioral flows in a software system. When using UML, scenarios are typically represented with activity models in the early stages of software development, while sequence models are used to describe more detailed object interactions as modeling progresses. This paper defines transformation rules to automate the migration from activity to sequence models. We present a case study illustrating the application of our transformation rules. Our preliminary assessment of the impact of the benefits of using these transformations points to: (i) a reduction of around 50% in the effort building sequence models, (ii) increased trace ability among models, and (iii) error prevention when migrating from different scenario notations.

Domain Specic Languages (DSLs) can contribute to increment productivity, while reducing the required maintenance and programming expertise. We hypothesize that Software Languages Engineering (SLE) developers consistently skip, or relax, Language Evaluation. Based on the experience of engineering other types of software products, we assume that this may potentially lead to the deployment of inadequate languages. The fact that the languages already deal with concepts from the problem domain, and not the solution domain, is not enough to validate several issues at stake, such as its expressiveness, usability,
effectiveness, maintainability, or even the domain expert's productivity while using them. We present a systematic review on articles published in top ranked venues, from 2001 to 2008, which report DSLs' construction, to characterize the common practice. This work conrms our initial hypothesis and lays the ground for the discussion on how to include a systematic approach to DSL evaluation in the SLE process.

Background: Aspect-oriented programming (AOP) is an
emerging programming paradigm whose focus is about improving
modularity, with an emphasis on the modularization of
crosscutting concerns.

Objective: The goal of this paper is to assess the extent to which
an AOP language – ObjectTeams/Java (OT/J) – improves the
modularity of a software system. This improvement has been
claimed but, to the best of our knowledge, this paper is the first
attempting to present quantitative evidence of it.

Method: We compare functionally-equivalent implementations of
the Gang-of-Four design patterns, developed in Java and OT/J,
using software metrics.

Results: The results of our comparison support the modularity
improvement claims made in the literature. For six of the seven
metrics used, the OT/J versions of the patterns obtained
significantly better results.

Limitations: This work uses a set of metrics originally defined
for object-oriented (OO) systems. It may be the case that the
metrics are biased, in that they were created in the context of OO
programming (OOP), before the advent of AOP. We consider this
comparison a stepping stone as, ultimately, we plan to assess the
modularity improvements with paradigm independent metrics,
which will conceivably eliminate the bias. Each individual
example from the sample used in this paper is small. In future, we
plan to replicate this experiment using larger systems, where the
benefits of AOP may be more noticeable.

Conclusion: This work contributes with evidence to fill gaps in
the body of quantitative results supporting alleged benefits to
software modularity brought by AOP languages, namely OT/J.

Background: Often, claims in Component-Based Development (CBD) are only sup-
ported by qualitative expert opinion, rather than by quantitative data. This contrasts
with the normal practice in other sciences, where a sound experimental validation of
claims is standard practice. Experimental Software Engineering (ESE) aims to bridge
this gap. Unfortunately, it is common to find experimental validation efforts that are
hard to replicate and compare, to build up the body of knowledge in CBD.

Objectives: In this dissertation our goals are (i) to contribute to evolution of ESE, in
what concerns the replicability and comparability of experimental work, and (ii) to ap-
ply our proposals to CBD, thus contributing to its deeper and sounder understanding.

Techniques: We propose a process model for ESE, aligned with current experimen-
tal best practices, and combine this model with a measurement technique called
Ontology-Driven Measurement (ODM). ODM is aimed at improving the state of prac-
tice in metrics definition and collection, by making metrics definitions formal and ex-
ecutable, without sacrificing their usability. ODM uses standard technologies that can
be well adapted to current integrated development environments.

Results: Our contributions include the definition and preliminary validation of a pro-
cess model for ESE and the proposal of ODM for supporting metrics definition and
collection in the context of CBD. We use both the process model and ODM to perform
a series experimental works in CBD, including the cross-validation of a component
metrics set for JavaBeans, a case study on the influence of practitioners expertise in
a sub-process of component development (component code inspections), and an ob-
servational study on reusability patterns of pluggable components (Eclipse plug-ins).
These experimental works implied proposing, adapting, or selecting adequate ontolo-
gies, as well as the formal definition of metrics upon each of those ontologies.

Limitations: Although our experimental work covers a variety of component models
and, orthogonally, both process and product, the plethora of opportunities for using
our quantitative approach to CBD is far from exhausted.

Conclusions: The main contribution of this dissertation is the illustration, through
practical examples, of how we can combine our experimental process model with
ODM to support the experimental validation of claims in the context of CBD, in a re-
peatable and comparableway. In addition, the techniques proposed in this dissertation
are generic and can be applied to other software development paradigms.

Reviews on software engineering literature have shown an insufficient experimental validation of claims, when compared to the standard practice in other well-established sciences. Poor validation of software engineering claims increases the risks of introducing changes in the software process of an organization, as the potential benefits assessment is based on hype, rather than on facts. The community lacks highly disseminated experimental best practices. We contribute with a model of the experimental software engineering process that is aligned with recent proposals for best practices in experimental data dissemination. The model can be used in the definition of software engineering experiments and in comparisons among experimental results.

Objective: To present an overview on the current state of the art concerning metrics-based
quality evaluation of software components and component assemblies.
Method: Comparison of several approaches available in the literature, using a framework
comprising several aspects, such as scope, intent, definition technique, and maturity.
Results: The identification of common shortcomings of current approaches, such as
ambiguity in definition, lack of adequacy of the specifying formalisms and insufficient
validation of current quality models and metrics for software components.
Conclusions: Quality evaluation of components and component-based infrastructures
presents new challenges to the Experimental Software Engineering community.