Catálogo de publicaciones - libros

Many organizations using agile processes would like to adopt a process measurement framework, e.g. for assessing their process maturity. In this paper we propose a meta-model supporting derivation of specific data models for agile development processes. Then, we show how our meta-model can be used to derive a model of the Scrum process.

The automated collection of source code metrics can help agile teams to understand the software they are producing, allowing them to adapt their daily practices towards an environment of continuous improvement. This paper describes the evolution of some object-oriented metrics in several agile projects we conducted recently in both academic and governmental environments. We analyze seven different projects, some where agile methods were used since the beginning and others where some agile practices were introduced later. We analyze and compare the evolution of such metrics in these projects and evaluate how the different project context factors have impacted the source code.

We conducted a survey on Executable Acceptance Test Driven Development (or: Story Test Driven Development). The results show that there is often a substantial delay between defining an acceptance test and its first successful pass. Therefore, it becomes important for teams to easily be able to distinguish between tasks that were never tackled before and tasks that were already completed but whose tests are now failing again. We then describe our FitClipse tool that extends Fit by maintaining a history of acceptance test results. Based on the history, FitClipse is able to generate reports that show when an acceptance test is suddenly failing again.

Unit testing is essential in the agile context. A unit test case written long ago may uncover an error introduced only recently, at a time at which awareness of the test and the requirement it expresses may have long vanished. Popular unit testing frameworks such as JUnit may then detect the error at little more cost than the run of a static program checker (compiler). However, unlike such checkers current unit testing frameworks can only detect the presence of errors, they cannot locate them. With EzUnit , we present an extension to the JUnit Eclipse plug-in that serves to narrow down error locations, and that marks these locations in the source code in very much the same way syntactic and typing errors are displayed. Because EzUnit is itself designed as a framework, it can be extended by algorithms further narrowing down error locations.

Extreme Programming aims at delivering working software for less money and still of high quality. It is well known that software maintainability is one of the most important concerns and cost factors of the software industry. The question of this research is whether Extreme Programming intrinsically delivers easily maintainable code or not. We propose a model on how to evaluate the evolution of source code quality and in particular maintainability in an Extreme Programming environment and evaluate it with a small case study. The results obtained from the case study seem to sustain the hypothesis that Extreme Programming enhances quality and in particular maintainability of a software product. Given such promising results, additional experimentation is required to validate and generalize the results of this work.

Testing is an essential part of an agile process as test is automated and tends to take the role of specifications in place of documents. However, whenever test cases are faulty, developers’ time might be wasted to fix problems that do not actually originate in the production code. Because of their relevance in agile processes, we posit that the quality of test cases can be assured through software inspections as a complement to the informal review activity which occurs in pair programming. Inspections can thus help the identification of what might be wrong in test code and where refactoring is needed. In this paper, we report on a preliminary empirical study where we examine the effect of conducting software inspections on automated test code. First results show that software inspections can improve the quality of test code, especially the repeatability attribute. The benefit of software inspections also apply when automated unit tests are created by developers working in pair programming mode.

We specify a non-invasive method allowing to estimate the time each developer of a pair spends over the development activity, during Pair Programming. The method works by performing first a behavioural fingerprinting of each developer – based on low level event logs – which then is used to operate a segmentation over the log sequence produced by the pair: in a timelined log event sequence this is equivalent to estimating the times of the switching between developers. We model the individual developer’s behaviour by means of a Markov Chain – inferred from the logs – and model the developers’ role-switching process by a further, higher level, Markov Chain. The overall model consisting in the two nested Markov Chains belongs to the class of Hierarchical Hidden Markov Models. The method could be used not only to assess the degree of conformance with respect to predefined Pair Programming switch-times policies, but also to capture the characteristics of a given programmers pair’s switching process, namely in the context of Pair Programming effectiveness studies.

The number of defects is an important indicator of software quality. Agile software development methods put an explicit requirement on automation and permanently low defect rates. Code analysis tools are seen as a prominent way to facilitate the defect prediction. There are only few studies addressing the feasibility of predicting a defect rate with the help of static code analysis tools in the area of embedded software. This study addresses the usefulness of two selected tools in the Symbian C++ environment. Five projects and 137 KLOC of the source code have been processed and compared to the actual defect rate. As a result a strong positive correlation with one of the tools was found. It confirms the usefulness of a static code analysis tool as a way for estimating the amount of defects left in the product.

Bringing software process change to an organisation is a real challenge. The authors have shown a sample attempt to carry out a process change and then reflected on its results and context. The present reflection points to a need for a set of principles and practices that would support the fragile process of introducing agility. For a start, the authors propose the Empirical Evidence principle exemplified using DICE® and the practice of Joint Engagement of the management and the developers. Both are results of a real-world process change case study in Poland.

Agile methods are finding their way into industry, and also into tertiary education. Approaches on tertiary capstone project are being presented, and questioned, if they provide a supportive learning environment. In this paper, an industrial strength holding, conceptual framework for realizing an agile grounded software project course in academic environment is described and rationalized by pedagogical aspects.