Context Of Software Maintenance Research Articles

Test case generation based on mutations over user execution traces

Automatic test case generation is usually based on models of the software under test. However, those models may not exist or may be outdated and so, the test case generation must resort to other artifacts. In a software maintenance context, test cases must adapt to software changes and should be improved continuously to test adequately the new versions of the software. Mutation testing is a fault-based testing technique that evaluates the quality of the tests by applying simple changes to the source code and checking afterwards if the tests are able to detects those changes. This paper presents a web testing approach in which test cases are generated from user execution traces as a way to deal with the absence of models. In addition, it applies mutation operators over those test cases to enrich the test suite. The mutation operators were designed so as to mimic possible real failures. The additional tests are analyzed, and those that generate different outcomes are kept because they exercise additional behavior of the web application under test. At the end, the overall approach is illustrated and validated in a case study.

Visual software analytics for the build optimization of large-scale software systems

Visual analytics is the science of analytical reasoning facilitated by interactive visual interfaces. In this paper, we present an adaptation of the visual analytics framework to the context of software understanding for maintenance. We discuss the similarities and differences of the general visual analytics context with the software maintenance context, and present in detail an instance of a visual software analytics application for the build optimization of large-scale code bases. Our application combines and adapts several data mining and information visualization techniques in answering several questions that help developers in assessing and reducing the build cost of such code bases by means of user-driven, interactive analysis techniques.

The structural complexity of software an experimental test

This research examines the structural complexity of software and, specifically, the potential interaction of the two dominant dimensions of structural complexity, coupling and cohesion. Analysis based on an information processing view of developer cognition results in a theoretically driven model with cohesion as a moderator for a main effect of coupling on effort. An empirical test of the model was devised in a software maintenance context utilizing both procedural and object-oriented tasks, with professional software engineers as participants. The results support the model in that there was a significant interaction effect between coupling and cohesion on effort, even though there was no main effect for either coupling or cohesion. The implication of this result is that, when designing, implementing, and maintaining software to control complexity, both coupling and cohesion should be considered jointly, instead of independently. By providing guidance on structuring software for software professionals and researchers, these results enable software to continue as the solution of choice for a wider range of richer, more complex problems.