Márcio de Oliveira Barros

Staffing a software project: A constraint satisfaction and optimization-based approach

Software development is a people intensive activity. The abilities possessed by developers are strongly related to process productivity and final product quality. Thus, one of the most important decisions to be made by a software project manager is how to properly staff the project. However, staffing software projects is not a simple task. There are many alternatives to ponder, several developer-to-activity combinations to evaluate, and the manager may have to choose a team from a larger set of available developers, according to the project and organizational needs. Therefore, to perform the staffing activity with ad hoc procedures can be very difficult and can lead the manager to choose a team that is not the best for a given situation. This work presents an optimization-based approach to support staffing a software project. The staffing problem is modeled and solved as a constraint satisfaction problem. Our approach takes into account the characteristics of the project activities, the available human resources, and constraints established by the software development organization. According to these needs, the project manager selects a utility function to be maximized or minimized by the optimizer. We propose several utility functions, each addressing values that can be sought by the development organization. A decision support tool was implemented and used in an experimental study executed to evaluate the relevance of the proposed approach.

Supporting risks in software project management

Complex software development is a risky job. The number of unsuccessful projects surpasses the number of successful developments, particularly when large projects are analyzed. This paper describes an approach to develop, retrieve, and reuse management knowledge and experience concerned with software development risks. Scenarios are used to model risk impact and resolution strategies efficacy within risk archetypes. A risk archetype is an information structure that holds knowledge about software development risks. A risk management process organizes the use of risk archetypes within an application development effort. The process resembles a reuse process framework, where two sub-processes are respectively responsible for identifying and reusing risk information. Simulating the impact of the expected risks can support some of the decisions throughout the software development process. The contribution of this paper is to show how risk archetypes and scenario models can represent reusable project management knowledge. An observational analysis of applying such an approach in an industrial environment and a feasibility study are also described.

Evaluating software project portfolio risks

As in any other business, software development organizations try to maximize their profits and minimize their risks. The risks represent uncertain events and conditions that may prevent enterprises from attaining their goals, turning risk management into a major concern, not only for project managers but also for executive officers involved with strategic objectives. In this sense, economical concepts can greatly support Software Engineers in the effort to better quantify the uncertainties of either a single project or even a project portfolio. In this paper, we present a technique for evaluating risk levels in software projects through analogies with economic concepts. This technique allows a manager to estimate the probability distribution of earnings and losses incurred by an organization in relation to its software project portfolio. This approach has been calibrated by data collected in an empirical study, which has been planned and accomplished to provide information about the relative importance of risk factors in software projects. A usage example of such an approach is presented. Finally, we introduce a case tool specially built to support the application of the proposed techniques.

An analysis of the effects of composite objectives in multiobjective software module clustering

The application of multiobjective optimization to address Software Engineering problems is a growing trend. Multiobjective algorithms provide a balance between the ability of the computer to search a large solution space for valuable solutions and the capacity of the human decision-maker to select an alternative when two or more incomparable objectives are presented. However, when more than a single objective is available, the set of objectives to be considered by the search becomes part of the decision. In this paper, we address the efficiency and effectiveness of using two composite objectives while searching solutions for the software clustering problem. We designed an experimental study which shows that a multiobjective genetic algorithm can find a set of solutions with increased quality and using less processing time if these composite objectives are suppressed from the formulation for the software clustering problem.

A system dynamics metamodel for software process modeling

In this paper we describe a metamodel to the system dynamics language that allows the development of software process models based on high-level constructors instead of mathematical equations. These constructors represent software process domain concepts such as developers, activities, resources and artifacts. A domain model allows the translation of these concepts to traditional stock-and-flow diagrams, which can be simulated to evaluate the behavior of software process models. The proposed approach helps inexperienced modelers to build process models by reducing the semantic gap between system dynamics and the software process domain. Thus, resulting models are more readable, easier to understand and maintain. We provide an example of a process model built with the proposed approach presenting its translation and simulation processes. Copyright

Software requirements selection and prioritization using SBSE approaches

A recent trend to use multi-objective modeling.The most frequent problem is related to releases.Meta-heuristics is the technique most commonly applied method in experiments.Aspects related to risk and uncertainties need to be considered in problem formulation.The majority of experiments use small scale data type. The selection and prioritization of software requirements represents an area of interest in Search-Based Software Engineering (SBSE) and its main focus is finding and selecting a set of requirements that may be part of a software release. This paper presents a systematic review and mapping that investigated, analyzed, categorized and classified the SBSE approaches that have been proposed to address software requirement selection and prioritization problems, reporting quantitative and qualitative assessment. Initially 39 papers returned from our search strategy in this area and they were analyzed by 18 previously established quality criteria. The results of this systematic review show which aspects of the requirements selection and prioritization problems were addressed by researchers, which approaches and search techniques are currently adopted to address these problems, as well as the strengths and weaknesses in this research area highlighted from the quality criteria.

Staffing a software project: a constraint satisfaction approach

This paper presents an optimization based approach to support staffing a software project. The approach takes into account the characteristics of the project activities, the characteristics of the available human resources, and constraints established by the software development organization in charge of the project. According to these needs, the project manager selects a utility function to be maximized or minimized by the optimizer. We propose several utility functions, each addressing specific values which can be sought by the development organization.

Learning from optimization: A case study with Apache Ant

Abstract Context Software architecture degrades when changes violating the design-time architectural intents are imposed on the software throughout its life cycle. Such phenomenon is called architecture erosion. When changes are not controlled, erosion makes maintenance harder and negatively affects software evolution. Objective To study the effects of architecture erosion on a large software project and determine whether search-based module clustering might reduce the conceptual distance between the current architecture and the design-time one. Method To run an exploratory study with Apache Ant. First, we characterize Ant’s evolution in terms of size, change dispersion, cohesion, and coupling metrics, highlighting the potential introduction of architecture and code-level problems that might affect the cost of changing the system. Then, we reorganize the distribution of Ant’s classes using a heuristic search approach, intending to re-emerge its design-time architecture. Results In characterizing the system, we observed that its original, simple design was lost due to maintenance and the addition of new features. In optimizing its architecture, we found that current models used to drive search-based software module clustering produce complex designs, which maximize the characteristics driving optimization while producing class distributions that would hardly be acceptable to developers maintaining Ant. Conclusion The structural perspective promoted by the coupling and cohesion metrics precludes observing the adequate software module clustering from the perspective of software engineers when considering a large open source system. Our analysis adds evidence to the criticism of the dogma of driving design towards high cohesion and low coupling, at the same time observing the need for better models to drive design decisions. Apart from that, we see SBSE as a learning tool, allowing researchers to test Software Engineering models in extreme situations that would not be easily found in software projects.

A Systematic Review of Software Requirements Selection and Prioritization Using SBSE Approaches

Selection and prioritization of software requirements represents an area of interest in Search-Based Software Engineering SBSE and its main focus is finding and selecting a set of requirements that may be part of a software release. This paper uses a systematic review to investigate which SBSE approaches have been proposed to address software requirement selection and prioritization problems. The search strategy identified 30 articles in this area and they were analyzed for 18 previously established quality criteria. The results of this systematic review show which aspects of the requirements selection and prioritization problems were addressed by researchers, the methods approaches and search techniques currently adopted to address these problems, and the strengths and weaknesses of each of these techniques. The review provides a map showing the gaps and trends in the field, which can be useful to guide further research.

An empirical study of the impact of OCL smells and refactorings on the understandability of OCL specifications

The Object Constraint Language (OCL) is a OMG standard that plays an important role in the elaboration of precise models. However, it is not hard to find models and metamodels containing overly complex OCL expressions. Refactoring is a technique that can be used in this context since its goal is to reduce complexity by incrementally improving the internal software quality. Indeed several refactorings have already been proposed to improve the quality of OCL expressions. This paper presents the results of an empirical study that investigates the impact of poor OCL constructs, also known as OCL Smells, and OCL refactorings on the understandability of OCL expressions. Current results show that most refactorings significantly improve the understandability of OCL specifications.