Submitted by Johnny Rodrigues (johnnyrodrigues@ufcg.edu.br) on 2018-08-29T17:29:04Z No. of bitstreams: 1 MARCOS FÁBIO PEREIRA - DISSERTAÇÃO PPGCC 2009..pdf: 1188660 bytes, checksum: 5038133be1ae4622c35b2e3720504775 (MD5) / Made available in DSpace on 2018-08-29T17:29:04Z (GMT). No. of bitstreams: 1 MARCOS FÁBIO PEREIRA - DISSERTAÇÃO PPGCC 2009..pdf: 1188660 bytes, checksum: 5038133be1ae4622c35b2e3720504775 (MD5) Previous issue date: 2009-08-23 / Aplicações corporativas têm como principal finalidade auxiliar nas atividades dos diversos setores de uma corporação. Atualmente existe uma grande necessidade por este tipo de aplicação e este número tende a aumentar com o surgimento de novas corporações, além do crescimento das já existentes. Do ponto de vista da Engenharia de Software, uma característica importante destas aplicações é o conjunto comum de requisitos não funcionais que apresentam. Aplicações corporativas devem prover, em geral: distribuição, facilitar a escalabilidade do software; balanceamento de carga e tolerância a falhas, para garantir robustez e alta disponibilidade; segurança, para garantir a proteção dos dados da corporação; serviços transacionais, para garantir a consistência dos dados e nas operações sobre eles; dentre outras funcionalidades. Além destes requisitos, tais aplicações precisam lidar com mudanças constantes nas regras de negócio das corporações. Dada a complexidade das aplicações, tais alterações, em geral, não podem ser previstas em tempo de projeto e normalmente afetam pontos do software que não foram preparados para mudanças. Além disto, durante esta alteração, muitas vezes a aplicação corporativa precisa ser mantida em execução para evitar perdas para a corporação. Sendo assim,tem-se como requisito primordial a possibilidade de evolução nas aplicações de forma dinâmica e não antecipada. Neste trabalho apresenta-se uma infra-estrutura para o desenvolvimento de aplicações corporativas que oferece o suporte à evolução dinâmica e não antecipada. Esta infra-estrutura é uma extensão de um modelo de componentes que oferece suporte nativo à evolução dinâmica e não antecipada, tornando a tarefa de evolução mais eficaz que em soluções já existentes. A validação do trabalho foi realizada através do desenvolvimento de aplicações corporativas a partir da infra-estrutura proposta.

A compreensão de sistemas é fundamental para a atividade de manutenção. Durante a manutenção e evolução dos sistemas, mudanças contínuas podem degradar o projeto modular do sistema, aumentando sua complexidade. Consequentemente, as empresas gastam muito tempo e recursos financeiros na compreensão e manutenção dos sistemas. Portanto, entender como o sistema evolui é uma etapa importante para o bom planejamento, desenvolvimento e gerenciamento de mudanças. Os desenvolvedores geralmente precisam entender rapidamente mudanças recentes antes de implementar novas mudanças. Mesmo que já existam abordagens para a compreensão, elas ainda são limitadas para detectar componentes diferentes com tarefas similares, para localizar tarefas no código fonte e para medir o impacto de uma determinada mudança nas funcionalidades do sistema. Neste trabalho, é proposto um mecanismo para localizar impactos causados por uma mudança no projeto e quais mudanças estruturais ocorreram em um sistema de uma versão para outra. Dada uma funcionalidade específica, o objetivo é localizar mudanças estruturais e mudanças de relacionamento entre componentes entre duas versões. Cada mudança estrutural detectada na primeira etapa é checada no código fonte para ambas as versões. Depois, as mudanças são classificadas em cinco padrões: i) movimentação de classe; ii) movimentação de método; iii) adição de método; iv) remoção de método; e v) mudança no modificador de acesso (os três últimos que representam mudanças de interface nas classes). A abordagem proposta é avaliada com três sistemas de código aberto com o objetivo de validar a metodologia: jFreeChart, Tomcat e JHotDraw. Os resultados revelam mudanças estruturais como movimentação de método, movimentação de classe e mudança de relacionamento de pacotes. Além disso, também é feito um levantamento de mudanças estruturais que afetam múltiplas funcionalidades, o que é chamado de avaliação de impacto de mudanças; análises sobre mudanças de relacionamento de pacotes no jFreeChart validado em termos de precisão e recall. Os resultados mostram que movimentações em métodos, em média, aparecem em 28,4% dos casos. Existem classes que afetam muitas funcionalidades, logo o desenvolvedor terá noção de quais funcionalidades serão afetadas com tais mudanças. As mudanças no jFreeChart mostram que a abordagem detecta os padrões de alterações em pacotes a uma precisão de 100% e revocação de 83%. Ao detectar uma mudança considerável na relação de pacotes entre o jFreeChart versões 0.7.0 e 0.9.5, foi constatado que os novos pacotes possuem um menor acoplamento, conforme a métrica efferent coupling, podendo indicar uma melhor modularização. Portanto detectar estas mudanças nos pacotes pode ajudar o desenvolvedor a explicar a coesão, acoplamento e a modularidade do sistema em termo de pacotes. Um dos resultados importantes da abordagem, a avaliação de impacto de mudanças, permite ao desenvolvedor avaliar o passado do sistema, e prever o impacto e abrangência de mudanças futuras em classes e funcionalidades. / Software system comprehension is a key maintenance activity. During the software maintenance and evolution, continuous changes may degrade the modular design overtime, thus, increasing its complexity. Consequently, companies spend a lot of time and resources trying to understand and implement changes on software. Therefore, understanding how system changes evolve is an important step towards future development planing and management. Developers usually need to rapidly understand recent changes before implementing a new feature. Despite of several approaches to improve software comprehension, they are still limited to different components with similar roles, to locate features in the source code and to measure the impact of an specific change in other features. In this work, we present an approach centered on dynamic and static analysis to reduce program comprehension effort. More specifically, we propose a mechanism to locate what structural changes have occurred in a program from one version to another. Given one specific functionality, we locate structural changes and component relationship changes between two versions. Each structural change previously detected in the first step, is then verified by a next step of static analysis to confirm if the method in the trace really exists in only one version or both versions. The candidate changes are classified in five patterns by parsing the source code of both analyzed version: i) Move Class, ii) Move Method, iii) Add Method, iv) Remove Method, and v) Access Modifier Change (where they represent Class Interface Change). We evaluated our approach with three open source-software systems: jFreeChart, Tomcat, and JHotDraw. Our results reveals structural changes such as, move method, move class, and package relationship changes. In this study, we further investigate the impact of structural changes over multiple functionalities. We also evaluated the package relationship change found in jFreeChart using precision and recall. The results show that the pattern Move Method dominates, in average, appearing in 28,4% of the changes. Also, there are changes in classes that affect many funcionalities. Also the results show that in jFreeChart there were changes in packages detected with a precision of 100% and a recall of 83%. After the approach detected many changes between versions 0.7.0 and 0.9.5 of jFreeChart, further analysis showed that the new package structure has less coupling measures, according to the Efferent Coupling metric. That can mean the package structure has a better modular structure. Then detecting those changes in the package structure can be valuable to the developer evaluate the cohesion, coupling and package modular structure. One of the results presented by this approach, the impact analysis, allow the developer, by evaluating the past of the system, foresee the impact and coverage of future changes that will be made in the system. / Dissertação (Mestrado)

Submitted by Nayara Passos (nayara.passos@ufpe.br) on 2015-03-13T13:04:40Z No. of bitstreams: 2 TESE Yaguaratã Cerqueira Cavalcanti.pdf: 2989671 bytes, checksum: cdde3d6cea6de1cabb90748865421b78 (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) / Made available in DSpace on 2015-03-13T13:04:40Z (GMT). No. of bitstreams: 2 TESE Yaguaratã Cerqueira Cavalcanti.pdf: 2989671 bytes, checksum: cdde3d6cea6de1cabb90748865421b78 (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) Previous issue date: 2014 / The efficient management of Change Requests (CRs) is fundamental for successful software maintenance; however the assignment of CRs to developers is an expensive aspect in this regard, due to the time and expertise demanded. To overcome this, researchers have proposed automated approaches for CR assignment. Although these proposals present advances to this topic, they do not consider many factors inherent to the assignments, such as: developers’ workload, CRs severity, interpersonal relationships, and developers know-how. Actually, as we demonstrate in this work, CR assignment is a complex activity and automated approaches cannot rely on simplistic solutions. Ideally, it is necessary to consider and reason over contextual information in order to provide an effective automation. In this regarding, this work proposes, implements, and validates a context-aware architecture to automate CR assignment. The architecture emphasizes the need for considering the different information available at the organization to provide a more context-aware solution to automated CR assignment. The development of such architecture is supported by evidence synthesized from two empirical studies: a survey with practitioners and a systematic mapping study. The survey provided us with a set of requirements that automated approaches should satisfy. In the mapping study, in turn, we figured out how state-of-the-art approaches are implemented in regarding to these requirements, concluding that many of them are not satisfied. In addition, new requirements were identified in this mapping study. For the implementation of the proposed architecture, we developed a strategy to automate CR assignments which is based on two main components: a Rule-Based Expert System (RBES) and an Information Retrieval (IR) model. The strategy coordinately applies these two components in different steps to find the potential developer to a CR. The RBES takes care of the simple and complex rules necessary to consider contextual information in the assignments, e.g., to prevent assigning a CR to a busy or unavailable developer. Since these rules vary from one organization/project to another, the RBES facilitates their modification for different contexts. On the other hand, the IR model is useful to make use of the historical information of CR assignments to match CRs and developers. Results from the validation study showed that our solution is promising. It is, by comparing the solution with an approach that uses only a machine learning algorithm, such as the Support Vector Machine (SVM), we could improve the accuracy of assignments by almost 50%. The analysis of the solution’s payoff also pointed that such an accuracy is able to pay for the efforts necessary to deploy the solution.-------------------------------------O gerenciamento eficiente de solicitações de mudança (SM) é fundamental para o sucesso das atividades de manutenção e evolução de software. Entretanto, a atribuição de SMs a desenvolvedores é um aspecto custoso desse gerenciamento, pois demanda tempo e conhecimento apropriado do projeto de software. Várias pesquisas já propuseram métodos de atribuição automática de SMs. Embora representem avanços na área, existem fatores inerentes a atribuição de SMs que não são considerados nessas pesquisas e são essenciais para a automação. Como demonstrado nesse trabalho, a atribuição automática deve, por exemplo, considerar a carga de trabalho, a experiência e o conhecimento dos desenvolvedores, a prioridade e a severidade das SMs, a afinidade dos desenvolvedores com os problemas descritos nas SMs, e até mesmo os relacionamentos interpessoais. Para tornar esse cenário ainda mais complexo, esses fatos podem variar de acordo com o projeto de software que está sendo desenvolvido. Assim, uma solução para o problema de atribuição de SMs depende de informações contextuais. Assim, esse trabalho propõe, implementa e valida uma solução arquitetural sensível ao contexto para atribuição automática de SMs. Dado o aspecto contextual da solução, a arquitetura considera diversas fontes de informações presentes na organização, assim como a necessidade de se desenvolver algorítimos que implementem diferentes estratégias de atribuição. Nossa proposta de solução é embasada em resultados de duas pesquisas quantitativas: um estudo de mapeamento sistemático da literatura, e uma pesquisa de questionário com desenvolvedores de software. Esse último forneceu um conjunto de requisitos que a solução automatizada deve satisfazer para que as estratégias de atribuição sejam atendidas, enquanto o mapeamento da literatura identificou técnicas, algoritmos, e outros requisitos necessários a automação. A implementação da arquitetura segue uma estratégia de automação, definida nesse trabalho, que possui dois componentes principais: um sistema especialista baseado em regras (SEBR); e um modelo de recuperação de informação (MRI) com técnicas de aprendizagem. Em nossa estratégia, esses dois componentes são executados alternadamente em momentos diferentes a fim de atribuir uma SM automaticamente. O SEBR processa regras, considerando informações contextuais do projeto de software e da organização que o desenvolve. O MRI é utilizado para fazer o casamento entre SMs e desenvolvedores de acordo com o histórico de atribuições. Os resultados do estudo de validação apontaram que a solução é promissora. Isto é, ao compararmos nossa solução com uma abordagem que utiliza apenas um algoritmo de aprendizado de máquina, como o Support Vector Machine (SVM), pudemos melhorar em quase 50% a acurácia de atribuição. Já a análise de custo de implantação apontou que a acurácia atingida pela solução possui um bom custo benefício.

Degradação do design é um problema central investigado na área de evolução de software. A densa rede de interdependências que emerge entre classes e módulos ao longo do tempo resulta em código difícil de mudar, não reutilizável e que não comunica por si só sua intenção. Dentre outros motivos, designs degradam porque requisitos mudam de maneiras não antecipadas pelo design inicial, ou seja, as modificações no código introduzem dependências novas e não planejadas entre classes e módulos do sistema. A gerência de dependências visa reduzir a degradação do design por meio de uma série de mecanismos que auxiliam na administração da complexidade estrutural inerente de sistemas orientados a objetos. Neste trabalho, investigamos as técnicas de identificação de dependências estruturais e lógicas. Em particular, por meio de um estudo de larga escala, comparamos os conjuntos desses dois tipos de dependências. Em seguida, conduzimos um estudo de caso a fim de identificar as origens de dependências lógicas. Por fim, fazemos um levantamento das técnicas de visualização de dependências e mostramos a ferramenta XFlow. / Design degradation is a central problem investigated in the area of software evolution. The dense web of interdependencies that emerges among classes and modules over time results in code that is hard to change, not reusable and that does not communicate its intention. Among other reasons, designs degrade because requirements changes in ways that were not anticipated by the initial design, i.e. the changes in code introduce new and unplanned dependencies among classes and modules of the system. Dependency management aims to reduce design degradation by means of a series of mechanisms that helps in the management of the inherent structural complexity of object oriented systems. In this work, we investigate structural and logical dependencies identification techniques. In particular, by means of a large scale study, we compare the sets of these two kinds of dependencies. Afterwards, we conduct a case study in order to uncover the origins of logical dependencies. Finally, we survey dependency visualization techniques and present the XFlow tool.

Several attempts to facilitate understanding the behavior of software systems have been proposed. Perfective changes in well-established software systems are easier to perform when the development team has a solid understanding of the internals. However, it is reasonable to assume that the use of an open source system to incorporate new features and obtain a new software product is an appealing approach instead of coding a new product from scratch. Considering this scenario, and considering that it is not uncommon that systems are poorly documented, there is no widely accepted approach to guide the perfective maintenance for developers with low understanding of the system or that recovers high-level information about both the structure and the behavior of large systems. This work proposes a new approach to simplify comprehension tasks of object oriented programs through the analysis of summarized execution traces. The approach is perfomed on two techniques: The rst technique enables the separation of common parts of source code from specic parts related to important features that drive the addition of the new one. An evaluation is done to verify if the summarized execution traces helps the technique to locate potential elements of code that can guide the development of a new feature. The evaluation was conducted with real-world systems and with meaningful evolution tasks. The second is based on a technique that reconstructs structural and behavioral highlevel diagrams by the analysis of summarized execution traces. Precision and recall were evaluated using two third-party open-source systems, including the webserver Tomcat. The result suggests the feasibility for using the approach on real world large scale systems. / Várias abordagens para facilitar a compreensão do comportamento de sistemas de software têm sido propostas. Mudanças perfectivas em sistemas de software bem estabelecidos são mais fáceis de executar quando a equipe de desenvolvimento tem um entendimento sólido do código fonte. Mas é razoável assumir que o uso de um sistema de código aberto para incorporar novas características e obter um novo produto de software é uma abordagem interessante, ao invés de codificar um novo produto a partir do zero. Em consideração a este cenário e considerando que não é incomum sistemas pobres em documentação, não existe uma abordagem amplamente aceita para guiar em mudanças perfectivas desenvolvedores com baixo conhecimento do sistema ou que recupera informações em alto nível de abstração sobre a estrutura e comportamento de sistemas complexos. Este trabalho propõe uma nova abordagem para simplificar tarefas de compreensão de programas orientados a objetos através da análise de rastros de execução sumarizados. A abordagem é aplicada sobre duas técnicas: a primeira permite a separação de partes comuns do código fonte das partes específicas relacionadas a características importantes que conduz a adição de uma nova. Uma avaliação é feita para verificar se os rastros de execução sumarizados ajudam a técnica na localização de elementos potenciais de código que podem guiar o desenvolvimento de uma nova característica. A avaliação foi realizada com sistemas do mundo real e com tarefas de evolução significativas. A segunda é baseada na reconstrução de diagramas estruturais e comportamentais de alto nível baseada na análise de rastros de execução sumarizados. É apresentada uma avaliação do desempenho da abordagem em termos de precisão e recall em dois sistemas públicos de terceiros, dentre eles o servidor Web Tomcat. O resultado sugere a viabilidade da abordagem para uso em sistemas reais de larga escala. / Mestre em Ciência da Computação

Degradação do design é um problema central investigado na área de evolução de software. A densa rede de interdependências que emerge entre classes e módulos ao longo do tempo resulta em código difícil de mudar, não reutilizável e que não comunica por si só sua intenção. Dentre outros motivos, designs degradam porque requisitos mudam de maneiras não antecipadas pelo design inicial, ou seja, as modificações no código introduzem dependências novas e não planejadas entre classes e módulos do sistema. A gerência de dependências visa reduzir a degradação do design por meio de uma série de mecanismos que auxiliam na administração da complexidade estrutural inerente de sistemas orientados a objetos. Neste trabalho, investigamos as técnicas de identificação de dependências estruturais e lógicas. Em particular, por meio de um estudo de larga escala, comparamos os conjuntos desses dois tipos de dependências. Em seguida, conduzimos um estudo de caso a fim de identificar as origens de dependências lógicas. Por fim, fazemos um levantamento das técnicas de visualização de dependências e mostramos a ferramenta XFlow. / Design degradation is a central problem investigated in the area of software evolution. The dense web of interdependencies that emerges among classes and modules over time results in code that is hard to change, not reusable and that does not communicate its intention. Among other reasons, designs degrade because requirements changes in ways that were not anticipated by the initial design, i.e. the changes in code introduce new and unplanned dependencies among classes and modules of the system. Dependency management aims to reduce design degradation by means of a series of mechanisms that helps in the management of the inherent structural complexity of object oriented systems. In this work, we investigate structural and logical dependencies identification techniques. In particular, by means of a large scale study, we compare the sets of these two kinds of dependencies. Afterwards, we conduct a case study in order to uncover the origins of logical dependencies. Finally, we survey dependency visualization techniques and present the XFlow tool.

Submitted by Johnny Rodrigues (johnnyrodrigues@ufcg.edu.br) on 2018-08-03T17:58:25Z No. of bitstreams: 1 ROBERTO ALMEIDA BITTENCOURT - TESE PPGCC 2012..pdf: 33887570 bytes, checksum: 348d0986ffb03c3554fefac4ab926a5a (MD5) / Made available in DSpace on 2018-08-03T17:58:25Z (GMT). No. of bitstreams: 1 ROBERTO ALMEIDA BITTENCOURT - TESE PPGCC 2012..pdf: 33887570 bytes, checksum: 348d0986ffb03c3554fefac4ab926a5a (MD5) Previous issue date: 2012-02-29 / A técnica dos modelos de reflexão é um processo de checagem de conformidade entre visões arquiteturais modulares e implementação que permite prevenir e remediar o envelhecimento de software através do combate à deterioração arquitetural. Contudo, o esforço manual necessário para aplicar a técnica pode terminar evitando seu uso na prática, especialmente no contexto de evolução de software em processos de desenvolvimento leves. Em termos mais específicos, a técnica é custosa para: i) produzir um modelo de alto nível e o mapeamento entre as entidades do código-fonte e este modelo; ii) manter tanto o modelo como o mapeamento atualizados à medida que o software evolui; e Ui) analisar a normalmente longa lista de violações arquiteturais no código fonte. Este trabalho procura habilitar a checagem de conformidade estática de software em evolução através da automação parcial do esforço manual para aplicar a técnica de modelos de reflexão. Para fazê-lo, primeiramente é avaliado o potencial de técnicas de agrupamento para a geração e manutenção de modelos de alto nívei. Também é proposta e avaliada uma técnica de mapeamento incremental entre entidades do código-fonte e modelos de alto nível baseada na combinação da recuperação de informação de vocabulário de software com dependências estruturais. Por fim, uma técnica de priorização baseada na história do software para recomendar as violações arquiteturais no código-fonte mais provavelmente relevantes do ponto de vista dos desenvolvedores de software é relatada e avaliada. Técnicas de agrupamento são avaliadas através de medidas de acurácia e estabilidade. Os resultados para quatro diferentes algoritmos de agrupamento mostram que nenhum deles consegue o melhor desempenho para todas as medidas, e que todos eles apresentam limitações para prover a geração automática de modelos de alto nível. Por outro lado, a avaliação sugere que a etapa de mapeamento da técnica de modelos de reflexão pode ser habilitada pela técnica proposta de mapeamento incremental automático que combina estrutura e vocabulário. Em dois estudos de caso, esta técnica obteve os maiores valores de medidaF em mudanças de código-fonte unitárias, pequenas ou grandes. Finalmente, a avaliação da técnica de priorização de violações mostra que, de cinco fatores estudados, a duração da violação e a co-locação da violação correlacionam bem com a relevância das violações. Os resultados sugerem que estes fatores podem ser usados para ordenar as violações mais provavelmente relevantes, com uma melhoria de pelo menos 57% em relação a uma linhabase de violações selecionadas aleatoriamente. A análise dos resultados sugere que a produção de modelos de alto nível para checagem estática de conformidade arquitetural pode ser auxi'iada por um processo semi-automático de recuperação arquitetural, e, à medida que o software evolui, por técnicas incrementais de agrupamento/mapeamento. Por outro lado, a análise dos resultados para a técnica de priorização sugere a eficácia de uma abordagem automatizada para a recomendação de violações arquiteturais a serem analisadas pelos desenvolvedore: do software. / The refíexion model technique is a static conformance checking technique to keep architecture module views and implementation conformant. It can either prevent or remedy software aging by combating architecture deterioration. However, the amount of manual effort to apply the technique may prevent its use in practice, especially in the context of software evolution in lightweight development methods. More specifically, it can be time-consuming and costly to: i) produce a high-level model and the mapping between source code entities and this model; ii) keep both model and mapping up-to-date as software evolves; and Ui) analyze the usual large number of architectural violations in the source code reported by the technique. This work tries to enable static conformance checking of evolving software by partially automating the manual effort to apply the refíexion model technique. To do so, the potential of clustering techniques to generate high-level models and keep them up-to-date is evaluated. It is also proposed and evaluated an incremental mapping approach between source code entities and high-level models based on the combination of information retrieval of software vocabulary and structural dependencies. Last, a prioritizing technique based on software history to recommend architectural violations in the source code most likely to be relevant to software developers is reported and evaluated. Clustering techniques are evaluated by measures of accuracy and stability, and results for four different clustering algorithms show that none of them performs best for ali measures, and that they are limited to provide fully automated generation of high-level models. On the other hand, evaluation suggests that the mapping step in the refíexion model technique can be enabled by the proposed incremental automated mapping technique that combines structure and vocabulary. In two case studies, the combined technique showed the highest F-measure values for both singleton, small and large source code changes. Finally, evaluation for the prioritizing technique shows that, from five studied factors, violation duration and violation co-location correlate well with violation relevance. Results suggest that these factors can be used to rank the violations most likely to be relevant, with an improvement of at least 57% against a baseline of randomly selected violations. Analysis of the results suggests that the producton of high-level models for static conformance checking can be aided by a semi-automated architecture recovery process, and, as software evolves, by incremental clustering/mapping techniques. On the other hand, analysis of the results for the prioritizing technique suggests the effectiveness of an automated approach to recommend architectural violations to bí analyzed by software developers.