Monografia

JOO LUCAS PEREIRA DE SANTANA
IMPLEMENTAO DE TCNICAS SEMNTICAS

DE MINERAO PARA IDENTIFICAR INDCIOS
DE INTERESSES TRANSVERSAIS EM SOFTWARES
ORIENTADOS A OBJETOS

Monografia de graduao apresentada ao Departamento
de Cincia da Computao da Universidade Federal de
Lavras como parte das exigncias do curso de Cincia
da Computao para obteno do ttulo de Bacharel em
Cincia da Computao.

LAVRAS
MINAS GERAIS - BRASIL
2011



Cincia da Computao.

rea de Concentrao:
Engenharia de Software

Orientador:
Prof. Dr. Heitor Augustus Xavier Costa

LAVRAS
2011

Ficha Catalogrfica preparada pela Diviso de Processo Tcnico da Biblioteca
Central da UFLA
Santana, Joo Lucas Pereira de

Implementao de Tcnicas Semnticas de Minerao para Identificar Indcios de
Interesses Transversais em Softwares Orientados a Objetos / Joo Lucas Pereira de
Santana. Lavras - Minas Gerais, 2011. 82 p.

Monografia de Graduao - Universidade Federal de Lavras. Departamento de
Cincia da Computao.

1. Engenharia de Software. 2. Orientao a Aspectos. 3. Minerao de Aspectos. I.
SANTANA, J. L. P. de. II. Universidade Federal de Lavras. III. Implementao de
Tcnicas Semnticas de Minerao para Identificar Indcios de Interesses Transversais em
Softwares Orientados a Objetos.



Cincia da Computao.

Aprovada em ___/___/______

Prof. Dr. Antnio Maria Pereira de Resende

Prof. Dr. Ahmed Ali Abdalla Esmin

Prof. Dr. Heitor Augustus Xavier Costa
(Orientador)

LAVRAS

SUMRIO

LISTA DE FIGURAS
LISTA DE TABELAS
1. INTRODUO ........................................................................................ 1
1.1. Motivao ............................................................................................................. 3
1.2. Objetivo ................................................................................................................ 3
1.3. Metodologia .......................................................................................................... 4
1.3.1. Tipo de Pesquisa .......................................................................................... 4
1.3.2. Procedimentos Metodolgicos .................................................................... 4
1.4. Estrutura do Trabalho ........................................................................................ 5
2. ORIENTAO A ASPECTOS .............................................................. 7
2.1. Consideraes Iniciais ......................................................................................... 7
2.2. Surgimento da Programao Orientada a Aspectos ........................................ 7
2.3. Elementos da Programao Orientada a Aspectos ........................................ 10
2.4. Consideraes Finais ......................................................................................... 13
3. TCNICAS SEMNTICAS DE MINERAO DE ASPECTOS ... 14
3.1. Consideraes Iniciais ....................................................................................... 14
3.2. Anlise Fan-In.................................................................................................... 15
3.2.1. Conceitos .................................................................................................... 15
3.2.2. Explicao do Funcionamento .................................................................. 16
3.3. Anlise dos Rastros de Execuo ..................................................................... 18
3.3.1. Conceitos .................................................................................................... 18
3.4. Anlise Baseada no Grafo de Fluxo de Controle ............................................ 21
3.4.1. Conceitos .................................................................................................... 21
3.5. Anlise para Deteco de Clones ...................................................................... 23
3.5.1. Utilizando rvore Sinttica Abstrata ...................................................... 24
3.5.1.1. Conceitos ................................................................................................ 24
3.5.1.2. Explicao do Funcionamento .............................................................. 25
3.5.2. Utilizando Grafos de Dependncia ........................................................... 26
3.5.2.1. Conceitos ................................................................................................ 26
3.5.2.2. Explicao do Funcionamento .............................................................. 27
3.6. Anlise Utilizando Clusters e Regras de Associao ....................................... 28
3.6.1. Conceitos .................................................................................................... 28
3.7. Comparao Entre os Mtodos ........................................................................ 33
4. FERRAMENTAS DE APOIO AO DESENVOLVIMENTO ............ 35

4.2. Plataforma IDE Eclipse..................................................................................... 35
4.3. Plugin Java Development Tools ......................................................................... 37
4.4. Outras Ferramentas .......................................................................................... 38
5. TRABALHOS RELACIONADOS ....................................................... 42
6. APOIOS COMPUTACIONAIS PARA IDENTIFICAR INDCIOS
DE INTERESSES TRANSVERSAIS EM CODIGO FONTE JAVA
.................................................................................................................. 46
6.2. Viso Geral dos Apoios Computacionais......................................................... 47
6.3. Caractersticas de Implementao Semelhantes aos Plug-ins ....................... 48
6.4. Plug-in Fan-In .................................................................................................... 48
6.5. Plug-in Flow Graph ............................................................................................ 50
6.6. Plug-in AST Clone .............................................................................................. 52
7. ESTUDO DE CASO ............................................................................... 56
7.2. Objetivos e Mtricas .......................................................................................... 56
7.3. Conduo do Experimento ............................................................................... 57
7.4. Resultados Obtidos ............................................................................................ 57
8. CONSIDERAES FINAIS ................................................................ 66
8.1. Concluses .......................................................................................................... 66
8.2. Contribuies ..................................................................................................... 67
8.3. Trabalhos Futuros ............................................................................................. 67
Referncias Bibliogrficas ............................................................................ 69

LISTA DE FIGURAS

Figura 2-1 - Interesses Transversais em um Software [Henry; Kafura, 1981] ............ 11
Figura 2-2 - Ponto de Juno ............................................................................................ 12
Figura 2-3 - Processo de Combinao de Aspectos com Ncleo do Software .............. 13
Figura 3-1 - Diagrama de Classes [Valle-Rai et al., 1999] ............................................ 17
Figura 3-2 - Rastro de Execuo [Marin et al., 2004] ..................................................... 19
Figura 3-3 - Relaes de Execuo Externa-Anterior [Marin et al., 2004] .................. 20
Figura 3-4 - Relaes de Execuo Interna-Inicial e Interna-Final [Breu; Krinke,
2004] .................................................................................................................................... 20
Figura 4-1 - Arquitetura da Plataforma Eclipse............................................................. 37
Figura 4-2 - Conexes entre o Plataforma e o JDT [Chapman, 2006] .......................... 38
Figura 4-3 - Visualizao de Mtodos com a Ferramenta Zest ..................................... 40
Figura 4-4 - Visualizador de Aspectos [Chapman, 2006] .............................................. 41
Figura 5-1 - Viso Geral do Aspect Browser [Griswold et al., 2005] ............................ 42
Figura 5-2 - Viso Geral da Ferramenta FEAT [Novais, 2009] .................................... 44
Figura 5-3 - Viso Geral do FINT [Marin, 2008] ........................................................... 45
Figura 6-1 - Marcador do Plug-in Fan-In ....................................................................... 49
Figura 6-2 - Methods View no Eclipse .............................................................................. 49
Figura 6-3 - Graph View no Eclipse .................................................................................. 50
Figura 6-4 - Marcadores do Plug-in Flow Graph ........................................................... 51
Figura 6-5 - Methods Count View no Eclipse ................................................................... 51
Figura 6-6 - Marcadores do Plug-in Flow Graph ........................................................... 52
Figura 6-7 - Marcadores do Plug-in AST Clone ............................................................. 53
Figura 6-8 - Clones View no Eclipse ................................................................................. 54
Figura 6-9 - View Visualiser do AJDT utilizado pelo Plug-in AST Clone ..................... 54

Figura 7-1 - Nmero de Mtodos x Tempo de Execuo ............................................... 63
Figura 7-2 - Nmero de LOC x Tempo de Execuo ..................................................... 64

LISTA DE TABELAS

Tabela 3-1 - Valores Fan-In para Cada Mtodo [Valle-Rai et al., 1999] .................... 17
Tabela 3-2 - Conjunto de Objetos [He; Bai, 2006].......................................................... 31
Tabela 3-3 - Conjunto de Transaes [IBM, 2006]......................................................... 32
Tabela 3-4 - Tcnicas de Deteco de Interesses Transversais ...................................... 33
Tabela 7-1 - Sumarizao dos Resultados da Anlise no Software MVCExample ..... 59
Tabela 7-2 - Sumarizao dos Resultados da Anlise no Software Praec .................... 60
Tabela 7-3 - Sumarizao dos Resultados da Anlise no Software HealthWatcher ... 61
Tabela 7-4 - Sumarizao dos Resultados da Anlise no Software JCCD ................... 61
Tabela 7-5 - Tempo de Execuo dos Plug-ins ................................................................ 62

Implementao de Tcnicas Semnticas de Minerao para
Identificar Indcios de Interesses Transversais em Softwares
Orientados a Objetos
RESUMO
A atividade de manuteno realizada visando a alterao da estrutura do software
garantindo sua integridade. Esta tarefa torna-se menos rdua quando se tem ampla
compreenso do comportamento dos diversos componentes de software. Visando a
obteno desta compreenso, pesquisas surgiram propondo abordagens para identificar e
separar cdigos de uma funcionalidade especfica que se encontram entrelaados e/ou
espalhados por vrios mdulos da aplicao, denominados interesses transversais.
Considerando esses fatos, so apresentados neste trabalho, o funcionamento de algumas
tcnicas de deteco de indcios de interesses transversais e uma comparao analisando
critrios de granularidade dos resultados, envolvimento do usurio, sintomas da existncia
de interesses transversais e tipos de informaes necessrias para computao das tcnicas.
Alm disso, abordado neste trabalho o desenvolvimento e comparao de trs apoios
computacionais em forma de plug-ins para o Eclipse visando a deteco indcios de
interesses transversais em software orientado a objetos escritos na linguagem de
programao Java. A execuo e a avaliao desses plug-ins foram realizadas em trs
softwares reais e os resultados so apresentados considerando critrios como cobertura e a
relao entre tempo de execuo e tamanho do software.

Palavras-chave: Manuteno de software, interesses transversais, tcnicas semnticas de
minerao, Orientao a Aspectos

Implementing of Mining Semantic Tecniques to Identify
Crosscutting Concern Indications in Object-Oriented Software

ABSTRACT
Maintenance activity is performed aiming modify the software structure ensuring their
integrity. And this task becomes easier when we have a full understanding of several
system components behavior. Aiming to gain this understanding, researchs emerged
suggesting approaches to identify and separate codes of a specific functionality which are
entangled or scattered through various application modules, called crosscutting concerns.
Considering these facts are presented in this paper the behavior of certain techniques for
crosscutting concerns indications detection and a comparision criteria considering results
granularity, user involvement, symptoms of existence of crosscutting concerns and
informations types required to technique computation. In addition, is discussed in this
paper the development and comparison of three computational tools as plug-ins for Eclipse
environment aiming to detect crosscutting concerns indications in Object-Oriented
Software in Java. The execution and assessment of theses plug-ins were performed in three
real software systems and the results are presented considering criteria as covering and
relation between execution time and the software size.

Keywords: Software maintence, crosscutting concerns, semantic mining techniques,
aspect orientation

1
1. INTRODUO
Produtos de software so delineados e construdos por engenheiros de software e
englobam desde programas executados em computadores de diversas escalas e arquiteturas
a documentos em formato impresso ou digital associados a eles. Eles correspondem
entidade de software disponvel para liberao a um usurio e passam por vrias fases
durante seu ciclo de vida (Definio, Desenvolvimento e Manuteno) [Sommerville,
2010].
Durante a fase Definio, devem-se identificar as informaes a serem manipuladas,
as funes a serem processadas, o nvel de desempenho desejado, as interfaces a serem
oferecidas, as restries do projeto e os critrios de validao. Na fase Desenvolvimento,
so abordadas questes de arquitetura do software, de estruturas de dados, sobre a forma
como o projeto ser codificado utilizando alguma linguagem de programao, dentre
outros assuntos. A fase Manuteno caracterizada pela realizao de alteraes das mais
diversas naturezas, seja para corrigir erros residuais da fase anterior (manuteno
corretiva), seja para incluir novas funes exigidas pelo cliente (manuteno evolutiva),
seja para adaptar o software a novas configuraes de hardware (manuteno adaptativa)
[Pfleeger; Atlee, 2010; Sommerville, 2010; Pressman, 2009].
Durante a fase Manuteno, deve-se concentrar esforos para realizar alteraes no
software preservando sua integridade. No entanto, fatores de mbito administrativo e/ou de
implementao podem dificultar a execuo desta tarefa, por exemplo, o software deve
permanecer disponvel enquanto as modificaes so efetuadas, o tempo disponibilizado
para os responsveis compreenderem o funcionamento do software pode ser curto e a
documentao relacionada ao software pode ser deficitria ou mesmo inexistente.
Alm dos problemas, percebe-se nos softwares atuais a presena de interesses
transversais que correspondem a codificaes relacionadas a uma determinada
responsabilidade podem estar distribudas em muitas partes do cdigo fonte. Mesmo que
um software seja bem projetado e decomposto em unidades modulares, algumas de suas
funes atravessam mdulos rompendo os princpios do encapsulamento [Ceccato et al.,
2005; Tarr et al., 1999].

2
A dificuldade de garantir o encapsulamento uma caracterstica inerente da
tecnologia de orientao a objetos (OO) [Bhatti; Ducasse, 2008]. Uma forma de combater
essa dificuldade, a qual no pode ser solucionada de maneira satisfatria utilizando
tcnicas tradicionais de programao [Cojocar; Serban, 2007], utilizar a tecnologia de
orientao a aspectos (OA) [Kiczales et al., 1997]. As linguagens de programao
orientadas a aspectos fornecem poderoso recurso o qual possibilita o encapsulamento de
interesses adicionando um mecanismo extra de abstrao, chamado Aspecto [Bruntink et
al., 2005].
O sucesso da tecnologia de OA fez surgir questes relacionadas possibilidade de
transformar softwares orientados a objetos em orientados a aspectos [Tourwe; Mens,
2004]. Este processo de transformao de software chamado Refatorao Orientada a
Aspectos, cujo intuito modularizar os interesses transverais identificando-os e
representando-os utilizando aspectos [Laddad, 2006] apud [Anbalagan; Xie, 2007]. Essa
refatorao tem duas etapas:
Aspect Mining. Identificar interesses transversais [Yuen; Robillard, 2007] e/ou
candidatos a aspectos [Tourwe; Mens, 2004] no cdigo fonte;
Aspect Refactoring. Definir aspectos apropriados e reestruturar o cdigo base
utilizando a tecnologia de orientao a aspectos [Tourwe; Mens, 2004] preservando o
comportamento externo do software [Anbalagan; Xie, 2007].
possvel perceber que, enquanto Aspect Mining a atividade de descoberta de
interesses transversais que potencialmente podem ser transformados em aspectos, Aspect
Refactoring a atividade de transformar esses potenciais aspectos em aspectos reais no
software [Kellens et al., 2007]. Alm disso, Aspect Refactoring se concentra nos desafios e
no problema de determinar os pontos de execuo do software a serem interceptados e
redirecionados para o cdigo do aspecto, visando sempre manter o comportamento original
do software enquanto as funes transversais so modularizadas [Binkley et al., 2005].
Existem trs distines possveis que podem ser consideradas na Aspect Mining
[Kellens et al., 2007]: i) identificao de interesses durante as fases iniciais do ciclo de
desenvolvimento de software, conhecido como Early Aspect [Baniassad et al., 2006]; ii)
utilizao de ferramentas para navegar pelo cdigo fonte a procura de trechos com
presena de interesses transversais, denominada Aspect Browser [Yoshikiyo et al., 1999]; e

3
iii) utilizao de processos automatizados para deteco de sintomas de interesses
transversais no cdigo fonte. Os processos automatizados da terceira distino utilizam
tcnicas de minerao e anlise de dados, como princpios de clusterizao, bem como
outros procedimentos clssicos de anlise de cdigo para verificar a existncia de indcios
de interesses transversais, os quais, possivelmente, tornar-se-o aspectos [Kellens et al.,
2007].
1.1. Motivao
Diversos tipos de interesses transversais podem ser encontrados nos softwares
existentes. Alguns mencionados com maior frequncia na literatura so os interesses
transversais de persistncia, de gerenciamento de logs, de autenticao, de distribuio, de
seguraa, de mobilidade e de tratamento de erros. Embora Aspect Mining seja uma rea de
pesquisa relativamente nova, diversas estratgias para identificao de interesses
transversais foram propostas [Tourwe; Mens, 2004; Breu; Krinke, 2004; Zhang; Jacobsen,
2007].
Por causa do tamanho dos softwares, da complexidade de implementao e da
ausncia/desatualizao de documentao, necessrio o apoio de ferramentas e de
tcnicas computacionais para ajudar os engenheiros de software a localizar/documentar os
interesses transversais bem como ferramentas e metodologias para transformar em aspectos
os interesses transversais descobertos [Kellens et al., 2007].
Um fator motivador desta pesquisa a possibilidade de utilizao da Refatorao
Orientada a Aspectos para identificar claramente os interesses transversais no software
visando a obteno de melhor entendimento do cdigo fonte e a facilidade para sua
manuteno e sua evoluo. A identificao de interesses transversais pode ser benfica,
pois destaca sutis oportunidades de refatorao no cdigo fonte viabilizando o uso da
Programao Orientada a Aspectos (POA) [Marin et al., 2004] [Shepherd et al. 2005].
1.2. Objetivo
A maioria dos mtodos para deteco de interesses transversais est em um estgio
prematuro e tcnicas automatizadas ainda no esto bem fundamentadas [Qu; Liu, 2007].
Alm disso, a aplicao manual de tcnicas de minerao de interesses transversais em
softwares legados um processo difcil e propenso a erros [Kellens et al., 2007].

4
O objetivo desse trabalho implementar trs tcnicas semnticas de minerao para
identificar indcios de interesses transversais em software orientado a objeto escritos na
linguagem de programao Java. Essa implementao so plug-ins para o ambiente de
desenvolvimento Eclipse
1
.
1.3. Metodologia
1.3.1. Tipo de Pesquisa
Analisando as diretrizes do mtodo cientfico, esta pesquisa pode ser caracterizada
em [Jung, 2004; Lakatos, Marconi 2001]:
Natureza tecnolgico-aplicada: pois utiliza conhecimentos existentes para criao de
novos produtos;
Objetivos de carter descritivo: uma vez que tem a finalidade de observar, registrar
fenmenos tcnicos;
Procedimentos experimentais em um trabalho de campo: pois so desenvolvidos
prottipos de software para serem utilizados em estudos de caso visnado investigar
fenmenos dentro de um contexto.
Tempo de aplicao transversal: visto que os estudos de caso so realizados em um
instante do tempo.
1.3.2. Procedimentos Metodolgicos
Os estudos foram iniciados realizando um levantamento bibliogrfico com uma
pesquisa ampla na Internet, em livros, acervos digitais de artigos cientficos e publicaes
relacionadas ao tema, por exemplo nas bibliotecas digitais da ACM e da IEEE.
Posteriormente, foi estudado a tecnologia de OA, com foco na linguagem de programao
AspectJ, de forma a verificar suas caractersticas, suas tcnicas e suas contribuies para a
rea de computao.
A etapa seguinte consistiu da anlise e da avaliao da aplicabilidade das principais
tcnicas de deteco de indcios de interesses transversais com propsito de refatorar
softwares legados orientados a objetos. Posteriormente, o ambiente de desenvolvimento
Eclipse e suas bibliotecas foram estudados e diversas abordagens para criao de plug-ins
foram analisadas visando ao melhor conhecimento do ambiente de desenvolvimento e suas

1
http://www.eclipse.org/

5
caracterticas. Em seguida, trs tcnicas foram escolhidas para serem implementadas no
Eclipse na forma de plug-ins. Aps implementados, os plug-ins foram comparados com o
objetivo de conhecer a relao entre tempo de anlise e tamanho do software. Alm disso,
as implementaes foram comparadas com relao cobertura dos resultados encontrados.
Durante o andamento do trabalho, ocorreram reunies peridicas entre o autor e seu
orientador visando a manuteno da consistncia, do foco e do bom andamento do
trabalho.
1.4. Estrutura do Trabalho
Este trabalho est organizado da seguinte forma.
Breve histrico do surgimento da tecnologia de OA e seus conceitos bsicos,
considerando caractersticas da linguagem de programao AspectJ so apresentados no
Captulo 2.
Tcnicas encontradas na literatura para identificar indcios de interesses transversais
em softwares orientados a objetos so descritas no Captulo 3. Alm disso, os pr-
requisitos so evidenciados e critrios de classificao so adotados visando a compao
das abordagens de identificao de interesses transversais.
Ferramentas que auxiliaram no desenvolvimento dos apoios computacionais
propostos neste trabalho, enfatizando o ambiente Eclipse, sua estrutura e componentes, so
abordadas no Captulo 4. Nesse captulo, so tratadas algumas caractersticas de construo
de plug-ins para o ambiente Eclipse.
Alguns trabalhos relacionados para identificao de interesses transversais em
softwares orientados a objetos so apresentados resumidamente no Captulo 5.
Estratgias e decises tomadas durante o desenvolvimento deste trabalho so
descritas no Captulo 6. Alm disso, apresentado o desenvolvimento de trs plug-ins para
o Eclipse para identificao de interesses transversais em software orientado a objetos
escritos na linguagem de programao Java.

6
Os plug-ins desenvolvidos correspondentes a trs tcnicas semnticas de minerao
de interesses transversais em software orientado a objetos, foram utilizados em trs
softwares reais e os resultados obtidos so analisados no Captulo 7.
Concluses e contribuies dos plug-ins desenvolvidos e sugestes de trabalhos
futuros so apresentados no Captulo 8.

7
2. ORIENTAO A ASPECTOS
2.1. Consideraes Iniciais
Principais conceitos da tecnologia de OA, cujo objetivo tentar solucionar
problemas no abordados pela tecnologia de OO, so apresentados nesse captulo. A
terminologia utilizada neste trabalho, quando referente POA, segue a traduo utilizada
pela Comunidade Brasileira de Desenvolvimento de Software Orientado a Aspectos
(AOSDbr) para a Lngua Portuguesa [AOSDbr, 2007].
Breve histrico do surgimento de POA e suas vantagens com relao OO so
apresentados na Seo 2.2. Conceitos bsicos de OA, considerando os elementos da
linguagem de programao AspectJ so descritos na Seo 2.3.
2.2. Surgimento da Programao Orientada a Aspectos
Softwares eram desenvolvidos utilizando programao desestruturada. Comandos de
desvio de fluxo (por exemplo, GOTO) eram utilizados indiscriminadamente, tornando rduo
o entendimento, a reutilizao e a manuteno do cdigo fonte. A programao estruturada
surgiu como um grande avano, pois funes/procedimentos eram agrupados e chamados a
partir de um programa principal. Usurios da programao estruturada podiam reutilizar
funes e procedimentos, desde que devidamente projetados [Resende; Silva, 2005]. Nesta
poca, a reusabilidade foi explorada utilizando o conceito de bibliotecas.
O advento da tecnologia de OO, em meados da dcada de 70, marcou o incio de
uma nova etapa na histria do desenvolvimento de software, na qual o reso foi
amplamente difundido e incentivado e as entidades do mundo real foram representadas por
meio de objetos, classes, atributos e mtodos. Nesta tecnologia, cada classe torna-se
responsvel pela implementao de um interesse visando a garantia do encapsulamento das
funes do software.
No entanto, garantir o encapsulamento uma tarefa onerosa quando se dispem
apenas dos elementos de OO [Tarr et al., 1999], pois a existncia de entrelaamento do
cdigo das funes dificulta a decomposio em unidades modulares resultando no
espalhamento da codificao da funcionalidade do software [Ceccato et al., 2005].

8
A separao de interesses [Kiczales et al., 1997] um princpio da engenharia de
software introduzido por Edsger Wybe Dijkstra [Dijkstra, 1976] e refere-se habilidade de
identificar, encapsular e manipular partes do software relevantes para um objetivo ou
propsito particular [Cojocar; Serban, 2007]. Uma forma de garantir a separao dos
interesses espalhados pelo cdigo fonte da aplicao usufruir das caractersticas de OA
[Tourwe; Mens, 2004]. Pois, esta uma tecnologia que possibilita o encapsulamento de
interesses transversais, adicionando mecanismo extra de abstrao, chamado Aspecto
[Bruntink et al., 2005].
O expresso Programao Orientada a Aspectos surgiu em meados da dcada de
90 no Palo Alto Reserach Center (PARC). Naquele tempo, pesquisadores refletiam sobre
separao de interesses e no estavam satisfeitos com as abordagens disponveis para
integrar interesses adicionais s principais funes dos softwares. Essa insatisfao foi
causada por solues existentes serem apenas extenses de linguagens de programao
conhecidas providas de alguma estrutura dedicada a tratar do interesse. Por exemplo, a
proposta de uma extenso da linguagem de programao C++ projetada para lidar com
sistemas distribudos denominada Distributed Real-time Object Languagem (DROL)
[Takashio; Tokoro, 1992 apud Filman et al., 2004].
Naquela ocasio, os esforos eram para encontrar uma soluo para garantir a
separao de interesse nos nveis conceitual e de implementao [Filman et al., 2004]. No
nvel conceitual, a separao de interesses precisa atentar para a questo de (1) fornecer
uma abstrao suficiente para cada interesse como um conceito individual e de (2)
assegurar que os conceitos individuais sejam primitivos, no sentido de que eles abranjam
um interesse natural na concepo do programador. No nvel de implementao, a
separao de interesse precisa fornecer uma adequada organizao que isole os interesses
uns dos outros. O objetivo deste nvel separar os blocos de cdigo, cada um responsvel
por um interesse e com baixo acoplamento entre eles.
Neste modelo de separao, os interesses identificados no nvel conceitual eram
mapeados ao nvel de implementao utilizando uma linguagem de programao. Algumas
tcnicas de programao prometiam tal mapeamento provendo mecanismos para
interceptar envios e recebimentos de mensagens. Algumas delas so [Filman et al., 2004]:

9
Meta-Level Programming. As construes bsicas das linguagens de programao, tais
como classe e mtodos, so descritas em um meta-nvel e podem ser estendidas ou
redefinidas por uma meta-programao. Cada objeto associado a um meta-objeto,
responsvel pela semntica da operao no objeto base, utilizando um meta-link. O
suporte a separao de interesses garantido pela interceptao, por parte dos meta-
objetos e de mensagens enviadas e recebidas pelos objetos. Os meta-objetos tm a
oportunidade de executar aes em nome de um interesse de propsito especial;
Adaptative Programming. um modelo de programao baseado em padres de
cdigo classificados em diferentes categorias visando a captura de abstraes durante a
codificao, tais como, padres de propagao, de transporte e de sincronizao. Cada
categoria atribuda a um interesse particular e pode ser vista como um componente de
software que interage com outros componentes;
Composition Filters. Estende a tecnologia de OO com a adio de filtros de
composio de objetos, cujo propsito gerenciar as mensagens enviadas e recebidas
pelos objetos, acrescentar condies para aceitao e rejeio e determinar uma ao
apropriada. A separao de interesses alcanada definindo um filtro para cada
interesse.
Como os recursos existentes no resolviam o problema de separao de interesses em
sua totalidade, pesquisadores do PARC desenvolveram diversos projetos, tratando
interesses especficos, em direo a uma soluo de propsito geral. O projeto inicial foi
denominado RG [Mendhekar et al., 1997], designado para aperfeioar o uso de memria
na composio de funes contendo laos de repetio em clculos de matrizes. Outro
projeto estudado no centro de pesquisas utilizava o MatlLab para otimizar o utilizao de
memria. Annotated MatLab [Irwin et al., 1997] possua diretivas no cdigo fonte
informando ao processador de cdigo os pontos nos quais poderiam ser gerado cdigo
otimizado. Em seguida, entre os anos de 1995 e 1997, John Lamping trabalhou em um
projeto chamado ETCML [Filman et al., 2004], o qual fornecia um conjunto de diretivas
com o objetivo de instruir o processador da linguagem sobre quando avaliar certos trechos
de cdigo.
Uma abordagem mais aprimorada foi considerada por Cristina Lopes no projeto DJ
[Lopes, 1997]. Alm de realizar uma anlise top-down semelhante s ideias anteriores, a
autora definiu construes de linguagem que permitiram que o cdigo fosse reorganizado e

10
certos interesses fossem "desembaraados" de uma forma bottom-up. Posteriormente,
Kiczales coordenou um projeto de implementao de um pr-processador (weaver)
baseado no projeto DJ para uma linguagem de programao chamada DJava, que deu
origem a linguagem de programao AspectJ [Pawlak et al., 2005].
2.3. Elementos da Programao Orientada a Aspectos
Para compreender as caractersticas das linguagens programao orientadas a
aspectos e conhecer as diretrizes que nortearam pesquisas na rea, necessrio o
entendimento de duas propriedades da tecnologia de OA [Filman et al., 2004]:
Inconscincia (obliviousness) assegura que no se pode dizer que o cdigo do aspecto
ir executar examinando o corpo do cdigo base. Esta propriedade desejvel porque
permite separao de interesses no processo de criao do software - interesses podem
ser separados na concepo dos desenvolvedores e na estrutura do software;
Quantificao (quantification) o conceito relacionado a execuo de um trecho de
cdigo em uma dada circunstncia. Sobre esta propriedade, a POA direciona a
utilizao de instrues da seguinte forma: Em um programa P, quando uma condio
C ocorrer, execute a ao A. Isso implica em trs escolhas para projetistas e
desenvolvedores de softwares orientados a aspectos: i) quais tipos de condies podem
ser especificadas; ii) como se d a interao entre as aes e o programa; e iii) como
mesclar a execuo das aes e do programa.
A tecnologia de OA no uma disciplina de programao que deve ser empregada
isoladamente para desenvolvimento de software. Ao invs disso, essa tecnologia deve
servir como complemento para facilitar a implementao, o entendimento, a manuteno e
a evoluo de softwares codificados em outros paradigmas. Para melhor entender os
elementos abordados na tecnolgia OA, segue a descrio de alguns termos especficos
[Resende; Silva, 2005] [Filman et al., 2004] [Laddad, 2003]:
Interesses (Concerns). Interesses so requisitos ou consideraes especficas que
devem ser tratadas para satisfazer o objetivo geral do software. Podem estar
relacionados com implementaes que variam desde questes de baixo nvel (software
deve armazenar valores em cache) a assuntos de alto nvel (software deve ser de fcil
usar - caracterstica de usabilidade [ISO/IEC 9126, 2001]);

11
Interesses Transversais (Crosscutting Concerns). Interesses transversais so
implementaes relacionadas a uma determinada responsabilidade no software
distribudas em muitas partes do cdigo fonte [Marin et al., 2004; Roy et al., 2007].
Em linhas gerais, so requisitos que demandam solues espalhadas em diversos
mdulos do software. Este problema conhecido como espalhamento de cdigo (Code
Scattering) [Marin et al., 2004; Roy et al., 2007]. Um interesse transversal tambm
pode ter sua codificao mesclada com cdigos relacionados s principais funes de
outros interesses da aplicao, problema denominado entrelaamento de cdigo (Code
Tangling) [Ceccato et al., 2005; Marin et al., 2004]. Exemplo de software com
interesses espalhados no cdigo fonte apresentado na Figura 2-1. Nesse software, h
o interesse de persistncia, de logging e de segurana, os quais esto entrelaados e
espalhados em seus mdulos.

Figura 2-1 - Interesses Transversais em um Software [Henry; Kafura, 1981]
Pontos de Juno (Join Points). Pontos de Juno so pontos bem definidos em uma
estrutura ou no fluxo de execuo de um software, nos quais um comportamento
adicional pode ser anexado. Os elementos mais comuns de pontos de juno so
chamadas de mtodos, embora linguagens de programao orientadas a aspectos
definam pontos de juno para outras circunstncias (por exemplo, acesso, modificao
e definio de atributos, excees e execuo de eventos). Se uma dessas linguagens
permitir chamadas de mtodos nos pontos de juno, um programador pode designar
um cdigo adicional para ser executado em uma chamada de mtodo. Um exemplo
dessa chamada de mtodo apresentado na Figura 2-2, quando um comportamento
extra pode ser adicionado no momento da execuo de um dado mtodo;

12

Figura 2-2 - Ponto de Juno
Conjunto de Pontos de Juno (Pointcut). Conjunto de Pontos de Juno uma
estrutura que seleciona diversos join points e coleta o seu contexto. Ele uma
caracterstica importante em linguagens de programao orientadas a aspectos, pois
provem a capacidade de atuao do aspecto em vrias partes do software por meio de
uma simples declarao. Este o mecanismo conhecido como quantificao e a
maneira de executar trechos de cdigos em vrios pontos do software empregando uma
simples instruo que identifica uma condio no fluxo de execuo ou estrutura do
software;
Adendo (Advice). Adendo a ao executada quando um join point selecionado por
um pointcut alcanado. No exemplo da Figura 2-2, a ao adicional representada
pele mtodo mX() do Objeto 2. Um advice pode ser executado antes (before), depois
(after) ou em substituio/a cerca (around) dos join points especificados. O mecanismo
de inconscincia (obliviousness) provido pelo advice, pois no h uma notao no
join point informando que o cdigo do advice ser executado naquele ponto. Isso
contrasta com as linguagens de programao convencionais, nas quais os mecanismos
comuns de modularizao de interesses (sub-rotinas) devem ser explicitamente
chamados;
Introdues (Introductions). Introdues so instrues que inserem modificaes nas
classes, nas interfaces e nos aspectos do software. Por no alterarem diretamente o
comportamento do software, elas so consideradas instrues entrecortantes estticas.
Como exemplo, mtodos ou atributos podem ser inseridos em uma classe utilizando
introductions;
Aspecto (Aspect). Aspecto a unidade central da linguagem de programao AspectJ e
contm o cdigo que expressa a implementao de um interesse. Os Pointcuts, os

13
advices, os introductions, os mtodos e os atributos so combinados em um aspecto
para determinar onde, como e quando determinada ao ser executada;
Combinao (weaving). Combinao o processo de composio das funes do
ncleo do software com os aspectos, produzindo um software em sua forma final. O
processo de weaving gerando um software a partir dos aspectos e componentes bsicos
do sistema ilustrado na Figura 2-3.

Figura 2-3 - Processo de Combinao de Aspectos com Ncleo do Software
2.4. Consideraes Finais
Neste captulo, foram apresentados conceitos bsicos e a gnese da tecnologia de
OA. Pelo exposto, essa tecnologia procura resolver alguns problemas difceis de serem
tratados utilizando tcnicas tradicionais de programao (por exemplo, tecnologia de OO).
Para isso, ela proporciona a separao de interesses transversais presentes no cdigo fonte
em mdulos denominados Aspectos visando a diminuio do entrelaamento e do
espalhamento de cdigo nos mdulos do software.

14
3. TCNICAS SEMNTICAS DE MINERAO DE ASPECTOS
Algumas tcnicas para deteco de interesses transversais so resumidamente
apresentadas nesse captulo, cuja essncia consiste na busca por indcios de espalhamento e
de entrelaamento no cdigo fonte de softwares orientados a objetos.
A minerao de aspectos pode ser conduzida de duas formas [Marin et al., 2004]: i)
abordagem top-down, a qual busca no cdigo fonte por interesses transversais comumente
tratados na literatura (como persistncia e log); e ii) abordagem bottom-up, a qual analisa o
cdigo fonte em busca de sintomas da ausncia de tratamento apropriado dos interesses
transversais, isto , espalhamento e entrelaamento de cdigo fonte. Apesar das distines
entre estas duas formas, o que ocorre na prtica uma combinao de ambas visando ao
alcance melhores resultados.
A literatura relacionada a procedimentos para identificao de interesses transversais
tem amadurecido e se desenvolvido bastante, o que contribui para o surgimento de novas
tcnicas. Algumas com grande variabilidade e distino entre si, outras com diferenas
sutis chegando ao ponto de se confundirem. Baseando-se em tais fatos, um conjunto de
critrios para categorizar e comparar tcnicas de identificao de interesses transversais foi
proposto [Kellens et al., 2007]:
Tipo de Dado de Entrada. A anlise pode ser feita a partir do cdigo fonte do
software (anlise esttica), a partir de informaes geradas durante a execuo do
software (anlise dinmica) ou ambos;
Granularidade. Algumas tcnicas identificam aspectos em nvel de mtodos, outras
fornecem granularidade mais refinada, informado fragmentos de cdigo ou declaraes
individuais como candidatos a aspectos;
Sintomas Analisados. Uma vez que os principais indcios da existncia de interesses
transversais so o espalhamento e o entrelaamento de cdigo, as tcnicas podem
enfatizar a busca por um ou ambos;
Envolvimento do Usurio. As tcnicas podem diferir quanto ao grau de envolvimento
do usurio durante o processo. Algumas carecem que o usurio conhea o software em

15
estudo, outras necessitam apenas de filtragem dos resultados. Em resumo, tcnicas
menos automatizadas requerem maior interveno do usurio.
O funcionamento da tcnica que utiliza a mtrica Fan-In para identificao de
interesses transversais descrita na Seo 3.2. As anlises baseadas nos rastros de
execuo e no grafo de fluxo de controle so apresentadas na Seo 3.3 e na Seo 3.4,
respectivamente. As anlises da existncia de clones como um indicativo de interesses
transversais para encontrar candidatos a aspectos usando rvore sinttica e grafo de
dependncia so apresentadas na Seo 3.5 e na Seo 3.6, respectivamente. A explicao
da utilizao de clusters e regras de associao no processo de minerao de aspectos
apresentada na Seo 3.7. Um quadro comparativo com algumas caractersticas das
tcnicas semnticas de minerao de aspectos em softwares orientados a objetos
apresentado na seo 3.8.
3.2. Anlise Fan-In
3.2.1. Conceitos
A anlise baseada na mtrica Fan-In foi apresentada no 11 Working Conference on
Reverse Engineering (WCRE) pelos pesquisadores Marius Marin, Arie van Deursen e
Leon Moonen, membros do Software Evolution Research Lab, situado na Holanda [Marin
et al., 2004; Marin et al., 2007].
A anlise Fan-In baseia-se na ideia que os principais sintomas da existncia de
interesses transversais em softwares orientados a objetos so causados por mtodos
invocados de diversas partes do cdigo fonte e cuja funcionalidade necessria em
diferentes pacotes, classes e mtodos do software. Tais mtodos podem ser encontrados
calculando a medida Fan-In a partir do grafo de chamadas estticas do software.
O Fan-In de um mtodo A o nmero de fluxos locais no mtodo A, somado ao
nmero de estruturas de dados das quais o mtodo A recupera informaes [Henry; Kafura,
1981], sendo que existe um fluxo local de um mtodo A para um mtodo B se uma ou mais
das seguintes condies so satisfeitas:
i) o mtodo A chama o mtodo B;
ii) se o mtodo B chama o mtodo A e o mtodo A retorna o valor para o mtodo B, o qual
ser posteriormente utilizado pelo mtodo B;

16
iii) se o mtodo C chama o mtodo A e o mtodo B passando o retorno do mtodo A para o
mtodo B.
Um mtodo relacionado a uma estrutura de dados D consiste dos procedimentos que
diretamente atualizam ou recuperam informaes de D. O Fan-In de um mdulo o
nmero de locais pelos quais o controle passado (chamadas para o mtodo em anlise)
somado ao nmero de acessos a dados globais [Marin et al., 2004].
As informaes necessrias para a computao da anlise Fan-In so adquiridas
estaticamente do cdigo fonte do software. Vale ressaltar que a granularidade desta tcnica
est em nvel de mtodos e o principal sintoma da existncia de interesses transversais o
espalhamento de cdigo. Alm disso, o envolvimento do usurio ao final do processo
necessrio para selecionar os candidatos a aspectos de uma lista de mtodos ordenados
com base no valor Fan-In calculado.
3.2.2. Explicao do Funcionamento
Para esclarecer o funcionamento desta tcnica, seus desenvolvedores consideram o
Fan-In de um mtodo m como o nmero de mtodos distintos que podem invocar m
[Marin et al., 2004]. Por causa do polimorfismo, chamadas a um mtodo podem afetar o
Fan-In de diversos outros mtodos. Desta forma, invocaes a um mtodo m contribuem
para o Fan-In de outros mtodos implementados por m bem como os mtodos que
implementam m.
O Diagrama de Classes [UML, 2011] apresentado na Figura 3-1 ilustra o
funcionamento da anlise de Fan-In e a Tabela 3-1 apresenta valores Fan-In de cada
mtodo desse diagrama. O mtodo m() da classe A1 tem o seu valor Fan-In incrementado
nas chamadas dos mtodos f1(), f3(), f4() e f5() totalizando o valor 4, semelhante ao
Fan-In do mtodo m() da classe A2, incrementado nas chamadas dos mtodos f2(),
f3(), f4() e f5(). O mtodo m() da classe B tem o seu valor Fan-In incrementado nas
chamadas dos mtodos f1(), f2(), f3(), f4() e f5() totalizando o valor 5. O mtodo
m() da classe C1 tem o seu valor Fan-In incrementado nas chamadas dos mtodos f1(),
f2(), f3() e f4() totalizando o valor 4. O mtodo m() da classe C2 tem o seu valor
Fan-In incrementado nas chamadas dos mtodos f1(), f2(), f3() e f4() totalizando o
valor 4.

17
Visando a obteno de melhores resultados na utilizao da tcnica Fan-In, foi
proposta uma sequncia de passos a serem seguidos [Marin et al., 2004]:
Passo 1. Computao automtica da mtrica Fan-In para os mtodos no cdigo fonte alvo.
O resultado pode ser apresentado como uma lista ordenada pelo valor Fan-In e
utilizado para inspecionar o local das chamadas de um mtodo selecionado.

Figura 3-1 - Diagrama de Classes [Valle-Rai et al., 1999]

Tabela 3-1 - Valores Fan-In para Cada Mtodo [Valle-Rai et al., 1999]
Contribuies para o Fan-In
Locais de Chamada A1.m A2.m B.m C1.m C2.m
f1(A1 a1){a1.m();} 1 0 1 1 1
f2(A2 a2){a2.m();} 0 1 1 1 1
f3(B b){b.m();} 1 1 1 1 1
f4(C1 c1){c1.m();} 1 1 1 1 0
f5(C2 c2){c2.m();} 1 1 1 0 1
Fan-In Total 4 4 5 4 4

Passo 2. Filtragem dos resultados do Passo 1.
a. Restringir o conjunto de invocadores queles que atingem um determinado
valor limitante. Normalmente, 5% dos mtodos alcanam valores de Fan-In
superiores a 10.
b. Filtrar mtodos acessores. Inicialmente, analisar a assinatura e, em seguida,
analisar a implementao do mtodo.
c. Filtrar do conjunto restante os mtodos utilitrios, tais como toString() e
gerenciadores de colees.
Passo 3. Anlise manual dos resultados. Os elementos considerados so os invocadores e
os locais de chamada, nomes e implementaes dos mtodos e comentrios no
cdigo fonte.

18
Pode-se distinguir trs situaes em que um alto valor de Fan-In indica a presena de
interesses transversais: i) quando o mtodo o elemento chave da codificao do interesse
transversal, tais como mtodos utilizados em classes de debug, tracing ou logging; ii)
quando a implementao do interesse transversal est baseada em alguma funo usual do
software, espalhando-se ele, e o mtodo com alto Fan-In participa desta implementao; e
iii) quando so utilizados Design Patters (padres de projeto) com estrutura distribuda
pelo software, por exemplo, o padro de projeto Observer.
3.3. Anlise dos Rastros de Execuo
3.3.1. Conceitos
A primeira abordagem para detectar interesses transversais em softwares legados
utilizando informaes geradas durante a execuo do software foi proposta por Silvia
Breu e Jens Krinke [Breu; Krinke, 2004] na 19 International Conference on Automated
Software Engineering, em Linz, ustria.
Os rastros de execuo so informaes sobre a sequncia de chamadas de mtodos
produzidas durante a execuo do software, as quais refletem o comportamento em tempo
de execuo do software [Kellens et al., 2007]. Este mtodo de investigao de interesses
transversais analisa os dados coletados a procura de padres de execuo recorrentes e
impe restries para definir quando uma amostra recorrente. Um exemplo de restrio
a garantia de um padro existir em diferentes contextos de chamadas nos rastros de
execuo. Os padres extrados descrevem aspectos comportamentais do software e,
quando implementam funes recorrentes no software, podem ser considerados interesses
transversais [Breu; Krinke, 2004].
A granularidade de cdigo considerada o mtodo, os subsdios para a computao
desta tcnica so gerados pela execuo do software, enquadrando-a como uma tcnica de
anlise dinmica, o indicador da presena de interesses transversais o espalhamento do
cdigo e o envolvimento do usurio durante processo baixo, h a necessidade apenas de
inspeo dos padres recorrentes [Kellens et al., 2007].
Para que seja possvel encontrar padres recorrentes nos rastros de execuo, torna-
se necessrio defini-los quanto forma e estabelecer alguns conceitos. Como a tecnologia

19
de OO encapsula os comportamentos em mtodos com funes especficas, o primeiro
conceito relacionado a rastros de execuo definido a partir das assinaturas dos mtodos.
Um rastro de execuo
de um programa com assinaturas de mtodos

definido como uma lista
de pares
, sendo a entrada de
um mtodo e a sada de um mtodo. Intuitivamente, um rastro de execuo uma
sequncia de invocaes e sadas dos mtodos de um software.
Para facilitar a leitura e o entendimento de um rastro de execuo, os smbolos e
so substitudos por "" e "", respectivamente. Alm disso, imposta uma estrutura ao
rastro de execuo para que a assinatura do mtodo
seja descartada dos pontos de sada

de mtodos, o que elimina informaes redundantes. Um exemplo de rastro de execuo
que assegura essa estrutura apresentado na Figura 3-2. Adotada esta estrutura, os
interesses transversais so demarcados por duas diferentes relaes de execuo possveis
de serem encontradas nos traos de execuo.

Figura 3-2 - Rastro de Execuo [Marin et al., 2004]
Um mtodo pode ser executado aps a execuo de um mtodo antecedente. Por
exemplo, na linha 12, o mtodo B() executado aps o mtodo A(), na linha 11. Esta
denominada uma relao de execuo externa ou outside-execution relation. Outra relao
de execuo possvel na ocasio de um mtodo ser chamado dentro do corpo de outro
mtodo, como exemplificado nas linhas 12 e 13. O mtodo C() invocado dentro do
mtodo B(). Esta uma relao de execuo interna ou inside-execution relation [Breu;
Krinke, 2004]. No entanto, esta notao no fornece as informaes suficientes para o
processo de minerao de aspectos. Por exemplo, os mtodos C(), A() e B() so
invocados, respectivamente, nas linhas 36, 37 e 38 pelo mtodo D() na linha 35, mas no
h informaes que garantam a sequncia das chamadas dos mtodos. Para solucionar este
problema, necessria uma formalizao da ordem das invocaes.

20
Sejam
, chamada uma relao de execuo externa-anterior se

uma sublista de
. O conjunto das relaes de execuo externa-

anterior denotado por
. Esta relao pode ter a ordem invertida, isto ,

uma relao de execuo externa-posterior se
e o conjunto com os
elementos deste tipo expresso por
.
Sejam
, a relao
chamada uma relao de execuo interna-inicial

se uma sublista de
uma relao de execuo interna-final

se uma sublista de
. Os respectivos conjuntos
dessas relaes so
.
Para o exemplo de rastro de execuo da Figura 3-2, tem-se o conjunto
de
relaes de execuo externa-anterior apresentado na Figura 3-3. O conjunto
das
relaes de execuo externa-posterior foi suprimido, uma vez que possvel encontr-lo
invertendo a ordem das relaes do conjunto
.

Figura 3-3 - Relaes de Execuo Externa-Anterior [Marin et al., 2004]
Os conjuntos das relaes de execuo interna-inicial (
) e interna-final (
) so
apresentados na Figura 3-4.

Figura 3-4 - Relaes de Execuo Interna-Inicial e Interna-Final [Breu; Krinke, 2004]
As relaes de execuo recorrentes podem ser vistas como indicadores dos mais
gerais padres de execuo [Breu; Krinke, 2004]. Mas, para determinar quais relaes de
execuo so recorrentes e, consequentemente, potenciais interesses transversais do
sistema, torna-se essencial definir algumas restries.
Por formalizao tcnica, necessrio declarar que no existem execues de outros
mtodos entre a entrada e a sada de um mtodo ou entre mtodos aninhados. Tomando
como apoio o rastro de execuo apresentado na Figura 3-2 para exemplificar esta

21
situao, pode-se ver que no h invocaes dentro do mtodo A() na linha 7. Alm disso,
no existem invocaes de outros mtodos dentro do mtodo B() antes do mtodoC() ser
chamado nas linhas 12 e 13, respectivamente. Ou seja, no h chamadas de mtodos a
menos que estejam declaradas no rastro de execuo do programa
. Esta ausncia de
invocao representada pela assinatura de mtodo nulo . O rastro execuo do programa
continua definido como antes, mas, a partir deste ponto, foram includas as assinaturas dos
mtodos contidas em
. Da mesma forma, os conjuntos
tambm
incluem as relaes de execuo envolvendo .
Formalmente, uma relao de execuo

chamada uniforme se
. Isto , existe sempre na

mesma composio. O conjunto
contm as relaes
que satisfazem esta restrio.

Uma relao de execuo
chamada
transversal se
'

. Isto , a relao ocorre em mais

de um nico contexto de chamada no rastro de execuo do programa
. Para relaes de
execuo internas (
ou
), o contexto da chamada o mtodo circundante .

Para relao de execuo externas ou , o contexto da chamada o mtodo
invocado depois (ou antes) de um mtodo a ser executado.
o conjunto de relaes de
execuo
as quais satisfazem este requisito. As relaes de execuo
so
chamadas de candidatas a aspectos, uma vez que elas representam um potencial interesse
transversal do software em anlise.
Em resumo, a tcnica de anlise dos rastros de execuo avalia o comportamento em
tempo de execuo do software classificando as relaes de chamadas entre os mtodos
como externa-anterior, externa-anterior, interna-inicial e interna-final. Baseando-se nessas
categorias, so definidos os conceitos de uniformidade e de transversalidade visando
formalizar o significado de interesses transversal.
3.4. Anlise Baseada no Grafo de Fluxo de Controle
3.4.1. Conceitos
Esta tcnica semntica de deteco de interesses transversais complementa a
abordagem de Anlise dos Rastros de Execuo [Breu; Krinke, 2004] descrita na Seo 3.3
com informaes estticas sobre o software em anlise, bem como utiliza as definies
fornecidas anteriormente. Essa tcnica foi igualmente proposta por Jens Krinke e Silvia

22
Breu [Krinke; Breu, 2004] e submetida ao 1 Workshop on Aspect Reverse Engineering.
Essa tcnica leva em considerao os padres recorrentes no cdigo fonte baseando-se em
diversas restries (por exemplo, um determinado padro ocorrer em diferentes contextos
de chamada) para determinar a existncia de possveis interesses transversais no software.
A anlise dinmica considerada em vrias abordagens de minerao de aspectos
uma mtrica razovel para avaliar o comportamento em tempo de execuo do software,
pois examina as informaes extradas das chamadas de mtodos ocorridas durante a sua
utilizao efetiva. No entanto, ao examinar essas informaes, pode-se encontrar
inconsistncia nos dados coletados. Por exemplo, a situao na qual uma estrutura de
controle de fluxo redireciona a execuo do software em duas direes distintas [Qu; Liu,
2007]. Caso uma determinada condio seja verdadeira, um mtodo A() executado; caso
contrrio, o mtodo B() executado. Como o fluxo de execuo bifurcado, torna-se
impossvel avaliar a relao existente entre esses mtodos, pois eles no se enquadram nas
restries proposta na tcnica, mesmo estando presentes em locais adjacentes no cdigo
fonte. Assim, os resultados das anlises esttica e dinmica so diferentes em decorrncia
de diversos fatores [Breu; Krinke, 2004].
O tipo de dado de entrada para computao desta tcnica definido como esttico,
pois apenas o cdigo fonte do software analisado. As demais caractersticas seguem as
definidas para a tcnica de Anlise dos Rastros de Execuo. O nvel de granularidade
limitado a mtodos, o espalhamento de cdigo o principal sintoma de interesse
transversal e o envolvimento do usurio baixo, sendo necessrio apenas para vistoriar os
padres recorrentes encontrados ao final do processo.
As informaes utilizadas na computao desta anlise so extradas do grafo de
fluxo de controle do software em anlise e a busca feita diretamente por relaes de
execuo uniforme e transversal, no se verificam as relaes iniciais no sujeitas a
restries.
Com o objetivo de concentrar esforos no processo de deteco de interesses
transversais, foi utilizado o apoio de uma ferramenta computacional, chamada Soot
[Valle-Rai et al., 1999], para extrair do cdigo fonte o grafo de fluxo de controle. Os

23
resultados produzidos pelo Soot so analisados e o grafo percorrido buscando relaes de
execuo uniforme e transversal. O processo realizado por esta abordagem parte do pr-
suposto que o grafo do cdigo fonte foi criado e est de acordo com as suas necessidades.
Aps esta etapa, as relaes de execuo so examinadas a fim de encontrar os padres
recorrentes. Como exemplo:
Para relaes de execuo do tipo interna-inicial (
), extrada no grafo de fluxo de

controle a chamada de mtodo imediatamente seguinte entrada de um mtodo
invocado . Tal relao uniforme se todo caminho para o mtodo inicia-se com a
mesma chamada de mtodo . Um determinado mtodo dito transversal se h no
mnimo duas relaes de execuo uniforme
, com ;
Para as relaes de execuo externa-anterior (
), extrai-se todo par de chamadas de

mtodo , se existe um caminho da invocao do mtodo para a invocao do
mtodo sem outras chamadas de mtodo entre elas. Tal par uma relao de
execuo externa-anterior uniforme se os caminhos, partindo da invocao do
mtodo , contm o mtodo como o prximo a ser chamado. O caso de uma relao
ter comportamento transversal incide na mesma situao para a relao do tipo interna-
inicial.
Em estudos de casos realizados em softwares de benchmarks, parte dos candidatos
interesses transversais encontrados no puderam ser refatorados em aspectos. No entanto,
percebeu-se melhor viso sobre o comportamento transversal do software em anlise
[Krinke; Breu, 2004].
3.5. Anlise para Deteco de Clones
O problema bsico da deteco de clones descobrir se os fragmentos de cdigo
fonte produzem o mesmo resultado e, para facilitar esta deteco, deve-se dividir esse
cdigo em trechos e compar-los para determinar se os pares de fragmentos so
equivalentes. Uma possibilidade prtica e eficiente comparar representaes do software
nas quais os fluxos de controle e de dados estejam explcitos [Baxter et al., 1998].
As tcnicas de deteco de clones tentam identificar trechos de cdigo duplicados ou
que tenham sofrido pequenas alteraes a partir de um fragmento de origem. Diversas
tcnicas so descritas na literatura, diferenciando-se com relao abstrao do cdigo

24
fonte que cada uma emprega como subsdio para computao. Possveis abordagens de
deteco so [Bruntink, 2004]:
Baseadas na AST. A AST (Abstract Sintax Tree - rvore Sinttica Abstrata) criada a
partir do cdigo fonte e a deteco de clones procura por subrvores similares;
Baseadas no PDG. O PDG (Program Dependence Graph - Grafo de Dependncia do
Programa) analisado para procurar subgrafos semelhantes, pois contm informaes
sobre fluxos de controle e dados.
3.5.1. Utilizando rvore Sinttica Abstrata
3.5.1.1. Conceitos
A ideia de utilizar a AST para deteco de clones [Baxter et al., 1998] visando a
identificao de interesses transversais foi proposta por Magiel Bruntink, Arie van
Deursen, Tom Tourwe e Remco van Engelen [Bruntink et al., 2004] e submetida 20
IEEE International Conference on Software Maintenance. Posteriormente, Magiel
Bruntink aperfeioou esta ideia utilizando mtricas distintas para encontrar candidatos
favorveis a aspectos [Bruntink, 2004].
Durante o processo de deteco de clones, trs principais algoritmos so aplicados
sobre a AST gerada a partir do cdigo fonte [Baxter et al., 1998]: i) algoritmo para detectar
subrvores clones; ii) algoritmo para detectar sequncias de tamanho varivel nas
subrvores clones; e iii) algoritmo para procurar por clones no idnticos tentando
generalizar combinaes de outros clones. Uma vez que os clones esto identificados,
inicia-se sua anlise para encontrar indcios de identificar interesses transversais. Nveis de
classificao baseados em mtricas podem ser utilizados com o objetivo de filtrar os clones
mantendo aqueles que apresentam valores significativos para as mtricas [Bruntink, 2004].
A granularidade dos resultados produzidos est em nvel de fragmentos de cdigo, o
que fornece um retorno mais representativo ao usurio, podendo inclusive utilizar as
informaes obtidas para definir as estruturas dos advices. O tipo de dado de entrada
considerado esttico. O espalhamento de cdigo o sintoma de interesse transversal
avaliado e o envolvimento do usurio consiste na navegao e inspeo de trechos de
cdigos considerados clones.

25
3.5.1.2. Explicao do Funcionamento
Aps a identificao, os clones so agrupados e denominados Classes Clones
[Kamiya et al., 2002 apud Bruntink et al., 2004]. Para satisfazer questes formais, uma
relao clone deve assegurar as propriedades de equivalncia: i) reflexividade (um
fragmento de cdigo um clone exato de si prprio); ii) simetria (se um cdigo A um
clone exato de um cdigo B, ento o cdigo B um clone exato do cdigo A); e iii)
transitividade (se um cdigo A um clone exato de um cdigo B e esse cdigo B um
clone exato de um cdigo C, ento o cdigo A um clone exato do cdigo C).
Depois de criadas as Classes Clones, filtros devem ser aplicados com o objetivo de
limitar a quantidade de resultados apresentados, os quais podem ser baseados em mtricas
que considerem o rigor da duplicao de cdigo para cada Classe Clone [Bruntink, 2004].
Para uma dada Classe Clone C, as seguintes mtricas podem ser avaliadas, sendo que
valores mais altos correspondem a casos mais severos de duplicao de cdigo:
Nmero de Clones (NC) inclusos na Classe Clone C;
Nmero de Linhas (NL) distintas na Classe Clone C;
Tamanho Mdio do Clone (TMC). Essa mtrica corresponde ao NL dividido pelo NC.
Instncias triviais de duplicao de cdigo podem ser solucionadas utilizando
tcnicas tradicionais de reengenharia. Para outras, relacionadas a espalhamento de cdigo,
torna-se necessrio a utilizao de medidas que estejam de acordo com as necessidades da
tecnologia de OA. As seguintes mtricas capturam esta noo de espalhamento para uma
dada Classe Clone C, sendo que valores mais altos indicam teores elevados de
espalhamento:
Nmero de Arquivos (NA) distintos nos quais a Classe Clone C ocorre;
Nmero de Funes/Mtodos (NFM) nos quais a Classe Clone C ocorre.
As Classes Clones devem estar ordenadas por algum critrio, por exemplo seus
valores de NL e NFM que indicam o grau de manutenibilidade ao aplicar o processo de
refatorao de OA. Nesse caso, Classes Clones com valores altos de NL e NFM tero
maior prioridade no processo de refatorao. Experimentos indicam eficincia em torno de
80% na identificao de interesses transversais relacionados a tratamento de erros,
rastreabilidade, verificao de parmetros e manipulao de memria [Bruntink et al.,
2004].

26
3.5.2. Utilizando Grafos de Dependncia
3.5.2.1. Conceitos
A utilizao de grafo de dependncia do programa foi proposta por David Shepherd,
Emily Gibson e Lori Pollock [Shepherd et al., 2004] na International Conference on
Software Engineering Research and Practice como um aperfeioamento da anlise da
rvore sinttica abstrata. Esta anlise considera a existncia de clones como indicador da
presena de interesses transversais no software. No entanto, os subsdios para a
computao so fornecidos pelo grafo de dependncia do software.
Diferentes definies da representao de dependncia do software tm sido dadas,
estando sempre vinculadas inteno do seu uso [Horwitz; Reps, 1992]. Entretanto, essas
definies so variaes do tema introduzido por David J. Kuck, Yoichi Muraoka e Shyh-
Ching Chen [Kuck et al., 1972] e compartilham a caracterstica comum de fornecer uma
explcita representao das dependncias de controle e dados. Na representao do PDG de
um mtodo, cada n representa uma declarao e as arestas entre os ns representam as
dependncias de controle ou dados entre as declaraes correspondentes [Shepherd et al.,
2004].
Com o objetivo de identificar os clones, a tcnica de anlise do grafo de dependncia
utiliza a abordagem proposta por Raghavan Komondoor e Susan Horwitz [Komondoor;
Horwitz, 2001], a qual particiona as declaraes do software em classes equivalentes
baseando-se na estrutura sinttica, ignorando nomes de variveis e valores de literais,
removendo redundncias e agrupando resultados.
Desta forma, um par de clones identificado por subgrafos isomrficos do PDG.
Outra abordagem de deteco de clones considerada na tcnica de anlise do grafo de
dependncia a relatada por Jens Krinke [Krinke, 2001]. Uma especializao do PDG
criada contendo os ns para expresses, variveis, mtodos e declaraes. Os ns so
ligados com arestas informando a ordem de avaliao, dependncia entre os dados e
valores armazenados nas variveis.
Baseando-se na eficincia em identificar clones das tcnicas descritas anteriormente,
refinamentos foram feitos na tcnica de anlise do grafo de dependncia visando a
obteno de benefcios para minerao de aspectos de forma automtica. O foco desta

27
abordagem encontrar trechos que possam ser refatorados em aspectos com advice do tipo
before.
A classificao da tcnica apresentada nesta seo equivalente quela apresentada
na Seo 3.5, o que difere apenas no modo como os dados (estticos) de entrada so
computados. Para esta abordagem, o cdigo fonte analisado e representado como grafo
de dependncia, a anterior cria uma rvore sinttica. A granularidade em nvel de
fragmentos de cdigo, o indicador de interesse transversal o espalhamento de cdigo e o
envolvimento do usurio necessrio ao final do processo para inspeo dos resultados.
3.5.2.2. Explicao do Funcionamento
O procedimento de minerao de aspectos abordado nesta seo est decomposto em
quatro fases descritas a seguir. Desta maneira, possibilita-se melhor compreenso de cada
etapa bem como realizar possveis otimizaes nas fases separadamente.
A primeira etapa a transformao de um PDG em nvel de representao
intermediria [Komondoor; Horwitz, 2001; Krinke, 2001] para um PDG em nvel de
cdigo, para que o usurio da tcnica tenha melhor entendimento dos resultados. Nesta
transformao, os ns do grafo intermedirio que correspondem mesma linha do cdigo
fonte so agrupados em um nico n. Para cada aresta que origina ou termina em um n do
PDG em nvel intermedirio, a aresta includa no PDG em nvel de cdigo no n
apropriado, evitando a insero de arestas duplicadas no PDG em nvel de cdigo.
A segunda fase pode ser vista como um processo de deteco de clones e
identificao do conjunto de candidatos a refatorao. Sabendo que o problema de
determinar se dois subgrafos so isomrficos NP-Completo [Krinke, 2001 apud
Shepherd et al., 2004], torna-se necessrio projetar o algoritmo de modo a escolher entre a
acurcia da deteco de clones ou o desempenho da execuo. Para conseguir o melhor
aproveitamento deste trade-off, o algoritmo realiza as comparaes entre as declaraes
utilizando a rvore sinttica abstrata e o grafo de dependncia. Dados dois PDGs
representando diferentes mtodos, o algoritmo inicia-se pelo n de entrada e executa uma
busca em largura em cada PDG realizando "podas" medida que percorre o grafo. Os
filhos do n de entrada de um dos PDGs so comparados com cada um dos filhos do n de
entrada do outro PDG. Quando encontrados ns que sejam equivalentes de acordo com a

28
comparao das declaraes na AST, eles so armazenados em uma lista a ser analisada
posteriormente. Aps a comparao entre os ns de entrada, um n retirado da lista e um
procedimento anlogo executado. O nmero de estados criados bastante reduzido por
causa da rigorosa comparao baseada na AST no momento da "poda". Alm disso, a
complexidade do processo de identificao amortizada, pois o incio d-se apenas nos
ns de entrada do PDG e no em qualquer ponto do mtodo [Shepherd et al., 2004]. Como
os PDGs so comparados vrias vezes durante o procedimento de identificao de clones,
esta deve ser feita de maneira eficiente. Alm disso, a comparao das AST apenas
estrutural; caso um n seja diferente de outro n na AST correspondente, as rvores so
consideradas diferentes. Variveis do mesmo tipo so consideradas equivalentes, assim
como variveis em uma hierarquia comum ou que uma seja subtipo da outra [Shepherd et
al., 2004].
A terceira fase consiste na filtragem dos resultados indesejados. A dependncia entre
os dados pode ser usada para desconsiderar candidatos que dependam de algum n que no
faz parte de nenhum clone.
A quarta fase recebe das etapas anteriores um conjunto de pares de mtodos e os
agrupam em cojuntos maiores de candidatos similares. Este agrupamento produz
resultados mais adequados para identificar os locais de espalhamento e duplicao de
cdigo e, possivelmente, adaptar o trecho de cdigo de uma forma adequada tecnologia
de OA.
A eficincia deste mtodo de deteco de Interesses Transversais comprovada com
a realizao de testes com softwares reais e a obteno de resultados expressivos, ou seja,
cerca de 90% dos candidatos relatados foram considerados passveis de refatorao.
3.6. Anlise Utilizando Clusters e Regras de Associao
3.6.1. Conceitos
Este procedimento de combinao de clusters e regras de associao para anlise de
cdigo foi sugerido por Lili He e Hongtao Bai [He; Bai, 2006] e submetido ao
International Journal of Computer Science and Network Security. Clusters so grupos de
objetos classificados com base nos princpios de maximizar a similaridade intraclasse e
minimizar a similaridade interclasse. Objetos pertencentes a um mesmo cluster tm alta

29
similaridade quando comparados um com outro e so bastante discrepantes em relao aos
objetos de outros clusters [Han; Kamber, 2000].
Para descobrir os candidatos a aspectos, foram realizados procedimentos de criao
de clusters sobre os rastros de execuo do programa com o objetivo de agrupar cenrios
de execuo com comportamento semelhante. Em seguida, regras de associao foram
detectadas entre as relaes de chamadas dos mtodos possibilitando que o relacionamento
entre o cdigo base e o cdigo transversal seja identificado [He; Bai, 2006].
Na definio de regras de associao, foram considereados um conjunto de itens

e um banco de dados de transaes , onde cada transao , associada a

um identificador , um conjunto de itens tal que . Sejam e conjuntos de itens,
uma transao dita contida em se, e somente se, . Uma regra de associao
uma implicao , sendo , e . Alm disso, podem ser
classificadas quanto aos tipos, dimenses e nveis de abstrao dos valores manipulados.
Regras de associao so condies com atributos e valores que ocorrem frequentemente
juntas em um determinado conjunto de dados. Formalmente, seguem o padro , isto
,
, sendo
(para ) e
(para ) pares
atributo-valor. A confiana de uma regra a medida da probabilidade (ou da certeza) da
proposio Y ocorrer quando a proposio X ocorrer e o suporte de um regra a proporo
de vezes que a relao ocorre [Han; Kamber, 2000].
Alguns exemplos podem ser utilizados para explicar os conceitos anteriores [Han;
Kamber, 2000]. Considerando o exemplo de um banco de dados de produtos eletrnicos,
alguns clusters que podem ser identificados so: produtos telefnicos, computadores,
produtos automotivos, eletrodomsticos e udio/vdeo. Para esse o exemplo, a seguinte
regra de associao pode ser encontrada:
20-29" 2000-3000" CD player"

Isso significa que, dos compradores de produtos eletrnicos em estudo, 2% (suporte)
tm idade entre 20 e 29 anos, salrio entre 2 mil e 3 mil e compraram um CD player. H
uma probabilidade de 60% (confiana) de que um novo comprador com idade e salrio
desse grupo compre um CD player.

30
A granularidade desta tcnica est em nvel de mtodos, necessria a interveno
do usurio para inspecionar os clusters resultantes, o sintoma de interesse transversal
procurado no cdigo fonte o espalhamento de cdigo e os dados de entrada necessrios
para a computao desta tcnica so dinmicos.
Para obter os rastros de execuo, o software manipulado e executado para cenrios
e entradas especficos. Cada cenrio, considerado um objeto, corresponde a uma sequncia
de chamadas de mtodos. Os mtodos executados em cada cenrio so os atributos dos
objetos e o nmero de vezes que cada mtodo foi chamado valor do atributo.
Seja a quantidade de cenrios e a quantidade de mtodos, ento o conjunto de
objetos
, e cada objeto um vetor
de
dimenso .
Uma aplicao bancria foi utilizada como estudo de caso para explicar o
funcionamento da tcnica [He; Bai, 2006]. O software foi desenvolvido utilizando a
tecnologia de OO e os cenrios para este estudo foram (i) criao de contas, (ii) depsito,
(iii) saque e (iv) balano. Alguns cenrios (KH
1
, KH
2
,CK
1
, ...) e seus respectivos mtodos
so mostrados no Tabela 3-2. O nmero entre parnteses aps o identificador do mtodo
indica a quantidade de vezes que ele foi executado. Por exemplo, no cenrio KH
1
, alguns
mtodos foram executados, tais como Trans.Accept(), Encry.TsMac(),
KH.hz_kh(), Error.Lock(), Trans.Send() e Ans.Process(),esses mtodos foram
executados apenas um vez, exceto o ltimo que foi executado duas vezes.
Em seguida, os autores definem uma estrura chamada matriz de dados dos objetos , a
qual montada da seguinte forma: para cada objeto
e mtodo
, se o mtodo

invocado pelo objeto
vezes, ento o valor da -sima posio do objeto

, caso contrrio, zero. Tambm definida a matriz de dissimilaridade entre objetos, a
qual armazena a medida de dissimilaridade para cada par de objetos em uma estrutura
. Se os valores da -sima posio do objeto
so ambos diferentes de zero,

significa que
invocam
. Ou seja,
tm comportamento similar em termos de
, a diferena entre eles pode ser o valor . Se ambos os valores so zero, significa que

31
nenhum deles invoca
. Caso um valor seja zero e o outro diferente de zero, significa que

existe uma dissimilaridade entre eles em termos do comportamento de
.
Tabela 3-2 - Conjunto de Objetos [He; Bai, 2006]
Cenrios Mtodos Executados
KH
1
Trans.Accept(1), Encry.TsMac(1), Ans.Process(2), KH.hz_kh(1), ..., Error.Lock(1),
Trans.Send(1)
KH
2
Trans.Accept(1), Encry.TsMac(1), Ans.Process(2), KH.zl_kh(1), ..., Trans.Send(1)
CK
1
Trans.Accept(1), Encry.TsMac(1), Ans.Process(3), KH.hz_ck(2), ..., Trans.Send(1)
CK
2
Trans.Accept(1), Encry.TsMac(1), Ans.Process(3), KH.zl_ck (2), ..., Trans.Send(1)
QK
1
Trans.Accept(1), Encry.TsMac(1), Ans.Process(3), KH.hz_qk(2), ..., Trans.Send(1)
QK
2
Trans.Accept(1), Encry.TsMac(1), Ans.Process(3), KH.zl_qk(2), ..., Trans.Send(1)
DLRJ
1
DB.Open(1), Lock.Table(5), RJ.rjemnllidr(1), Lock.UnlockTable(5), ..., DB.Close(1)
DLRJ
2
DB.Open(1), Lock.Table(5), RJ.rjmemlcmsj(1), Lock.UnlockTable(5), ..., DB.Close(1)
JZRJ
1
DB.Open(1), Lock.Table(8), RJ.rj1zzjzzc(1), Lock.UnlockTable(8), ..., DB.Close(1)
JZRJ
2
DB.Open(1), Lock.Table(8), RJ.rj1hzlsz(1), Lock.UnlockTable(8), ..., DB.Close(1)
....
Clusters na matriz de dados dos objetos e na matriz de dissimilaridade entre objetos
produzem grupos de conjuntos de objetos. Elementos com atributos comuns em cada
conjunto (cdigos similares dos cenrios) so candidatos a interesses transversais. Para o
exemplo da aplicao bancria, dois clusters foram obtidos referentes aos mdulos de
balano dirio (DLRJ
1
, DLRJ
2
,..., JZRJ
1
, JZRJ
2
,...) e tarifas (KH
1
, KH
2
,..., QK
1
, QK
2
,...).
Para o primeiro cluster, o conjunto de atributos comuns indica a existncia de dois
interesses transversais: i) acesso banco de dados; e ii) bloquear/desbloquear tabela. No
segundo cluster, os interesses transversais encontrados so referentes a (i) comunicao,
(ii) encriptao/decriptao e (iii) mensagens.
Uma vez que os interesses transversais foram identificados, necessita-se apontar a
sua localizao. Os passos seguintes descrevem o procedimento. Seja

uma sequncia de chamada de mtodos e
indicado como interesse transversal. Cada

mtodo considerado como uma transao da regra de associao e a sequncia de
mtodos chamados por constitui seu conjunto de itens. Com o objetivo de identificar as
posies iniciais e finais, os mtodos first() e end() so adicionados ao conjunto de
itens de para marcar, respectivamente, o incio e fim das invocaes de mtodos. Um
conjunto de itens
constitudo por mtodos no cdigo fonte, cada qual

considerado como um item. Como foram adicionados os mtodos first() e end() ao
conjunto de itens, eles recebem as respectivas notaes
. Portanto, a extenso do
conjunto
.

32
Para a aplicao bancrio, os itens so first(), Trans.accept(),
Encry.TsMac(), ..., DB.Close(), end(), representados por
. Como
cada transao determinada por um cenrio do cdigo fonte, cada cenrio recebe um
e o conjunto de transaes
, para cada
, inclui as
transaes. Para a aplicao analisada, os cenrios KH
1
, KH
2
, ..., JZRJ
2
, ... so
representados pelas transaes T
0
, T
1
, T
2
, ..., T
9
, .... O conjunto de transaes para a
aplicao bancria apresentado na Tabela 3-3. Caso algum item se repita em uma
transao, ele representado pela notao conforme o item 3 da transao
.
Tabela 3-3 - Conjunto de Transaes [IBM, 2006]
Conjunto de Itens

. . .
As regras de associao so produzidas depois de fornecidos o conjunto de
transaes e de itens, os valores de confiana e o suporte a um algoritmo de minerao de
regras de associao. Nesta anlise, o suporte assegura que os candidatos a aspectos sejam
frequentes, enquanto a confiana especifica a estabilidade da localizao dos interesses
transversais. Aps a execuo de um algoritmo de minerao de regras de associao, as
seguintes regras foram encontradas com confiana e suporte de 40%:
(1)

(2)

(3)

(4)

Pela regra (1), percebe-se que no incio de alguns cenrios (KH
1
, KH
2
, CK
1
, CK
2
,
QK
1
, QK
2
), os mtodos
so executados. De forma semelhante, imediatamente

antes do final de outros cenrios (DLRJ
1
, DLRJ
2
, JZRJ
1
, JZRJ
2
), os mtodos
so
executados.

33
3.7. Comparao Entre os Mtodos
Analisando as tcnicas apresentadas nas sees anteriores, possvel notar que
apenas as abordagens de anlise dos rastros de execuo e de utilizao de clusters com
regras de associao so consideradas tcnicas dinmicas. Os mtodos que consideram os
trechos de cdigo clonados como indcios de interesses transversais conseguem retornar ao
usurio um resultado mais detalhado, pois informam os fragmentos de cdigo espalhados
pela aplicao, os demais mtodos tm granularidade em nvel de mtodos.
No que diz respeito aos sintomas de interesses transversais investigados pelas
tcnicas supracitadas, todas levam em considerao o espalhamento de cdigo para efetuar
a computao. No quesito de envolvimento do usurio, pode-se notar que em todas as
tcnicas considerado escasso, h a necessidade de intruso apenas ao final do processo.
A anlise das tcnicas estudadas, caracterizando-as seguindo os critrios de
granularidade, tipo de dados de entrada, sintomas de interesse transversal e envolvimento
do usurio, e uma breve descrio para facilitar a identificao de cada tcnica so
apresentadas na Tabela 3-4.
Tabela 3-4 - Tcnicas de Deteco de Interesses Transversais
Tcnica de Deteco de Interesse Transversal
Critrio Anlise Fan-In
Anlise dos
Rastros de
Execuo
Anlise do
Grafo de
Fluxo de
Controle
Deteco de
Clones
utilizando
AST
Deteco de
Clones
utilizando
PDG
Clusters e
Regras de
Associao
Descrio
Clcula o Fan-In
para determinar
espalhamento
de cdigo
Busca por
padres re-
correntes nos
rastros de
execuo
Busca por
padres re-
correntes no
grafo de
fluxo de
Controle
Identifica c-
digo duplica-
do utilizando
rvore sint-
tica abstrata
Identifica c-
digo duplica-
do utilizando
grafo de de-
pendncia
Agrupa cen-
rios de exe-
cuo com
desempenho
semelhante
Tipo de
Anlise
Esttica Dinmica Esttica Esttica Esttica Dinmica
Granula-
ridade
Mtodos Mtodos Mtodos
Fragmentos
de cdigo
Fragmentos
de cdigo
Mtodos
Sintoma
Analisado
Espalhamento
de Cdigo
Espalhamen-
to de Cdigo
Espalha-
mento de
Cdigo
Espalhamen-
to de Cdigo
Espalhamen-
to de Cdigo
Espalhamen-
to de Cdigo
Envolvi-
mento do
Usurio
Selecionar
candidatos a
aspectos de
uma lista
Examinar
padres
recorrentes
Examinar
padres
recorrentes
Examinar tre-
chos de cdi-
gos conside-
rados clones
Examinar tre-
chos de cdi-
gos conside-
rados clones
Examinar
clusters
resultantes

34
Neste captulo, foram apresentadas algumas tcnicas encontradas na literatura com o
objetivo de identificar indcios de interesses transversais no cdigo fonte de softwares
orientados a objetos. Para cada abordagem estudada, os autores foram identificados, os
pr-requisitos necessrios para entendimento da tcnica foram esclarecidos e critrios de
comparao foram aplicados. Alm disso, foram utilizados exemplos com o intuito de
melhor ilustrar o funcionamento das tcnicas.
Por causa do aperfeioamento e considervel desenvolvimento das pesquisas
relacionadas a identificao de interesses transversais, o nmero de tcnicas de minerao
de aspectos propostas tem crescido bastante. Com o objetivo de identificar de forma mais
clara e simples as semelhanas e as diferenas entre as principais tcnicas, ao final do
captulo foi apresentado um quadro resumo com as categorias definidas por [Kellens et al.,
2007] utilizadas para agrupar e comparar tcnicas de minerao de aspectos.

35
4. FERRAMENTAS DE APOIO AO DESENVOLVIMENTO
A utilizao de ferramentas computacionais durante as etapas de desenvolvimento de
novos aplicativos comumente incentivada e bastante difundida em razo dos benefcios
que elas podem porporcionar. Um das principais vantagens a minimizao do tempo
gasto no projeto, pois uma determinada funo pode ser implementada utilizando um
cdigo pronto, eficiente, estvel e que atende as necessidades do projeto. As ferramentas
computacionais utilizadas na implementao dos plug-ins desenvolvidos neste trabalho so
comentadas nesse captulo.
Breve histria e a arquitetura da plataforma IDE
2
Eclipse so resumidas na Seo
4.2. O plug-in Java Development Tools apresentado na Seo 4.3. Ferramentas
computacionais utilizadas para a implementao dos plug-ins so descritas na Seo 4.4.
4.2. Plataforma IDE Eclipse
A empresa Object Technology International (OTI) foi a responsvel pelo
desenvolvimento do cdigo Java que forma a base do Eclipse. Posteriormente, em meados
de 1996, a International Business Machines (IBM) comprou a OTI para dar incio aos
trabalhos sobre o cdigo do Eclipse visando a integrao de suas diversas ferramentas de
acordo com os padres definidos pelo Object Management Group (OMG), o qual produz e
mantm especificaes de interoperabilidade entre aplicaes [Geer, 2005].
Para a comunidade de desenvolvimento de software, o termo Eclipse normalmente
est associado com o Eclipse Software Development Kit (Eclipse SDK), lder entre os
ambientes integrados de desenvolvimento Java [IBM, 2006], e com a ferramenta para
construo de produtos baseados na plataforma Eclipse. O Eclipse SDK (doravante,
Eclipse) uma combinao de esforos de diversos projetos, incluindo Java Development
Tools (JDT) e Plug-in Development Environment (PDE). O Eclipse Platform (doravante,
Plataforma) uma composio de componentes com as funes necessrias para construir
uma IDE.

2
Integrated Development Environment

36
Uma das principais vantagens em utilizar a Plataforma a possibilidade de
integrao entre diversas ferramentas e de executar em mltiplos sistemas operacionais.
Por exemplo, a Plataforma torna-se uma IDE para desenvolvimento Java adicionando o
plug-in JDT, assim como se torna um ambiente para desenvolvimento C/C++ ao adicionar
o plug-in C/C++ Development Tools (CDT). Esta caracterstica pode ser muito til
principalmente para organizaes que desejam integrar grandes projetos que utilizam
vrias tecnologias. Plug-ins so pacotes estruturados de cdigo-fonte e/ou dados que
contribuem para a funcionalidade do software, representando cdigos de bibliotecas
(classes Java com API
3
pblica), extenses da plataforma e, at mesmo, documentao.
Alm disso, plug-ins podem definir pontos de extenso, isto , locais bem definidos em
que outros plug-ins podem adicionar funcionalidade [Kawakami, 2007].
A Plataforma construda com um mecanismo de descoberta, integrao e execuo
de plug-ins que seguem especificaes Open Services Gateway initiative (OSGi
4
). Um
desenvolvedor cria ferramentas adicionais que operam em arquivos de configurao do
workspace e workbench e as insere no diretrio de plug-ins do Eclipse. Quando a
Platforma executada, o diretrio verificado pelo Platform Runtime e os arquivos de
configurao dos plug-ins so lidos para que sejam construdos seus registros em memria.
Ao final do processo de iniciao, o usurio provido de um ambiente de desenvolvimento
composto de um conjunto de plug-ins.
Para desenvolver interfaces grficas personalizadas, o Eclipse equipado com os
toolkits Standar Widget Toolkit (SWT) e JFace fornecidos pelo workbench. A estrutura do
Eclipse com esses componentes ilustrada na Figura 4-1. Essa figura inclui a plataforma
bsica do Eclipse e ferramentas teis para o desenvolvimento de plug-ins (JDT), que
implementa um ambiente de desenvolvimento Java completo, e o ambiente desenvolvedor
de plug-in (PDE), que acrescenta ferramentas especializadas para organizar o
desenvolvimento de plug-ins e extenses. Os componentes nomeados Plug-in
representam outros plug-ins desenvolvidos e conectados ao Eclipse com o objetivo de
estender sua funcionalidade e atender solicitaes de um projeto ou ambiente de trabalho
especficos.

3
Application Programming Interface
4
http://osgi.org

37

Figura 4-1 - Arquitetura da Plataforma Eclipse
4.3. Plugin Java Development Tools
O plug-in JDT est includo no Eclipse e adiciona capacidades Plataforma
transformando-a em ambiente de desenvolvimento Java com diversos recursos. A seguinte
lista sumariza algumas funes implementadas pelo JDT [JDT, 2011]:
Organizar cdigos fonte Java, bibliotecas de arquivos .jar (Java ARquive - JAR) e
outros recursos necessrios aos usurios em estruturas de projetos. Alm disso, isolar
os arquivos binrios (.class) em de diretrios exclusivos;
Permitir navegao em projetos Java em termos de pacotes, classes, mtodos e
atributos;
Dispor de um editor de cdigo fonte com diferentes marcaes para palavras
reservadas da linguagem de programao Java e identificadores de classes, de atributos
e de mtodos criados pelo desenvolvedor. Fornecer, ainda, eficiente visualizao de
erros e avisos de compilao utilizando anotaes na margem do editor;
Possuir API de ajuda para exibir documentao no padro Javadoc de elementos
selecionados pelo usurio, ferramentas de auto-complete e assistentes para criar e
organizar declaraes de import de bibliotecas;
Fornecer ferramentas de refatorao de cdigo para extrao e edio de assinatura de
mtodos, atualizao de referncias e pr-visualizao de modificaes;
Acionar o compilador Java automaticamente aps modificaes no cdigo fonte e
informar erros em um painel especfico;
Executar programas Java possibilitando comunicao do usurio com fluxos de entrada
e sada mediante o uso do console;

38
Fornecer ferramenta de debug que permita adicionar pontos de interrupo em mtodos
e inspeo de atributos e variveis locais.
O JDT implementado no Eclipse por um conjunto de plug-ins em uma arquitetura
que garanta a separao entre as unidades de interface com usurio e as unidades do ncleo
do JDT [IBM, 2006]. Esta arquitetura e as principais conexes entre a Plataforma e o JDT
ilustrada na Figura 4-2.

Figura 4-2 - Conexes entre o Plataforma e o JDT [Chapman, 2006]
A estrutura JDT UI (org.eclipse.jdt.ui) presente nessa arquitetura a unidade
responsvel por tratar a comunicao com o usurio. Ela define reas ou vises onde o
usurio pode editar o cdigo fonte Java, visualizar informaes dos projetos, pacotes e
bibliotecas JAR, criar novos projetos, alterar atributos de configurao, dentre outras
funes. Ao JDT Core (org.eclipse.jdt.core), compete executar funes mais
rduas como compilao, debug e refatorao. Alm disso, sua utilizao no dependente
de uma biblioteca grfica em particular, o que possibilita seu aproveitamento como um
mdulo separado do JDT.
4.4. Outras Ferramentas
Durante o desenvolvimento dos plug-ins, alguns softwares com funes especficas
foram utilizados para implementar pontos particulares do projeto, com o objetivo de
alcanar melhores resultado e abreviar o tempo de desenvolvimento. Foram desenvolvidos

39
trs plug-ins que correspondem a trs tcnicas semnticas de minerao de indcios de
interesses transversais em softwares orientados a objetos.
Para implementao da tcnica deteco de clones utilizando rvore de sinttica
abstrata, foi utilizado o software JCCD
5
(A Flexible Java Code Clone Detector API)
[Biegel; Diehl, 2010] para encontrar os Trechos Clones no cdigo fonte (trechos de cdigo
similares). Em seguida, as mtricas descritas no Captulo 3 foram aplicadas para encontrar
os candidatos a aspectos. O JCCD baseado em uma arquitetura de pipeline criado a partir
da AST, tal arquitetura permite substituir qualquer parte do processo de deteco de clones
sem alterar o pipeline como um todo. Esta caracterstica possibilita utiliz-lo na
implementao de novas tcnicas de deteco de clones, bem como avaliar novos
conceitos relacionados ao assunto. Alm disso, o JCCD utiliza pr-processadores e
comparadores em diferentes fases do pipeline. Pr-processadores so utilizados para
generalizar o cdigo fonte original por meio da deleo de ns da rvore e comparadores
so utilizados para identificar declaraes de mtodos semelhantes ignorando seus nomes.
Outra ferramenta utilizada foi Zest
6
[Bull et al., 2004] que consiste em um conjunto
de componentes de visualizao construdos especialmente para o Eclipse. Zest foi
desenvolvida utilizando componentes grficos SWT/Draw2D (bibliotecas grficas)
presentes no Eclipse, o que permite uma integrao perfeita com o ambiente de
desenvolvimento. O principal objetivo da Zest proporcionar rpida e simples criao de
ferramentas para visualizao de grafos os quais podem ser apresentados em diferentes
layouts, abrangendo estrutura hirrquia de rvore, estrutura radial, em grade e spring. Zest
foi utilizado para visualizar a estrutura de chamadas de mtodos das tcnicas Fan-In e
Anlise do Grafo de Fluxo de Controle. Os resultados da tcnica Fan-In so exibidos de
forma que cada n do grafo representa um mtodo chamado e os mtodos declarados
dentro da mesma classe so dispostos com a mesma cor. De forma semelhante
implementao da tcnica Fan-In, na Anlise de Grafo de Fluxo de Controle, os mtodos
do software so representados em forma de ns do grafo, sendo que cada cor representa a
classe onde o mtodo foi declarado. Um exemplo de como a Zest foi utilizada
apresentada na Figura 4-3.

5
http://sourceforge.net/projects/jccd/files/jccd-1.0.6.tar.gz/download
6
http://www.eclipse.org/gef/zest/

40
Para uma melhor visualizao dos resultados da tcnica de Anlise do Fluxo de
Controle foi utilizada a ferramenta Visualiser, presente no plugin AJDT (AspectJ
Development Tools) desenvolvido para o Eclipse. O AJDT est para o desenvolvimento de
projetos usando a linguagem de programao AspectJ assim como o JDT est para projetos
Java. As funes mais importantes adicionadas por esse plug-in esto relacionadas
visualizao do comportamento tranversal das linguagens de programao orientadas a
aspectos, incluindo ambientes para visualizar informaes pontuais do software e
informaes em um contexto global, possibilitando uma viso geral do software.

Figura 4-3 - Visualizao de Mtodos com a Ferramenta Zest
A Visualiser uma View do Eclipse que prov uma apresentao visual de um
projeto selecionado consistindo de uma rea com vrias colunas dispostas verticalmente,
sendo cada coluna relacionada a um arquivo fonte. O tamanho das colunas proporcional
quantidade de linhas de cdigo do arquivo e listras so inseridas em posies apropriadas
para representar os locais no cdigo onde um advice est atuando. No entanto, para o
desenvolvimento dos plug-ins propostos neste trabalho, a Visualiser foi utilizada com o
intuito de evidenciar Trechos Clones entre si, o que permite ao usurio ter uma viso de
como os clones afetam o software. Um exemplo da utilizao da Visualiser apresentada
na Figura 4-4.

41

Figura 4-4 - Visualizador de Aspectos [Chapman, 2006]
Este captulo apresentou os principais componentes do ambiente de desenvolvimento
Eclipse dando nfase aos conceitos de Eclipse SDK e Eclipse Platform, bem como a forma
de integrao e de execuo de plug-ins utilizada pelo Eclipse Platform. Alm disso, foram
citados os principais componentes de criao de interfaces grficas disponveis no Eclipse:
SWT e JFace.
Foram apresentados neste captulo breve resumo sobre o incio do processo de
desenvolvimento do cdigo fonte do eclipse e as empresas envolvidas. Posteriormente, o
plug-in para desenvolvimento Java (JDT) foi apresentado e suas principais caractersticas
evidenciadas, ressaltando sua arquitetura e sua forma de integrao com a Plataforma
Por fim, foram descritas as ferramentas com funes especficas utilizadas durante as
etapas de desenvolvimento deste trabalho. Uma ferramenta para deteco de clones em
cdigo fonte Java (JCCD), uma biblioteca de componentes grficos para o Eclipse (Zest), e
uma ferramenta para visualizar cdigo fonte em forma de barras e listras (View
Visualiser).

42
5. TRABALHOS RELACIONADOS
Percebe-se que h algumas referncias na literatura sobre ferramentas para
minerao de aspectos. Este captulo apresenta, sucintamente, alguns trabalhos
relacionados.
William G. Griswold, Jimmy J. Yuan e Yoshikiyo Kato criaram uma das primeiras
ferramentas com o propsito de identificao de interesses transversais no cdigo fonte,
denominada Aspect Browser [Griswold et al., 2001]. Aspect Browser utiliza um padro
lxico para consultar o cdigo fonte e mapas para manipulao e representao de
resultados. Alm disso, Aspect Browser usa o Grep internamente viabilizando consultas
complexas por meio de expresses regulares, o que o torna uma ferramenta poderosa,
mesmo utilizando padres lxicos do cdigo fonte. Para utilizar a Aspect Browser, o
usurio deve fornecer uma sequncia de caracteres a qual deseja consultar e, em seguida,
ela apresenta ao usurio uma viso do software por meio de barras verticais indicando os
arquivos que contm a sequncia fornecida como entrada. Uma viso geral da ferramenta
apresentada na Figura 5-1.

Figura 5-1 - Viso Geral do Aspect Browser [Griswold et al., 2005]

43
possvel notar na parte esquerda uma View chamada Aspect Tree onde o usurio
pode criar/editar aspectos encontrados a partir da expresso Grep informada; nessa View,
informaes sobre o cdigo fonte em anlise so apresentadas. Na parte central, uma
representao grfica em alto nvel dos pacotes e arquivos do software apresentada na
View Visualization and Navigation, o que permite ao usurio analisar a modularizao e o
entrelaamento de cdigo fonte. Alm disso, o editor de cdigo fonte apresentado,
destacando o trecho que o usurio analisa.
O software chamado AMT (Aspect Mining Tool) desenvolvido por Jan Hannemann e
Gregor Kiczales analisa o cdigo fonte buscando por padres lxicos [Hannemann;
Kiczales, 2001]. No entanto, o AMT permite realizar consultas estruturais considerando
tipos de dados encontrados no cdigo. Tal abordagem um avano com relao ao Aspect
Browser, mas no estvel, pois, se muitas instncias de um mesmo tipo forem utilizadas
para diferentes propsitos, essa abordagem torna-se insatisfatria. Alm das anlises
lxicas e estruturais, o ATM pode ser extendido com outros tipos de anlises, por exemplo,
anlises baseadas na assinatura. Assim, o AMT considerado um conjunto de ferramentas
multi-modal, o que permite o uso combinado de vrias tcnicas. Cada anlise funciona
como uma consulta e o resultado visualizado no cdigo fonte como um conjunto de
linhas semelhantes.
A ferramenta FEAT (Feature Exploration and Analysis Tools) desenvolvida por
Martin P. Robillard e Gail C. Murphy permite a localizao e classificao de interesses
transversais no cdigo fonte por meio de uma abordagem denominada Concern Graphs
[Robillard; Murphy, 2007]. Para tanto, ela utiliza tipos de dados, mtodos e atributos
encontrados no cdigo fonte na gerao do seu modelo. A FEAT foi implementada como
um plug-in para o Eclipse e uma de suas principais vantagens a possibilidade de ser
utilizada para registrar conhecimento sobre o cdigo fonte. Uma vez criados, os interesses
transversais podem ser armazenados e associados entre si verificando suas interaes e
existncia de interdependncia. A FEAT no Eclipse apresentada na Figura 5-2.
A View Concern Graph apresentada na parte superior esqueda da Figura 5-2 mostra
hierarquicamente os interesses transversais e permite ao usurio edit-los. Ao selecionar
um interesse transversal, os seus participantes so apresentados na View Participants, na
parte superior central da Figura 5-2. Aps selecionar um item na View Participants, o

44
usurio pode utilizar a View Projection para adicionar relacionamentos entre o participante
atual e qualquer outro participante do interesse transversal selecionado na View Concern
Graph. Alm disso, com o cdigo fonte do participante selecionado apresentado em um
editor de cdigos na parte inferior da Figura 5-2.

Figura 5-2 - Viso Geral da Ferramenta FEAT [Novais, 2009]
Outra ferramenta criada para o Eclipse chamada FINT, seus autores so Marius
Marin, Leon Moonen e Arie van Deursen [Marin et al., 2006], com a qual a ferramenta
desenvolvida neste trabalho compartilha vrias semelhanas. A FINT mantida pelos
integrantes do SERG (Software Engineering Research Group) sob a liderana de Arie van
Deursen e a verso mais recente o FINT 0.6. A FINT implementa trs tcnicas de anlise
de cdigo: i) Fan-In; ii) Grouped Call; e iii) Redirections Finder. As duas primeiras
relacionadas com a identificao de interesses transversais implementados por chamadas
de mtodos espalhadas pelo cdigo fonte do software, como logging, persistncia e
tratamento de excees. A Redirections Finder est relacionada com a busca por classes
cujos mtodos redirecionam chamadas para mtodos da mesma ou de outras classes. A
FINT como parte do Eclipse apresentada na Figura 5-3.
A rea de visualizao do Eclipse dividida pelo FINT de modo a apresentar as
Views das trs tcnicas implementadas no plug-in e uma View para o editor de cdigo Java,

45
no qual o usurio pode vizualizar a declarao de um determinado mtodo ao selecionar
uma das Views. Para a tcnica Redirections Finders, so apresentadas as classes
redirecionadoras e receptora do redirecionamento como razes de conjunto de mtodos
dessas classes, em um relacionamento um-para-um. Os resultados da tcnica Grouped Call
so apresentados utilizando a view Cloned Calls, onde os mtodos so agrupados de forma
que os ns em uma mesma hierarquia so os mtodos chamados pelo mtodos na
hierarquia imediatamente superior. Na view da tcnica Fan-In, os mtodos so agrupados
de forma que os ns filhos so mtodos chamados pelo mtodo na hierarquia superior.

Figura 5-3 - Viso Geral do FINT [Marin, 2008]
Analisando os trabalhos apresentados, possvel notar que seus desenvedores
buscam sempre utilizar ferramentas existentes e bem fundamentadas como base para seus
trabalhos. Isso pode ser percebido pelo fato de vrias ferramentas utilizarem o Eclipse
como plataforma base, uma vez que este fornece diversas facilidade relacionadas
inspeo do cdigo fonte em anlise.

46
6. APOIOS COMPUTACIONAIS PARA IDENTIFICAR INDCIOS DE
INTERESSES TRANSVERSAIS EM CODIGO FONTE JAVA
A identificao de indcios de interesses transversais em softwares implementados na
linguagem de programao Java requer habilidade e conhecimento por parte do engenheiro
de software envolvido [Kawakami, 2007]. Assim, no Captulo 3, algumas das principais
tcnicas semnticas para deteco de indcios de interesses transversais foram descritas e
estudadas de forma a fornecer maior entendimento de suas caractersticas e explicar como
podem ser utilizadas para obter conhecimento sobre o software em anlise.
De forma a agilizar e facilitar o processo de entendimento do software, foi
desenvolvido neste trabalho um conjunto de ferramentas computacionais para auxiliar
engenheiros de software e desenvolvedores a descobrirem funes do software que podem
estar espalhadas pelo cdigo fonte de seus mdulos. Trs tcnicas semnticas de minerao
de aspectos foram escolhidas e implementadas em forma de plug-ins para o Eclipse: i)
Anlise Fan-In; ii) Anlise do Grafo de Fluxo de Controle; e iii) Deteco de Clones
utilizando AST.
A deciso de quais tcnicas seriam implementadas foi tomada considerando o tipo de
dado necessrio para a sua computao. Considerando que o cdigo fonte do software
um dos elementos a ser estudado para encontrar os interesses transversais presentes no
cdigo fonte, as trs tcnicas de anlise esttica foram selecionadas para implementao.
Alm disso, a existncia de ferramentas para auxiliar no processo de desenvolvimento
influnciou a deciso.
Uma viso geral dos apoios computacionais (plug-ins) desenvolvidos apresentada
na Seo 6.2. Algumas caractersticas de implementao comuns aos plug-ins
implementados so detalhadas na Seo 6.3. A funcionalidade disponvel nos plug-ins
denominados Fan-In, Flow Graph e AST Clone so apresentadas na Seo 6.4, na Seo
6.5 e na Seo 6.4, respectivamente.

47
6.2. Viso Geral dos Apoios Computacionais
Os apoios computacionais desenvolvidos foram implementados na linguagem de
programao Java e integrados ao Eclipse como plug-ins. As principais razes que
justificam essa integrao so:
Utilizao de bibliotecas. O Eclipse contm grande nmero de bilbiotecas que podem
ser utilizadas por outros softwares caso sejam implementados como plug-ins deste
ambiente. Alm disso, utilizar o Eclipse e suas bibliotecas para implementar novos
produtos possibilita adaptao rpida do usurio nova ferramenta, visto que ele est
ambientado com a aparncia e caracterstica do Eclipse;
Uso de extenses. possvel desenvolver novas funes e ao mesmo tempo conseguir
economia na quantidade de linhas de cdigo utilizando pontos de extenso definidos
por outros plug-ins do Eclipse;
Anlise sinttica do cdigo-fonte. Utilizando classes do Eclipse e do JDT, possvel
percorrer uma estrutura de dados similar a da AST sem que seja necessria a criao de
um compilador para a sua construo e a sua manipulao. Com isso, a implementao
agilizada e a confiabilidade do apoio computacional maior, pois as classes do
Eclipse e de seus plug-ins esto estveis;
Ambiente de desenvolvimento amplamente utilizado. O Eclipse um dos ambientes
de desenvolvimento mais utilizados pela comunidade de desenvolvedores em Java, o
que favorece a utilizao do apoio computacional.
A instalao dos apoios computacioanis simples, entretanto depende da instalao
prvia dos componentes Java 2 Plataform Standard Edition 6.0 Development Kit (JDK
6.0), IDE Eclipse 3.4 e Plug-in AJDT 2.1.
Os trs apoios computacionais desenvolvidos foram implementados na forma de
plug-ins que trabalham independentemente:
br.ufla.dcc.plugin.ASTClone. Esse plug-in implementa a tcnica de deteco de
indcios de interesses transversais por meio da deteco de clones utilizando rvore
sinttica abstrata, doravante Plug-in AST Clone;
br.ufla.dcc.plugin.FanIn. Esse plug-in implementa a tcnica de deteco de indcios
de interesses transversais utilizando a mtrica Fan-In, doravante Plug-in Fan-In;

48
br.ufla.dcc.plugin.FlowGraph. Esse plug-in implementa a tcnica de deteco de
indcios de interesses transversais utilizando grafo de fluxo de controle, doravante
Plug-in Flow Graph.
6.3. Caractersticas de Implementao Semelhantes aos Plug-ins
Para possibilitar que o usurio acione as suas funes, os trs plug-ins as
disponibilizam por meio da implementao da interface
IworkbenchWindowActionDelegate, a qual pertence ao pacote org.eclipse.ui e
disponibilizada pela extenso org.eclipse.ui.actionSets. As aes so apresentadas ao
usurios em forma de botes presentes na barra de ferramentas principal do eclipse.
Para utilizar os plug-ins e iniciar a deteco dos indcios de interesses transversais de
forma correta, necessrio ter um projeto selecionado no View Package Explorer. Aps
selecionar um projeto, pode-se selecionar a tcnica de deteco desejada por pressionar o
boto de ao correspondente. Em seguida, o projeto selecionado pelo usurio capturado
e inicia-se o processo de deteco. Cada plug-in implementado possui Views utilizados
para apresentar os resultados ao usurio. Antes de iniciar a anlise do cdigo fonte, o plug-
in instancia o View correspondente e mostra-o no Eclipse. Dessa forma, ao concluir o
processamento do cdigo, os resultados podem ser exibidos no View visvel ao usurio.
Com o objetivo de promover a separao entre o cdigo fonte de implementao das
aes e o cdigo fonte correspondente implementao das tcnicas, os plug-ins utilizam
objetos controladores que recebem a instncia do projeto selecionado pelo usurio e passa-
a ao objeto responsvel por analisar o cdigo fonte. Desta forma, o cdigo fonte da tcnica
completamente independente da forma como o usurio interage .
6.4. Plug-in Fan-In
O Plugin Fan-In analisa o projeto escolhido pelo usurio de forma semelhante a um
visita em pr-ordem nos arquivos do projeto. Em cada arquivo, o plug-in recupera as
classes Java e seus respectivos mtodos. Em seguida, cada corpo de mtodo analisado de
forma a verificar e armazenar as chamadas de mtodos existentes. Feito isso, o plug-in
analisa a hierarquia de classes para calcular o Fan-In dos mtodos chamados
polimorficamente e, em seguida, marcadores so criados no editor de cdigo fonte Java na
linha correspondente ao local de declarao do mtodo. Desta forma, ao navegar pelo

49
cdigo fonte, o usurio pode perceber os mtodos que possuem alto valor de Fan-In e seu
respectivo nmero de chamadores. Um exemplo de marcador no editor de cdigo fonte
para destacar um mtodo com alto valor de Fan-In apresentado na Figura 6-1. O destaque
dado ao mtodo getStudents() da classe Teacher declarado na linha 22. Ao
posicionar o ponteiro do mouse sobre o marcador, uma mensagem apresentada
mostrando a quantidade de chamadores do mtodo.

Figura 6-1 - Marcador do Plug-in Fan-In
Alm das informaes no editor de cdigo Java, o Plug-in Fan-In fornece outras
formas para visualizar os resultados. Dois Views so criados no Eclipse os quais
apresentam: i) informaes gerais sobre os resultados; e ii) informaes para um mtodo e
seu conjunto de chamadores. O primeiro View tem o ttulo Methods View e suas principais
informaes so apresentadas em duas listas. A primeira lista mostra o conjunto de
mtodos com maiores valores de Fan-In. Ao selecionar um mtodo desta lista, a segunda
lista preenchida com os chamadores do mtodo selecionado. Alm dessas informaes, o
Methods View apresenta o total de mtodos com alto valor de Fan-In, o nmero total de
chamadores para cada mtodo e o nmero de classes distintas entre os chamadores. O
Methods View aps a anlise de um determinado projeto apresentado na Figura 6-2.

Figura 6-2 - Methods View no Eclipse
H tambm no primeiro View uma opo para visualizar o grafo que representa um
mtodo e seus chamadores. Ao selecionar um mtodo da primeira lista, o segundo View

50
apresentado ao usurio (Graph View) o qual exibe um grafo, cujos ns so caixas de texto
com o nome do mtodo e da classe onde foi declarado, seguindo o padro
NomeDaClasse.nomeDoMtodo. O n central o mtodo escolhido pelo usurio e os ns
que o cercam so seus respectivos chamadores. Os ns coloridos de uma mesma cor
represetam mtodos declarados em uma mesma classe. Um caso em que o Graph View
utilizado para exibir o grafo de chamadores de um determinado mtodo apresentado na
Figura 6-3.

Figura 6-3 - Graph View no Eclipse
Alm de colocar o Graph View em primeiro plano, para o usurio visualize o grafo, o
boto Visualizar Grafo faz com que o mtodo escolhido pelo usurio seja apresentado no
editor de cdigo Java. Caso o mtodo no tenha sido declarado pelo desenvolvedor, uma
mensagem apresentada informando que o mtodo no est declarado no projeto. Tal
situao ocorre, por exemplo, quando um mtodo da API Java possui um alto Fan-In e
detectado pela anlise. Como o cdigo fonte de um mtodo da API Java pode no ser
encontrado no projeto do usurio, ele no pode ser visualizado no editor. Dessa forma, uma
mensagem mostrada ao usuario informado que o mtodo no foi declarado por ele.
6.5. Plug-in Flow Graph
A anlise inicial de cdigo no Plug-in Flow Graph realizada por meio de uma
busca em pr-ordem aos arquivos do projeto, verificando os mtodos das classes. No corpo
de mtodos, as chamadas internas e externas so verificadas e armazenadas. Aps o
clculo do nmero de relaes internas e externas, este plug-in cria marcadores no editor
de cdigo fonte para facilitar a visualizao do usurio quando estiver navegando pelo
cdigo. O valor Flow Graph informado no marcador calculado considerando a mdia

51
entre relaes internas e externas. Este o mesmo clculo feito para ordenar os mtodos
para posterior apresentao na lista de mtodos com maior caracterstica transversal. Um
marcador no editor de cdigo apresentado na Figura 6-4.

Figura 6-4 - Marcadores do Plug-in Flow Graph
Os dois Views criados pelo Plug-in Flow Graph so semelhantes aos criados pelo
Plug-in Fan-In. O primeiro View apresenta uma viso geral dos resultados (Methods Count
View) e o segundo exibe informaes para um determinado mtodo selecionado pelo
usurio (Flow Graph View). O Methods Count View segue a forma apresentada na Figura
6-5, uma lista contendo os mtodos com comportamento transversal apresentada, campos
de texto informam a quantidade de relaes internas e externas para cada mtodo
selecionado pelo usurio e o nmero de classes distintas dentro de cada relao.

Figura 6-5 - Methods Count View no Eclipse
Ao escolher um mtodo da lista e selecionar o boto Visualizar Grafo, o Flow
Graph View colocado em primeiro plano para o usurio analise o grafo, cujos mtodos,
que compem uma relao interna com o mtodo selecionado, possuem arestas apontando
para ele e mtodos que compem relaes externas so ligados ao mtodo selecionado por

52
arestas saindo dele (Figura 6-6). Alm de mostrar ao usurio o grafo das relaes internas e
externas, o boto Visualizar Grafo responsvel por fazer com que o mtodo
selecionado pelo usurio seja apresentado no editor de cdigo fonte, como feito no Plug-
in Fan-In.

Figura 6-6 - Marcadores do Plug-in Flow Graph
6.6. Plug-in AST Clone
O Plug-in AST Clone inicia sua execuo de forma semelhante execuo dos plug-
ins descritos anteriormente. No entanto, durante a anlise do cdigo fonte do software, o
corpo dos mtodos no verificado. A busca em pr-ordem e percorre at encontrar os
arquivos do projeto, pois a anlise do contedo dos arquivos feita pela ferramenta JCCD
[Biegel; Diehl, 2010].
Aps encontrar os arquivos do software, o Plug-in AST Clone os passa para o JCCD,
detector de clones utilizando AST, para encontrar os trechos similares entre os arquivos.
Estes trechos so separados em grupos de similaridade contendo informaes de quais
arquivos e respectivos trechos so clonados (Trechos Clones). Posteriormente, o Plug-in
AST Clone faz o clculo da mtrica a fim de verificar quais blocos de cdigo mais afetam
no comportamento transversal do software. Para realizar o clculo, o tamanho de cada
clone considerado como 40% do valor e o nmero de arquivos afetados tem relevncia de
60% no valor final da mtrica. Essa proporo em decorrncia da quantidade de arquivos
afetados por um clone ser mais importante que o tamanho dos clones.

53
O Plug-in AST Clone utiliza o valor da mtrica para acrescentar informaes no
editor de cdigo por meio da criao de marcadores na barra lateral do editor Java. Um
exemplo de marcadores utilizando o Plug-in AST Clone apresentado na Figura 6-7.

Figura 6-7 - Marcadores do Plug-in AST Clone
O Plug-in AST Clone utiliza outros Views, alm dos contidos no Eclipse para
fornecer informaes aos seus usurios. Um dos Views foi criado especialmente para o
Plug-in AST Clone e outros dois so utilizados a partir de pontos de extenso do plug-in
AJDT. O View criado chamado Clones View e apresenta um conjunto de informaes
sobre (i) os grupos de arquivos clones, (ii) o tipo do bloco de cdigo similar dentro do
grupo de arquivos, (iii) o valor da mtrica calculada, (iv) o nmero da linha inicial do
trecho clonado e (v) o nmero da linha final do trecho clonado. O tipo do bloco
informado e segue o padro de nomenclatura utilizada na implementao da ferramenta
Antlr
7
, a qual utilizada internamente pelo JCCD. Um caso em que o Clones View foi
utilizado para exibir os resultados da anlise de um determinado projeto apresentado na
Figura 6-8.
Para facilitar o processo de localizao dos Trechos Clones, o Plug-in AST Clone
permite ao usurio visualizar no editor Java o bloco de cdigo clonado, semelhante
maneira como feito para os plug-ins anteriormente citados. Uma viso mais geral sobre
quanto os Trechos Clones afetam o sistema fornecida utilizando o View Visualizer
provido pelo Plug-in AST Clone. Como explicado em sees anteriores, o Viusalizer
8

permite anlise universal sobre o cdigo projeto.

7
www.antlr.org
8
http://www.eclipse.org/ajdt/visualiser/

54
Para utilizar o Visualiser no Plug-in AST Clone, View deve estar aberto e item que
agrupa os blocos de clones do Clones View deve ser selecionado. Para o caso mostrado na
Figura 6-9, ao selecionar o primeiro item da lista do Clones View (Tipo de bloco:
CONSTRUCTOR_DECL, valor da mtrica: 4) marcadores de cor vermelha so criados
no cdigo fonte dos Trechos Clones que correspondem a este grupo, permitindo que sua
exibio no Visualiser. Alm de marcar os trecho selecionados, outros Trechos Clones so
marcados em verde para o usurio verifique o quanto um determinado grupo de clones
afeta o software.

Figura 6-8 - Clones View no Eclipse

Figura 6-9 - View Visualiser do AJDT utilizado pelo Plug-in AST Clone
Para facilitar a visualizao, a cor verde foi substituida por linhas verticais e a cor
vermelha por linhas horizontais. Tais modificaes podem ser feitas a qualquer momento
utilizando o menu de preferncias do Visualiser. Como o Visualiser precisa carregar os
arquivos do projeto para apresentar as informaes, necessrio o usurio realizar o
recarregamento, selecionando um projeto e voltando a carregar o projeto de seu interesse.

55
Dessa forma, as alteraes feitas n cdigo ao selecionar um item do Clones View passam
a ser consideradas pelo Visualiser.
A construo de apoios computacionais para a deteco de interesses transversais
no uma atividade trivial, pois diversas caractersticas so imprescindveis em sua
concepo, tais como, facilidade de uso, compatibilidade com ambiente de
desenvolvimento integrado, desempenho, acurcia e portabilidade. Alm disso, deve
cumprir com sua tarefa fundamental, encontrar trechos de cdigo fonte que sejam indcios
de interesses transverais.
Considerando esssas caractersticas, os plug-ins desenvolvidos foram implementados
de forma independente, o que viabiliza melhoras futuras e permite acopl-los a um
conjunto mais extenso de ferramentas de minerao de aspectos. Alm disso, o
desenvolvimento separado de cada plug-in possibilita modularidade e manutenibilidade do
seu cdigo fonte.

56
7. ESTUDO DE CASO
Neste captulo, discutida a avaliao dos apoios computacionais desenvolvidos,
realizada por meio de anlises em softwares reais, e so brevemente comentadas algumas
questes relacionadas ao desempenho. Durante a avaliao, foram conduzidos
experimentos envolvendo o cdigo fonte de softwares da categoria sistema de informao
e de pequeno porte implementados na linguagem de programao Java: HealthWatcher
[Soares et al., 2002], JCCD, MVCExample
9
e Praec.
Objetivos e mtricas utilizadas para comparar tcnicas e implementaes so
enunciados na Seo 7.2. Detalhes da conduo do experimento so fornecidos na Seo
7.3. Resultados obtidos com a execuo dos plug-ins no cdigo fonte de softwares reais
so apresentados na Seo 7.4. Ainda na Seo 7.4, so mencionados e apresentados as
principais funes de cada software analisado, os resultados mais relevantes da execuo
de cada tcnica em cada software analisado, tabelas comparativas com os resultados da
execuo e grficos comparando o nmero de linhas e nmero de mtodos dos softwares
analisados com o tempo de execuo das tcnicas.
7.2. Objetivos e Mtricas
A anlise nos softwares orientados a objetos na linguagem de programao Java
citados anteriormente tm o objetivo de verificar a eficincia dos plug-ins desenvolvidos e
sua aplicabilidade em softwares reais. Alm disso, objetivo comparar as tcnicas a fim de
verificar qual delas aprensenta melhores resultados para o usurio. Para os trs plug-ins
implementados foram analisados (i) a escalabilidade, (ii) a cobertura dos resultados e (iii) o
tempo de execuo.
A escalabilidade foi estudada a relao entre o crescimento do nmero de linhas e o
crescimento do nmero de mtodos, visto que duas das trs tcnicas implementadas
oferecem como retorno os mtodos do software. O tempo de execuo foi medido a partir
da introduo de instrues no cdigo fonte para capturar o tempo antes e aps a execuo
do cdigo fonte referente anlise, desconsiderando o tempo gasto com apresentao dos
resultados. A cobertura est relacionada com a qualidade dos resultados apontados pelas

9
http://java.sun.com/developer/technicalArticles/javase/mvc/MVCExample.zip

57
tcnicas. No entanto, como os cdigos fonte no foram analisados manualmente e no
tinha especialista para verificar os resultados apresentados, a qualidade foi calculada
baseando-se no resultados encontrados pelas trs tcnicas. Assim, se a tcnica A no
encontrou um interesse transversal identificado pelas outras duas tcnicas, h indicao de
que a tcnica A falhou na cobertura desse interesse.
7.3. Conduo do Experimento
Para comparar a complexidade dos softwares analisados, foram calculadas para cada
software (i) a quantidade de classes, (iii) a quantidade de mtodos e (iii) o LOC
10

utilizando o software LocMetrics
11
.
Para capturar com fidelidade razovel a relao entre os tempos de execuo, cada
anlise foi executada trs vezes e a mdia entre os tempos foi calculada. Dessa forma,
espera-se maior confiabilida nos valores obtidos, uma vez que diversos fatores podem
influenciar a execuo do software. Para anlise Fan-In, foram comparados apenas os
mtodos declarado no softwares; assim, implementaes no pertencentes aos softwares
analisados foram desconsideradas nos resultados.
O equipamento utilizado para execuo do experimento foi um computador modelo
Asus N61J, com processador Intel(R) Core(TM) i5 M520 2.4GHz, 4 GB de memria RAM,
e sistema operacional Windows 7 Home Premium 64-bit. Durante a execuo, apenas o
Eclipse e os processos bsicos do sistema operacional estavam ativos.
7.4. Resultados Obtidos
O sistema MVCExample possui um total de 2350 linhas de cdigo, 10 classes Java e
96 mtodos. Foi desenvolvido exclusivamente para introduzir o conceito de
desenvolvimento em camadas seguindo o modelo Model-View-Controller. O software
possui a funcionalidade de um editor de texto no qual o usurio pode alterar a forma de
exibio do contedo do editor, por exemplo, tamanho e cor da fonte, rotacionar o texto e
alterar o tamanho da rea disponvel para entrada de dados.
Na execuo do Plug-in Fan-In, dez mtodos foram apontados como indcios de
interesses transversais, o que corresponde a aproximadamente 10% do total de mtodos do

10
Line of Code
11
http://www.locmetrics.com/

58
MVCExample. No entanto, sete destes no foram declarados pelos desenvolvedores, pois
fazem parte de APIs externas utilizadas no desenvolvimento, e no sero considerados nos
resultados. Dentre os trs mtodos identificados pelo Plug-in Fan-In, dois deles possuem
chamadores da mesma classe, ou seja, so mtodos da prpria classe que invocam mtodos
identificados na anlise: setModelProperty() da classe AbstractController, com
16 chamadores, e createFontFromDialog() da classe JfontChooserDialog, com 9
chamadores. O outro mtodo detectado, firePropertyChange() da classe
AbstractModel, possui 9 chamadores, mas de 2 classes distintas.
Para a execuo do Plug-in AST Clone, os trechos de cdigo encontrados pertencem
principalemente a mtodos de tratamento de eventos de interface e, em sua maioria, so da
classe PropertiesViewPanel. Os Trechos Clones mais significativos encontrados esto
presentes nas classes PropertiesViewPanel e DisplayViewPanel e tm, em mdia,
9 linhas semelhantes. Os Trechos Clones com mdia de 3 linhas de cdigo foram
encontrados nos mtodos da classe JFontChooserDialog.
Assim como no resultado obtido com o Plug-in Fan-In, a anlise utilizando o Plug-in
AST Clone indica trechos de cdigo da classe JfontChooserDialog como indcios de
interesses transversais. No entanto, os resultados produzidos indicam mtodos
responsveis por tratamento de eventos como possveis interesses transversais e no o
mtodo createFontFromDialog() indicado pelo Plug-in Fan-In.
Os resultados obtidos com a utilizao do Plug-in Flow Graph so mais prximos
dos resultados obtidos pelo Plug-in Fan-In. O mtodo com maior nmero de relaes o
createFontFromDialog() da classe JfontChooserDialog, com 13 relaes internas
e 1 relao externa. As relaes so com mtodos da mesma classe. Outros mtodos que
merecem destaque so firePropertyChange() da classe AbstractModel e o mtodo
setModelProperty() da classe AbstractController, pois foram encontrados pelo
Plug-in Fan-In. Os mtodos encontrados pelo Plug-in Flow Graph correspondem a 38 %
dos mtodos do software, sendo que no foram aplicados filtros como no caso do Plug-in
Fan-In.
Os principais resultados encontrados pelas anlises realizadas so sumarirados na
Tabela 7-1. Os campos marcados com x indicam que o mtodo, disposto na linha da

59
tabela, foi detectado pela tcnica, disposto na coluna da tabela. Para melhor interpretao e
comparao dos resultados produzidos pelas tcnicas, essa tabela apresenta resultados em
nvel de mtodos. No entanto, para a anlise baseada no Plug-in AST Clone, os resultados
podem ser observados em trechos de cdigo.
Tabela 7-1 - Sumarizao dos Resultados da Anlise no Software MVCExample
Mtodo Fan-In AST Clones Flow Graph
JFontChooserDialog.createFontFromDialog x x
AbstractModel.firePropertyChange x x
AbstractController.setModelProperty x x
DisplayViewPanel.DisplayViewPanel x
PropertiesViewPanel.PropertiesViewPanel x
PropertiesViewPanel.widthTextFieldActionPerformed x
O software Praec foi desenvolvido como trabalho da disciplina de Modelagem e
Implementao de Software ministrada aos alunos dos cursos de Cincia da Computao e
de Sistemas de Informao da Universidade Federal de Lavras. Esse software consiste
basicamente das funes de manuteno de cadastro de moradores e de residncias,
realizao de pagamentos e gerao de relatrios de pagamentos efetuados por moradores
em um determinado perodo. O cdigo do software composto por 254 mtodos, 26
classes e total de 5273 linhas de cdigo.
As trs anlises foram executadas no cdigo fonte desse software e resultados
semelhantes aos do MVCExample foram encontrados. O Plug-in Fan-In e o Plug-in Flow
Graph encontraram indcios de interesses transversais em mtodos relacionados com
persistncia de dados e comportamentos do modelo. Analisando o resultado por completo,
possvel notar que o Plug-in AST Clones detectou com maior eficincia os trechos de
cdigos relacionados com tratamentos de eventos. Alguns mtodos identificados pelos
plug-ins so apresentados na Tabela 7-2, de forma semelhante como foram aprensentados
os resultados na Tabela 7-1. Para o software Praec, o Plug-in Fan-In detectou interesse
transversal em cerca de 5% do mtodos do sistema, e o Plug-in Flow Graph em cerca de
22% dos mtodos.
Outro software utilizado na avaliao dos plug-ins foi o HealthWatcher, comumente
utilizado como um benchmark para estudos e experiementos relacionados as tecnologias de
OO e OA em diferentes nveis do processo de desenvolvimento. O HealthWatcher um

60
software web que coleta e gerencia informaes relacionadas a problemas do sistema de
sade. Os usurios podem acessar o software a partir de mquinas em locais pblicos e
realizar queixas ou pedir informaes sobre o sistema de sade. Quando da ocorrncia de
alguma queixa, esta atribuida a um departamento especfico e, assim que resolvida da
maneira apropriada, a resposta deve ser encaminhada ao usurio que a efetuou. O cdigo
fonte do HealthWatcher composto por 11644 linhas, distribudas em 894 mtodos e 135
classes.
Tabela 7-2 - Sumarizao dos Resultados da Anlise no Software Praec
ConnectionFactory.connect x x
ConnectionFactory.disconnect x x
Morador.getMatricula x
Apartamento.getNumero x
TelaConsultarMorador.consultar x
TelaRemoverMorador.consultar x
ActionListener.actionPerformed x
TelaEfetuarPagamento.btCancelarActionPerformed x
Morador.getNome x
MoradorDAO getInstance x
O cdigo fonte do HealthWatch foi anlisado pelos plug-ins e uma amostra dos
resultados apresentada na Tabela 7-3. possvel verificar a semelhana dos resultados
encontrados pelo Plug-in Fan-In e pelo Plug-in Flow Graph. O Plug-in Fan-In encontrou
cdigo transversal basicamente nas classes relacionadas a persistncia de dados, por
exemplo, IpersistenceMechanism; e classes da camada de controle, como o caso
da classe ServletResponseAdapter. O Plug-In Flow Graph detectou interesse
transversal na classe de persistncia IpersistenceMechanism, em classes da camada
de modelo do software, como o caso Complaint, e em classes relacionadas a padres
de projeto, caso da classe HealthWatcherFacade. No o software HealthWatcher, o
Plug-in Fan-In detectou interesse transversal em cerca de 3% do mtodos do sistema, e o
Plug-in Flow Graph em cerca de 25% dos mtodos.
O JCCD, diferentemente dos softwares analisados anteriormente, no possui meios
para interao com usurios finais, pois consiste de um conjunto de classes teis para a
realizao de tarefas relacionadas a deteco de clones. Ele possui apenas uma interface de

61
programao que pode ser utilizada por outros desenvolvedores para criar novas
ferramentas. Resultados simplificados da anlise do cdigo do JCCD pelos plug-ins so
apresentados na Tabela 7-4. Uma vez que esse software no possui interesses trasnversais
mais comuns encontrados na literatura, os resultados foram diferentes dos encontrados para
os softwares anteriores. Neste caso, o Plug-in Fan-In e o Plug-in Flow Graph encontraram
indcios de interesses transversais em mtodos de classes da camada de modelo, como o
caso da classe ANode. Assim como nos estudos anteriores, bastante clara a similaridade
dos resultados produzidos pelo Plug-in Fan-In e pelo Plug-in Flow Graph. No o software
JCCD, o Plug-in Fan-In detectou interesse transversal em cerca de 5% do mtodos do
sistema, e o Plug-in Flow Graph em cerca de 37% dos mtodos.
Tabela 7-3 - Sumarizao dos Resultados da Anlise no Software HealthWatcher
PersistenceMechanism.getCommunicationChannel x
IPersistenceMechanism.getCommunicationChannel x x
ServletResponseAdapter.getWriter x x
CommandResponse.getWriter x
ServletRequestAdapter.isAuthorized x
HealthUnit.notifyObservers x
Symptom.notifyObservers x
ComplaintRepositoryArray.getIndex x
SpecialityRepositoryArray.getIndex x
SpecialityRepositoryArray.next x
HealthUnitRepositoryArray.next x
HealthWatcherFacade.getPm x
Complaint.getCodigo x
Complaint.getSituacao x
PersistenceMechanism.getCommunicationChannel x

Tabela 7-4 - Sumarizao dos Resultados da Anlise no Software JCCD
ANode.getType x x
ANode.getChildCount x x
ANode.getChild x x
ASTManager.markChild x
ASTManager.getChildCountOfMarkedNode x x

62
CompareUnitThreading.checkNodeSimilarity x
ASTCompareUnit.checkNodeSimilarity x
JCCDEvaluation.countNodes x
APipeline.countNodes x
StandardPoolingStrategy.getPools x
TokenLengthPoolingStrategy.getPools x
ANode.getMarkedNode x
ANode.getParent x
Os tempos de execuo obtidos no experimento so descritos na Tabela 7-5. Cada
linha da tabela corresponde a um software analisado. Para cada software, os plug-ins foram
executados trs vezes e os tempos obtidos em segundos esto dispostos nas colunas T1, T2
e T3. A coluna Mdia corresponde mdia aritmtica dos trs tempos. As colunas Fan-
In, AST Clones e Flow Graph agrupam os resultados das trs medies de cada plug-in.
Tabela 7-5 - Tempo de Execuo dos Plug-ins
Softwares
Tempo de Execuo
Fan-In AST Clones Flow Graph
T1 T2 T3 Mdia T1 T2 T3 Mdia T1 T2 T3 Mdia
MVCExample 19 17 17 17,7 1 1 1 1 1 1 1 1
Praec 67 68 67 67,3 1 1 1 1 1 1 1 1
HealthWatche 225 221 240 228,7 4 1 1 2 4 1 1 2
JCCD 80 79 79 79,3 1 1 1 1 2 1 1 1,3
Para analisar a escalabilidade de cada tcnica implementada, os tempos de execuo
foram obtidos e dois grficos foram elaborados para melhor visualizar os resultados. Esses
grficos so apresentados na Figura 7-1 e na Figura 7-2, os quais mostram a relao entre a
quantidade de mtodos do software e quantidade de LOC com o tempo gasto na execuo.
Nessas figuras, os valores no eixo X foram gerados utilizando valores das mtricas
calculadas para os quatro softwares analisados. Ou seja, para a anlise do Tempo(s) em
funo do Nmero de Mtodos, os quatro softwares foram ordenados de acordo com a
quantidade de mtodos presentes no cdigo e seus respectivos tempo de execuo foram
calculados. Em seguida, os grficos foram montados para observar o comportamento de
tempo de execuo dos plug-ins em relao ao crescimento do nmero de mtodos no
software. Processo semelhante foi feito para obter um viso do tempo gasto na execuo de
acordo com o crescimento do nmero de linhas no cdigo fonte.

63
Para ambos os grficos, a linha azul marcada com losangos representa o tempo de
execuo do Plug-in Fan-In, a linha vermelha com retngulos o tempo de execuo do
Plug-in AST Clone e a linha verde com tringulos o tempo de execuo do Plug-in Flow
Graph. Analisando o grfico da Figura 7-1, percebe-se que o tempo de execuo tende a
aumentar de acordo com o aumento do nmero de mtodos do software, o que ocorre para
os trs plug-ins. Analisando o grfico da Figura 7-2, outro comportamento percebido
quando comparado o tempo de exeuo e a quantidade de linhas de cdigo fonte. Pode-se
notar que nem sempre o software com mais linhas de cdigo levar um tempo maior para
ser analisado.

Figura 7-1 - Nmero de Mtodos x Tempo de Execuo

64

Figura 7-2 - Nmero de LOC x Tempo de Execuo
Em ambos os grficos, percebe-se que o nmero de mtodos do software tem maior
influncia no tempo de execuo do que na quantidade de linhas no cdigo fonte. Tal
caracterstica pode ser explicada pelo fato das tcnicas implementadas nos plug-ins
realizarem anlise criteriosa sobre os mtodos do software. Mesmo o Plug-in AST Clone,
com granularidade em nvel de trechos de cdigo, realiza anlises sobre o corpo de cada
mtodo do software.
Esta seo apresentou os principais resultados extrados das anlises efetuadas em
quatro softwares da categoria sistemas de informao de pequeno porte, especificando as
principais caractersticas de cada um deles e quais trechos de cdigo podem ser
considerados como indcios de interesses transversais. Alm disso, foi verificada a
influncia do nmero de linhas de cdigo e nmero de mtodos sobre o tempo de execuo
das tcnicas implementadas.
Na comparao entre os plug-ins, percebeu-se proximidade dos resultados
encontrados pelo Plug-in Fan-In e pelo Plug-in Flow Graph. Dessa forma, uma boa

65
abordagem utiliz-los como complementares para detectar indcios de interesses
transversais nos softwares.
No estudo do comportamento do tempo de execuo com relao ao LOC e ao
nmero de mtodos, no se pode afirmar que o LOC diretamente proporcional ao tempo,
uma vez que o nmero de mtodos do software exerce influncia na execuo das tcnicas.

66
8. CONSIDERAES FINAIS
Interesses so implementaes no cdigo fonte responsveis por tratar uma
determinada funo do software e, mesmo que este tenha sido bem modularizado em
unidades como mtodos e classes, algumas funes podem "atravessar" mdulos
comprometendo o encapsulamento. Uma possvel forma de identificar interesses
transversais em um software utilizar minerao de aspectos do processo de refatorao
orientada a aspectos, a qual permite representar interesses transversais identificados com
mecanismos apropriados de linguagens de programao orientadas a aspectos.
Com o objetivo de aprimorar o processo de deteco de interesses transversais em
um software, vrias tcnicas de anlise de cdigo esto presentes na literatura e algumas
delas foram descritas nos captulos anteriores. Entre as tcnicas descritas, trs delas foram
escolhidas para serem implementadas em forma de plug-in para o Eclipse. As tcnicas
implementadas foram utilizadas para analisar o cdigo fonte de softwares desenvolvidos na
linguagem de programao Java e os resultados foram estudados a fim de comparar as
tcnicas quanto eficincia e qualidade.
Neste captulo, so apresentadas algumas observaes resultantes deste trabalho.
Breve concluso do trabalho apresentada na Seo 8.1. Algumas contribuies obtidas
com a realizao deste trabalho so citadas na Seo 8.2. Alguns trabalhos futuros a serem
desenvolvidos como desdobramento deste so sugeridos na Seo 8.3.
8.1. Concluses
Aps analisada a viabilidade de implementao de cada tcnica, trs delas foram
escolhidas para serem codificadas como plug-ins para o Eclipse. Os plug-ins foram
desenvolvidos de forma independente prezando a modularizao do cdigo fonte visando a
facilidade de futuras melhorias e foram testados para detectar indcios de interesses
transversais em softwares reais. Durante os testes, critrios como cobertura e a relao
entre tempo de execuo e tamanho do software foram analisadas buscando verificar quais
tcnicas tm o melhor desempenho.
Com relao a tempo de execuo, o Plug-in AST Clone e o Plug-in Flow Graph
tiveram desempenho claramente superior ao Plug-in Fan-In. Por outro lado, o Plug-in Fan-

67
In e o Plug-in Flow Graph mostraram melhores resultados quando avaliados no quesito
cobertura dos resultados, uma vez que seus resultados foram semelhantes, alm de detectar
mtodos relacionados com interesses transversais comumente conhecidos, neste caso, o de
persistncia.
Analisando os resultados obtidos, pode-se perceber que mtodos relacionados a
alguns interesses transversais no software foram identificados. Dentre os quais, destacam-
se a persistncia, tratamento de eventos, camada de controle e outros especficos da
modelagem de cada software. Tais resultados evidenciaram o ganho de conhecimento
sobre o cdigo fonte dos softwares e mostraram como as tcnicas de deteco de interesses
transversais podem ser utilizadas para encontrar mtodos e trechos de cdigos com
comportamento transversal no software.
8.2. Contribuies
Conforme apresentado neste trabalho, observam-se poucos casos na literatura
relacionados a criao e a comparao de ferramentas para deteco de indcios de
interesses transversais. Alm disso, os escassos trabalhos relacionados foram
desenvolvidos em instituies estrangeiras, o que deixa a literatura nacional praticamente
fora deste cenrio.
Desta forma, este trabalho deixa como contribuio um conjunto de ferramentas
computacionais (plug-ins) para deteco de indcios de interesses transversais em
softwares orientados a objetos escritos na linguagem de programao Java, alm de um
estudo acerca do comportamento das tcnicas implementadas com relao ao tempo de
execuo da anlise e sua variao de acordo com o tamanho do cdigo fonte e nmero de
mtodos declarados no mesmo.
8.3. Trabalhos Futuros
A seguir, so apresentados alguns tpicos que podem ser levados em considerao no
processo de continuidade deste trabalho:
Implementar outras tcnicas de deteco de interesses transversais visando criar um
conjunto de ferramentas mais diverso e robusto. Alm disso, uma ferramenta nacional
com um grande nmero de abordagens de analise de cdigo colocaria o Brasil em um
ponto de maior destaque no cenrio mundial de pesquisas em minerao de spectos;

68
Aprimorar as ferramentas criadas com a funcionalidade de anlise de dois ou mais
projetos Java dependentes entre si, visto que grandes projetos so modularizados em
diversos subprojetos Java no Eclipse. Esta funcionalidade possibilitaria a anlise do
cdigo fonte de vrios projetos e os resultados serem apresentados de umaforma
combinada;
Desenvolver um mdulo para importar/exportar os resultados em forma de arquivos de
log. Esta funcionalidade possibilitaria que anlises de um mesmo software fossem
comparadas durante vrios estgios do desenvolvimento, uma vez que armazenados os
resultados, os mesmos poderiam ser carregados pelos plug-ins em uma outra ocasio;
Aperfeioar as ferramentas desenvolvidas acoplando os diversos Views necessrios em
uma nica perspectiva. Isto daria ao usurio uma viso mais clara de que os plug-ins
fazem parte de um nico ambiente de deteco de interesses transversais;
Realizar estudos para encontrar novos mtodos para deteco de indcios de interesses
transversais. Uma boa abordagem a incorporao de conceitos de outras reas de
pesquisa dentro da rea de minerao de aspectos, tal como foi feito com os conceitos
de deteco de clones, regras de associao e clusters em algumas das anlises
apresentadas neste trabalho.

69
Referncias Bibliogrficas
Anbalagan, P.; Xie, T. Automated Inference of Pointcuts in Aspect-Oriented Refactoring.
ICSE 07: Proceedings of the 29th international conference on Software
Engineering, Washington, DC, USA: IEEE Computer Society, 2007, pp. 127-136.
AOSDbr, C.B.D.D.D.S.O.A., Comunidade Brasileira de Desenvolvimento de Software
Orientado a Aspectos para a Lngua Portuguesa - AOSDbr. Terminoloagia em
portugus para orientao a aspectos. Braslia, 2007. Disponvel em:
<http://wiki.dcc.ufba.br/bin/view/AOSDbr/TermosEmPortugues>. Acessado em:
Abr. 2010.
Baniassad, E.; Clements, P.C.; Araujo, J.; Moreira, A.; Rashid, A.; Tekinerdogan, B.
Discovering Early Aspects. Software, IEEE, vol. 23, 2006, pp. 61-70.
Baxter, I. D.; Yahin, A.; Moura, L.; SantAnna, M.; Bier, L. Clone Detection Using
Abstract Syntax Trees. Software Maintenance, 1998. Proceedings. International
Conference on, 1998, pp. 368-377.
Bhatti, M. U.; Ducasse, S. Mining and Classification of Diverse Crosscutting Concerns.
LATE 08: Proceedings of the 2008 AOSD workshop on Linking aspect technology
and evolution, New York, NY, USA: ACM, 2008, pp. 1-5.
Biegel, B.; Diehl, S. Highly Configurable and Extensible Code Clone Detection.
Proceedings of the 2010 17th Working Conference on Reverse Engineering,
Washington, DC, USA: IEEE Computer Society, 2010, pp. 237-241.
Binkley, D.; Ceccato, M.; Harman, M.; Ricca, F.; Tonella, P. Automated Refactoring of
Object Oriented Code into Aspects. Software Maintenance, 2005. ICSM05.
Proceedings of the 21st IEEE International Conference on, 2005, pp. 27-36.
Breu, S.; Krinke, J. Aspect Mining Using Event Traces. Automated Software Engineering,
2004. Proceedings. 19th International Conference on, 2004, pp. 310-315.
Bruntink, M. Aspect Mining Using Clone Class Metrics. 1st Workshop on Aspect Reverse
Engineering, 2004 Disponvel
em:<http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.59.2557&rep=rep1&
type=pdf>. Acessado: Mai. 2011.
Bruntink, M.; Deursen, A. van; Tourwe, T. Isolating Idiomatic Crosscutting Concerns.
Software Maintenance, 2005. ICSM05. Proceedings of the 21st IEEE International
Bruntink, M.; Deursen, A. van; Tourwe, T.; Engelen, R. van. An Evaluation of Clone
Detection Techniques for Identifying Crosscutting Concerns. ICSM 04:
Proceedings of the 20th IEEE International Conference on Software Maintenance
(ICSM04), Washington, DC, USA: IEEE Computer Society, 2004, pp. 200-209.

70
Bull, R. I.; Best, C.; Storey, M. A. Advanced Widgets for Eclipse. Proceedings of the 2004
OOPSLA workshop on eclipse technology eXchange, New York, NY, USA: ACM,
2004, pp. 6-11.
Ceccato, M.; Marin, M.; Mens, K.; Moonen, L.; Tonella, P.; Tourwe, T. A Qualitative
Comparison of Three Aspect Mining Techniques. IWPC 05: Proceedings of the
13th International Workshop on Program Comprehension, Washington, DC, USA:
IEEE Computer Society, 2005, pp. 13-22.
Chapman, M. Introducing AJDT: The AspectJ Development Tools. International Business
Machines Corporation, 2006. Disponvel em: http://www.eclipse.org/articles/Article-
Introducing-AJDT/article.html. Acessado em: Mar. 2011.
Chen, S. C. On the Number of Operations Simultaneously Executable in Fortran-Like
Programs and Their Resulting Speedup. IEEE Transactions on Computers, vol. 21,
1972, pp. 1293-1310.
Cojocar, G. S.; Serban, G. On Evaluating Aspect Mining Techniques. Intelligent Computer
Communication and Processing, 2007 IEEE International Conference on, 2007, pp.
217-224.
Dijkstra, E. W. A Discipline of Programming, Prentice Hall PTR, 1976.
Filman, R.; Elrad, T.; Clarke, S.; Aksit, M. Aspect-Oriented Software Development.
Addison-Wesley Professional, 2004.
Geer, D. Eclipse Becomes the Dominant Java IDE. Computer, v. 38, 2005, pp. 16-18.
Griswold, W. G.; Yuan, J. J.; Kato, Y. AspectBrowser for Eclipse. 2005. Disponvel em:
<http://cseweb.ucsd.edu/~wgg/Software/AB/>. Acessado em: Mar. 2011.
Griswold, W. G.; Yuan, J. J.; Kato, Y. Exploiting the Map Metaphor in a Tool for Software
Evolution. In: Proceedings of the 23rd International Conference on Software
Engineering. ICSE '01. 2001. pp. 265 - 274.
Han, J.; Kamber, M. Data Mining: Concepts and Techniques. Morgan Kaufmann, 2000.
Hannemann, J.; Kiczales, G. Overcoming the Prevalent Decomposition of Legacy Code.
In: Proceedings of the 23rd International Conference on Software Engineering (ICSE
2001). Workshop on Advanced Separation of Concerns in Software Engineering
2001.
He, L.; Bai, H. Aspect Mining Using Clustering and Association Rule Method.
International Journal of Computer Science and Network Security, 2006, pp. 247-251.
Henry, S.; Kafura, D. Software Structure Metrics Based on Information Flow. Software
Engineering, IEEE Transactions on, vol. SE-7, 1981, pp. 510-518.
Horwitz, S.; Reps, T. W. The Use of Program Dependence Graphs in Software
Engineering. Proceedings of the 14th International Conference on Software
Engineering, 1992, pp. 392-411.

71
IBM. Eclipse Platform Technical Overview, 2006. . Diponvel em:
<http://www.eclipse.org/whitepapers/eclipse-overview.pdf>. Acessado em: Mar
2011.
Irwin, J.; Loingtier, J. M.; Gilbert, J. R.; Kiczales, G.; Lamping, J.; Mendhekar, A.;
Shpeisman, T. Aspect-Oriented Programming of Sparse Matrix Code. ISCOPE 97:
Proceedings of the Scientific Computing in Object-Oriented Parallel Environments,
London, UK: Springer-Verlag, 1997, pp. 249-256.
ISO/IEC 9126. ISO/IEC 9126-1 - Software engineering - Product quality - Part 1: Quality
model (2001), ISO/IEC TR 9126-2 - Software engineering - Product quality - Part 2:
External metrics (2003), ISO/IEC TR 9126-3 - Software engineering - Product
quality - Part 3: Internal metrics (2003) e ISO/IEC TR 9126-4 - Software
engineering - Product (2004).
JDT. JDT Core Component. The Eclipse Foundation, 2011. Disponvel em:
http://www.eclipse.org/jdt/core/. Acessado em: Mar. 2011.
Jung, C.F. Metodologia para Pesquisa e Desenvolvimento: Aplicada a Novas Tecnologias,
Produtos e Processos, Rio de Janeiro: Axcel Books do Brasil, 2004.
Kamiya, T.; Kusumoto, S.; Inoue, K. CCFinder: A Multilinguistic Token-Based Code
Clone Detection System for Large Scale Source Code. Software Engineering, IEEE
Transactions on, vol. 28, Jul. 2002, pp. 654-670.
Kawakami, D. Um Apoio Computacional para Auxiliar a Reengenharia de Sistemas
Legados Java para AspectJ. Dissertao de Mestrado. Universidade Federal de So
Carlos, 2007.
Kellens, A.; Mens, K.; Tonella, P. A Survey of Automated Code-Level Aspect Mining
Techniques. Transactions on Aspect-Oriented Software Development IV, A. Rashid
and M. Aksit, eds., Berlin, Heidelberg: Springer Berlin Heidelberg, 2007, pp. 143-
162.
Kiczales, G.; Lamping, J.; Mendhekar, A.; Maeda, C.; Lopes, C.; Loingtier, J. M.; Irwin, J.
Aspect-Oriented Programming. Europeen Conference on Object-Oriented
Programming (ECOOP), M.A.A.S. Matsuoka, ed., Springer Verlag, 1997, pp. 220-
242.
Komondoor, R.; Horwitz, S. Using Slicing to Identify Duplication in Source Code. SAS
01: Proceedings of the 8th International Symposium on Static Analysis, London,
UK: Springer-Verlag, 2001, pp. 40-56.
Krinke, J. Identifying Similar Code with Program Dependence Graphs. In Proc. Eigth
Working Conference on Reverse Engineering, 2001, pp. 301-309.
Krinke, J.; Breu, S. Control-Flow-Graph-Based Aspect Mining. 1st Workshop on Aspect
Reverse Engineering, Citeseer, 2004, pp. 1-5.

72
Kuck, D. J.; Muraoka, Y.; Chen, S. C. On the Number of Operations Simultaneously
Executable in Fortran-Like Programs and Their Resulting Speedup. IEEE
Transactions on Computers, vol. 21, 1972, pp. 1293-1310.
Laddad, R. Aspect Oriented Refactoring. Addison-Wesley Professional, 2006.
Laddad, R. AspectJ in Action: Practical Aspect-Oriented Programming, Greenwich, CT,
USA: Manning Publications Co., 2003.
Lakatos, E.M.; Marconi, M.D. Fundamentos De Metodologia Cientfica, So Paulo: 2001.
Lopes, C. V. D: A Language Framework For Distributed Programming. College of
Computer Science of Northeastern University, 1997. Disponvel em:
<http://www2.parc.com/csl/groups/sda/publications/papers/Lopes-
Thesis/Bibliography.pdf>. Acessado em: Mar 2011.
Marin, M. FINT - Tool Support for Aspect Mining. 2008. Disponvel em:
http://swerl.tudelft.nl/bin/view/AMR/FINT. Acessado em Mar 2011.
Marin, M.; Deursen, A. V.; Moonen, L. Identifying Crosscutting Concerns Using Fan-In
Analysis. ACM Trans. Softw. Eng. Methodol., vol. 17, 2007, pp. 1-37.
Marin, M.; Deursen, A. van; Moonen, L. Identifying Aspects Using Fan-In Analysis.
Reverse Engineering, 2004. Proceedings. 11th Working Conference on, 2004, pp.
132-141.
Marin, M.; Moonen, L.; Deursen, A. van. FINT: Tool Support for Aspect Mining.
Proceedings of the 13th Working Conference on Reverse Engineering, Washington,
DC, USA: IEEE Computer Society, 2006, pp. 299-300.
Mendhekar, A.; Kiczales, G.; Lamping, J. RG: A Case-Study for Aspectoriented
Programming. 1997.
Novais, R. L. Uma Arquitetura para Ferramentas de Aspect Mining. Bahia, 2009.
Disponvel em: <http://im.ufba.br/MATA23/TrabalhoRenatoNovais>. Acessado em
Mar. 2010.
Pawlak, R.; Retaill, J. P.; Seinturier, L. Foundations of AOP for J2EE Development
(Foundation), Berkely, CA, USA: Apress, 2005.
Pfleeger, S. L.; Atlee, J. M. Software Engineering: Theory and Practice. Prentice Hall. 792
pages. 2009.
Pressman, R. S. Software Engineering: A Practitioner's Approach. McGraw-Hill. 928
pages. 2009.
Qu, L.; Liu, D. Aspect Mining Using Method Call Tree. Multimedia and Ubiquitous
Engineering, 2007. MUE 07. International Conference on, 2007, pp. 407-412.
Resende, A. M. P. de; Silva, C. C. da. Programao Orientada a Aspectos em Java -
Desenvolvimento de Software Orientado a Aspectos, Rio de Janeiro: Brasport, 2005.

73
Robillard, M. P.; Murphy, G. C. Representing Concerns in Source Code. ACM Trans.
Softw. Eng. Methodol., vol. 16, 2007.
Roy, C. K.; Uddin, M. G.; Roy, B.; Dean, T. R. Evaluating Aspect Mining Techniques: A
Case Study. Program Comprehension, 2007. ICPC 07. 15th IEEE International
Shepherd, D.; Gibson, E.; Pollock, L. L. Design and Evaluation of an Automated Aspect
Mining Tool. Software Engineering Research and Practice, H.R. Arabnia and H.
Reza, eds., CSREA Press, 2004, pp. 601-607.
Shepherd, D.; Palm, J.; Pollock, L.; Chu-Carroll, M. Timna: A Framework for
Automatically Combining Aspect Mining Analyses. ASE 05: Proceedings of the
20th IEEE/ACM international Conference on Automated software engineering, New
York, NY, USA: ACM, 2005, pp. 184-193.
Soares, S., Laureano, E., and Borba, P. Implementing distribution and persistence aspects
with AspectJ. In ACM Press, editor, 17th ACM conference OOPSLA02, pages
174 190, 2002.
Sommerville, I. Software Engineering (International Computer Science Series), Addison
Wesley, 2010.
Takashio, K.; Tokoro, M. DROL: An Object-Oriented Programming Language for
Distributed Real-Time Systems. OOPSLA, 1992, pp. 276-294.
Tarr, P.; Ossher, H.; Harrison, W.; Sutton Jr., S. M. N Degrees of Separation: Multi-
Dimensional Separation of Concerns. Software Engineering, 1999. Proceedings of
the 1999 International Conference on, 1999, pp. 107-119.
Tourwe, T.; Mens, K. Mining Aspectual Views Using Formal Concept Analysis. Source
Code Analysis and Manipulation, 2004. Fourth IEEE International Workshop on,
2004, pp. 97-106.
UML. Unified Modeling Language. Disponvel em: <http://www.uml.org/>. Acessado em:
Mai 2011.
Valle-Rai, R.; Co, P.; Gagnon, E.; Hendren, L.; Lam, P.; Sundaresan, V. Soot - A Java
Bytecode Optimization Framework. 1999.
Yoshikiyo, W. G.; Kato, Y.; Yuan, J. J. Aspect Browser: Tool Support for Managing
Dispersed Aspects. In First Workshop on Multi-Dimensional Separation of Concerns
in Object-oriented Systems - OOPSLA 99, 1999.
Yuen, I.; Robillard, M. P. Bridging the Gap Between Aspect Mining and Refactoring.
LATE 07: Proceedings of the 3rd workshop on Linking aspect technology and
evolution, New York, NY, USA: ACM, 2007, p. 1.
Zhang, C.; Jacobsen, H. A. Efficiently Mining Crosscutting Concerns Through Random
Walks. AOSD 07: Proceedings of the 6th international conference on Aspect-
oriented software development, New York, NY, USA: ACM, 2007, pp. 226-238.

Monografia

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Monografia

Загружено:

Авторское право:

Доступные форматы

JOO LUCAS PEREIRA DE SANTANA

IMPLEMENTAO DE TCNICAS SEMNTICAS

de um programa com assinaturas de mtodos

seja descartada dos pontos de sada

, chamada uma relao de execuo externa-anterior se

. O conjunto das relaes de execuo externa-

. Esta relao pode ter a ordem invertida, isto ,

chamada uma relao de execuo interna-inicial

uma relao de execuo interna-final

. Da mesma forma, os conjuntos

. Isto , existe sempre na

que satisfazem esta restrio.

. Isto , a relao ocorre em mais

), o contexto da chamada o mtodo circundante .

as quais satisfazem este requisito. As relaes de execuo

), extrada no grafo de fluxo de

), extrai-se todo par de chamadas de

e um banco de dados de transaes , onde cada transao , associada a

, e cada objeto um vetor

vezes, ento o valor da -sima posio do objeto

so ambos diferentes de zero,

tm comportamento similar em termos de

. Caso um valor seja zero e o outro diferente de zero, significa que

indicado como interesse transversal. Cada

constitudo por mtodos no cdigo fonte, cada qual

so executados. De forma semelhante, imediatamente

Вам также может понравиться