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)