Software tends to decline in quality over time, causing development and maintenance costs to rise. However, by measuring, tracking, and controlling quality during the lifetime of a software product, its technical debt can be held in check, reducing total cost of ownership. The measurement of quality faces challenges due to disagreement in the meaning of software quality, the inability to directly measure quality factors, and the lack of measurement practice in the software industry. This report addresses these challenges through both a literature survey, a metrics derivation process, and a survey of professional software developers. Definitions of software quality from the literature are presented and evaluated with responses from software professionals. A goal, question, metric process is used to derive quality-targeted metrics tracing back to a set of seven code-quality subgoals, while a survey to software professionals shows that despite agreement that metrics and metric visualizations would be useful for improving software quality, the techniques are underutilized in practice. / text

Copying a code fragment and reusing it by pasting with or without minor modifications is a common practice in software development for improved productivity. As a result, software systems often have similar segments of code, called software clones or code clones. Due to many reasons, unintentional clones may also appear in the source code without awareness of the developer. Studies report that significant fractions (5% to 50%) of the code in typical software systems are cloned. Although code cloning may increase initial productivity, it may cause fault propagation, inflate the code base and increase maintenance overhead. Thus, it is believed that code clones should be identified and carefully managed. This Ph.D. thesis contributes in clone management with techniques realized into tools and large-scale in-depth analyses of clones to inform clone management in devising effective techniques and strategies. To support proactive clone management, we have developed a clone detector as a plug-in to the Eclipse IDE. For clone detection, we used a hybrid approach that combines the strength of both parser-based and text-based techniques. To capture clones that are similar but not exact duplicates, we adopted a novel approach that applies a suffix-tree-based k-difference hybrid algorithm, borrowed from the area of computational biology. Instead of targeting all clones from the entire code base, our tool aids clone-aware development by allowing focused search for clones of any code fragment of the developer's interest. A good understanding on the code cloning phenomenon is a prerequisite to devise efficient clone management strategies. The second phase of the thesis includes large-scale empirical studies on the characteristics (e.g., proportion, types of similarity, change patterns) of code clones in evolving software systems. Applying statistical techniques, we also made fairly accurate forecast on the proportion of code clones in the future versions of software projects. The outcome of these studies expose useful insights into the characteristics of evolving clones and their management implications. Upon identification of the code clones, their management often necessitates careful refactoring, which is dealt with at the third phase of the thesis. Given a large number of clones, it is difficult to optimally decide what to refactor and what not, especially when there are dependencies among clones and the objective remains the minimization of refactoring efforts and risks while maximizing benefits. In this regard, we developed a novel clone refactoring scheduler that applies a constraint programming approach. We also introduced a novel effort model for the estimation of efforts needed to refactor clones in source code. We evaluated our clone detector, scheduler and effort model through comparative empirical studies and user studies. Finally, based on our experience and in-depth analysis of the present state of the art, we expose avenues for further research and development towards a versatile clone management system that we envision.

Software development is a largely collaborative effort, of which the actual encoding of program logic in source code is a relatively small part. Software developers have to collaborate effectively and communicate with their peers in order to avoid coordination problems. To date, little is known how developer communication during software development activities impacts the quality and evolution of a software. In this thesis, we present and evaluate tools and techniques to recover communication data from traces of the software development activities. With this data, we study the impact of developer communication on the quality and evolution of the software through an in-depth investigation of the role of developer communication during software development activities. Through multiple case-studies on a broad spectrum of open-source software projects, we find that communication between developers stands in a direct relationship to the quality of the software. Our findings demonstrate that our models based on developer communication explain software defects as well as state-of-the art models that are based on technical information such as code and process metrics, and that social information metrics are orthogonal to these traditional metrics, leading to a more complete and integrated view on software defects. In addition, we find that communication between developers plays a important role in maintaining a healthy contribution management process, which is one of the key factors to the successful evolution of the software. Source code contributors who are part of the community surrounding open-source projects are available for limited times, and long communication times can lead to the loss of valuable contributions. Our thesis illustrates that software development is an intricate and complex process that is strongly influenced by the social interactions between the stakeholders involved in the development activities. A traditional view based solely on technical aspects of software development such as source code size and complexity, while valuable, limits our understanding of software development activities. The research presented in this thesis consists of a first step towards gaining a more holistic view on software development activities. / Thesis (Ph.D, Computing) -- Queen's University, 2014-05-22 12:07:13.823

Software evolution refers to continuous change that a software system endures from inception to retirement. Each change must be efficiently and tractably propagated across models representing the system at different levels of abstraction. Model synchronization activities needed to support the systematic specification and analysis of evolution activities are still not adequately identified and formally defined. In our research, we first introduce a formal notation for the representation of domain models and model instances to form the theoretical basis for the proposed model synchronization framework. Besides conforming to a generic MOF metamodel, we consider that each software model also relates to an application domain context (e.g., operating systems, web services). Therefore, we are addressing the problems of model synchronization by focusing on domain-specific contexts. Secondly, we identify and formally define model dependencies that are needed to trace and propagate changes across system models at different levels of abstraction, such as from design to source code. The approach for extraction of these dependencies is based on Formal Concept Analysis (FCA) algorithms. We further model identified dependencies using Unified Modeling Language (UML) profiles and constraints, and utilize the extracted dependency relations in the context of coarse-grained model synchronization. Thirdly, we introduce modeling semantics that allow for more complex profile-based dependencies using Triple Graph Grammar (TGG) rules with corresponding Object Constraint Language (OCL) constraints. The TGG semantics provide for fine-grained model synchronization, and enable compliance with the Query/View/Transformation (QVT) standards. The introduced framework is assessed on a large, industrial case study of the IBM Commerce system. The dependency extraction framework is applied to repositories of business process models and related source code. The extracted dependencies were evaluated by IBM developers, and the corresponding precision and recall values calculated with results that match the scope and goals of the research. The grammar-based model synchronization and dependency modelling using profiles has also been applied to the IBM Commerce system, and evaluated by the developers and architects involved in development of the system. The results of this experiment have been found to be valuable by stakeholders, and a patent codifying the results has been filed by the IBM organization and has been granted. Finally, the results of this experiment have been formalized as TGG rules, and used in the context of fine-grained model synchronization.

There is a strong synergy between the concepts of evolution and adaptation in software engineering: software adaptation refers to both the current software being adapted and to the evolution process that leads to the new adapted software. Evolution changes for the purpose of adaptation are usually made at development or compile time, and are meant to handle predictable situations in the form of software change requests. On the other hand, software may also change and adapt itself based on the changes in its environment. Such adaptive changes are usually dynamic, and are suitable for dealing with unpredictable or temporary changes in the software's operating environment. A promising solution for software adaptation is to develop self-adaptive software systems that can manage changes dynamically at runtime in a rapid and reliable way. One of the main advantages of self-adaptive software is its ability to manage the complexity that stems from highly dynamic and nondeterministic operating environments. If a self-adaptive software system has been engineered and used properly, it can greatly improve the cost-effectiveness of software change through its lifespan. However, in practice, many of the existing approaches towards self-adaptive software are rather expensive and may increase the overall system complexity, as well as subsequent future maintenance costs. This means that in many cases, self-adaptive software is not a good solution, because its development and maintenance costs are not paid off. The situation is even worse in the case of making current (legacy) systems adaptive. There are several factors that have an impact on the cost-effectiveness and usability of self-adaptive software; however the main objective of this thesis is to make a software system adaptive in a cost-effective way, while keeping the target adaptive software generic, usable, and evolvable, so as to support future changes. In order to effectively engineer and use self-adaptive software systems, in this thesis we propose a new conceptual model for identifying and specifying problem spaces in the context of self-adaptive software systems. Based on the foundations of this conceptual model, we propose a model-centric approach for engineering self-adaptive software by designing a generic adaptation framework and a supporting evolution process. This approach is particularly tailored to facilitate and simplify the process of evolving and adapting current (legacy) software towards runtime adaptivity. The conducted case studies reveal the applicability and effectiveness of this approach in bringing self-adaptive behaviour into non-adaptive applications that essentially demand adaptive behaviour to sustain.

Software has been studied at a variety of granularities. Code, classes, groups of classes, programs and finally large scale applications have been examined in detail. What lies beyond is the study of software collections that group together many individual applications. Collecting software and distributing it via a central repository has been popular for a while in the open source world, and only recently caught on commercially with Apple’s Mac app store and Microsoft’s Windows store. In many of these software collections, there is normally a complex process that must be followed in order to fully integrate new applications into the system. Moreover, in the case of open source software collections, applications frequently rely on each other for functionality and their interactions can be complex. We know that there are thousands of applications in these software collections that people depend on worldwide, but research in this area has been limited compared to other areas and granularities of software. In this thesis, we explore the evolution and architecture of a large open source software collections by using Debian as a case study. Debian is a software collection based off the Linux kernel with a large number of packages spread over multiple hardware platforms. Each package provides a particular service or application and is actively maintained by one or more developers. This thesis investigates how these packages evolve through time and their interactions with one another. The first half of the thesis describes the life cycle of a package from inception to end by carrying out a longitudinal study using the Ultimate Debian Database (UDD). The birth of packages is examined to see how Debian is growing. Conversely, package death is also analyzed to determine the lifespan of these packages. Moreover, four different package attributes are examined. They are package age, package bugs, package maintainers and package popularity. These four attributes combine to give us the overall biography of Debian packages. Debian’s architecture is explored in the second part of the thesis, where we analyze how packages interact with each other by examining the package dependencies in detail. The dependencies within Debian are extensive, which makes for an interesting architecture, but they are complex to analyze. This thesis provides a close look at the layered pattern. This pattern categorizes each package into one of five layers based on how they are used. These layers may also be visualized to give a concise view of how an application is structured. Using these views, we define five architectural subpatterns and anti-subpatterns which can aid developers in creating and maintaining packages.

People trying to understand, develop and maintain software have faced greater challenges as the complexity of software systems has increased. These challenges include the difficulty of cleanly separating different intertwined parts of a system, or relating parts of the system spread across many modules. This makes it difficult to neatly identify an area of interest, which in turn makes it difficult to understand or edit that area. The ability to separate these areas of interest, called concerns, into their own modules has been shown to improve the situation. Several approaches have been developed to enable this separation: aspect-oriented programming allows program code to be divided into smaller modules that better match areas of interest; reverse engineering tools help programmers extract information from an existing system; requirements traceability tools track individual requirements through the development process. This thesis describes a technique that works in a wide variety of circumstances. This technique allows users to create simple diagrams that describe the concern and then annotate this diagram with query expressions which link the diagram to related development artefacts like source code or documents. This research has used the tool in a set of common scenarios and compared the results to those achieved using other approaches.

Submitted by Lara Oliveira (lara@ufersa.edu.br) on 2018-03-20T20:55:57Z No. of bitstreams: 1 JoséRSF_DISSERT.pdf: 953765 bytes, checksum: cfa6e9ab2efbc54639a0e33a50b01261 (MD5) / Approved for entry into archive by Vanessa Christiane (referencia@ufersa.edu.br) on 2018-06-18T17:00:58Z (GMT) No. of bitstreams: 1 JoséRSF_DISSERT.pdf: 953765 bytes, checksum: cfa6e9ab2efbc54639a0e33a50b01261 (MD5) / Approved for entry into archive by Vanessa Christiane (referencia@ufersa.edu.br) on 2018-06-18T17:01:05Z (GMT) No. of bitstreams: 1 JoséRSF_DISSERT.pdf: 953765 bytes, checksum: cfa6e9ab2efbc54639a0e33a50b01261 (MD5) / Made available in DSpace on 2018-06-18T17:01:14Z (GMT). No. of bitstreams: 1 JoséRSF_DISSERT.pdf: 953765 bytes, checksum: cfa6e9ab2efbc54639a0e33a50b01261 (MD5) Previous issue date: 2017-08-25 / Coordenação de Aperfeiçoamento de Pessoal de Nível Superior / Software systems are constantly changing during their evolution. These changes are directly linked with the management of their product requirements. When requirements are well managed, they evolve more accurately and development costs are reduced, which includes avoiding unnecessary changes to evolving code. It is known that much of the changes demanded during the evolution of the code is associated with the scope of its elements. However, there are no studies investigating whether variations in the scope of requirements are correlated with variations in the scope of code compositions. The main purpose of this master’s thesis is to provide means to requirements engineers to monitor variation in the scope of software requirements and to correlate them with the scope of evolving code elements, which has a proven negative impact on the number of changes demanded in evolving code artifacts. In this context, a metric was formulated to quantify the scope of requirements and based on it a plug-in, called MeRS, was developed. MeRS provides means to automate this quantification. Using MeRS, an exploratory study was conducted to correlate the scopes at the requirements and code levels. To do so, we analyze the evolution of the requirements and code, focusing on the scope of two applications in evolution: NotePad and Mobile Media. The results showed that the requirements scope values are correlate with the scope of the code / Sistemas de software estão em constantes mudanças durante sua evolução, essas mudanças estão diretamente ligadas com a gestão de requisitos de seus produtos. Quando requisitos são bem gerenciados, eles evoluem de forma mais precisa e os custos de desenvolvimento são reduzidos, isso inclui evitar mudanças desnecessárias no código em evolução. Sabe-se que boa parte das mudanças demandadas durante a evolução do código está associada ao escopo dos seus elementos. Porém, não há estudos que investiguem se variações no escopo dos requisitos estão correlacionadas com variações no escopo das composições de código.Oobjetivo principal desta dissertação de mestrado é prover aos engenheiros de requisitos meios de monitorar a variação do escopo dos requisitos de software e correlacioná-los com o escopo dos elementos de código em evolução, o qual possui impacto negativo comprovado sobre o número de mudanças demandadas em artefatos de código em evolução. Neste contexto, foi formulado uma métrica para quantificar o escopo de requisitos e com base nela foi desenvolvido um plug-in, denominado MeRS, que fornece meios para automatizar esta quantificação. Por meio do MeRS foi conduzido um estudo exploratório com o objetivo de correlacionar os escopos nos níveis de requisitos e código. Para tanto, analisamos a evolução dos requisitos e código, com foco em escopo, de duas aplicações em evolução: NotePad e Mobile Media. Os resultados mostraram que os valores do escopo dos requisitos estão correlacionados com o escopo do código / 2018-03-20

Submitted by Kleber Silva (kleberbs@ufba.br) on 2017-06-01T20:36:17Z No. of bitstreams: 1 2015_Thesis_Final_v01.pdf: 25381943 bytes, checksum: cf9b5a7ab05c5f433c6abe06c7c8815e (MD5) / Approved for entry into archive by Vanessa Reis (vanessa.jamile@ufba.br) on 2017-06-07T11:38:56Z (GMT) No. of bitstreams: 1 2015_Thesis_Final_v01.pdf: 25381943 bytes, checksum: cf9b5a7ab05c5f433c6abe06c7c8815e (MD5) / Made available in DSpace on 2017-06-07T11:38:56Z (GMT). No. of bitstreams: 1 2015_Thesis_Final_v01.pdf: 25381943 bytes, checksum: cf9b5a7ab05c5f433c6abe06c7c8815e (MD5) / Software Product Line (SPL) has emerged as an important strategy to cope with the increasing demand of large-scale products customization. SPL has provided companies with an efficient and effective means of delivering products with higher quality at a lower cost, when compared to traditional software engineering strategies. However, such benefits do not come for free. There is a necessity in SPL to deal with the evolution of its assets to support changes within the environment and user needs. These changes in SPL are firstly represented by requirements. Thus, SPL should manage the commonality and variability of products by means of a “Requirements Engineering (RE) - change management” process. Hence, besides dealing with the reuse and evolution of requirements in an SPL, the RE for SPL also needs an approach to represent explicitly the commonality and variability information (e.g., through feature models and use cases). To understand the evolution in SPL, this Thesis presents two empirical studies within industrial SPL projects and a systematic mapping study on SPL evolution. The two empirical studies evaluated Lehman’s laws of software evolution in two industrial SPL projects,demonstrating that most of the laws are supported by SPL environments. The systematic mapping study on SPL evolution identified approaches in the area and revealed gaps for researching, such as, that most of the proposed approaches perform the evolution of SPL requirements in an ad-hoc way and were evaluated through feasibility studies. These results led to systematize, through guidelines, the SPL processes by starting with the SPL requirements. Thus, it was proposed an approach to specify SPL requirements called Feature-Driven Requirements Engineering (FeDRE). FeDRE specifies SPL requirements in a systematic way driven by a feature model. To deal with the evolution of FeDRE requirements, a new approach called Feature-Driven Requirements Engineering Evolution (FeDRE2) was presented. FeDRE2 is responsible for guiding, in a systematic way, the SPL evolution based on activities from RE. Both proposed approaches, FeDRE and and FeDRE2, were evaluated and the results, besides being preliminaries, shown that the approaches were perceived as easy to use and also useful, coping with the improvement and systematization of SPL processes.

Submitted by Rodrigo Souza (rodrigorgs@gmail.com) on 2015-08-10T11:52:14Z No. of bitstreams: 1 rodrigo-thesis-final.pdf: 3966742 bytes, checksum: a3ca54b041cfdc2f5dad0f568b6d3a61 (MD5) / Made available in DSpace on 2015-08-10T11:52:14Z (GMT). No. of bitstreams: 1 rodrigo-thesis-final.pdf: 3966742 bytes, checksum: a3ca54b041cfdc2f5dad0f568b6d3a61 (MD5) / Introdução: A escrita de mudanças no código-fonte para corrigir defeitos ou implementar novas funcionalidades é uma tarefa importante no desenvolvimento de software, uma vez que contribui para evoluir um sistema de software. Nem todas as mudanças, no entanto, são aceitas na primeira tentativa. Mudanças inadequadas podem ser rejeitadas por causa de problemas encontrados durante a revisão de código, durante o teste automatizado, ou durante o teste manual, possivelmente resultando em retrabalho. Nosso objetivo é entender melhor a associação estatística entre diferentes tipos de rejeição --- revisões de código negativas, commits suplementares, reversão de commits e reabertura de tíquetes ---, caracterizar seus impactos em um projeto e entender como elas são afetadas por certas mudanças de processo. Para este fim, esta tese apresenta uma análise de três grandes projetos de software livre desenvolvidos pela Mozilla Foundation, os quais sofreram mudanças significativas no seu processo, como a adoção de lançamentos frequentes. Métodos: Para perseguir nosso objetivo, nos baseamos em tíquetes e commits de um período de mais de quatro anos do histórico dos projetos. Computamos métricas sobre a ocorrência de diversos tipos de rejeição de mudanças e medimos o tempo que leva tanto para submeter uma mudança quanto para rejeitar mudanças inapropriadas. Além disso, validamos nossos resultados com desenvolvedores da Mozilla. Resultados: Descobrimos que técnicas usadas em estudos anteriores para detectar mudanças inadequadas são imprecisas; por isso, propusemos uma técnica alternativa. Determinamos que mudanças inadequadas são um problema relevante e diário, que afeta cerca de 18% de todos os tíquetes em um projeto. Também descobrimos que, quando a Mozilla adotou lançamentos frequentes, embora a proporção de commits revertidos tenha aumentado, as reversões foram realizadas mais cedo no processo. / Background: Writing source code changes to fix bugs or implement new features is an important software development task, as it contributes to evolve a software system. Not all changes are accepted in the first attempt, though. Inappropriate changes can be rejected because of problems found during code review, automated testing, or manual testing, possibly resulting in rework. Our objective is to better understand the statistical association between different types of rejection---negative code reviews, supplementary commits, reverts, and issue reopening---to characterize their impacts within a project, and to understand how they are affected by certain process changes. To this end, this thesis presents an analysis of three large open source projects developed by the Mozilla Foundation, which underwent significant changes in their process, such as the adoption of rapid releases. Methods: To pursue our objective, we analyzed issues and source code commits from over four years of the projects' history. We computed metrics on the occurrence of multiple types of change rejection and measured the time it takes both to submit a change and to reject inappropriate changes. Furthermore, we validated our findings by discussing them with Mozilla developers. Results: We found that techniques used in previous studies to detect inappropriate changes are imprecise; because of that, we proposed an alternative technique. We determined that inappropriate changes are a relevant, daily problem, that affects about 18% of all issues in a project. We also discovered that, under rapid releases, although the proportion of reverted commits at Mozilla increased, the reverts were performed earlier in the process.