Daltro José Nunes

Crosscutting patterns and design stability: An exploratory analysis

It is often claimed that inaccurate modularisation of crosscutting concerns hinders program comprehension and, as a consequence, leads to harmful software instabilities. However, recent studies have pointed out that crosscutting concerns are not always harmful to design stability. Hence, software maintainers would benefit from well documented patterns of crosscutting concerns and a better understanding about their actual impact on design stability. This paper presents a catalogue of crosscutting concern patterns recurrently observed in software systems. These patterns are described and classified based on an intuitive vocabulary that facilitates their recognition by software engineers. We analysed instances of the crosscutting patterns in object-oriented and aspect-oriented versions of three evolving programs. The outcomes of our exploratory evaluation indicated that: (i) a certain category of crosscutting patterns seems to be good indicator of harmful instabilities, and (ii) aspect-oriented solutions were unable to modularise concerns matching some crosscutting patterns.

Automated support for software process reuse: requirements and early experiences with the APSEE model

This paper discusses the need to provide better support for software processes reuse in PSEEs (Process-centered Software Engineering Environments). This discussion is influenced by the recent work on the process reuse field presented in the literature and the experience of the authors in the definition of a meta-model for process modeling, enaction and simulation in an integrated environment (APSEE). This model proposes templates and policies as basic constructs to store generic and reusable knowledge about process models, which are integrated with a search engine based on similarity measurement. The basic set of data types used in the definition of the meta-model is presented. The paper concludes by presenting the proposed functionality to retrieve and adapt reusable process descriptions to a specific context.

A policy-based resource instantiation mechanism to automate software process management

Process-Centered Software Engineering Environments (PSEEs) deal with activities that demand specialized personnel and limited resources. Characteristics about required resources and people (and their dynamic availability) are used by software process instantiation phase to define process allocation strategies. However, most of existing PSEEs do not allow precise resource specification, and the instantiation is often based on the knowledge of a process designer, mostly without automated support. Thus, process managers must make all major decisions based on their individual insights and experience: this constitutes a major obstacle for resource allocation analysis and optimization in process systems and can influence project management and overall software quality. This paper proposes Instantiation Policies as a compact formalism, integrated to a process modeling language, to allow user-defined reusable management strategies for resource instantiation. Through the proposed language it is possible to plan or automate allocation depending on process and organization current situation. This paper discusses the motivations for this solution, shows the proposed meta-model, language and some application examples for this approach.

Automatic Verification of Static Policies on Software Process Models

Software Process Technology evolved to support software processes management by assisting the modeling, enacting and evolution of complex process models. This paper presents a contribution to this field, describing a mechanism to formally model Static Policies, which are useful to automate the verification of user-defined process syntactical properties. The proposed mechanism acts during software process modeling, promoting the reuse of policy instances across different processes in a software organization. In this text, the language for Static Policy definition is presented first through its informal description, followed by examples. This paper also discusses some of the main issues related to the formal (algebraic) semantics defined for the Policy interpreter, which based the implementation of a Java-based prototype.

Flexible software process enactment support in the APSEE model

Software process technology recently evolved to automate software process management by providing specialized languages and environments to control the human performance in software development activities. This paper presents APSEE as an executable visual language for software process modeling. The meta-model was specified using graph-grammars, which successfully derived a Java-based implementation. Finally, this experience is discussed with respect to the support for dynamic changes in enacting processes.

Revealing the relationship between architectural elements and source code characteristics

Understanding how a software system is structured, i.e. its architecture, is crucial for software comprehension. It allows developers to understand an implemented system and reason about how non-functional requirements are addressed. Yet, many systems lack any architectural documentation, or it is often outdated due to software evolution. In current practice, the process of recovering a systems architecture relies primarily on developer knowledge. Although existing architecture recovery approaches can help to identify architectural elements, these approaches require improvement to identify architectural concepts of a system automatically. Towards this goal, we analyze the usefulness of adopting different code-level characteristics to group elements into architectural modules. Our main contributions are an evaluation of the relationships between different sets of characteristics and their corresponding accuracies, and the evaluation results, which help us to understand which characteristics reveal information about the source code structure. Our experiment shows that an identified set of characteristics achieves an average accuracy of 80%, which indicates the usefulness of the considered characteristics for architecture recovery and thus to improving software comprehension.

On the Effectiveness of Bug Predictors with Procedural Systems: A Quantitative Study

Many bug predictors have been proposed, and their main target is object-oriented systems. Although object-orientation is currently the choice for most of the software applications, the procedural paradigm is still being used in many--sometimes crucial--applications, such as operating systems and embedded systems. Consequently, they also deserve attention. We present a study in which we investigated the effectiveness of existing bug prediction approaches with procedural systems. Such approaches use as input static code metrics. We evaluated to what extent they are applicable to our context, and compared their effectiveness using standard metrics, with adaptations when needed. We assessed five approaches, using eight procedural software systems, including open-source and industrial projects. We concluded that lines of code is the metric that plays the key role in our context, and approaches that use of a large set of metrics can introduce noise in the prediction model. In addition, the best results were obtained with open-source systems.

Using Graph Transformation as the Semantical Model for Software Process Execution in the APSEE Environment

Software Process Technology recently evolved to automate software process management by providing specialized languages and environments to control the human performance in software development activities. This paper presents APSEE as an executable visual language for software process modeling. The underlying meta-model was specified using graph grammars, which successfully derived a Java-based implementation. Finally, this experience is discussed with respect to the provided management mechanism to handle dynamic changes in executing processes.

The WGB method to recover implemented architectural rules

Abstract Context: The identification of architectural rules, which specify allowed dependencies among architectural modules, is a key challenge in software architecture recovery. Existing approaches either retrieve a large set of rules, compromising their practical use, or are limited to supporting the understanding of such rules, which are manually recovered. Objective: To propose and evaluate a method to recover architectural rules, focusing on those implemented in the source code, which may differ from planned or conceptual rules. Method: We propose the WGB method, which analyzes dependencies among architectural modules as a graph, adding weights that correspond to the proposed module dependency strength (MDS) metric and identifies the set of implemented architectural rules by solving a mathematical optimization problem. We evaluated our method with a case study and an empirical study that compared rules extracted by the method with the conceptual architecture and source code dependencies of six systems. These comparisons considered efficiency and effectiveness of our method. Results: Regarding efficiency, our method took 45.55 s to analyze the largest system evaluated. Considering effectiveness, our method captured package dependencies as extracted rules with a reduction of 87.6%, on average, to represent this information. Using allowed architectural dependencies as a reference point (but not a gold standard), provided rules achieved 37.1% of precision and 37.8% of recall. Conclusion: Our empirical evaluation shows that the implemented architectural rules recovered by our method consist of abstract representations of (a large number of) module dependencies, providing a concise view of dependencies that can be inspected by developers to identify occurrences of architectural violations and undocumented rules.

A Simulation Model for Process-Centered Software Engineering Environments Using Sensitivity Analysis

Software development is a high risk activity that requires planning to reduce costs and meet deadlines. This paper presents a simulation model, integrated to a tool that supports project management centered processes, uses the information in the PSEE database, offers resources to manipulate process data in a deterministic or stochastic way (simulation), allows testing various scenarios and identifies the variables that have most impact on the final result (sensitivity analysis). The results achieved by implementing this model, using the information of a real case study, were able to provide important data to improve the process under study.