Você está na página 1de 144

Padres de Software a partir da Engenharia

Reversa de Sistemas Legados


Rosana Teresinha Vaccare Braga
Orientador: Prof. Dr. Paulo Cesar Masiero
Dissertao apresentada ao Instituto de Cincias Matemticas e de
Computao - USP, como parte dos requisitos para a obteno do
ttulo de Mestre em Cincias - rea de Cincias de Computao e
Matemtica Computacional
USP - SO CARLOS
Novembro de 1998
Dedicoestetrabalho
a Deus
aoCirilo, aoThales eaoVitor
Agradecimentos
Ao Prof. Dr. Paulo Cesar Masiero pela orientao que me deu, sempre com muita ateno e
entusiasmo. Pelo direcionamento que deu pesquisa, to essencial para aproveitar ao mximo as
minhas potencialidades. Pela oportunidade de voltar pesquisa e poder associ-la prtica
profisssional.
Aos professores do ICMC pela acolhida calorosa depois de dez anos de afastamento da
Universidade.
Aos Profs. Drs. Norm Kerth e Ralph J ohnson pela recepo generosa que me deram na rea de
pesquisa em padres de software.
Prof. Dra. Rosngela Dellosso Penteado pela total disponibilidade na execuo de trabalhos
conjuntos e por sua amizade e ateno.
Ao Prof. Dr. Antonio Francisco do Prado pela oportunidade de ter contato com a mquina Draco-
Puc.
s alunas de graduao Fabiana Rocha, do ICMC e Tiemi Sakata, da UFSCAR, pelos trabalhos
de iniciao cientfica que contribuiram para as publicaes feitas durante a execuo deste
trabalho.
Aos mestrandos, doutorandos, pesquisadores e bolsistas do Laboratrio de Engenharia de
Software do ICMC pela amizade, ateno e auxlio na utilizao de mquinas e programas.
Aos colegas da Universidade de Franca pelo apoio e incentivo durante todo o programa de
mestrado.
Aos colegas do Senac So Carlos pelo incentivo que me deram para que eu pudesse contribuir
efetivamente na atividade de treinamento profissional em que esto empenhados e que so to
importantes para o desenvolvimento do pas.
s secretrias da ps-graduao pela ateno, pacincia e disponibilidade com que sempre me
atenderam.
s secretrias, bibliotecrias e funcionrios do ICMC que se mostraram sempre prestativos no
meu atendimento.
Fapesp pela bolsa de iniciao cientfica concedida durante meu curso de graduao que me
deu oportunidade de travar os primeiros contatos com a pesquisa e que abriram caminho para as
atividades aqui relatadas.
s empresas que me deram a oportunidade de exercer as minhas atividades profissionais na rea
de consultoria e desenvolvimento de sistemas.
Aos meus pais Miguel e Maria Teresa pela educao que me deram e pelo suporte aos meus
filhos durante minha ausncia.
Aos meus irmos Ailton e Anderson pela disposio e prontido com que sempre me atenderam
nas situaes imprevistas.
Ao Cirilo pelo companheirismo durante os momentos difceis, pela dedicao em me substituir
junto a nossos filhos durante muitas vezes neste perodo, pelo incentivo constante e pelas
sugestes na correo da ortografia desta dissertao. Ao Thales e ao Vitor pela compreenso da
importncia deste trabalho para mim.
Resumo
A execuo da engenharia reversa orientada a objetos de um sistema legado desenvolvido com
orientao procedimental usada como base para sua reengenharia, seguindo duas abordagens
diferentes. Na primeira, o sistema passa por reengenharia com mudana de orientao, por meio
de segmentao e, posteriormente, transformado para uma linguagem orientada a objetos de
forma semi-automtica. Na segunda, feito o reconhecimento de padres recorrentes de software
no modelo de objetos produzido pela engenharia reversa, para depois efetuar a reengenharia
utilizando esses padres. Os resultados obtidos por intermdio dessas duas abordagens podem ser
comparados quanto manutenibilidade, legibilidade e reuso. A verso original do sistema legado
escolhido para a realizao da experincia est implementado na linguagem Clipper e possui
cerca de vinte mil linhas de cdigo. Trata-se de uma oficina auto-eltrica e mecnica de veculos.
Para a engenharia reversa foi escolhido o mtodo Fusion/RE, sendo feita uma proposta para sua
evoluo, adicionando um maior detalhamento da etapa de abstrao do modelo de anlise do
sistema. Para mudana de orientao do paradigma de desenvolviemnto, de procedimental para
orientado a objetos, so propostas duas etapas adicionais a serem executadas aps a aplicao do
Fusion/RE: o projeto avante do sistema e a segmentao do programa legado. Indicaes sobre
como fazer a segmentao so fornecidas. A transformao do cdigo segmentado em Clipper
para J ava feita com auxlio da mquina Draco-Puc. Uma estratgia proposta para o
reconhecimento de padres a partir do modelo de objetos do sistema obtido pela engenharia
reversa. Por meio dela, instncias dos padres Type-Object, Association-Object, State Across a
Collection e Behaviour Across a Collection podem ser reconhecidas. Experincias de
implementao de alguns desses padres, em Delphi, so feitas.
Abstract
The object oriented reverse engineering of a legacy system, originally developed using the
procedural paradigm, is the basis for two different reengineering approaches. In the first, the
reengineering is done to change the implementation paradigm by segmentation, followed by the
semi-automatic transformation to an object oriented language. In the second, recurring patterns
are first recognized in the object model produced by the reverse engineering, and then the
reengineering is done adopting these patterns. Results obtained by these two approaches are
compared to assess their maintainability, legibility and reuse. The original version of the legacy
system used in this experience has about twenty thousand lines of Clipper code and refers to an
electric and mechanic car repair shop. For the reverse engineering phase the Fusion/RE method is
used, and a proposal is done for its evolution, adding features to detail its system analysis model
abstraction phase. To change the system orientation paradigm, from procedural to object-
oriented, two additional phases are proposed to be conducted after the application of the
Fusion/RE method: the forward design of the system and the legacy code segmentation. Hints
and rationales are supplied to conduct the code segmentaion. The code transformation from
segmented Clipper to J ava is done with support of the Draco-Puc machine. A strategy is
proposed for pattern recognition based on the system object model obtained through reverse
engineering. Through it, instances of Type-Object, Association-Object, State Across a Collection
and Behaviour Across a Collection patterns can be recognized. Delphi implementation
experiments of these patterns are done.
i
Sumrio
CAPTULO 1 INTRODUO .......................................................................................................... 1
1.1 CONSIDERAES INICIAIS............................................................................................................. 1
1.2 MOTIVAO................................................................................................................................. 2
1.3 OBJ ETIVOS ................................................................................................................................... 3
1.4 ORGANIZAO DA DISSERTAO................................................................................................. 4
CAPTULO 2 - RESENHA BIBLIOGRFICA.................................................................................. 6
2.1 - CONSIDERAES INICIAIS ............................................................................................................. 6
2.2 - ENTENDIMENTO DE PROGRAMAS.................................................................................................. 8
2.2.1 - Introduo............................................................................................................................. 8
2.2.2 - Contribuies Relevantes.................................................................................................... 11
2.2.3 - Concluses .......................................................................................................................... 16
2.3 - ENGENHARIA REVERSA............................................................................................................... 16
2.3.1 - Introduo........................................................................................................................... 16
2.3.2 - Contribuies Relevantes.................................................................................................... 18
2.3.3 - Concluses .......................................................................................................................... 23
2.4 - REENGENHARIA .......................................................................................................................... 24
2.4.1 - Introduo........................................................................................................................... 24
2.4.2 - Contribuies Relevantes.................................................................................................... 25
2.4.3 - Concluses .......................................................................................................................... 29
2.5 - PADRES..................................................................................................................................... 29
2.5.1 - Introduo........................................................................................................................... 29
2.5.2 - Contribuies Relevantes.................................................................................................... 31
2.5.3 - Concluses .......................................................................................................................... 41
2.6 - CONSIDERAES FINAIS.............................................................................................................. 41
CAPTULO 3 ENGENHARIA REVERSA..................................................................................... 43
3.1 CONSIDERAES INICIAIS........................................................................................................... 43
3.2 UM RESUMO DO FUSION/RE ...................................................................................................... 43
3.3 SOBRE A ABSTRAO DO MODELO DE ANLISE DO SISTEMA..................................................... 46
3.4 ESTUDO DE CASO....................................................................................................................... 47
3.4.1 - Recuperao da arquitetura do sistema legado.................................................................. 49
3.4.2 - Obteno do Modelo de Anlise do Sistema Atual ............................................................. 52
3.4.3 - Abstrao do Modelo de Anlise do Sistema...................................................................... 58
3.4.4 - Mapeamento MAS/MASA.................................................................................................... 69
3.5 CONSIDERAES FINAIS............................................................................................................. 71
CAPTULO 4 REENGENHARIA................................................................................................... 73
4.1 CONSIDERAES INICIAIS........................................................................................................... 73
4.2 REENGENHARIA COM MUDANA DE ORIENTAO E SEM MUDANA DE LINGUAGEM.................. 73
4.2.1 Abordagem proposta .......................................................................................................... 73
4.2.2 Estudo de Caso................................................................................................................... 76
4.3 REENGENHARIA COM MUDANA DE LINGUAGEM........................................................................ 80
4.3.1 Sistema de Transformao utilizado .................................................................................. 81
4.3.2 Estudo de Caso................................................................................................................... 83
4.4 CONSIDERAES FINAIS............................................................................................................. 87
CAPTULO 5 - RECONHECIMENTO DE PADRES DE SOFTWARE..................................... 89
ii
5.1 CONSIDERAES INICIAIS........................................................................................................... 89
5.2 PADRES RECORRENTES PARA SISTEMAS DE INFORMAO....................................................... 89
5.2.1 Padro Type-Object ........................................................................................................... 89
5.2.2 Padro Association-Object ................................................................................................ 91
5.2.3 Padro State across a collection........................................................................................ 92
5.2.4 Padro Behaviour across a collection ............................................................................... 92
5.3 UMA ESTRATGIA PARA RECONHECIMENTO DE PADRES........................................................... 94
5.3.1 Padro Type-Object ........................................................................................................... 94
5.3.2 Padro Association-Object ................................................................................................ 95
5.3.3 Padro State across a Collection....................................................................................... 96
5.3.4 Padro Behaviour across a collection ............................................................................... 96
5.4 ESTUDO DE CASO....................................................................................................................... 97
5.4.1 Reconhecimento dos padres no modelo de objetos do sistema legado............................ 97
5.4.2 Exemplo de implementao de padro............................................................................. 101
5.5 CONSIDERAES FINAIS........................................................................................................... 121
CAPTULO 6 CONCLUSES FINAIS E SUGESTES PARA NOVAS PESQUISAS .......... 122
6.1 CONSIDERAES INICIAIS......................................................................................................... 122
6.2 CONCLUSES GERAIS............................................................................................................... 122
6.3 CONTRIBUIES DESTE TRABALHO........................................................................................... 125
6.4 SUGESTES PARA FUTURAS PESQUISAS..................................................................................... 126
BIBLIOGRAFIA................................................................................................................................ 128
iii
Lista de Figuras
FIGURA 1.1 - ILUSTRAO DA ABORDAGEM DA DISSERTAO......................................................................................4
FIGURA 2.1 - RELACIONAMENTO ENTRE TERMOS [CHI 90].............................................................................................6
FIGURA 2.2 - RELACIONAMENTO ENTRE OS TPICOS DO CAPTULO.................................................................................8
FIGURA 2.3 - SISTEMA RECUPERADOR DE PROJ ETO BASEADO EM MODELO [BIG 89] ....................................................12
FIGURA 2.4 - METAMODELO INTEGRADO [MAY 95]....................................................................................................15
FIGURA 2.5 - INSTANCIAO DO PARADIGMA GOALS/MODELS/TOOLS [BEN 92].....................................................19
FIGURA 2.6 - DOCUMENTAO DE OBJ ETOS [SNE 95]..................................................................................................20
FIGURA 2.7 - PADRO ROLES-PLAYED (PAPIS DESEMPENHADOS) E EXEMPLO [COA 92].........................................31
FIGURA 2.8 - DIAGRAMA DO PADRO ABSTRACT FACTORY [GAM 93].....................................................................33
FIGURA 2.9 - EXEMPLO DO PADRO ABSTRACT FACTORY [GAM 93] .......................................................................34
FIGURA 2.10 - COREM E TIPOS DE PADRO BSICOS [GAL 96]...................................................................................36
FIGURA 2.11 - ARQUITETURA DO SISTEMA PAT [KRA 96]........................................................................................37
FIGURA 2.12 - DIAGRAMA DE INTERAO DOS PADRES [YOD 98].............................................................................40
FIGURA 3.1 - ESQUEMA DO FUSION/RE........................................................................................................................44
FIGURA 3.2 - PROCESSO DE TRANSIO DO MASA PARA O MAS...............................................................................46
FIGURA 3.3 - DIAGRAMA DA BASE DE DADOS..............................................................................................................49
FIGURA 3.4 - DESCRIO DE UM DOS ARQUIVOS DA BASE DE DADOS...........................................................................50
FIGURA 3.5 - DESCRIO DE UM DOS MDULOS DO SISTEMA, COM A RELAO CHAMA/CHAMADO POR......................51
FIGURA 3.6 - TRECHO DE UM PROGRAMA CLIPPER DO SISTEMA LEGADO.....................................................................52
FIGURA 3.7 - PARTE DOS MENUS DO SISTEMA LEGADO.................................................................................................52
FIGURA 3.8 - MOSA MODELO DE OBJ ETOS DO MASA.............................................................................................54
FIGURA 3.9 - PARTE DO MASA E PROCEDIMENTOS DO SISTEMA LEGADO...................................................................55
FIGURA 3.10 - MCVSA - MODELO DE CICLO DE VIDA DO SISTEMA ATUAL ................................................................56
FIGURA 3.11 - ESQUEMA PARA A OPERAO LANCAMENTO_PRIM_PARTE DO MOPSA............................................57
FIGURA 3.12 - MOS-1 MODELO DE OBJ ETOS DO MAS ETAPA 1...........................................................................60
FIGURA 3.13 - MOS-2 MODELO DE OBJ ETOS DO MAS ETAPA 2...........................................................................61
FIGURA 3.14 - MOS-3 MODELO DE OBJ ETOS DO MAS ETAPA 3...........................................................................62
FIGURA 3.15 - MOS-4 MODELO DE OBJ ETOS DO MAS ETAPA 4...........................................................................64
FIGURA 3.16 - MOS-5 MODELO DE OBJ ETOS DO MAS ETAPA 5...........................................................................65
FIGURA 3.17 - MOS-6A MODELO DE OBJ ETOS DO MAS ETAPA 6 PARTE A .......................................................66
FIGURA 3.18 - MOS-6B MODELO DE OBJ ETOS DO MAS ETAPA 6 PARTE B........................................................67
FIGURA 3.19 - PARTE DO MAS E MTODOS CORRESPONDENTES..................................................................................68
FIGURA 3.20 - MCVS - MODELO DE CICLO DE VIDA DO SISTEMA...............................................................................69
FIGURA 3.21 - ESQUEMA PARA A OPERAO ABRE_ORDEM_DE_SERVIO DO MOPS...............................................70
FIGURA 4.1 - ABORDAGEM PROPOSTA PARA REENGENHARIA COM MUDANA DE ORIENTAO....................................74
FIGURA 4.2 - EXEMPLO DE UM GRAFO DE INTERAO DE OBJ ETOS............................................................................76
FIGURA 4.3 - PROGRAMA SEGMENTADO CORRESPONDENTE OPERAO ABRE_ORDEM_DE_SERVIO.....................78
FIGURA 4.4 - ALGUNS MTODOS DO PROGRAMA SEGMENTADO..................................................................................79
FIGURA 4.5 - ATIVIDADES BSICAS PARA A CONSTRUO DOS DOMNIOS DE ORIGEM E DESTINO NO DRACO...............82
FIGURA 4.6 - CONSTRUO DOS DOMNIOS CLIPPER E J AVA NO DRACO [PEN 98B]......................................................85
FIGURA 4.7 - CDIGO J AVA RESULTANTE DA TRANSFORMAO, REF. OPERAO ABRE_ORDEM_DE_SERVICO......86
FIGURA 4.8 - ALGUNS MTODOS DO PROGRAMA TRANSFORMADO...............................................................................86
FIGURA 5.1 - PADRO TYPE-OBJ ECT [J OH 98].............................................................................................................90
FIGURA 5.2 - EXEMPLO DO TYPE-OBJ ECT [J OH 98]......................................................................................................90
FIGURA 5.3 - PADRO ITEM-DESCRIPTION [COA 92]....................................................................................................90
FIGURA 5.4 - EXEMPLO DO ITEM-DESCRIPTION [COA 92] ............................................................................................90
FIGURA 5.5 - PADRO ASSOCIATION-OBJ ECT [BOY 98]..............................................................................................91
FIGURA 5.6 - ASSOCIATION-OBJ ECT [BOY 98].............................................................................................................92
FIGURA 5.7 - PADRO STATE ACROSS A COLLECTION [COA 92]...................................................................................92
FIGURA 5.8 - EXEMPLO DO PADRO STATE ACROSS A COLLECTION [COA 92] .............................................................93
FIGURA 5.9 - PADRO BEHAVIOUR ACROSS A COLLECTION [COA 92] .........................................................................93
FIGURA 5.10 - EXEMPLO DO PADRO BEHAVIOUR ACROSS A COLLECTION [COA 92]...................................................93
FIGURA 5.11 - NOTAO USADA PARA EXPRESSAR PADRES EM UML........................................................................98
FIGURA 5.12 - RECONHECIMENTO DE PADRES ..........................................................................................................99
iv
FIGURA 5.13 - MODELO DE OBJ ETOS DETALHADO DO PADRO TYPE-OBJ ECT ..........................................................102
FIGURA 5.14 - ESQUELETO DA DECLARAO DA CLASSE CLASS DO PADRO TYPE-OBJ ECT..................................103
FIGURA 5.15 - ESQUELETO DE ALGUNS MTODOS DO PADRO TYPE-OBJ ECT ...........................................................104
FIGURA 5.16 - ESQUELETO DE UM DOS MDULOS DE DADOS DO PADRO TYPE-OBJ ECT...........................................105
FIGURA 5.17 - CDIGO SQL DE ALGUNS COMPONENTES DO MDULO DE DADOS CLASS......................................105
FIGURA 5.18 - MODELO DE OBJ ETOS DE UMA INSTNCIA DO PADRO TYPE-OBJ ECT................................................106
FIGURA 5.19 - CDIGO EM DELPHI REFERENTE DECLARAO DA CLASSE PEA ....................................................107
FIGURA 5.20 - CDIGO EM DELPHI REFERENTE DECLARAO DA CLASSE FABRICANTE.........................................108
FIGURA 5.21 - CDIGO EM DELPHI REFERENTE A ALGUNS MTODOS DO PADRO RECONHECIDO..............................109
FIGURA 5.22 - MDULO DE DADOS DA CLASSE PEA ................................................................................................109
FIGURA 5.23 - CDIGO SQL DE ALGUNS COMPONENTES DO MDULO DE DADOS PECA........................................110
FIGURA 5.24 - INTERFACE DA OPERAO DE CADASTRO DE PEAS...........................................................................111
FIGURA 5.25 - TRECHO DE CDIGO REFERENTE AO FORMULRIO DE CADASTRO DE PEAS.......................................111
FIGURA 5.26 - MODELO DE OBJ ETOS DA OUTRA INSTNCIA DO PADRO TYPE-OBJ ECT............................................112
FIGURA 5.27 - CDIGO EM DELPHI DA DECLARAO DAS CLASSES VECULO E TIPO DE VECULO............................113
FIGURA 5.28 - CDIGO EM DELPHI REFERENTE A ALGUNS MTODOS DA SEGUNDA INSTNCIA DO PADRO..............114
FIGURA 5.29 - MODELO DE OBJ ETOS PARA A OPERAO ABRE_ORDEM_DE_SERVIO..........................................115
FIGURA 5.30 - DEFINIO DA CLASSE ORDEMDESERVIO.....................................................................................117
FIGURA 5.31 - ALGUNS MTODOS DA CLASSE ORDEMDESERVIO.........................................................................118
FIGURA 5.32 - INTERFACE DO SISTEMA MOSTRANDO UM DOS MENUS ........................................................................119
FIGURA 5.33 - INTERFACE DA OPERAO DE ABERTURA DA ORDEM DE SERVIO.....................................................119
FIGURA 5.34 - TRECHOS DO CDIGO REFERENTE AO FORMULRIO DE ABERTURA DA ORDEM DE SERVIO..............120
v
Lista de Tabelas
TABELA 3.1 CORRESPONDNCIA ENTRE CLASSE DO MAS E ARQUIVOS DO MASA...................................................71
TABELA 3.2 CORRESPONDNCIA ENTRE CLASSES/ATRIBUTOS DO MAS E OS ARQUIVOS/CAMPOS DO MASA............72
TABELA 3.3 CORRESPONDNCIA ENTRE ALGUMAS OPERAES DO MAS E DO MASA.............................................72
TABELA 6.1 COMPARAO DOS RESULTADOS.........................................................................................................124
vi
Siglas Utilizadas
DAST Draco Abstract Sintax Tree
KB Knowledge Base Base de Conhecimento
MASA Modelo de Anlise do Sistema Atual
MAS Modelo de Anlise do Sistema
MOSA Modelo de Objetos do MASA
MOS Modelo de Objetos do MASA
MCVSA Modelo de Ciclo de Vida do Sistema Atual
MCVS Modelo de Ciclo de Vida do Sistema
MOpSA Modelo de Operaes do Sistema Atual
MOpS Modelo de Operaes do Sistema
1
CAPTULO 1 Introduo
1.1 Consideraes Iniciais
O desenvolvimento de sistemas a partir do zero , na maioria das vezes, mais difcil do
que quando existe algo pronto para ser usado como base. Por exemplo, em muitos sistemas de
informao pode-se aproveitar a estrutura geral de um programa existente, os mdulos para
montagem de menus, relatrios, consultas e a estrutura de insero, alterao e eliminao de
dados. Esse aproveitamento pode ser maior ou menor de acordo com o tipo de aplicao a ser
desenvolvida e de acordo com os sistemas prontos disponveis.
Ao longo de alguns anos de trabalho pode-se acumular inmeros mdulos, que podem
servir como base para elaborao de novos sistemas. Desenvolver sistemas dessa forma tem seus
problemas: na nsia de aproveitar algo j pronto, muitas vezes o sistema resultante no fica to
eficiente; existe a tendncia de colar remendo sobre remendo, produzindo sistemas difceis de
manter; as alteraes feitas so tantas que no resta nada do sistema original (nesse caso, talvez
tivesse sido melhor partir do zero); tambm difcil saber qual dos sistemas prontos seria a
melhor base para o novo sistema, devido falta de rigor na documentao.
Alm desse aproveitamento puramente de cdigo, seria desejvel aproveitar solues de
anlise e projeto, que exigiram bastante esforo para serem elaboradas e poderiam ser
reutilizadas em novos desenvolvimentos. Essas solues poderiam ser sintetizadas em padres,
sejam eles de anlise, de projeto ou de cdigo. Para criar esses padres nada mais natural do que
investigar sistemas prontos, em busca de trechos de cdigo que representem solues para
determinados problemas e que possam ser reutilizados no futuro. Deve-se estudar, ento, uma
forma de documentar esses padres, disponibilizando-os a quem possa interessar.
Padres de software podem se referir a diferentes nveis de abstrao no desenvolvimento
de sistemas orientados a objetos. Assim pode-se ter desde padres de anlise, em que esse nvel
bastante alto, passando por padres de projeto e indo at padres de cdigo. Coad [Coa 92]
apresenta padres de anlise bem gerais, teis principalmente no desenvolvimento de sistemas de
informao na rea empresarial. Gamma [Gam 95] apresenta padres de projeto de utilizao
bastante ampla que abrange sistemas os mais diversos, para vrias reas de aplicao. Fowler
[Fow 97] discute padres de anlise especficos para as reas de contabilidade, observaes e
2
medidas, finanas empresariais, referenciao de objetos, controle de estoque, planejamento,
comercializao de bens, negociao em bolsas de valores e negociao de lotes de papis, entre
outros.
1.2 Motivao
Minha formao acadmica enfatizou o uso do desenvolvimento estruturado de sistemas,
tanto com base nos dados como nos processos. Recebi uma bolsa de Iniciao Cientfica da
FAPESP, cujo plano de trabalho Estudo Comparativo de uma Abordagem Convencional com
uma Operacional para o Desenvolvimento de Sistemas de Informao levou preparao de
vrios relatrios tcnicos, entre os quais [Bra 86a] e [Bra 86b]. No primeiro foi usado o mtodo
J SD [J ac 83], que um mtodo estruturado com base nos dados e no segundo foi usado o mtodo
de Gane [Gan 83], que um mtodo estruturado com base nos procedimentos. Na poca, o J SD
era considerado uma abordagem operacional, enquanto que o mtodo de Gane era considerado
uma abordagem convencional. O trabalho de Masiero [Mas 88], mostra como o J SD pode ser
considerado como um mtodo orientado a objetos. Seu estudo motivou-me a saber mais sobre a
orientao a objetos, familiarizando-me com a bibliografia sobre esse assunto.
Durante cerca de dez anos de prtica profissional utilizei a anlise, projeto e programao
estruturados para o desenvolvimento de mais de vinte sistemas de informao. Esses sistemas
usaram bases de dados relacionais e foram desenvolvidos em linguagens como Dbase, Clipper,
FoxPro for Windows, Visual FoxPro e Access, em um total de aproximadamente 400.000 linhas
de cdigo.
Muitos desses sistemas foram feitos baseados em outros sistemas anteriormente por mim
desenvolvidos. Por exemplo, com base em um sistema para Controle de Estoque e Emisso de
Notas Fiscais de Produtos Agrotxicos, foi feito um sistema para uma Revendedora de
Motocicletas e Peas. Mais tarde, algumas partes desse sistema foram adaptadas para uma
Oficina Eletrnica de Reparos. A parte financeira do primeiro sistema por mim construdo foi
usada quase que integralmente em muitos outros sistemas. As bases de dados tambm possuem
diversos arquivos similares, aproveitando-se toda a idia de projeto.
Nessas atividades de reuso, deparei-me com todos os problemas citados na seo anterior.
Alguns sistemas ficaram ineficientes, com caractersticas desnecessrias para a aplicao
especfica; algumas adaptaes foradas dificultaram a manuteno; alguns mdulos ficaram
3
totalmente diferentes daqueles nos quais foram baseados; houve dificuldade em escolher qual o
melhor sistema para servir de base, devido similaridade dos mesmos e falta de documentao
explicando detalhadamente cada um. Pude sentir, tambm, dificuldades na manuteno desses
sistemas. Alguns deles foram feitos em pequenas equipes (analista e um ou dois programadores),
que nem sempre mantinham a documentao em ordem. Assim, muitos efeitos colaterais
ocorreram devido a pequenas alteraes, alm da constante dificuldade encontrada para localizar
a origem dos problemas que causaram a necessidade de manuteno. Diante disso, surgiu a
grande motivao para estudar uma forma de facilitar o reuso, no somente de trechos de cdigo,
mas tambm de conceitos de anlise e projeto, bem como de facilitar a manuteno dos sistemas.
Apesar dessa prtica profissional ter sido desenvolvida principalmente orientada a
procedimentos, foi usada orientao a objetos em outros trabalhos, como um relatrio tcnico do
ICMC [Bra 98a] e dois artigos em congressos internacionais [Pen 98a, Pen 98b] dos quais sou
co-autora.
Trata-se principalmente de execuo de engenharia reversa orientada a objetos em
sistemas legados desenvolvidos com orientao a procedimentos. Essa engenharia reversa foi
feita de acordo com um processo geral denominado Fusion/RE [Pen 95, Pen 96, Pen 96a e Pen
96b], que ser detalhado mais adiante. Esse processo baseado no mtodo Fusion [Col 94] para
desenvolvimento orientado a objetos.
1.3 Objetivos
Este trabalho prope uma abordagem alternativa usual, que descartar o cdigo antigo
quando se cogita de ampliar a funcionalidade de um sistema existente, com idade avanada e
desatualizado. O objetivo dessa abordagem reconhecer padres de software, sejam eles de
anlise, de projeto ou de cdigo, que sejam teis no reuso, na ampliao de funcionalidade e na
manuteno de sistemas. A base para esse reconhecimento a realizao de experimentos de
reengenharia de sistemas legados, mudando a orientao procedimental original para orientao
a objetos. D-se um enfoque maior para o domnio de sistemas de informao. A reengenharia
com mudana de linguagem feita tanto de forma automtica como de forma manual, obtendo-se
sistemas em linguagens orientadas a objetos. Uma comparao feita entre os sistemas obtidos
por transformao automtica de linguagem e por reengenharia manual com uso de padres.
4
A figura 1.1 ilustra a abordagem da dissertao. Aps a engenharia reversa do sistema
legado, obtm-se o Modelo de Anlise do Sistema, seguindo a orientao a objetos. Dois
caminhos so ento percorridos: primeiramente, o projeto avante e a segmentao do sistema
legado so realizados, aps os quais obtm-se o sistema segmentado, na linguagem
procedimental em que foi desenvolvido. Pode-se ento usar uma ferramenta para fazer a
transformao automtica para uma linguagem orientada a objetos. O caminho alternativo,
explorado depois, faz o reconhecimento de padres a partir do Modelo de Anlise do Sistema,
elaborando a seguir o projeto avante e implementando o sistema, manualmente, em uma
linguagem orientada a objetos. Durante esse processo, pode-se fazer uma busca por situaes em
que esses padres encontrados possam ser empregados, elaborando-se diretrizes para o
reconhecimento e uso de padres.
Figura 1.1 - Ilustrao da Abordagem da Dissertao
1.4 Organizao da Dissertao
Este trabalho est organizado como segue. No captulo 2 relatada a pesquisa
bibliogrfica feita sobre o assunto. No captulo 3 descrita a realizao da engenharia reversa em
um sistema legado de oficina auto-eltrica e mecnica de veculos. No captulo 4 descrita a
reengenharia desse sistema com mudana de orientao mas sem mudana de linguagem e,
Transformao
pela mquina
Draco
Projeto avante +
Implementao
Orientada a
Objetos +Padres
Projeto Avante+
Segmentao
Sistema
segmen-
tado
Sistema
orientado
a objetos
usando
padres
Sistema
Legado
Reengenharia com mudana de linguagem Reengenharia com mudana de orientao
Estratgia
para
reconhe-
cimento de
padres
Engenharia
Reversa
Modelo
de
Anlise
do
Sistema
Sistema
pseudo-
orientado
a objetos
(TAD)
Modelo
de
Anlise
com
padres
Reconhe-
cimento de
padres
Reengenharia com mudana de linguagem
5
posteriormente, a reengenharia com mudana de linguagem de Clipper para J ava. No captulo 5
estabelecida uma estratgia para reconhecimento de padres recorrentes, com base nos modelos
de anlise do sistema e feita uma experincia de reengenharia com mudana para linguagem
Delphi usando esses padres. O captulo 6 apresenta as concluses finais, sugerindo tambm
novas pesquisas que poderiam ser feitas nesta rea.
6
CAPTULO 2 - Resenha Bibliogrfica
2.1 - Consideraes Iniciais
A terminologia empregada na engenharia de software para referenciar as tecnologias de
anlise e entendimento de sistemas existentes apresentada por Chikofsky em [Chi 90], com o
objetivo de racionalizar termos que j esto em uso. Os termos definidos e relacionados so:
engenharia avante, engenharia reversa, redocumentao, recuperao de projeto, reestruturao e
reengenharia.
Figura 2.1 - Relacionamento entre termos [Chi 90].
Engenharia avante o processo tradicional de partir de um nvel de abstrao alto, de
requisitos do sistema, e chegar ao nvel fsico, de implementao do sistema. Restruturao a
transformao de uma forma de representao para outra no mesmo nvel relativo de abstrao,
preservando o comportamento externo do sistema (funcionalidade e semntica). Como exemplos
de reestruturao pode-se citar estruturao de programas e normalizao de dados. Engenharia
reversa, bem como duas sub-reas amplamente referenciadas, a saber, redocumentao e
recuperao de projeto, so definidas na seo 2.3. Reengenharia definida na seo 2.4. O
relacionamento entre os termos (figura 2.1) feito considerando-se que o ciclo de vida do
Redocumentao,
reestruturao
Engenharia
Reversa
Requisitos
( restries, objetivos,
regras de negcios)
Implementao
Engenharia Avante Engenharia Avante
Engenharia
Reversa
Reestruturao Reestruturao
Recuperao de
Projeto
Recuperao
de Projeto
Reengenharia Reengenharia
Projeto
7
software possui trs grandes etapas (requisitos, projeto e implementao) com claras diferenas
no nvel de abstrao. Requisitos tratam da especificao do problema, incluindo objetivos,
restries e regras de negcio. Projeto trata da especificao da soluo. Implementao trata da
codificao, teste e entrega do sistema em operao.
A figura 2.1 mostra claramente a direo seguida pela engenharia avante, do nvel mais
alto para o nvel mais baixo de abstrao. Mostra, tambm, que a engenharia reversa percorre
exatamente o caminho inverso, podendo utilizar-se da recuperao de projeto para aumentar o
nvel de abstrao. A reengenharia geralmente inclui alguma forma de engenharia reversa,
seguida de alguma forma de engenharia avante ou reestruturao. A redocumentao uma
forma mais fraca de reestruturao, permanecendo no nvel de implementao do sistema.
O entendimento de programas essencial para a manuteno e reuso de software.
Qualquer que seja a manuteno a ser feita no software haver a necessidade de primeiramente
entender o programa, para depois efetuar as alteraes. O mesmo ocorre no reuso. Um programa,
para ser reutilizado, deve ser primeiramente entendido a fim de verificar se h necessidade de
adapt-lo antes do reuso.
A engenharia reversa orientada a objetos pode ser feita em sistemas legados
desenvolvidos com orientao a procedimentos. Nela so recuperadas informaes com maior
nvel de abstrao do que o cdigo fonte, teis para o entendimento do sistema, ao mesmo tempo
em que o mesmo modelado segundo a orientao a objetos e preparado para uma futura
reengenharia.
A reengenharia com mudana de orientao, que transforma sistemas originalmente
procedimentais em sistemas orientados a objetos, deve ser feita aps a engenharia reversa citada
acima, que obtm modelos de anlise e projeto orientados a objetos, mudando tambm a
implementao para uma linguagem orientada a objetos.
Com padres de software, podem ser preservadas solues tanto de anlise, como de
projeto e implementao, teis em futuros desenvolvimentos. O estabelecimento e uso de
padres de software pode aumentar a produtividade, qualidade e custo do software.
Os grandes tpicos deste captulo so intimamente inter-relacionados, como mostra a
figura 2.2. O entendimento de programas (seo 2.2) uma fase essencial da engenharia reversa
(seo 2.3), que por sua vez a etapa inicial para se fazer a reengenharia (seo 2.4). Padres
(seo 2.5) so um recurso para reusabilidade, necessitando tambm da engenharia reversa e
8
consequentemente do entendimento de programas. Esses tpicos so explorados com maior ou
menor intensidade, de acordo com os objetivos pretendidos.
Figura 2.2 - Relacionamento entre os tpicos do captulo
A importncia de fazer uma resenha bibliogrfica envolvendo esses quatro tpicos est no
fato de que eles esto intimamente ligados com os objetivos propostos no ttulo da dissertao.
Padres devem ser estudados, pois devero ser reconhecidos facilmente. Engenharia reversa deve
ser explorada, pois durante ela que os padres sero identificados. O entendimento de
programas importante por ser uma parte essencial da engenharia reversa e a reengenharia por
ser um dos objetivos deste trabalho fazer a reengenharia do sistema legado adotando os padres
reconhecidos.
2.2 - Entendimento de Programas
2.2.1 - Introduo
Entender um programa significa poder explicar o programa, sua estrutura, seu
comportamento, seus efeitos e seus relacionamentos com o domnio de aplicao [Big 94]. O
entendimento de programas (ou, similarmente, a compreenso de programas) a construo de
uma estrutura semntica em diversos nveis de abstrao, para represent-los. Para isso, o
Padres
Reengenharia
Engenharia
Reversa
Entendimento
de Programas
Faz
parte da
a
primeira
etapa da
Podem ser
identificados
durante a
Podem ser
usados na
9
programador pode contar com o auxlio de seu conhecimento sinttico da linguagem de
programao e com seu conhecimento sobre o domnio da aplicao [Shn 79].
O nvel de abstrao em que um programa entendido pode ser alto (por exemplo, a
descoberta do qu o programa faz) ou baixo (por exemplo, o reconhecimento de seqncias
familiares de comandos). Ressalta-se que possvel ter uma compreenso de alto nvel mesmo
sem ter-se a compreenso de baixo nvel, e vice-versa [Shn 79].
A maneira mais elementar de obter conhecimento sobre um sistema por meio da leitura
do cdigo fonte, o que pode ser efetivo mas muito difcil devido grande quantidade de
informao contida no cdigo e dificuldade de extrair o conhecimento necessrio [Rob 91].
Assim, necessrio um instrumental para apoiar o entendimento de programas, que compreende
a criao de modelos cognitivos, a construo de ferramentas para ajudar o entendimento e a
realizao de estudos empricos sobre entendimento de programas.
Modelos cognitivos so criados para ajudar a entender como funciona o processo
cognitivo, ou seja, o processo de aquisio de conhecimento. O conhecimento do entendedor
de programas um elemento de grande importncia em um modelo de cognio, podendo ser
geral (por exemplo, conhecimento sobre o domnio de aplicao ou sobre um algoritmo) ou
especfico (por exemplo, conhecimento sobre a linguagem de programao ou estrutura de
dados). Alm disso, o nvel de experincia do especialista (no caso o programador ou analista de
sistemas), a forma de organizao do conhecimento (representao mental do entendimento) e a
eficincia na decomposio do problema (direo top-down ou bottom-up) so fatores que
influenciam diretamente no entendimento de programas.
Ferramentas para apoio ao entendimento de programas tm sido construdas,
compreendendo desde parsers de programao, que fazem, por exemplo, a anlise sinttica do
programa, produzindo informaes sobre a hierarquia de chamadas, at ferramentas mais
elaboradas, que se utilizam de bases de conhecimento e inteligncia artificial para inferir
possveis resultados.
Estudos empricos so uma forma de obter dados sobre o processo de cognio e valid-
lo. Esses estudos podem ser conduzidos de trs formas diferentes: observao, correlao e teste
de hipteses. A primeira observa o comportamento da maneira como ocorre no mundo real, por
exemplo o comportamento de programadores diante de situaes especficas. A segunda assume
que uma teoria tenha sido construda a partir dos estudos observacionais e tenta explorar o
relacionamento entre as variveis em questo. A terceira investiga causas e efeitos entre
10
variveis, a fim de validar uma teoria existente. Os estudos empricos levam em considerao,
tambm, o tamanho do cdigo fonte, linguagem de programao e o tipo de programador. Por
exemplo, pequeno refere-se a programas de menos de 900 linhas, mdio refere-se a
programas entre 900 e 40.000 linhas e grande acima de 40.000 linhas. Programadores podem
ser novios, estudantes de graduao e programadores profissionais [May 95] .
O principal motivo que leva necessidade de entender um programa que muitas regras
de negcios esto embutidas nos programas e no esto documentadas de forma explcita e
precisa em nenhum outro lugar. Essas regras de negcios so bens valiosos para as empresas e
muito difceis de serem captadas e redesenvolvidas [Nin 94].
O entendimento de programas tem algumas aplicaes de grande importncia na
Engenharia de Software, entre elas: a manuteno de software, o reuso e a recuperao de
projeto.
A manuteno de software a modificao de um produto de software, depois da entrega,
para corrigir falhas, melhorar o desempenho e outros atributos, ou para adaptar o produto a
mudanas de ambiente [Chi 90]. A manuteno s possvel aps o entendimento do programa,
para que possam ser localizados os problemas a serem tratados. Estima-se que 50-90% do tempo
de manuteno gasto com a compreenso de programas. Mesmo quando existe documentao,
o tempo gasto para estudo de cdigo trs vezes e meia maior do que o tempo gasto para estudo
da documentao [Rob 91].
O reuso, atividade que tem por finalidade reutilizar componentes de software
anteriormente desenvolvidos, envolve diretamente o entendimento de programas. Para reutilizar
partes de um software existente, necessrio primeiro entender detalhadamente essas partes, para
que seja avaliado seu potencial de reuso e para que sejam feitas as adaptaes necessrias para
torn-las componentes reutilizveis.
A recuperao de projeto, um subconjunto da engenharia reversa discutida posteriormente
na seo 2.3.1, deve reproduzir toda a informao necessria ao entendimento total de: o qu
um programa faz, como o faz e porqu o faz. Por intermdio dela so criadas abstraes de
projeto do sistema, a partir de uma combinao de cdigo, documentao existente (se
disponvel), experincia pessoal e conhecimentos gerais sobre os problemas e o domnio de
aplicao [Big 89].
A seo seguinte relata contribuies consideradas relevantes para o entendimento de
programas.
11
2.2.2 - Contribuies Relevantes
Shneiderman, em [Shn 79], apresenta um modelo cognitivo do comportamento do
programador, dividindo seu conhecimento em semntico e sinttico. O conhecimento semntico
consiste de conceitos gerais de programao independentes de linguagens especficas, enquanto
que o conhecimento sinttico mais preciso, detalhado e fcil de esquecer. O programador cria
representaes internas na resoluo de problemas tais como composio, compreenso,
depurao, modificao e aprendizagem do programa. Os componentes da memria humana so
utilizados de maneira distinta na resoluo de problemas. O conhecimento semntico e sinttico
do programador armazenado em sua memria de longo prazo. Esse conhecimento usado
como base na resoluo de problemas que envolvem novas informaes contidas na memria de
curto prazo. So relatados diversos experimentos empricos, cujas concluses levam
constatao de que a construo de uma estrutura semntica interna facilita a compreenso de
programas.
Soloway, em [Sol 84], trata da compreenso de programas por meio de experimentos
empricos, visando a determinar como esta afetada pela maior ou menor experincia de
programao de quem tenta obt-la. Quem tem maior experincia possui dois tipos de
conhecimento ausentes em quem tem menos: de planos de programas e de regras de raciocnio de
programas. Os primeiros so fragmentos de programas que constituem tpicas seqncias de
comandos que o programador tem experincia de uso em situaes anteriores, as segundas so
regras de bom senso comumente adotadas na prtica de programao. Programadores experientes
compreendem mais facilmente programas que tenham sido construdos com um determinado
plano e que no infrinjam tais regras. Tm dificuldade de compreender programas que no
tenham tais caractersticas. J os novatos no so afetados por essas diferenas.
Biggerstaff, em [Big 89], estabelece um processo bsico de recuperao de projeto,
composto de trs passos. O primeiro ajuda no entendimento de programas, identificando
estruturas de grande porte e associando-as com conceitos semnticos informais. O segundo ajuda
na alimentao e recuperao de bibliotecas de reuso. O terceiro aplica os resultados obtidos na
recuperao de projeto para descobrir candidatos a componentes de um sistema novo. Mostra a
importncia da utilizao de informaes informais, tais como comentrios e nomes de variveis
mnemnicos, e de um modelo do domnio, para a construo de abstraes conceituais do
projeto. Introduz as conexes associativas e os padres estruturais como um modo de formalizar
12
parcialmente as abstraes conceituais informais. As conexes associativas fazem a ligao
entre um conceito abstrato e o respectivo cdigo. Os padres estruturais definem os tipos de
estrutura de cdigo fonte que representam cada abstrao. Apresenta o primeiro prottipo do
DESIRE (Design Recovery), um sistema recuperador de projetos baseado em modelos, que
auxilia os engenheiros de software no entendimento de programas, mostrado na figura 2.3. O
sistema consiste de trs partes principais: um parser, um conjunto de funes de ps-
processamento e um sistema de hipertexto chamado PlaneText. O parser processa programas
em linguagem C e gera as parse trees, que so usadas pelos ps-processadores para produzir
um dicionrio contendo informaes e relacionamentos entre funes e itens de dados, alm de
associ-las a informaes informais (comentrios, por exemplo). O sistema de hipertexto exibe
os relacionamentos por meio de um browser, permitindo vises especficas em janelas
separadas, de acordo com a necessidade do usurio. O sistema oferece, tambm, queries pr-
definidas em Prolog, que ajudam na busca por padres.
Figura 2.3 - Sistema recuperador de projeto baseado em modelo [Big 89]
Robson, em [Rob 91], refora a idia de que a compreensibilidade de programas uma
parte vital do processo de manuteno. Comenta algumas teorias de compreenso de programas,
que modelam o processo de compreenso. Discute a dificuldade de entendimento de cdigo
13
apenas pela leitura, a qual diretamente dependente do tamanho e complexidade do programa.
Discute ainda outros fatores que afetam o entendimento de programas, tais como: estilo de
programao, modularizao, nomes de variveis, tabulao e comentrios. Descreve algumas
das tcnicas empregadas para automatizar a leitura de cdigo, categorizando-as em estratgias
estticas e dinmicas. Considera-as como auxiliares de baixo nvel ao processo de compreenso,
pois ajudam na compresso de pequenas unidades do programa, mas oferecem muito pouca ajuda
na determinao do projeto geral. As vantagens da automao so bvias na manuteno de
sistemas grandes nos quais nenhum dos mantenedores participou do desenvolvimento. A
engenharia inversa ou engenharia reversa considerada como auxiliar de alto nvel, porm ainda
precisa de muito trabalho para se tornar efetiva. As tcnicas de inteligncia artificial so
consideradas uma rea de pesquisa muito til compreenso de programas, porm pouco
exploradas.
Biggerstaff, em [Big 94], relaciona o entendimento de programas com o problema de
assimilao de conceito. Define como Problema de assimilao de conceito a descoberta de
conceitos que envolvem um grande conhecimento do domnio de informao e sua associao
com um programa ou contexto especfico, defendendo a idia de que no h algoritmo que
permita o reconhecimento desses conceitos com plena confiana. feita uma comparao entre
conceitos orientados programao, que podem ser derivados de forma dedutiva ou algortmica,
e conceitos orientados ao ser humano, que requerem um raciocnio razovel e exigem um
conhecimento prvio do domnio em questo. Sugere a utilizao de uma ferramenta para
recuperao de Projeto, o DESIRE, composto de um assistente ingnuo, que oferece servios
simples para apoiar a inteligncia humana e um assistente inteligente, que oferece uma
assistncia inteligente, por meio de um motor de inferncia baseado em Prolog e um
reconhecedor de padres baseado em conhecimento.
Ning, em [Nin 94], prope uma abordagem para recuperao de componentes reusveis,
na qual componentes funcionais de sistemas legados so reconhecidos, recuperados, adaptados e
reutilizados no desenvolvimento de um novo sistema. Essa recuperao requer profunda anlise e
entendimento do cdigo antigo. apresentado um conjunto de ferramentas chamado Cobol/SRE,
que ajuda no entendimento de programas por meio da segmentao de programas que,
basicamente, divide o programa em partes mais fceis de serem compreendidas por quem for
utiliz-las. O Cobol/SRE oferece recursos para demarcar os segmentos e posteriormente
empacot-los em mdulos independentes. Para a demarcao possvel englobar,
14
automaticamente, as linhas de cdigo afetadas por um perform, uma condio, o valor de uma
entrada ou sada. O empacotamento gera novos mdulos de programas, baseando-se nos
segmentos criados na demarcao, tornando o cdigo antigo mais modularizado e portanto mais
reusvel.
Mayrhauser, em [May 95], discute a compreenso de programas durante a manuteno e
evoluo do software. Subdivide a manuteno em adaptativa, aperfeioativa e corretiva,
detendo-se tambm no reuso e na alavancagem de cdigo (code leverage). Ressalta que, para
que o processo de entendimento de programas possa ser otimizado, necessrio que se
compreenda como os programadores entendem o cdigo, o que pode ser apoiado pelos modelos
de cognio. Identifica os elementos comuns aos modelos de cognio, a saber, o conhecimento,
o modelo mental e as caractersticas do especialista. Descreve vrios modelos de cognio de
cdigo, entre os quais: o modelo de Letovsky; o modelo de Shneiderman e Mayer [Shn 79]; o
modelo de Brooks; os modelos de fluxo de controle e o funcional, concebidos por Pennington; o
modelo Top-down, concebido por Soloway, Adelson e Ehrlich e o seu prprio modelo
integrado (figura 2.4). O modelo integrado considera trs componentes: o modelo do
programa, o modelo da situao e os planos de programao. No modelo do programa esto
consolidados o conhecimento do domnio do programa, isto , da estrutura de texto, dos planos e
das regras de raciocnio. No modelo da situao esto reunidos os conhecimentos do domnio do
problema, ou seja, o conhecimento funcional. Nos planos de programao constam os planos
estratgicos, tticos e de implementao, bem como regras de raciocnio. A cada um dos trs
componentes corresponde um processo de modelagem e um setor integrado na base de
conhecimento. No processo de entendimento h alternncia entre os trs modelos, de modo a
conseguir novos conhecimentos que tornam a alimentar a base de conhecimento. Esse modelo
permite tanto o entendimento top-down quanto o entendimento bottom-up, ou a mistura dos
dois.
Mayhauser apresenta tambm uma anlise comparativa quanto aos critrios estticos:
estruturas de conhecimento e representaes mentais; dinmicos e de experimentao, indicando
o grau de abstrao e dimenso da escala dos experimentos, bem como se o objetivo ganhar um
entendimento geral superficial ou parcial e mais aprofundado. Em [May 96], Mayrhauser refora
a parte experimental do trabalho, comprovando que os processos cognitivos atuam
simultaneamente em todos os nveis de abstrao, medida em que os programadores constrem
o modelo mental do cdigo.
15
Figura 2.4 - Metamodelo Integrado [May 95]
16
2.2.3 - Concluses
O entendimento de programas imprescindvel para o sucesso de diversas atividades da
engenharia de software, principalmente a manuteno, o reuso e a engenharia reversa. Um cdigo
s pode passar por alteraes depois de entendido. Um componente s pode ser reusado se for
entendido. Vises de um sistema em nveis de abstrao mais altos que o prprio cdigo s
podem ser produzidas aps o entendimento desse cdigo.
Uma forma de facilitar o entendimento de programas, cujo domnio de aplicao seja
totalmente desconhecido, utilizar conhecimento geral, como por exemplo proximidade de
comandos, separao por linhas em branco, similaridade entre smbolos formais e informais e
acoplamento de definies via smbolos em comum. Porm, nem todo programador utiliza-se
dos bons preceitos da programao. Isso tem que ser levado em conta quando se fazem estudos
empricos.
Entender um programa que contm implcitas regras de negcio valiosas e desconhecidas
por qualquer pessoa na empresa, pode ser um estmulo incomparvel a qualquer outro para o
avano da tecnologia de entendimento de programas. Muitas empresas que possuem programas
nessa situao fazem constantemente investimentos nessa rea.
A correspondncia entre conceitos orientados ao ser humano e trechos de cdigo nunca
ser totalmente automatizada, mas possvel apoio por computador, de utilidade para o
engenheiro de software. Acrescentando-se elementos por ele fornecidos para completar os
aspectos no atingidos pela automao, pode-se acelerar e simplificar de forma significativa o
entendimento de programas [Big 94]. Essa idia unnime em todos os trabalhos estudados.
2.3 - Engenharia Reversa
2.3.1 - Introduo
O termo engenharia reversa tem sua origem em anlise de hardware, na qual a prtica
de extrair projetos do produto final trivial. A Engenharia Reversa regularmente aplicada para
melhorar o produto de uma empresa a partir da anlise dos produtos do adversrio. Engenharia
Reversa o processo de desenvolvimento de um conjunto de especificaes para um sistema de
17
hardware complexo por exame de espcimes daquele sistema, de forma ordenada. [Rek 85].
Esse processo , em geral, conduzido por outro desenvolvedor, sem o benefcio de algum dos
desenhos originais, com o propsito de fazer um clone do sistema de hardware original.
No software, a engenharia reversa o processo de anlise de um sistema para identificar
seus componentes e inter-relacionamentos e criar representaes do mesmo em outra forma ou
num nvel mais alto de abstrao [Chi 90]. As informaes extradas do cdigo fonte via
engenharia reversa podem estar em diversos nveis de abstrao. Por exemplo, num baixo nvel
de abstrao tm-se representaes de projeto procedimental, subindo para informaes sobre a
estrutura de dados e de programa, modelos de fluxo de controle e de dados e chegando a modelos
entidade-relacionamento, que constituiriam o nvel de abstrao mais alto. O ideal seria ter um
nvel de abstrao o mais alto possvel [Pre 95].
A engenharia reversa deve produzir, preferencialmente de forma automtica, documentos
que ajudem a aumentar o conhecimento geral de sistemas de software, facilitando o reuso,
manuteno, teste e controle de qualidade de software. Alm disso, a engenharia reversa justifica
a necessidade de utilizar o conhecimento implementado em software antigo (ou legado) na
produo de software novo e ajustar software e documentao existentes a novos padres e
ferramentas introduzidos por novos mtodos e tecnologias de produo. Ressalte-se que
necessrio adicionar experincia pessoal e conhecimentos gerais a respeito do problema e do
domnio de aplicao informao extrada automaticamente do cdigo [Ben 92].
Existem diversas sub-reas da engenharia reversa: entendimento de programas (visto na
seo 2.1), redocumentao e recuperao de projeto. A redocumentao a criao de uma
representao alternativa de um programa, que seja equivalente e esteja no mesmo nvel de
abstrao. Alguns a consideram uma forma de restruturao. Seu objetivo recuperar
documentao que existiu ou deveria ter existido de um sistema alvo. A redocumentao pode
ser auxiliada por ferramentas automticas, tais como os pretty printers, que mostram a
listagem do cdigo de uma forma melhor; geradores de diagramas, que criam diagramas para
mostrar fluxo de controle a partir do cdigo e geradores de listagens de referncia cruzada. A
recuperao de projeto usa conhecimentos sobre o domnio de aplicao, informaes externas e
raciocnio, juntamente com observaes sobre o sistema em questo, para identificar abstraes
de nvel mais alto do que as produzidas diretamente pelo exame do sistema em si [Chi 90].
As duas maiores aplicaes da engenharia reversa so o reuso e a manuteno de
software. O reuso de software pode ser apoiado pela engenharia reversa tanto na identificao e
18
composio de componentes a partir de partes reutilizveis de sistemas existentes quanto na
elaborao da documentao dos novos sistemas compostos. A manuteno de software uma
tarefa difcil e por isso deve contar com a ajuda de uma documentao completa de todo o
processo de desenvolvimento. Nesse ponto, a engenharia reversa pode fornecer as vises em
diversos nveis de abstrao, permitindo a localizao dos componentes a serem mantidos, alm
de melhorar a compreensibilidade do software, pela documentao produzida.
As ferramentas de apoio engenharia reversa executam uma anlise ps-
desenvolvimento num programa existente. Existem ferramentas estticas, que usam o cdigo
fonte de um programa como entrada e extraem a arquitetura do programa, estrutura de controle,
fluxo lgico, estrutura de dados e fluxo de dados; e ferramentas dinmicas, que monitoram o
software em execuo e usam as informaes para construir um modelo comportamental do
programa [Pre 95].
Diversas ferramentas e mtodos tm sido propostos para apoiar a engenharia reversa. A
seo seguinte sumariza alguns deles.
2.3.2 - Contribuies Relevantes
Benedusi, em [Ben 92], define um paradigma de referncia, chamado
Goals/Models/Tools, para estabelecer processos de engenharia reversa capazes de gerar,
automaticamente, informaes e documentos de projeto, a partir do cdigo fonte. A fase Goals
analisa as razes pelas quais o processo de engenharia reversa deve ser estabelecido e define os
documentos a serem produzidos. A fase Models analisa os documentos a serem produzidos,
identifica as informaes e relacionamentos que podem ser extradas diretamente do cdigo e
que so direta ou indiretamente necessrias produo desses documentos, define os modelos de
programas que podem representar essas informaes e relacionamentos e define os algoritmos de
abstrao que permitiro que os documentos desejados sejam produzidos a partir desses modelos,
via o processo de engenharia reversa. A fase Tools define, adquire ou constri todas as
ferramentas de software necessrias produo dos documentos da engenharia reversa. dado
um exemplo de aplicao do paradigma (figura 2.5) a um caso real de reconstruo dos
documentos de projeto a partir de cdigo PASCAL. No exemplo, a fase Goals tem por
objetivo a produo de diagramas de estrutura, a fase Models usa expresses algbricas de
programas e tcnicas de fluxo de dados global e a fase Tools executada por um extrator
19
Pascal. Em [Ben 96], mostrado como a qualidade dos modelos obtidos pela engenharia reversa
pode ser melhorada quando, alm do cdigo fonte, da documentao de uso e da experincia
humana, utilizam-se os resultados de casos de teste que ocorrem durante a manuteno. Assim, a
anlise esttica pode ser complementada com a anlise dinmica.
Figura 2.5 - Instanciao do Paradigma Goals/Models/Tools [Ben 92]
Wong, em [Won 95], ressalta que, para sistemas grandes, o entendimento de aspectos
estruturais da arquitetura do sistema mais importante do que o entendimento de um
componente isolado qualquer. A redocumentao estrutural definida como uma engenharia
reversa dos aspectos arquitetnicos do software. Apresenta uma ferramenta, chamada Rigi,
para redocumentao estrutural de sistemas, que fornece um mtodo para identificar, construir e
documentar hierarquias de subsistemas em camadas. O Rigi possui trs componentes: o
Rigireverse, um sistema de parser; o Rigiserver, para armazenar a informao extrada do
cdigo fonte e o Rigiedit, um editor grfico interativo para manipular representaes de
programa. Para usar de forma efetiva a informao extrada pelo Rigi deve-se acrescentar o
conhecimento sobre o domnio especfico de aplicao. Isso feito por meio de scripts, que
permitem que o usurio escreva rotinas sob medida para atividades comuns, tais como extrao
de artifcios, apresentao de grficos e pesquisa e seleo de objetos. O Rigi foi testado em
Diagrama de
Estrutura
Expresso
Algbrica do
Mdulo
Matriz
Varivel /
Expresso
Extrator
PASCAL
Abstrator
SC1
Abstrator
SC2
Abstrator
SC3
Goals
Models
Tools
20
sistemas com mais de um milho de linhas de cdigo, confirmando que as vises produzidas
durante a redocumentao estrutural auxiliaram no entendimento desses sistemas legados.
Figura 2.6 - Documentao de objetos [Sne 95]
Sneed, em [Sne 95], apresenta uma abordagem para extrair documentao de projeto
orientada a objetos, automaticamente, a partir de programas existentes em COBOL. Comenta que
a migrao de sistemas legados em operao em "mainframes" para arquiteturas cliente/servidor
exige, na maioria das vezes, uma engenharia reversa seguida de reimplementao, sem mudana
de funcionalidade, que a noo de reengenharia proposta por Chikofsky [Chi 90]. Essa
migrao pode beneficiar-se da reusabilidade, interface grfica, comunicao inter-programas e
outras tcnicas modernas de programao proporcionadas pela orientao a objetos. Para isso,
Sneed prope uma abordagem que produz documentos de projeto compatveis com os vrios
mtodos de anlise orientada a objetos, como por exemplo Coad/Yourdon, Shlaer/Mellor ou
Rumbaugh. As etapas dessa abordagem, denotadas por retngulos na figura 2.6, so as seguintes:
Estruturas
Comuns
Descrio da
Interface
Definio da
Sequncia de
Execuo
Estruturas de
Dados
Seleo de
Objetos
Estruturas de
Procedimentos
Extrao de
Operaes
Especificao
de casos de
teste
Referncia
cruzada
Objetos
Mtodos
Mensagem
Doc.
Mtodos
Doc.
Interface
Doc.
Processos
Doc. casos
de teste
Doc.
Ref. cruzada
Doc.
Objetos
21
identificao de objetos, extrao de operaes, conexo dos objetos, re-especificao da
seqncia de operao e re-especificao de casos de uso. apresentada uma ferramenta,
chamada OBJ ECT-REDOC, projetada para analisar cdigo legado em COBOL e produzir
documentos de projeto orientado a objetos, tais como: rvores de objetos/atributos, grafos de
colaborao, rvores de condio, especificao de casos de teste e listas de referncia cruzada.
Penteado, em [Pen 95] e [Pen 96], apresenta um mtodo (posteriormente denominado
Fusion/RE) para engenharia reversa de sistemas legados, implementados sem usar a tecnologia
de orientao a objetos, com o objetivo de produzir o modelo de anlise orientado a objetos.
Baseia-se no mtodo Fusion para desenvolvimento orientado a objetos [Col 94], que rene
diversas tcnicas propostas por outros mtodos. A engenharia reversa feita em quatro passos,
que sero descritos na seo 3.2. Penteado faz um estudo de caso, aplicando seu mtodo a um
ambiente para edio e simulao de statecharts, chamado Statsim, desenvolvido no
ICMSC/USP. O estudo confirma a viabilidade de derivao de um modelo orientado a objetos
com base em uma implementao no orientada a objetos.
Dando continuidade ao trabalho apresentado em [Pen 95], Penteado utiliza, em [Pen 96a]
e [Pen 96b], mtricas para avaliao da qualidade da implementao atual e do esforo de
converso gastos na eventual reengenharia do sistema. Essas mtricas baseiam-se,
principalmente, nos procedimentos do sistema atual que contm anomalias e nos procedimentos
de implementao. Os procedimentos com anomalias so aqueles que fazem uso de mais de uma
classe. Ao serem convertidos, no novo sistema, exigem maior esforo, pois precisam ser
desmembrados em diversos mtodos de diversas classes. Os procedimentos de implementao
so aqueles relacionados interface, mdulo escalonador, etc. O fato deles existirem em grande
volume pode indicar grande esforo de converso, ao passo que se forem poucos pode significar
que a interface muito simples e deveria ser reformulada na reengenharia. So discutidas quatro
alternativas a serem seguidas aps a engenharia reversa do sistema: uso da documentao
produzida para facilitar a manuteno, melhoria da qualidade do sistema atual, desenvolvimento
do sistema por reengenharia e conservao da implementao atual, com aperfeioamentos
futuros realizados usando a orientao a objetos.
Hainaut, em [Hai 96], prope um processo para elicitao da estrutura na engenharia
reversa de bases de dados, que composto por dois processos principais. O primeiro cuida da
extrao da estrutura de dados, buscando reconstruir completamente o esquema lgico. O
segundo cuida da conceitualizao da estrutura de dados, visando a especificar as estruturas
22
semnticas desse esquema lgico na forma de um esquema conceitual. So relatados alguns
problemas encontrados na extrao da estrutura de dados, sendo que o maior deles descobrir e
explicitar as estruturas e restries que esto implementadas de forma implcita. Um exemplo
disso o problema da elicitao de chaves estrangeiras, que estudado mais profundamente para
ilustrar o mtodo proposto. apresentada uma ferramenta, chamada DB-MAIN [Hai 96a], que
um ambiente CASE programvel de propsito geral dedicado Engenharia de Aplicao de
banco de dados. Alguns de seus assistentes, dedicados elicitao de estruturas implcitas, so
tambm descritos.
Finnigan, em [Fin 97], prope um ambiente de apoio migrao de software, chamado
Software bookshelf, que prov meios de captar, organizar e gerenciar informaes sobre sistemas
legados. O ambiente possui trs componentes principais: o construtor, o bibliotecrio e o
patrocinador, responsveis por construir, alimentar e utilizar a bookshelf (estante de livros),
respectivamente. O construtor monta a arquitetura da bookshelf por meio de mecanismos
automticos de coleta, estruturao e armazenamento de informaes que satisfaam o
bibliotecrio. Para isso, utiliza-se de parsers, analisadores, conversores e visualizadores que
permitem que o bibliotecrio alimente o repositrio a partir de uma grande variedade de fontes
de informao. O bibliotecrio alimenta a bookshelf com informaes especficas de um
determinado sistema. Utiliza como fontes de informao os cdigos fonte e documentao
externa (disponvel em papel ou de forma eletrnica) tal como dados de teste, registro de
defeitos, informao arquitetural, registros de manuteno, etc. Ele deve selecionar os dados que
so teis ou no ao propsito especfico de reengenharia, sendo parcialmente auxiliado pelo
ambiente. O patrocinador um usurio final da bookshelf, podendo ser um desenvolvedor, um
gerente ou qualquer pessoa que precise de mais detalhes para fazer a reengenharia do cdigo
legado. Depois que a bookshelf estiver alimentada, o patrocinador pode editar o contedo
existente, adicionar notas e evidenciar pontos chave. Pode tambm acrescentar novas
informaes a partir das armazenadas no repositrio e da execuo de ferramentas de anlise e
visualizao do ambiente.
Armstrong, em [Arm 98], compara cinco ferramentas para recuperao da arquitetura de
sistemas legados: Rigi, Dali workbench, Software Bookshelf, CIA e SniFF+. O Rigi e o Sofware
Bookshelf so brevemente apresentados nesta mesma seo. O Dali workbench uma ferramenta
que ajuda na interpretao de dados extrados a partir de informaes arquiteturais, combinando-
os com outros dados j armazenados em um repositrio, usando o sistema de visualizao do
23
Rigi. O CIA uma base de dados relacional usada para extrair e armazenar informaes sobre
cdigo em C, juntamente com uma ferramenta de consulta e visualizao. O SNiFF um
ambiente de programao extensvel e escalonvel com recursos de parsing e recuperao de
informao. Todas as ferramentas comparadas so construdas para a linguagem C. Elas foram
analisadas com relao sua habilidade em efetuar a extrao de dados, a classificao e a
visualizao dos modelos. Trs sistemas reais foram utilizados na comparao, sendo que um
deles foi especialmente criado para causar dificuldades em parsers comuns. A capacidade de
extrao das ferramentas pde ser testada com relao chamada de rotinas de biblioteca
escondidas, variveis globais externas, recurso, compilao condicional, variveis locais e
funes com o mesmo nome, etc. A ferramenta SNiFF provou ser a melhor nesse quesito,
fornecendo um nvel de detalhe suficiente para a anlise arquitetural. A capacidade de
classificao das ferramentas, isto , de combinao de diversos fatos de baixo nvel em objetos
mais abstratos, foi tambm testada. Nesse quesito as ferramentas Software Bookshelf e Dali
mostraram alguma habilidade de abstrao para nveis mais altos. A capacidade de visualizao,
essencial para o entendimento da arquitetura do sistema, existe em todas as ferramentas
comparadas, havendo caractersticas espalhadas por todas elas que juntam formariam a
ferramenta ideal para visualizao.
2.3.3 - Concluses
A engenharia reversa de grande importncia na manuteno de sistemas, facilitando
tambm sua futura reengenharia. Unindo-se ao entendimento de programas, a engenharia reversa
produz excelentes resultados de grande utilidade para o engenheiro de software responsvel por
alteraes, reuso e evoluo do sistema. Quando os modelos por ela obtidos seguem o paradigma
da orientao a objetos, ainda mais vantagens so oferecidas, principalmente quanto facilidade
de reengenharia com mudana de orientao do sistema.
A engenharia reversa pode ser realizada com base nos diferentes mtodos para
desenvolvimento de sistemas, sendo facilitada quando o mtodo adotado apresenta transio
suave entre as fases de anlise e projeto e de projeto e implementao. Por exemplo, se projeto e
implementao possuem correspondncia natural, fica mais fcil caminhar no sentido contrrio,
como necessrio fazer na engenharia reversa. No mtodo Fusion para desenvolvimento de
sistemas orientados a objetos [Col 94], essa transio bastante suave, por isso o Fusion/RE
24
[Pen 96] usado com facilidade. Mesmo considerando que o sistema legado no foi
desenvolvido orientado a objetos, essa vantagem continua a existir. Deve-se lembrar tambm
que, no Fusion/RE, obtm-se os modelos de anlise sem passar pelos modelos de projeto.
2.4 - Reengenharia
2.4.1 - Introduo
A reengenharia tem por finalidade examinar e alterar um sistema existente para
reconstitu-lo em uma nova forma e depois implement-lo na nova forma [Chi 90]. A
reengenharia tem como objetivo principal melhorar a qualidade global do sistema, mantendo, em
geral, as funes do sistema existente. Mas, ao mesmo tempo, pode-se adicionar novas funes e
melhorar o desempenho [Pre 95]. Segundo J acobson [J ac 91], a reengenharia consiste da
engenharia reversa, seguida de mudanas no sistema (que podem ser mudanas de funcionalidade
ou mudanas de tcnica de implementao) e seguida da engenharia avante. Ou seja,
reengenharia o processo de criar uma descrio abstrata do sistema, elaborar mudanas em
alto nvel de abstrao e ento implement-las no sistema. De acordo com Sneed [Sne 95a], a
reengenharia engloba a reengenharia do procedimento empresarial, a reengenharia dos dados, a
reengenharia do software e a reciclagem (que produz componentes reusveis, de maneira anloga
ao processo de retirada de peas aproveitveis de um automvel abandonado).
Uma das grandes motivaes para aplicao da reengenharia a diminuio dos altos
custos de manuteno de sistemas, que devem-se a diversos fatores, discutidos por Wilkening em
[Wil 95]. A manuteno contnua faz com que a implementao fique inconsistente com o
projeto original, o cdigo torne-se difcil de entender e sujeito a erros, alm da documentao
desatualizada. As linguagens em que esses sistemas foram implementados esto ultrapassadas,
no havendo suporte por parte dos fabricantes nem tampouco programadores que as dominem,
alm de no haver ferramentas CASE que as suportem. Esses sistemas foram desenvolvidos
sem seguir os preceitos da engenharia de software, tendo, na maioria das vezes, um cdigo
desestruturado e difcil de entender. A alta rotatividade de funcionrios faz com que muita
informao seja perdida, diminuindo o conhecimento existente sobre o sistema.
25
Muitas empresas possuem programas ou sistemas passveis de reengenharia, mas deve-se
avaliar cautelosamente os prs e contras de efetu-la. Programas pouco usados, que no sofrem
mudanas, no compensam o custo da reengenharia. Programas que sofrem mudanas constantes
podem passar pela reengenharia como forma de manuteno preventiva, para evitar problemas
futuros. O custo para a reengenharia de um sistema pode ser compensado, a longo prazo, pela
melhoria da manutenibilidade e reuso.
A seo seguinte relata contribuies consideradas relevantes para a reengenharia,
preferencialmente aquelas cujo enfoque seja a mudana de paradigma para a orientao a objetos.
Nota-se que muitos artigos sobre reengenharia tratam, com mais destaque, ou de entendimento
de programas, ou de engenharia reversa ou de padres. Esses artigos foram discutidos nas sees
respectivas desses assuntos, como por exemplo [Nin 94] (seo 2.2.2) e [Gal 96] (seo 2.5.2).
Artigos importantes sobre reengenharia, como [Wel 95] e [Sem 95], no so aqui includos
porque no tratam especificamente da reengenharia com mudana de orientao.
2.4.2 - Contribuies Relevantes
J acobson, em [J ac 91], apresenta uma tcnica para efetuar a reengenharia de sistemas
legados, implementados em uma linguagem procedimental como C ou Cobol, obtendo sistemas
orientados a objetos. Mostra como fazer essa reengenharia de forma gradual, pois considera
impraticvel substituir um sistema antigo por um completamente novo (o que exigiria muitos
recursos). Considera trs cenrios diferentes: no primeiro se faz mudana de implementao sem
mudana de funcionalidade; no segundo se faz a mudana parcial da implementao sem
mudana de funcionalidade; e no terceiro se faz alguma mudana na funcionalidade. Apresenta
trs estudos de caso: um sistema de peas sobressalentes, um sistema de telecomunicaes e um
sistema de controle de trfego. Usa uma ferramenta Case especfica para orientao a objetos, o
ObjectOry. Nota-se que o autor no justificou o porqu de passar para a orientao a objetos,
tendo apenas usado o termo modernizao do sistema.
Markosian, em [Mar 94], reclama da falta de apoio computadorizado para a reengenharia
de sistemas, em contraposio grande proliferao de ferramentas CASE para desenvolvimento
de software novo. Diz que as ferramentas de transformao atuais so muito limitadas, sendo
difcil a adaptao a um projeto em particular. Aborda uma nova tecnologia para reengenharia,
que chama de tecnologia facilitadora (enabling technology), relatando resultados prticos
26
bastante animadores quanto produtividade da sua aplicao. A tecnologia facilitadora
consiste no rpido desenvolvimento de ferramentas para analisar e modificar, de forma
sistemtica, sistemas existentes. Deve ser usada em tarefas complexas de reengenharia, que
estejam sendo feitas mo ou com automatizao parcial. Usa como exemplo ilustrativo de
aplicao dessa tecnologia o sistema da Boeing Computer Services, que mantm muitos
sistemas legados grandes, como por exemplo um sistema de folha de pagamento com vinte e
dois anos e 650.000 linhas de cdigo Cobol. Explica detalhadamente o processo de
modularizao desse sistema, para torn-lo compatvel com tipos abstratos de dados. Usa para
efetuar essa modularizao duas ferramentas que incorporam a tecnologia facilitadora de
reengenharia, a Software Refinery
TM
e a REFINE/Cobol
TM
, da empresa Reasoning Systems. A
ferramenta Software Refinery foi usada para estender a ferramenta REFINE/Cobol a fim de
executar a modularizao. Essas ferramentas oferecem uma base de dados orientada a objetos
para modelar o software e suas informaes, uma linguagem de especificao executvel de
muito alto nvel, juntamente com um compilador, auxlio para depurao e uma biblioteca run-
time com utilitrios independentes de linguagem. Suas sadas so: o grafo de chamadas do
programa, anlise set/use, grafo de fluxo de controle e modelo de dados. O trabalho de
modularizao usando essas ferramentas mostrou-se produtivo, tendo-se detectado menos erros
do que na modularizao feita mo.
Sage, em [Sag 95], discute os possveis tipos de reengenharia que podem ser
considerados: reengenharia de produto, de processo e de gesto de sistemas. A reengenharia de
produto definida como sendo o exame, estudo, captao e modificao dos mecanismos
internos ou da funcionalidade de um produto ou sistema existente, para reconstitui-lo em uma
nova forma e com novas caractersticas, geralmente para desfrutar de vantagens de novas
tecnologias emergentes, mas sem maiores mudanas na funcionalidade e propsitos do sistema.
A reengenharia de processo o exame, estudo, captao e modificao dos mecanismos
internos ou da funcionalidade de um processo existente, ou ciclo de vida de engenharia de
sistemas, para reconstitui-lo em uma nova forma e com novas caractersticas funcionais e no
funcionais, geralmente para desfrutar de capacidades organizacionais ou tecnolgicas novas ou
desejveis, mas sem mudar o propsito inerente ao processo em si. A reengenharia de gesto de
sistemas o exame, estudo, captao e modificao dos mecanismos internos ou da
funcionalidade de processos e prticas de gesto de sistemas existentes em uma organizao,
para reconstitui-los em uma nova forma e com novas caractersticas, geralmente para desfrutar de
27
requisitos de competitividade organizacional emergentes, mas sem mudar o propsito inerente
organizao em si. Segundo Sage, qualquer que seja o tipo de reengenharia, sempre envolve um
ciclo de vida de trs fases: definio, desenvolvimento e disposio. Na primeira fase, so
definidos os objetivos da reengenharia, obtendo-se um conjunto de requisitos para a entidade a
passar pela reengenharia. Na segunda fase so determinadas as necessidades arquiteturais e
feito o projeto da entidade a passar pela reengenharia, que testada e avaliada. Finalmente, na
terceira fase, implementada a reengenharia da entidade, de forma operacional, garantindo-se
que a manuteno possa ter continuidade. Sage discute detalhadamente todos os tipos de
reengenharia, dando uma viso geral da literatura atual sobre o assunto. Cita os fatores que
devem ser levados em conta ao decidir pela reengenharia, os riscos que devem ser tratados
durante a mesma e os fatores para aumentar a chance de sucesso na reengenharia.
Wilkening, em [Wil 95], apresenta um processo para efetuar a reengenharia de sistemas
legados, aproveitando partes de sua implementao e projeto. Esse processo inicia-se com a
reestruturao preliminar do cdigo fonte, para fazer algumas melhorias no mesmo, como
remoo de construes no estruturadas, cdigo morto e tipos implcitos. A finalidade dessa
reestruturao preliminar produzir um programa fonte mais fcil de analisar, entender e
reestruturar. Em seguida, o cdigo fonte produzido analisado e so construdas representaes
do mesmo em nveis mais altos de abstrao. Com base nisso, pode-se prosseguir com os passos
de reestruturao, re-projeto e redocumentao, que so repetidos quantas vezes forem
necessrias para se obter o sistema totalmente reestruturado. Pode-se, ento, gerar o programa na
linguagem destino e dar seqncia aos testes que verificaro se a funcionalidade no foi afetada.
Wilkening apresenta a ferramenta RET, que automatiza parcialmente esse processo, sendo
portanto uma reengenharia assistida por computador. Essa ferramenta foi instanciada para
sistemas cuja linguagem original FORTRAN, e que aps a reengenharia so transformados,
automaticamente, para a linguagem ADA. Com a RET, o engenheiro de software no tem que se
preocupar com detalhes sintticos, como por exemplo as diferenas de sintaxe entre a linguagem
fonte e destino, podendo dar mais ateno a decises de projeto e implementao que requerem
ajuda humana.
Klsh, em [Klo 96], discute uma abordagem para reengenharia com mudana de
orientao, na qual aplica primeiramente a engenharia reversa para depois mudar a linguagem
para uma linguagem orientada a objetos. Esse trabalho uma continuao do trabalho de Gall
[Gal 95], no qual apresentado o mtodo COREM para transformao de programas, que refaz
28
sistemas de arquitetura procedimental, tornando-os orientados a objetos. Klsh justifica o uso da
orientao a objetos como forma de melhorar a manutenibilidade futura, devido a conceitos
como abstrao, encapsulamento e passagem de mensagens. contrrio utilizao de herana e
polimorfismo, por acreditar que esses conceitos complicam potencialmente as operaes de
manuteno. A abordagem proposta por Klsh possui quatro passos: recuperao de projeto,
modelagem da aplicao, mapeamento dos objetos e adaptao do cdigo fonte. No primeiro
passo so recuperados modelos do projeto, como por exemplo o diagrama entidade-
relacionamento. Esse transformado em um modelo reverso orientado a objetos da aplicao
(RooAM), que um modelo obtido de forma direta, sem considerar aspectos dinmicos como
servios e conexo de mensagens. No segundo passo construdo o modelo progressivo
orientado a objetos da aplicao (FooAM), usando-se algum dos mtodos disponveis para
anlise orientada a objetos. Nesse passo h interferncia de um especialista humano que seja
experiente no domnio de aplicao ou que tenha participado do desenvolvimento do sistema em
questo. No terceiro passo feita a correspondncia entre o RooAM e o FooAM, para resolver as
possveis ambigidades surgidas durante o passo de recuperao de projeto. No quarto passo
feita a adaptao da implementao procedimental para a arquitetura orientada a objetos. Klsh
concorda com a automatizao de partes do processo de reengenharia, mas acredita que seja
melhor uma abordagem hbrida, que use a assistncia automtica de uma ferramenta
computadorizada mas que, quando ela alcanar seus limites, conte com a interveno da
sabedoria humana para super-los.
Sneed, em [Sne 96], descreve um processo de reengenharia apoiado por uma ferramenta
para extrair objetos a partir de programas existentes em COBOL. Ressalta a predominncia da
tecnologia de objetos nos dias de hoje, principalmente em aplicaes distribudas com interfaces
grficas, questionando a necessidade de migrao de sistemas legados para essa nova tecnologia.
Identifica alguns obstculos reengenharia orientada a objetos, como por exemplo a
identificao dos objetos, a natureza procedimental da maioria dos sistemas legados, que leva a
blocos de cdigo processando muitos objetos de dados, a existncia de cdigo redundante e a
utilizao arbitrria de nomes. Assume como pr-requisitos para a reengenharia orientada a
objetos a estruturao e modularizao dos programas, alm da existncia de uma rvore de
chamadas do sistema. apresentado um processo de reengenharia orientada a objetos composto
de cinco passos: seleo de objetos, extrao de operaes, herana de caractersticas, eliminao
de redundncias e converso de sintaxe. A seleo de objetos feita com apoio da ferramenta,
29
mas o responsvel pela determinao dos objetos o engenheiro de software. A extrao de
operaes particiona o programa em subrotinas, removendo os segmentos referentes a um
determinado objeto e substituindo-os por envio de mensagens ao objeto no qual os dados locais
estiverem encapsulados.
2.4.3 - Concluses
Fazer ou no reengenharia em um sistema legado uma deciso que deve ser tomada com
muito cuidado. Sistemas que esto operando de forma satisfatria no devem ser
necessariamente substitudos, mesmo que os novos sistemas prometam ser melhores. Na
verdade, a melhora teria que ser significativamente grande para compensar o risco introduzido
[Sne 96].
A transformao de programas procedimentais em programas orientados a objetos no
trivial, requerendo interveno humana para escolher os objetos [Sne 96]. A quantidade dessa
interveno pode diminuir se houver integrao da reengenharia com padres predefinidos em
vrios nveis de abstrao, tais como padres do domnio de aplicao, padres de projeto ou
padres de linguagem [Klo 96].
Ferramentas de apoio reengenharia ajudam a diminuir o trabalho tedioso de
transformao de linguagens, deixando o engenheiro de software com tempo livre para tarefas
mais nobres.
2.5 - Padres
2.5.1 - Introduo
Segundo o dicionrio Aurlio [Fer 95], padro aquilo que serve de base ou norma para a
avaliao de qualidade ou quantidade; ou qualquer objeto que serve de modelo feitura de outro;
ou modelo, exemplo, prottipo, arqutipo. Essas definies aplicam-se a diversos campos, como
por exemplo na msica, na literatura, na arte, na psicologia, na costura, na decorao, no jogo de
xadrez e na aviao [Coa 92]. Na engenharia de software, desenvolvedores tm tentado encontrar
padres que venham ao encontro dos planos, algoritmos, estruturas de dados e idiomas
30
aprendidos no passado [Gam 95]. Padres tm sido usados para descrever solues para um
problema repetido de projeto [Vli 95], ou princpios de projeto que se mostraram teis no
desenvolvimento de software [Gal 96]. Estudos mostram que quando especialistas trabalham em
um problema particular raro que inventem uma nova soluo para atac-lo, completamente
diferente das j existentes. Diversas solues de projeto so por eles conhecidas, de acordo com a
prpria experincia ou a de outros profissionais. Quando confrontam-se com novos problemas,
freqentemente lembram-se de outros similares e reusam a soluo antiga, pensando em pares
problema/soluo. Esses pares podem ser agrupados em famlias de problemas e solues
similares, sendo que cada famlia exibe um padro tanto de problema quanto de soluo [Bus
97]. Projetistas familiarizados com certos padres podem aplic-los imediatamente a problemas
de projeto, sem ter que redescobr-los [Gam 95].
Os padres tm pelo menos dois propsitos: primeiro, fornecem exemplos a serem
seguidos e artifcios a serem copiados e posteriormente refinados ou estendidos. Segundo, eles
garantem uniformidade na estrutura do software. H, portanto, um considervel aumento de
produtividade no desenvolvimento e manuteno do software [Gal 96].
Padres de projeto so definidos como descries de objetos e classes que se
comunicam, os quais so ajustados para resolver um problema genrico de projeto, em um
contexto particular. Um padro de projeto identifica as classes e instncias participantes,
juntamente com seus papis, colaboraes e distribuio de responsabilidade [Gam 95]. Padres
de projeto podem ser considerados micro-arquiteturas reutilizveis que contribuem para a
arquitetura geral de um sistema [Gam 93]. Padres de projeto so definidos como cliches
adicionados de sugestes para seu devido uso na construo de software; eles embutem o
conhecimento do especialista, representando uma soluo para um problema comum de projeto e
podem ser reusados freqentemente e facilmente [Kra 96].
O processo de desenvolvimento de software orientado a objetos pode ser facilitado pelo
uso de padres de projeto. Eles proporcionam um vocabulrio comum para a comunicao entre
projetistas, criando abstraes num nvel superior ao de classes e instncias. A construo de
software reutilizvel incentivada, bem como o reuso do conhecimento de projeto obtido por
projetistas experientes. O tempo gasto para aprendizado de uma biblioteca de padres reduzido,
ajudando um novio a agir como um especialista [Gam 93].
31
2.5.2 - Contribuies Relevantes
Rich, em [Ric 90], define clichs como estruturas de programao ou algoritmos
comumente usados no desenvolvimento de sistemas. Aponta como vantagens do reconhecimento
automtico de clichs o aumento da facilidade de manuteno, documentao, evoluo,
otimizao e depurao de software. Alm disso, ajuda no estudo de como representar e usar o
conhecimento e experincia de programao. Apresenta o prottipo do Recognizer, uma
ferramenta que encontra, automaticamente, todas as ocorrncias de determinados tipos de clichs
em um programa e com base nisso, constri uma descrio hierrquica do programa. O
Recognizer possui um mdulo dependente da linguagem, que traduz o cdigo fonte para uma
representao grfica chamada Plan Calculus, produzindo uma rvore de projeto. Aponta
algumas caractersticas dos clichs que dificultam seu reconhecimento automtico, como a
variao sinttica e de implementao, a no contiguidade e a sobreposio de implementaes.
Mostra, depois, por meio de exemplos escritos na linguagem LISP, como o Recognizer supera
essas dificuldades.
Figura 2.7 - Padro Roles-played (papis desempenhados) e exemplo [Coa 92]
Coad, em [Coa 92], aborda o uso de padres na anlise orientada a objetos e no projeto
orientado a objetos. Define padres e d algumas dicas de como encontr-los, especialmente para
anlise e projeto orientados a objetos. Lembra que os mtodos orientados a objetos j destacam
Ator
Papel
datainicio
datafim
Papel 1 Papel 2
Pessoa
Nome
Telefone
Papel
data
Cliente
desconto
calcular valor desc.
Empregado
Nmero
32
certos padres de relacionamentos, como a generalizao-especializao, agregaes, associao
e mensagens. Diferencia padres de frameworks de aplicao, que so esqueletos de classes,
objetos e relacionamentos agrupados para construir aplicaes especficas. Define um padro
orientado a objetos como uma abstrao de uma dupla, tripla ou pequeno agrupamento de classes
que seja til muitas vezes no desenvolvimento orientado a objetos. Apresenta sete desses
padres, explicando-os de forma textual e por meio de uma figura, bem como dando um exemplo
ilustrativo e normas para utiliz-los. No final, d um exemplo de um modelo maior que usa seis
padres.
A figura 2.7 mostra um dos padres apresentados por Coad, o roles-played (papis
desempenhados). Outros de seus padres so mostrados na seo 5.2. Um objeto ator possui
atributos e servios que valem sempre, podendo, s vezes, desempenhar um ou mais papis. Para
cada papel pode haver especializaes, de acordo com os atributos e servios necessrios para
desempenh-lo. No exemplo, pessoa tem os atributos nome e telefone, mas pode, em um certo
instante, desempenhar o papel de cliente ou empregado. No caso de cliente, possui um atributo
extra, desconto, bem como um servio extra, calcular valor desconto. No caso de
empregado, possui um atributo extra, nmero.
Coplien, em [Cop 92], define idiomas e estilos de linguagem como recurso para aumentar
a expressividade de programas em C++e dar ao software uma estrutura melhor e mais eficiente.
Segundo ele, muitas tarefas de programao tornaram-se idiomticas e devem ser incorporadas
naturalmente funcionalidade do C++, dando a iluso de que fazem parte da linguagem.
Caractersticas do C++para obteno de blocos construtivos, como classes e funces-membro,
so largamente utilizadas na definio dos idiomas. A forma cannica ortodoxa um idioma
que define princpios e padres envolvidos no funcionamento de um objeto. Ela faz parte dos
idiomas que fazem com que uma classe se torne um tipo completo, sendo um padro a ser
seguido na implementao de qualquer classe. Um classe nessa forma contm sempre: um
construtor default, que trata da construo da classe quando um objeto definido sem
parmetros; um construtor copy, que cria um objeto baseado em uma cpia do parmetro de
entrada fornecido na chamada; um operador de atribuio, para transferir o contedo de um
objeto para outro objeto; e um destrutor, para liberar os recursos adquiridos pelo objeto durante
sua construo. Esse idioma deve ser usado sempre que objetos de uma classe precisarem ser
atribudos ou passados como parmetros (por valor) de uma funo e o objeto contiver ponteiros
33
para objetos contados por referncia, ou o destrutor da classe precisar executar um delete em
um objeto.
O idioma funo operador de membro usado para converter um tipo declarado pelo
usurio para um tipo nativo do C. O idioma classe manuseador/corpo (handle/body class)
usado para decompor uma abstrao complexa em classes menores e portanto mais fceis de
manusear. O idioma contagem referencial (reference counting) um caso particular desse
ltimo idioma, no qual a classe corpo contm um contador referencial manipulado pela classe
manuseador. Ele til quando so feitas cpias freqentes de um objeto grande ou complexo,
pois permite a cpia lgica, que menos dispendiosa. Outros idiomas so definidos por Coplien,
todos especficos da linguagem C++e num nvel de abstrao baixo como os citados acima.
Figura 2.8 - Diagrama do padro Abstract Factory [Gam 93]
Gamma, em [Gam 93, Gam 95], prope o uso de padres de projeto como um novo
mecanismo para registrar a experincia conseguida com projetos anteriores. Descreve como
expressar padres, sugerindo o uso de um gabarito (template) para estruturar informaes e
garantir uniformidade. Organiza os padres de projeto, categorizando-os em termos de jurisdio
e caracterizao. J urisdio o domnio sobre o qual um padro se aplica, podendo ser classe,
objeto ou composto. Caracterizao diz respeito a o qu o padro faz, podendo ser: padres
criativos, que tratam do processo de criao de objetos; padres estruturais, que lidam com a
composio de classes ou objetos e padres comportamentais, que caracterizam as formas pelas
quais classes ou objetos interagem e distribuem responsabilidade. Introduz um catlogo com
vinte e trs padres de projeto, explicando detalhadamente trs deles: o Abstract Factory, o
Strategy e o Wrapper. Relata sua experincia com padres no projeto e construo de dois
AbstractFactory
MakeProductA()
MakeProductB()
ConcreteFactory1
MakeProductA()
MakeProductB()
ConcreteFactory2
MakeProductA()
MakeProductB()
Return
new ProductA2
Return
new ProductA1
Generic ProductA Generic ProductB
ProductA1 ProductB1 ProductB2 ProductA2
34
sistemas, uma ferramenta de anlise financeira e uma ferramenta de manipulao de restries.
Observa que padres de projeto motivam os desenvolvedores a irem alm dos objetos concretos,
isto , eles objetivam conceitos do domnio do problema que no so to aparentes como objetos.
Comenta a similaridade de seu trabalho com o de Coad [Coa 92], ressaltando que os padres de
Coad so mais prximos da anlise que do projeto, pois surgem naturalmente na modelagem do
sistema. O nico padro que coincide o Broadcast, que o mesmo que seu padro
Observer.
Figura 2.9 - Exemplo do padro Abstract Factory [Gam 93]
A figura 2.8 mostra o diagrama que representa graficamente o padro Abstract
Factory. O diagrama baseado na notao OMT (Object Modeling Technique), qual
acrescentou-se o pseudo-cdigo dos mtodos. A classe AbstractFactory generaliza as
ConcreteFactories, que por sua vez do origem aos produtos especficos. Esses so por sua
vez generalizados pelas classes GenericProducts. A figura 2.9 mostra uma instanciao desse
padro a uma aplicao cuja interface contm janelas e barras de rolagem de dois tipos
diferentes: Motif e Open Look. Nesse caso, deseja-se que o cliente seja independente desses
tipos, isto , que o acesso s classes concretas seja feito apenas pela sua interface genrica (a
classe abstrata).
Vlissides, em [Vli 95], diferencia engenharia reversa de arquitetura reversa, dizendo
que a primeira analisa um sistema de software para recuperar seu projeto, enquanto a segunda
analisa diversos sistemas de software para recuperar projetos repetidos e o raciocnio envolvido
neles. Na verdade, usa arquitetura reversa como um termo mais ousado para o
desenvolvimento de padres de projeto, discutido em [Gam 95]. Mostra, inicialmente, um
Return
new J anelaMotif
Kit-J anela
CrieBarraRolagem()
CrieJ anela()
Kit-J anelaMotif
CrieBarraRolagem()
CrieJ anela()
KitJ anelaOpenWindow
CrieBarraRolagem()
CrieJ anela()
Return
new BarraRolagemOpenLook
J anela BarradeRolagem
J anelaMotif BarraRolagem
Motif
BarraRolagem
OpenWindow
J anelaOpen
Window
35
exemplo de padro de projeto tirado desse livro, mais especificamente o Strategy. Considera
que a reflexo a atividade mais importante na arquitetura reversa. Deve-se reservar um tempo
para refletir sobre os sistemas construdos, os problemas que surgiram e as solues encontradas
para resolv-los (ou no). Tudo deve ser anotado, pois esse ser o material bsico para extrao
de padres. Discute alguns princpios para a escrita de padres, recomendando, tambm, o uso de
um gabarito para uniformizar a estrutura da informao e facilitar a aprendizagem, comparao e
utilizao dos padres de projeto.
Budingsky, em [Bud 96], apresenta uma ferramenta para gerar cdigo automaticamente a
partir de padres de projeto de software, constituda de trs componentes: um apresentador, um
gerador de cdigo e um mdulo para estabelecer correspondncia entre os outros dois. O
apresentador usa pginas semelhantes s da Web para colocar disposio do usurio as
informaes sobre padres de software disponveis em [Gam 95]. O gerador de cdigo produz
fragmentos de cdigo semelhantes aos exemplos de cdigo que ilustram os padres em [Gam
95]. Cabe ao usurio escolher em cada caso de gerao de cdigo, qual alternativa de
implementao deseja adotar entre as mencionadas em [Gam 95], guiando-se pelos trade-offs
l mencionados. Para tornar esta escolha mais prtica, a ferramenta exibe esses trade-offs na
hora da escolha. O mdulo que estabelece correspondncia entre o apresentador e o gerador de
cdigo tem utilidade transparente ao usurio. A ferramenta permite maior flexibilidade para o
usurio de padres, que pode mudar decises de projeto e ter seu cdigo automaticamente
reescrito pela ferramenta, bastando para isso escolher os trade-offs correspondentes. Ao
usurio cabe fornecer informaes especficas da aplicao, de modo que o cdigo gerado seja
coerente com ela. A ferramenta tambm til para que se possa dominar a aplicao de padres
de software dinamizando a necessria experimentao que com eles deve ser realizada.
Gall, em [Gal 96], comenta a aplicao de padres na reengenharia, pela identificao e
utilizao de conceitos reusveis. Explica que o COREM, um mtodo por ele desenvolvido para
reestruturao arquitetural, atualmente requer a interveno de um especialista humano para
fornecer informaes perdidas que no podem ser recuperadas de forma automtica. Entretanto,
diz que est sendo feita uma extenso ao COREM, pela integrao de conceitos de padro ao
longo de alguns passos do processo, para reduzir essa interveno humana. Discute a utilizao
de padres na engenharia de software, em diversos nveis de abstrao, desde a anlise at a
codificao. Utiliza os exemplos de padres apresentados por Coad [Coa 92]. A figura 2.10
mostra as principais atividades no processo do COREM no contexto de camadas de abstrao. A
36
seta contnua representa a engenharia avante, enquanto que a seta pontilhada representa a
engenharia reversa. Gall lembra que o uso de padres orientados a objetos na engenharia avante
tm-se mostrado til e avalia sua adequao melhoria do processo de engenharia reversa. Para
isso, so propostas duas estratgias diferentes: busca por padres orientados a objetos no cdigo
fonte guiada pelos padres e guiada pelo cdigo fonte. A primeira, parte de um certo padro e
vasculha o cdigo, procurando sua ocorrncia. A segunda, parte das estruturas de dados presentes
no cdigo fonte e tenta fazer a correspondncia com padres existentes. Conclui que o
conhecimento semntico da aplicao necessrio, no sendo possvel a automao total. Porm,
uma ferramenta pode auxiliar o engenheiro de software, fazendo as tarefas montonas e
oferecendo uma interface sofisticada para o registro de conhecimento semntico da aplicao.
Figura 2.10 - COREM e tipos de padro bsicos [Gal 96]
Krmer, em [Kra 96], prope a recuperao de projeto pela busca automtica por padres
estruturais de projeto em software orientado a objetos. Afirma que a localizao de padres
estruturais de projeto, como Adapter, Bridge, Composite, Decorator e Proxy
(introduzidos por Gamma [Gam 95]), em software produzido sem uso explcito de padres, pode
melhorar sua manutenibilidade, porque pedaos maiores do software podem ser entendidos como
um todo. Apresenta uma ferramenta, o sistema Pat, que busca por instncias de padres de
projeto em software existente, implementado em C++. Resumidamente, a abordagem cria
representaes em PROLOG tanto dos padres quanto das informaes de projeto extradas do
Correspon-
dncia Modelos Reverso
orientado a objetos
da aplicao
Diagrama de
fluxo de dados
Modelos Progressi-
vo orientado a ob-
jetos da aplicao
Tabela de
modelos de
anlise
orientada a
objetos
Anlise
orientada a
objetos
Diagrama Entidade-
relacionamento
C++
Padres de Aplicao
Padres
de projeto
Padres de
Linguagem
Cdigo
fonte antigo
Cdigo
fonte novo
Requisitos
C
Projeto
orientado a
objetos
37
cdigo-fonte. Ento um motor de inferncia PROLOG faz a busca, necessitando de ps-
processamento manual para remover falsos positivos (instncias ilegtimas). A figura 2.11 mostra
a arquitetura do sistema Pat. Krmer utilizou a ferramenta CASE Paradigm Plus para fazer a
anlise estrutural do cdigo, obtendo nomes de classes, atributos, mtodos e propriedades,
relaes de herana, associao e agregao, embora com algumas limitaes. Avaliou quatro
programas aplicativos, sendo dois sistemas de comunicao e duas bibliotecas de classes
largamente usadas. Comparou os resultados obtidos quanto ao nmero de instncias verdadeiras
e preciso, tendo obtido preciso entre 14 e 50 por cento de padres identificados.
Figura 2.11 - Arquitetura do sistema Pat [Kra 96].
Campo, em [Cam 97], apresenta uma abordagem para engenharia reversa com base no
reconhecimento e visualizao de padres de projeto presentes em um dado framework. Fala das
vantagens do uso de frameworks no aumento de produtividade e qualidade do desenvolvimento
de software. Por outro lado, lembra que, para obter o benefcio mximo do reuso de frameworks,
necessrio entender o projeto interno de suas classes, a colaborao entre elas e a forma pela
qual instncias dessas classes colaboram em tempo de execuo. Esse entendimento uma tarefa
dispendiosa e demorada. Em frameworks complexos, desenvolvem-se estruturas de projeto
flexveis, para possibilitar adaptaes dinmicas. Essa flexibilidade acarreta projetos complexos,
difceis de entender e, consequentemente, difceis de reusar. O objetivo maior dos frameworks
o reuso do conhecimento que o projetista possui sobre o domnio de aplicao. A identificao
de padres de projeto embutidos na estrutura do framework importante para oferecer ao usurio
vises mais abstratas dessa estrutura, no nvel arquitetural. Facilita-se, assim, o reuso, sem
prejuzo do entendimento do programa. A abordagem proposta por Campo baseada no
framework Luthier, para construo de ferramentas para anlise e visualizao de aplicaes.
Diagramas
OMT dos
padres
Cdigo
fonte C++
Padro-para-
PROLOG
Projeto-para-
PROLOG
Anlise
estrutural
Regras PROLOG
Fatos PROLOG
Query
PROLOG
Candidatos
a instncia
de padres
38
Prolog usada na representao das regras para reconhecimento de padres, construo de
visualizaes de padres em potencial e explicaes sobre esses padres, e razes pelas quais
sugere-se sua presena no projeto.
Bosch, em [Bos 97], identifica quatro problemas encontrados na implementao de
padres de projeto usando linguagens de programao orientadas a objeto tradicionais. O
primeiro problema a identificao de padres de projeto no cdigo, pois quase sempre os
padres ficam perdidos durante a implementao, j que as linguagens de programao no
oferecem o conceito correspondente a padro. Assim, os padres ficam espalhados em partes de
um objeto ou mltiplos objetos. O segundo problema o auto-problema. Ele ocorre porque
objetos que j no mais existem podem ser referenciados quando uma mensagem passada
adiante e posteriormente delegada a outros objetos. O terceiro problema a limitao da
reusabilidade, pois a implementao do padro de projeto acaba misturando-o com o domnio de
aplicao, fazendo com que apenas o projeto possa ser reusado. O quarto problema a
sobrecarga de implementao, devido ao grande nmero de mtodos simples gerados, geralmente
com comportamento trivial. Para tentar resolver tais problemas, prope um modelo de objetos
em camadas, chamado LayOM, que uma linguagem orientada a objetos estendida. LayOM
permite a representao explcita de padres de projeto na linguagem de programao. Ilustra
como um padro de projeto pode ser implementado por camadas que encapsulam o objeto, de
forma que mensagens enviadas ou recebidas pelo objeto tenham que passar por essas camadas.
Essa abordagem aplicada a oito dos padres de projeto catalogados por Gamma [Gam 95].
Fowler, em [Fow 97], apresenta setenta e seis padres de anlise que refletem estruturas
conceituais de processos de negcios, ao invs de implementaes reais de software. Define
padro como uma idia que tem sido til em um contexto prtico e que provavelmente ser til
em outros. Diz que um padro, mesmo que ainda no tenha sido escrito, tem quatro partes
essenciais: o estabelecimento do contexto no qual ele til; o problema por ele endereado;
as foras que regem a formao da soluo; e a soluo que soluciona aquelas foras. Seus
padres so baseados em sua experincia pessoal de aplicao de modelagem orientada a objetos
a grandes sistemas de informao corporativos. Entre os padres por ele apresentados esto: o
Accountability, que define responsabilidades entre partes, como por exemplo contratos formais
ou informais; o Observation, para lidar com informaes qualitativas dos objetos; o
Measurement, para lidar com informaes quantitativas dos objetos; o Inventory e o Accounting,
que descrevem como uma rede de contas e regras de lanamento podem formar um sistema de
39
contabilidade; o Plan, para o planejamento e uso de recursos; o Contract e o Portfolio, para lidar
com comrcio de recursos, entre outros.
Martin, em [Mar 98], rene os melhores artigos sobre padres apresentados nas
conferncias PLop96 e EuroPLop96. Nesta seo alguns deles so resumidos. Segundo Martin,
os padres devem ser lidos, entendidos e incorporados ao modelo mental de projeto dos
desenvolvedores, para ento poderem ser utilizados quando um software especfico estiver sendo
projetado. Ressalta-se a importncia de saber aplicar o padro correto e de maneira correta, j
que os padres tm finalidade especfica e muitas vezes confundida por seus usurios. So
discutidos padres em diversos nveis de abstrao, desde os padres de padro, padres de
processo, padres arquiteturais e padres de anlise, at os padres de projeto e padres de
programao. Os padres de padro apresentam heursticas sobre a forma de apresentar padres.
Os padres de processo fornecem recomendaes sobre como conduzir as vrias fases de
desenvolvimento de software. Os padres arquiteturais definem propriedades globais do sistema,
ajudando na especificao da estrutura fundamental de um sistema de software. Os padres de
anlise e de projeto encontram-se distribudos em diversos sub-tipos, como os padres de
persistncia, padres de distribuio, padres de domnio especfico, padres de interface com o
usurio e padres de uso geral. Os padres de programao descrevem solues para problemas
especficos de programao, tornando o cdigo mais claro de entender, adaptar e modificar. Esse
trabalho refora a idia de que ainda existem muitos padres a serem descobertos, por exemplo
nos casos de padres de interface com o usurio e padres de distribuio.
J ohnson, em [J oh 98], descreve o padro Type-Object, mostrando sua aplicao a dois
sistemas: uma videolocadora e uma fbrica. Fornece o cdigo fonte em Smalltalk referente
implementao desses exemplos particulares, no qual pode-se entender o relacionamento entre as
classes que formam o padro. J ohnson apresenta diversas variaes na aplicao do padro,
como por exemplo o uso de Type-Objects aninhados ou recursivos, em que pode-se ver a
flexibilidade desse padro. Por outro lado, comenta as conseqncias de seu uso, como por
exemplo o aumento da complexidade do projeto e implementao e a gesto de referncias. O
padro Type-Object descrito na seo 5.2.
Boyd, em [Boy 98], descreve padres para representar a associao entre objetos em
sistemas de negcios. So eles: o padro Association-Object, o padro Customer Contact e o
padro 3-Level Order. O primeiro, descrito na seo 5.2, comumente encontrado em sistemas
de informao, j que representa algo que acontece em um ponto especfico do tempo associando
40
dois outros objetos. O segundo uma variao do primeiro, sendo uma associao mais
especfica entre um negcio e um cliente, porm envolvendo uma terceira classe, que
responsvel por controlar os diversos contatos feitos com o cliente e estabelecer regras de
contato. O terceiro uma srie de associaes de objetos, com uma estrutura para separ-los em
grupos de responsabilidades.
Figura 2.12 - Diagrama de Interao dos Padres [Yod 98]
Yoder, em [Yod 98], apresenta dez padres usados na implementao de objetos de
negcios, de forma que possam ser mapeados para bases de dados no orientadas a objetos. Esses
padres tentam amenizar a diferena existente entre objetos, que representam tanto dados quanto
comportamento, e bases de dados relacionais, que consistem de tabelas e relacionamentos. O
padro Persistence Layer fornece uma camada para fazer a correspondncia entre os objetos e
a base de dados. Essa camada o centro de interao com os demais padres, isolando o
desenvolvedor dos detalhes de armazenagem e recuperao de objetos. O padro CRUD
fornece as operaes bsicas utilizadas na persistncia de objetos, a saber: Create, para criar o
novo objeto na base de dados; Read, para ler objetos da base de dados; Update, para atualizar os
dados do objeto na base de dados; e Delete, para eliminar um objeto da base de dados. So
sugeridas tambm duas outras operaes que podem ser necessrias: LoadAllLike, para carregar
pode usar
cria
manipula mudanas
por meio de
fornece
conecta-se por
meio de
obtm nome de
tabelas com
manipula
transaes com
Attribute Mapping
Methods
OID
Manager
Transaction
Manager
Table
Manager
Connection
Manager
SQL Code
Description
Change
Manager
CRUD
Type
Conversion
Persistence
Layer
usa
mapeia
valores com
gera chaves
com
obtm nome de
tabelas com
41
todos os objetos que satisfazem uma dada condio e LoadAll, para carregar todos os objetos de
uma classe. O padro SQL Code Description usado para construir as chamadas SQL para a
base de dados. O padro Attribute Mapping Methods faz a correspondncia entre os valores na
base de dados e os atributos da classe e vice-versa. O padro Type conversion faz a
transformao de valores da base de dados para o tipo correspondente no objeto e vice-versa,
assegurando a integridade dos dados. O padro Change Manager acompanha as mudanas
efetuadas nos valores dos objetos para que fiquem consistentes com a base de dados. Ele
determina a necessidade de escrever ou no os valores para a base de dados. O padro OID
Manager gera chaves nicas para identificar os objetos durante uma insero. O padro
Transaction Manager fornece um mecanismo para manipular transaes ao salvar objetos. O
padro Connection Manager estabelece e mantm a conexo com a base de dados. O padro
Table Manager gerencia o mapeamento entre um objeto e suas tabelas e colunas na base de
dados. O diagrama da figura 2.12 mostra a interao entre esses dez padres, que juntos
estabelecem um mecanismo para mapear objetos persistentes para uma base de dados.
2.5.3 - Concluses
Os padres de projeto desempenham diversos papis no processo de desenvolvimento
orientado a objetos. Primeiro, eles fornecem ao projeto um vocabulrio comum. Segundo, eles
reduzem a complexidade do sistema, nomeando e definindo abstraes. Terceiro, eles constituem
uma base de experincia para construo de software reutilizvel. Por ltimo, eles atuam como
blocos construtivos a partir dos quais projetos mais complexos podem ser construdos [Gam 93].
Os padres de projeto documentam uma parte repetida de um projeto orientado a objetos
de forma que permitem seu entendimento e aplicao em um contexto particular. Com os
padres, pode-se discutir o projeto em um nvel de abstrao maior do que classes e objetos.
Assim, as informaes sobre o projeto podem ser divulgadas de forma mais rpida e precisa,
facilitando tanto o processo de projeto quanto a documentao [Vli 95].
2.6 - Consideraes Finais
42
Como os tpicos de interesse, conforme mencionado em 2.1, so intimamente inter-
relacionados, muitos trabalhos poderiam figurar em mais de uma das sees deste captulo. A
deciso de coloc-los numa certa seo foi subjetiva e determinada, no pelo assunto considerado
predominante pelo autor, mas pelo maior interesse apresentado, de acordo com os objetivos deste
trabalho mencionados em 1.3.
O entendimento de programas foi investigado exaustivamente, por ser de grande
importncia para a engenharia reversa de sistemas legados. A engenharia reversa foi bastante
explorada, porm considerou-se predominantemente o apoio fornecido pelo trabalho recente de
Penteado [Pen 96]. Na reengenharia foi dado enfoque especial a trabalhos que visavam
mudana de paradigma para orientao a objetos. Padres foram explorados de forma intensa,
principalmente visando descoberta de padres orientados a objetos a partir da engenharia
reversa de sistemas legados.
Apesar de no ter sido dado destaque em separado ao Reuso de Software, ele foi uma
preocupao sempre presente no contexto dos tpicos de interesse. O reuso uma das aplicaes
tanto de entendimento de programas, quanto de engenharia reversa e padres de software,
conforme destacado nas respectivas sees.
A reviso bibliogrfica evidenciou a importncia de padres para melhoria de qualidade e
produtividade das atividades de manuteno e reuso de software. Mostrou tambm sua
atualidade, havendo muitos trabalhos recentes enfocando esse assunto.
43
CAPTULO 3 Engenharia Reversa
3.1 Consideraes Iniciais
Diante dos conhecimentos obtidos com o estudo da bibliografia mencionada no captulo
2, neste captulo d-se uma idia das pesquisas que desenvolvemos na rea de engenharia
reversa. Essas pesquisas referem-se sobretudo extenso da aplicao do Fusion/RE [Pen 96] ao
domnio de sistemas de informao. Seus resultados foram objeto do relatrio tcnico [Bra 98a],
de parte da seo 3 de [Pen 98 a] e da seo 3 de [Pen 98b]. Note-se que as aplicaes anteriores
[Pen 96a, Pen 96b] foram feitas a uma ferramenta chamada STATSIM para edio e simulao
de statecharts desenvolvida em linguagem C, que no pertence ao domnio de sistemas de
informao. Assim, na seo 3.2 feito um resumo do Fusion/RE. Na seo 3.3 apresentado o
detalhamento do processo de abstrao originalmente descrito em [Bra 98a]. Na seo 3.4
mostrado o estudo de caso no qual feita a aplicao da metodologia descrita nas sees 3.2 e
3.3 a um sistema legado do domnio de sistemas de informao. Na seo 3.5 so feitas as
consideraes finais deste captulo.
3.2 Um Resumo do Fusion/RE
O Fusion/RE [Pen 96a] um processo geral para efetuar engenharia reversa orientada a
objetos, tomando-se como ponto de partida sistemas desenvolvidos com orientao
procedimental, j citado no captulo 2. A figura 3.1 mostra o esquema do Fusion/RE e a seguir
seus quatro passos so descritos resumidamente, pois em [Pen95, Pen96] encontram-se mais
detalhes dos mesmos.
O primeiro passo da abordagem consiste na revitalizao da arquitetura do sistema com
base na documentao existente ou no cdigo fonte, caso no exista. Ao final desse passo, tem-se
uma lista de todos os procedimentos, com sua descrio e hierarquia de chamadas
(chama/chamado por).
O segundo passo tem por objetivo recuperar o Modelo de Anlise do Sistema Atual
(MASA). Nele elabora-se um pseudo Modelo de Objetos do sistema, identificando-se as classes
e seus relacionamentos, bem como seus atributos e procedimentos associados.
44
Figura 3.1 - Esquema do Fusion/RE
Observa-se que a maioria dos procedimentos do sistema legado contm anomalias, ou
seja, um mesmo procedimento lida com vrias classes. Para classificar os procedimentos, adota-
se a conveno: (c) para construtor, quando o procedimento altera a estrutura de dados e (o) para
observador, quando o procedimento somente consulta a estrutura de dados. Quando um
procedimento consulta e altera uma mesma classe ele classificado somente como (c). O sinal de
+associado s siglas (c) e/ou (o), representa que o procedimento consulta e/ou observa duas ou
45
mais estruturas de dados. Desse modo, os procedimentos anmalos podem ser classificados
como (oc), (o+c), (oc+) e (o+c+). Os procedimentos so classificados como (i) quando referem-
se ao tipo de implementao utilizada.
Aps a criao do modelo de objetos pode-se, opcionalmente, elaborar os cenrios. As
entradas e sadas do sistema necessitam de agentes para manipul-las e, sendo assim, deve-se
identificar esses agentes, observando-se o funcionamento do sistema e criando-se os cenrios.
Um cenrio uma seqncia de eventos fluindo entre agentes e o sistema com algum propsito.
Cada cenrio envolve agentes, as tarefas que eles querem que o sistema faa e a seqncia de
comunicao envolvida para que sejam feitas essas tarefas. Os cenrios auxiliam na elaborao
do Modelo de Ciclo de Vida e do Modelo de Operaes.
A seguir, define-se o Modelo de Ciclo de Vida do sistema, que retrata o seu
comportamento global, preocupando-se com a ordem cronolgica em que as operaes so
realizadas. Estas servem como base para a construo do Modelo de Operaes do Sistema, no
qual cada operao descrita de forma minuciosa, de acordo com um gabarito preestabelecido.
Na verdade, trata-se de um pseudo-modelo orientado a objetos, pois no atende s restries da
orientao a objetos.
O terceiro passo visa 1a criao do Modelo de Anlise do Sistema (MAS), dando
enfoque ao domnio da aplicao e no implementao. Os modelos de Objetos, de Ciclo de
Vida e de Operaes so abstrados daqueles construdos anteriormente, com alguns cuidados
adicionais, como por exemplo a mudana de nomes para outros mais significativos,
generalizao e especializao de classes. Os procedimentos sem anomalias geram mtodos
diretamente, enquanto os com anomalias devem ser desmembrados em diversos mtodos, de
modo que cada mtodo interaja com apenas uma classe.
O quarto passo faz o mapeamento do Modelo de Anlise do Sistema para o Modelo de
Anlise do Sistema Atual, descrevendo a relao entre eles. So mapeadas as classes, atributos e
mtodos do MAS para os elementos correspondentes do MASA, anotando-se possveis
incluses/excluses. Esse passo importante na futura manuteno e reuso do sistema, caso s se
faa a engenharia reversa.
Portanto, ao final do Fusion/RE dispe-se de um Modelo de Anlise do Sistema orientado
a objetos que pode ser utilizado na reengenharia do sistema, seja para mudana de linguagem,
seja para mudana do paradigma de implementao ou seja ainda para aperfeioamento da
funcionalidade.
46
3.3 Sobre a abstrao do Modelo de Anlise do Sistema
No Fusion/RE, aps a execuo dos passos 1 e 2, feita a abstrao do Modelo de
Anlise do Sistema, baseada no Modelo de Anlise do Sistema Atual. Muitas dificuldades
podem surgir ao fazer essa abstrao de forma direta. O detalhamento desse passo de abstrao
foi sugerido para contornar essas dificuldades [Bra 98a] e ilustrado na figura 3.2. Considera-se
que o Modelo de Objetos do Sistema Atual (MOSA) foi construdo na fase 2 do Fusion/RE e est
disponvel durante o processo de detalhamento.
Figura 3.2 - Processo de Transio do MASA para o MAS
Inicialmente feita a abstrao do Modelo de Objetos do Sistema. Essa abstrao feita
em seis etapas, produzindo diversos modelos intermedirios, denominados MOS-1 a MOS-
6.
Na primeira etapa elaborado o MOS-1. Os pseudo-relacionamentos existentes no
MOSA so transformados em relacionamentos, removendo-se os atributos das classes cujo nico
objetivo era fazer o relacionamento entre tabelas, ou seja, as chaves estrangeiras so removidas.
Na segunda etapa elaborado o MOS-2. Nele, algumas tabelas do MOSA so
transformadas em relacionamentos. Classes do MOS-1 que no contm atributos, ou que contm
apenas um atributo fraco, podem ser transformadas em relacionamentos. Considera-se como
atributo fraco aquele que no identifica unicamente o objeto da classe, podendo ser repetido em
diversos objetos. Tais classes so tipicamente tabelas do MOSA com duas chaves estrangeiras e
nenhum ou apenas um atributo. Outra caracterstica marcante dessas classes que cada uma das
chaves estrangeiras faz a ligao da classe com outra classe por intermdio de um
MASA
Modelo de Objetos -
MOSA
Modelo de Ciclo de
Vida - MCVSA
Modelo de Operaes -
MOpSA
MAS
Modelos de Objetos
MOS-1 a MOS-6
Modelo de Ciclo de
Vida - MCVS
Modelo de Operaes
MOpS
47
relacionamento com cardinalidade muitos para um. No caso de haver um atributo na classe
sendo eliminada, o relacionamento dever carreg-lo.
Na terceira etapa elaborado o MOS-3. Nessa etapa so identificadas as agregaes e
especializaes de classes. Agregaes podem ser criadas sempre que uma classe englobar
outras. Especializaes podem ser criadas para isolar em uma superclasse os atributos e mtodos
comuns a diversas subclasses.
Na quarta etapa elaborado o MOS-4. Nele acrescentam-se as entradas mais relevantes e
os agentes externos que interagem com o sistema, estabelecendo seus limites.
Na quinta etapa elaborado o MOS-5, que mostra as sadas do sistema, bem como os
agentes externos que as manuseiam.
Na sexta etapa elaborado o MOS-6, no qual so generalizados os nomes de classes,
atributos e relacionamentos referentes ao MOS-4 e MOS-5. O objetivo dar nomes mais
significativos, de acordo com o domnio de aplicao.
Vale observar que essas etapas so mais apropriadas para sistemas desenvolvidos com
bases de dados relacionais, podendo ser modificadas ou condensadas dependendo da aplicao.
Aps a abstrao do Modelo de Objetos do Sistema deve ser feita a abstrao dos
Modelos de Ciclo de Vida e de Operaes. No caso do Modelo de Ciclo de Vida, faz-se a
mudana de nomes para outros mais significativos. Tambm podem ser efetuadas mudanas na
seqncia em que as operaes so invocadas ou no seu agrupamento dentro do ciclo de vida do
sistema. No caso do Modelo de Operaes, os esquemas devem ser revistos de maneira a
referenciar as classes do MOS ao invs do MOSA. Os nomes de atributos e operaes tambm
devem ser adaptados de acordo com os novos modelos de objetos e de ciclo de vida.
3.4 Estudo de Caso
O sistema utilizado como exemplo neste trabalho foi originalmente desenvolvido na
linguagem Clipper 5.0, possuindo aproximadamente vinte mil linhas de cdigo. Possui vinte e
cinco tabelas do tipo dbf, relacionadas por chaves estrangeiras.
Trata-se de um sistema real de Oficina Auto-eltrica e Mecnica que controla os servios
executados em uma oficina de veculos, fazendo tambm o controle de estoque das peas
utilizadas e do seu ressuprimento. O cliente vai at a oficina para solicitar a realizao de
servios em seu veculo, sendo que um cliente pode ter diversos veculos. O mesmo veculo pode
48
voltar oficina diversas vezes, sendo preparada, em cada uma delas, uma Ordem de Servio
distinta. Essa Ordem de Servio contm os dados do cliente, do veculo e dos reparos a serem
feitos.
Quando o veculo consertado, a Ordem de Servio completada, registrando-se as
peas utilizadas e a mo-de-obra executada. Muitas vezes o reparo pode exigir peas no
existentes no estoque, que so adquiridas fora da oficina mecnica e tambm fazem parte da
Ordem de Servio. O registro dessas peas importante para o gerente da oficina, pois elas so
candidatas a serem estocadas no futuro. Os possveis tipos de veculos devem ser cadastrados
pelo sistema, pois so utilizadas tabelas para cobrana de servios, tanto eltricos como
mecnicos, de acordo com o tipo de veculo. A venda de peas em estoque diretamente no balco
tambm realizada, sendo que nesse caso no aberta nenhuma ordem de servio.
FABRICAN
TEMPREP
TIPOVEIC CLIENTES CLIVEIC
CODMOBRA
CONTAREC
OSPECAS VENDAS
PECAS ITEMVEND
ORDSERV OSMOBRA
EMPREGAD
OUTPECAS
VEICOMP
PECACOMP COMPONEN
VEIPECA
FORNEC COMPRAS
CONTAPAG
TIPORAMO
RAMOFORN
ITEMCOMP
49
Figura 3.3 - Diagrama da Base de Dados.
3.4.1 - Recuperao da arquitetura do sistema legado
O sistema em questo j possua uma documentao razovel [Oli 91], constituda da
descrio detalhada da base de dados, da relao chama/chamado por e de um manual do
usurio [Bra 90]. A figura 3.3 mostra o diagrama entidade-relao da base de dados, que foi
usado no desenvolvimento do sistema legado.
A figura 3.4 ilustra a documentao complementar do diagrama, detalhando, para cada
arquivo, seus campos com as respectivas caractersticas, seus ndices e os programas que com ele
interagem. Na figura esto mostrados os detalhes do arquivo ORDSERV, que pode ser visto na
parte superior da figura 3.3.
A figura 3.5 mostra um dos mdulos que fazem parte da relao chama/chamado por,
na qual para cada mdulo existente no sistema h uma descrio de sua funcionalidade, os
arquivos lidos e/ou alterados, as rotinas chamadas e as rotinas que o chamam. No caso
especfico, refere-se ao mdulo OSTELA1, que consta na parte inferior da figura 3.4 como um
dos programas que alteram o arquivo ORDSERV. Note-se que essa interao de OSTELA1
com ORDSERV tambm est indicada na figura 3.5, em que ORDSERV indicado como
um dos arquivos lidos e/ou alterados pelo mdulo OSTELA1.
A figura 3.6 contm um trecho do cdigo fonte, em Clipper, do mdulo OSTELA1,
com cada linha numerada para futuras referncias. Algumas linhas pouco significativas para a
lgica do programa foram omitidas, tendo sido colocadas reticncias em seu lugar.
A figura 3.7 mostra parte dos menus do sistema legado, nos quais est indicado, direita,
o nome do mdulo que executado quando cada opo do menu selecionada. Por exemplo,
OSTELA1 executado quando as opes 1-Lanamento, 1-Ordem de Servio e 1-
Lanamentos 1 parte so selecionadas em seqncia.
Ao realizar a revitalizao da arquitetura do sistema legado, correspondente ao primeiro
passo do Fusion/RE, notou-se que essa documentao no estava atualizada. Por exemplo, na
figura 3.5 consta como rotina chamada por OSTELA1 apenas LOGOTIPO. Mas, na figura
3.6 nota-se que outras rotinas, tais como AVISO (linhas 29, 47, 80 e 99), BUSCLI (linha 28)
e IMPOS1 (linha 104), tambm so chamadas. Outra falha encontrada foi com relao aos
arquivos CONTAPAG e CONTAREC, que constam da figura 3.3, mas o cdigo fonte faz
50
referncia apenas a um arquivo CONTAS, que sequer consta do diagrama da base de dados. Os
arquivos VTREP e EQUIVPEC no constam do diagrama da figura 3.3, embora sejam
importantes na funcionalidade do sistema e constem da descrio de arquivos. Alm disso, os
nomes de arquivos, procedimentos, campos e ndices muitas vezes so pouco significativos, ora
por problemas de limitao do Clipper, ora por descuido do programador.
+======================================+
| ESTRUTURA DO ARQUIVO ORDSERV .dbf |
+======================================+
ORDEM DE SERVIO
+-------------------------------------------------------------------------+
| Nro | Nome do | Tipo | Nro de | Descrio |
| Campo | Campo | do Campo | Caract.| |
+=========================================================================+
| 1 | OSNRO | NUMERICO | 5 | NUMERO DA ORDEM DE SERVICO |
| 2 | DATAENTRA | DATA | 8 | DATA DE ENTRADA DA ORD. SERVICO |
| 3 | DATACOMPRA | DATA | 8 | DATA DA COMPRA DAS PECAS P/GAR. |
| 4 | CODCLIENTE | NUMERICO | 5,0 | CODIGO DO CLIENTE |
| 5 | NROVEICULO | NUMERICO | 4,0 | NUMERO DO VEICULO DO CLIENTE |
| 6 | SERVAEX1 | CARACTER | 60 | SERVICOS A EXECUTAR - PARTE 1 |
| 7 | SERVAEX2 | CARACTER | 60 | SERVICOS A EXECUTAR - PARTE 2 |
| 8 | SERVAEX3 | CARACTER | 60 | SERVICOS A EXECUTAR - PARTE 3 |
| 9 | ORCAMENTO | CARACTER | 1 | INDICADOR DO ORCAMENTO (S/N) |
| 10 | DATAPROM | DATA | 8 | DATA PROMETIDA PARA ENTREGA |
| 11 | HORAPROM | DATA | 8 | HORA PROMETIDA PARA ENTREGA |
| 12 | CONDPAG | CARACTER | 15 | CONDICOES DE PAGAMENTO |
| 13 | PRECOTOT | NUMERICO | 11,2 | PRECO TOTAL COBRADO |
| 14 | DESCONTO | NUMERICO | 11,2 | DESCONTO CONCEDIDO |
| 15 | DESPEXTRA | NUMERICO | 11,2 | DESPESAS.EXTRAS INCLUSAS |
+-------------------------------------------------------------------------+
ARQUIVOS DE INDICE
CLIORDSE.ntx --> CODCLIENTE
ORDSERV .ntx --> OSNRO
Programas que o leem:
ALTCAREC ELICAREC INDEXACA INSCAREC QUITCARE
Programas que o alteram:
OSTELA1 OSTELA2
Figura 3.4 - Descrio de um dos arquivos da base de dados.
Com base na metodologia resumida nas sees 3.2 e 3.3 e usando esse sistema legado, foi
conduzida a engenharia reversa cujos passos so descritos a seguir.
--------------------------------------------------------------------------
Mdulo Fsico: OSTELA1
Descrio: PRIMEIRA TELA DA ORDEM DE SERVICO
Arquivos apenas lidos:
Arquivos lidos e/ou alterados: CLIENTES CLIVEIC ORDSERV TIPOVEIC
Rotinas chamadas: LOGOTIPO
Rotinas que o chamam: LANCAMEN
51
Figura 3.5 - Descrio de um dos mdulos do sistema, com a relao chama/chamado por.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
* Nome do programa: OSTELA1.PRG
DO LOGOTIPO
SELECT 2
USE ORDSERV INDEX CLIORDSE, ORDSERV
SELECT 6
USE CLIENTES INDEX CODCLI, NOMECLI
SELECT 7
USE CLIVEIC INDEX CLICODVE
SELECT 8
USE TIPOVEIC INDEX CODVEIC, MARCVEI,
MARCTIP
SELECT 2
SET ORDER TO 2
GO BOTTOM
gravou=.f.
codcli =" "
nrov =0
imp =" "
nrord =OSNRO +1
dtent =DATE()
mv =SPACE(15)
tv =SPACE(30)
@ 6, 15 SAY "Lancamento da 1a. Parte da Ordem de
Servico"
@ 7, 15 SAY '"""""""""" "" """ """"" "" """"" "" """""""'
@ 9, 5 SAY "Data de Entrada:"
@ 9, 22 GET dtent PICTURE "@E"
@ 9, 48 SAY "O.S.Nro:"
@ 9, 56 SAY nrord PICTURE[99999]
@ 10, 5 SAY "Codigo do Cliente:"
@ 10, 24 GET codcli PICTURE [99999] when buscli()
DO AVISO WITH " <99999>- Cliente nao Cadastrado
<0>Abandonar"
READ
codcli=val(codcli)
IF lastkey()#27 .and. codcli <>0
nro_os=nrord
SELECT CLIENTES
SET ORDER TO 1
SEEK codcli
IF .NOT. FOUND()
GO BOTTOM
codcli =CODCLIENTE +1
dtmov =DATE()
APPEND BLANK
REPLACE CODCLIENTE WITH codcli
REPLACE DATAMOV WITH dtmov
DO AVISO WITH "Digite os Dados do Novo Cliente"
novo ="S"
ELSE
DO AVISO WITH "Verifique os Dados do Cliente,
Modificando se Necessario"
novo ="N"
ENDIF
ok ="N"
DO WHILE ok ="N"
@ 11, 5 SAY "Cliente:"
IF novo ="S"
@ 11, 14 GET NOME PICTURE REPL ("!",30)
ELSE
@ 11, 14 SAY NOME PICTURE REPL ("!",30)
ENDIF
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
@ 12, 5 SAY "Endereco:"
@ 12, 15 GET ENDERECO PICT REPL ("!",30)
@ 12, 53 SAY "Bairro:"
@ 12, 62 GET BAIRRO PICTURE REPL ("!",15)
. . .
@ 14, 30 SAY "Servicos a Executar"
@ 15, 30 SAY '"""""""" " """"""""'
serv1 =SPACE(60)
serv2 =SPACE(60)
serv3 =SPACE(60)
orcam =" "
dtpro =CTOD(" / / ")
horapro =SPACE(5)
@ 17, 7 GET serv1 PICTURE REPLICATE ("!",60)
@ 18, 7 GET serv2 PICTURE REPLICATE ("!",60)
@ 19, 7 GET serv3 PICTURE REPLICATE ("!",60)
@ 20, 7 SAY "Orcamento (S/N) :"
@ 20, 26 GET orcam PICT [!] VALID orcam $ "SN"
@ 21, 7 SAY "Prometido para as horas"
@ 21, 23 GET dtpro PICT "@E" VALID dtpro>=dtent
@ 21, 37 GET horapro PICTURE [!!!!!]
READ
grava =" "
DO AVISO WITH ga
cl =COLUNA(ga)
@ 24, cl GET grava PICT [!] VALID grava $ "GA"
READ
IF grava ="G"
. . .
SELECT ordserv
APPEND BLANK
REPLACE OSNRO WITH nrord
REPLACE DATAENTRA WITH dtent
REPLACE CODCLIENTE WITH codcli
REPLACE NROVEICULO WITH nrov
REPLACE SERVAEX1 WITH serv1
REPLACE SERVAEX2 WITH serv2
REPLACE SERVAEX3 WITH serv3
REPLACE ORCAMENTO WITH orcam
REPLACE DATAPROM WITH dtpro
REPLACE HORAPROM WITH horapro
gravou=.t.
men ="Imprime 1a. Parte da Ordem de Servico?
(S/N) ===> <>"
DO AVISO WITH men
cl =COLUNA(men)
@ 24, cl GET imp PICTURE [!] VALID imp $ "SN"
READ
IF imp ="S"
DO IMPOS1
ENDIF
ENDIF
ENDIF
ENDIF
CLOSE DATABASES
RETURN
52
Figura 3.6 - Trecho de um programa Clipper do sistema legado
Figura 3.7 - Parte dos menus do sistema legado
3.4.2 - Obteno do Modelo de Anlise do Sistema Atual
Apesar dos defeitos constatados na documentao existente do sistema legado, com base
nos resultados do passo de revitalizao da arquitetura, foi possvel construir o Modelo de
Objetos do Sistema Atual (MOSA) mostrado na figura 3.8. Pode-se observar que todas as tabelas
presentes no diagrama da base de dados da figura 3.3 foram transformadas em classes no MOSA
da figura 3.8. Os relacionamentos entre as classes tambm foram mantidos. Foram acrescentados
1-LANAMENTOS {LANCAMEN}
===============
1-ORDEM DE SERVIO {MENUOS}
1-LANAMENTO 1 PARTE {OSTELA1}
2-LANAMENTO 2 PARTE {OSTELA2}
3-LANAMENTO TOTAL {OSTELA}
4-MODIFICAO 1 PARTE {MODOS1}
5-MODIFICAO 2 PARTE {MODOS2}
6-CANCELAMENTO DA O.S. {CANCELOS}
2-COMPRAS {MENUCOM}
1-PEDIDO DE PEAS {MENUPP}
1-INSERO {INSEPEPE}
2-MODIFICAO {ALTPEPE}
3-ELIMINAO {ELIPEPE}
2-COMPRAS DE PEAS {MENUCE}
1-INSERO {INSECE}
2-MODIFICAO {ALTPCE}
3-ELIMINAO {ELICE}
3-VENDAS DE PEAS POR BALCO {MENUVEND}
1-INSERO {INSECVE}
2-MODIFICAO {ALTCVE}
3-ELIMINAO {ELICVE}
4-CONTAS A PAGAR {CONTASPA}
1-INSERO {INSCAPAG}
2-MODIFICAO {ALTCAPAG}
3-ELIMINAO {ELICAPAG}
4-QUITAO {QUITCAPG}
5-CONTAS A RECEBER {CONTASPA}
1-INSERO {INSCAREC}
2-MODIFICAO {ALTCAREC}
3-ELIMINAO {ELICAREC}
4-QUITAO {QUITCARE}
53
ao MOSA as classes que estavam faltando no diagrama da figura 3.3, VTREP e EQUIVPEC,
conforme explicado na seo 3.4.1.
54
Figura 3.8 - MOSA Modelo de Objetos do MASA
*
*
rel-21
*
rel-23
1
rel-6
rel-10
*
1
1
rel-19 *
1
* rel-15
1
1 *
rel-18
1
rrel-12
rel-11
rel-13
rel-14
*
1
1
*
*
*
rel-30
1
1
1
rel-26
*
rel-29
1
rel-25
1
*
*
*
*
*
1
*
0..1
*
1
rel-8
*
1
rel-5
* 1
rel-7
*
rel-9
*
1
*
1
1
*
*
*
*
rel-20
* *
1 1
rel-34
*
1
rel-31
rel-28
0..1
rel-4
*
rel-22
*
1
1
rel-33
*
1
*
* 1
1
*
rel-27
1
*
rel-3
rel-2
Ordserv
osnro
codcliente
nroveiculo
dataentra
Clientes
codcliente
nome
Cliveic
codcliente
nroveiculo
codveiculo
placa
Ospecas
osnro
codbarra
codoutpeca
quantidade
precotot
Osmobra
osnro
codmobra
codemp
preco
Empregad
codemp
nome
1
Tipoveic
codveiculo
marca
tipo
Outpecas
codoutpeca
descricao
codfabric
custounit
Pecas
codbarra
descricao
codfabric
eletmec
custounit
qtest
Contarec
osnro
nrovenda
datavenc
parcela
valor
Vendas
nrovenda
codcliente
codempreg
data
Itemvend
nrovenda
codbarra
quantidade
precounit
rel-24
rel-32
Fabrican
codfabric
nome
rel-1
Codmobra
codmobra
descricao
Componen
componente
descricao
Compras
nrocompra
nropedido
codfornec
dataped
datacomp
situacao
Itemcomp
nrocompra
codbarra
quantidade
precounit
Fornec
codfornec
nome
Ramoforn
codfornec
codramo
Contapag
numero
datavenc
parcela
valor
Temprep
codmobra
codveiculo
tempo
Vtrep
codmobra
codveiculo
quantvt
Pecacomp
componente
codpeca
*
rel-16
*
*
rel-17
Veicomp
componente
veiculo
Veipeca
codbarra
veiculo
Tiporamo
codramo
descricao
Equivpeca
codpeca1
codpeca2
55
Ao invs da notao do mtodo Fusion, preconizada em [Col 94], os Modelos de Objetos
so aqui representados utilizando a notao UML (Unified Modeling Language) [Eri 98, Fow
98], que plenamente compatvel. Vale observar que, na UML, o modelo equivalente ao Modelo
de Objetos denominado Diagrama de Classes. A UML foi adotada por suportar a
representao de padres de software, que necessria no captulo 5.
Alguns acrscimos de notao foram feitos. Entre esses pode-se mencionar o uso de
linhas tracejadas para denotar os pseudo-relacionamentos, o uso de palavras sublinhadas para
denotar atributos que so chaves estrangeiras e o uso de palavras em negrito para denotar
atributos que so chave primria da classe. Por exemplo, Ordserv tem o pseudo-
relacionamento rel-29 com Ospecas, devido existncia da chave estrangeira osnro em
Ospecas. Por motivos de falta de espao, foram colocados nas classes apenas os atributos mais
significativos. Por exemplo, dos quinze campos do arquivo ORDSERV que constam da figura
3.4, apenas quatro atributos constam na classe Ordserv da figura 3.8. Maiores detalhes dessa
obteno do MASA podem ser encontrados em [Bra 98a]. Note-se que l usada a prpria
notao do Fusion.
Figura 3.9 - Parte do MASA e Procedimentos do Sistema Legado
56
Terminada a construo do MOSA, possvel analisar alguns procedimentos do sistema
legado a fim de detectar a ocorrncia de anomalias, conforme descrito na seo 3.2. A figura 3.9
ilustra dois procedimentos do sistema legado, Ostela1 (P1) e Altveic (P2), classificados
respectivamente como c+e c, nos quais pode-se observar claramente a ocorrncia de anomalias
em P1, j que ele l e/ou altera quatro classes. No trecho de cdigo mostrado na figura 3.6
possvel constatar algumas dessas anomalias, como por exemplo a alterao da classe Clientes
(linhas 41 a 43).
lifecycle Auto-eltrico e Mecnica:=(Lanamentos | Relatrios | Consultas |
Manuteno_de_arquivos | Manuteno_de_tabelas | Impressos )*
Lanamentos =(lancamento_prim_parte . [#Ordem_Servio_impressa]) |
(lanamento_seg_parte . [#Relat_servios_executados]) |
modificao_prim_parte | modificao_seg_parte | cancelamento_os |
insero_pedido | modificao_pedido | eliminao_pedido |
insero_compra | modificao_compra | eliminao_compra |
insero_vendas | modificao_vendas | eliminao_vendas |
insero_conta_a_pagar | alterao_conta_a_pagar |
eliminao_conta_a_pagar | quitao_conta_a_pagar |
insero_conta_a_receber | alterao_conta_a_receber |
eliminao_conta_a_receber | quitao_conta_a_receber)
Relatrios =(rel_ord_serv_pendentes | rel_ord_serv_do_ms | rel_pecas_estoque_critico
| rel_pecas_em_estoque | rel_precos_por_fabricante | rel_equivalencia_entre_pecas
| rel_pecas_por_componente | rel_pecas_adquiridas_fora | rel_pedidos_pendentes
| rel_pedidos_pendentes_por_fornecedor | rel_compras_ms | rel_itens_cancelados
| rel_vendas_ms | rel_contas_a_pagar | rel_contas_a_receber | rel_balanco_mensal
| rel_cliente_ord_alfabet | rel_cliente_por_entidade | rel_fornecedor_ord_alfabet
| rel_fornecedor_por_ramo | rel_fabricante | rel_empregado | rel_componentes
| rel_veiculos | rel_mao_de_obra | tabela_sugestao_precos
| tabela_servicos_eletricos | tabela_servicos_mecaNicos)
Consulta =( cons_peca_letra_inicial | cons_peca_fabricante | cons_peca_codigo_barras |
cons_peca_codigo_original | cons_equivalencia_peca | cons_estatistica_custos |
cons_fornecedores | cons_vendas | cons_empregados | cons_compras |
cons_componentes | cons_clientes )
Manuteno_de_arquivos =( insero_pecas | alterao_pecas | eliminao_peas |
insero_fornecedores | alterao_fornecedores | eliminao_fornecedores |
insero_empregados | alterao_empregados | eliminao_empregados |
insero_clientes | alterao_clientes | eliminao_clientes |
insero_fabricantes | alterao_fabricantes | eliminao_fabricantes |
insero_componentes | alterao_componentes | eliminao_componentes |
insero_mo_de_obra | alterao_mo_de_obra | eliminao_mo_de_obra |
insero_veculos | alterao_veculos | eliminao_veculos )
Manuteno_de_tabelas =(tabela_sugesto_de_preos | insero_tabela_valor_trabalho |
alterao_tabela_valor_trabalho | eliminao_tabela_valor_trabalho |
insero_tabela_tempo_reparo | alterao_tabela_tempo_reparo )
eliminao_tabela_tempo_reparo)
Impressos = (cheques | duplicatas | ord_servico | termo_garantia
| recibo| cancelamento_protestos | carta_cancelamento | vales
| etiq_cod_barra_por_fornecedor | etiq_cod_barra_por_peca
| etiq_cod_barra_por_compra | etiq_cod_barra_pecas_miudas | etiq_por_estantes
| etiq_clientes | etiq_pessoa_juridica | etiq_pessoa_fisica | etiq_cli_por_entidade
| etiq_clientes_desejados | etiq_clientes_duplicatas | etiq_fornecedores )
Figura 3.10 - MCVSA - Modelo de Ciclo de Vida do Sistema Atual
57
Na figura 3.10 mostrado o Modelo de Ciclo de Vida do Sistema Atual (MCVSA),
obtido com base nos menus do sistema legado e no cdigo fonte. Comparando a figura 3.7 com a
figura 3.10, pode-se observar que a opo 1-Lanamento da figura 3.7 deu origem ao smbolo
no-terminal Lanamentos da figura 3.10. Qualquer uma das opes de lanamento pode ser
executada a qualquer momento dentro do ciclo de vida do sistema. Assim, foram criadas
operaes representando cada uma dessas opes, sendo permitida a execuo de qualquer uma
delas por meio de um | (operador ou).
Na figura 3.11 mostrado um dos esquemas do Modelo de Operaes do Sistema Atual
(MOpSA), correspondente ao lanamento da primeira parte da ordem de servio. A elaborao
desses esquemas baseou-se no cdigo fonte do sistema legado e tambm na execuo da opo
correspondente operao nos menus do sistema legado. Por exemplo, na figura 3.6 um
programador Clipper poderia facilmente reconhecer os trechos referentes gerao do nmero
nico de ordem de servio (linhas 10 a 12 e 17) e criao de um novo cliente (linhas 34 a 43),
que so tarefas especificadas na clusula Result do esquema da figura 3.11. Esquemas para
outras operaes podem ser encontrados em [Bra 98a].
Operation : lanamento_prim_parte
Description : "Faz o lanamento da primeira parte da Ordem de Servio "
Reads : Supplied : Data_entr : char , Orcam : int , Serv_a_exec : char ,
Dt_entrega : char , Hora_entrega : char
Changes : new cli : Clientes,
new os : Ordserv ,
new veic : Cliveic
new mod : Tipoveic
Sends : Oficina {Ordem_de_Servio_Impressa }
Result : " Uma new os foi criada
Um nmero nico de os foi gerado
os.dataentra foi iniciada com Data_entr
os.orcamen foi iniciada com Orcam
os.servex1 foi iniciada com Serv_a_executar
os.dataprom foi iniciada com Dt_entrega
os.horaprom foi iniciada com Hora_entrega
Se o cliente ainda no estava cadastrado
ento um new cli foi criado
Se era a primeira vez que o veiculo estava sendo consertado
ento um new veic foi criado
Ordem_de_Servio_Impressa (Ordem de Servio) foi enviada oficina
Se o modelo de veculo ainda no estava cadastrado
ento um new mod foi criado"
Figura 3.11 - Esquema para a operao lancamento_prim_parte do MOpSA
58
3.4.3 - Abstrao do Modelo de Anlise do Sistema
O passo de abstrao do MAS foi feito utilizando o processo de detalhamento proposto
em [Bra 98a] e descrito na seo 3.3, ao invs do processo recomendado em [Pen 96a]. As
diversas etapas da abstrao efetuada so mostradas a seguir, englobando as transies do MOSA
para o MOS, do MCVSA para o MCVS e do MOpSA para o MOpS.
Na figura 3.12 mostrado o MOS-1, obtido na primeira etapa, no qual os pseudo-
relacionamentos existentes no MOSA da figura 3.8 foram transformados em relacionamentos,
removendo-se os atributos das classes cujo nico objetivo era fazer o relacionamento entre elas.
Por exemplo, da classe Cliveic foram removidos os atributos codcliente e codveiculo, cuja
funo era relacion-la s classes Clientes e Tipoveic, respectivamente. Dessa forma, os
pseudo-relacionamentos entre elas (rel-1 e rel-4), que eram denotados por linhas tracejadas,
tornaram-se relacionamentos, denotados por linhas contnuas.
Na segunda etapa do processo de detalhamento, diversas classes foram eliminadas, alm
de modificar os relacionamentos existentes. A figura 3.13 mostra o MOS-2 obtido. As
classes Ramoforn, Pecacomp, Veipeca e Veicomp, que aparecem na figura 3.12, foram
eliminadas de forma direta. O fato delas terem ficado sem atributo algum aps a primeira etapa
forneceu a indicao de que sua utilidade era apenas de ligao entre duas outras classes. As
classes Temprep e Vtrep foram analisadas cuidadosamente por possurem apenas um
atributo. Como esse atributo no identifica unicamente um elemento da classe, ele pde ser
transferido para o relacionamento resultante entre Tipoveic e Codmobra. Isso representado
no modelo da figura 3.13 pelos rtulos junto classe Codmobra com os nomes desses atributos
(tempo e quantvt, respectivamente).
A classe Equivpec foi eliminada com base no conhecimento sobre o domnio da
aplicao. O arquivo do MOSA Equivpec possui atributos codpeca1 e codpeca2 (ver
figura 3.8). Estudando o problema em questo e os procedimentos responsveis por alimentar
esse arquivo, deduz-se que esses atributos representam um auto-relacionamento da classe
Pecas, indicando que a pea cujo cdigo codpeca1 equivalente pea cujo cdigo
codpeca2. Adotou-se a conveno de dar o prprio nome da classe sendo excluda ao
relacionamento resultante aps sua excluso.
Na terceira etapa do processo de detalhamento foram criadas agregaes envolvendo as
classes Ordserv, Ospecas e Osmobra, as classes Vendas e Itemvend e as classes
59
Compras e Itemcomp. A figura 3.14 mostra o MOS-3 obtido nessa etapa. Duas
especializaes foram identificadas: nas classes Peas e Outpecas, originando a superclasse
Pea e nas classes Contarec e Contapag, originando a superclasse Conta. Os atributos
comuns s subclasses foram devidamente transferidos para a superclasse recm criada.
*
*
rel-21
*
rel-23
1
rel-6
rel-10
*
1
1
rel-19 *
1
* rel-15
1
1 *
rel-18
1
rrel-12
rel-11
rel-13
rel-14
*
1
1
*
*
*
rel-30
1
1
1
rel-26
*
rel-29
1
rel-25
1
*
*
*
*
*
1
*
0..1
*
1
rel-8
*
1
rel-5
* 1
rel-7
*
rel-9
*
1
*
1
1
*
*
*
*
rel-20
* *
1 1
rel-34
*
1
rel-31
rel-28
0..1
rel-4
*
rel-22
*
1
1
rel-33
*
1
*
* 1
1
*
rel-27
1
*
rel-3
rel-2
Ordserv
osnro
dataentra
Clientes
codcliente
nome
Cliveic
nroveiculo
placa
Ospecas
quantidade
precotot
Osmobra
preco
Empregad
codemp
nome
1
Tipoveic
codveiculo
marca
tipo
Outpecas
codoutpeca
descricao
custounit
Pecas
codbarra
descricao
eletmec
custounit
qtest
Contarec
datavenc
parcela
valor
Vendas
nrovenda
data
Itemvend
quantidade
precounit
rel-24
rel-32
Fabrican
codfabric
nome
rel-1
Codmobra
codmobra
descricao
Componen
componente
descricao
Compras
nrocompra
nropedido
dataped
datacomp
situacao
Itemcomp
quantidade
precounit
Fornec
codfornec
nome
Ramoforn
Contapag
datavenc
parcela
valor
Temprep
tempo
Vtrep
quantvt
Pecacomp
*
rel-16
*
*
rel-17
Veicomp
Veipeca
Tiporamo
codramo
descricao
Equivpeca
60
Figura 3.12 - MOS-1 Modelo de Objetos do MAS Etapa 1
* *
veipeca
veicomp
*
*
* *
equivpec
*
rel-23
1
rel-6
1
* *
vtrep
temprep
*
rel-30
1
1
1
rel-26
*
rel-29
1
rel-25
1
*
*
*
*
*
1
*
0..1
*
1
rel-8
*
1
rel-5
* 1
rel-7
*
ramoforn
*
*
*
1
1
* pecacomp
*
rel-34
* 1
rel-31
rel-28
0..1
rel-4
*
rel-22
*
1
1
rel-33
*
1
*
* 1
1
*
rel-27
1
*
rel-3
rel-2
Ordserv
osnro
dataentra
Clientes
codcliente
nome
Cliveic
nroveiculo
placa
Ospecas
quantidade
precotot
Osmobra
preco
Empregad
codemp
nome
1
Tipoveic
codveiculo
marca
tipo
Outpecas
codoutpeca
descricao
custounit
Pecas
codbarra
descricao
eletmec
custounit
qtest
Contarec
datavenc
parcela
valor
Vendas
nrovenda
data
Itemvend
quantidade
precounit
rel-24
rel-32
Fabrican
codfabric
nome
rel-1
Codmobra
codmobra
descricao
Componen
componente
descricao
Compras
nrocompra
nropedido
dataped
datacomp
situacao
Itemcomp
quantidade
precounit
Fornec
codfornec
nome
Contapag
datavenc
parcela
valor
Tiporamo
codramo
descricao
quantvt tempo
61
Figura 3.13 - MOS-2 Modelo de Objetos do MAS Etapa 2
62
*
*
*
*
*
1
*
0..1
*
*
1 1
rel-8
rel-8a
*
1
rel-5
1 0..1
refere-se a
*
*
1
1
rel-7a
rel-7
*
*
ramoforn
*
*
*
*
*
*
veicomp
*
veipeca
*
*
pecacomp
* *
*
*
temprep
rel-34
vtrep
*
1
rel-31
rel-28
0..1
equivpec
*
*
1
rel-4
*
rel-23
* 1
1
rel-33
*
1
*
* 1
1
* rel-26
1
*
rel-3
rel-2
Ordserv
osnro
dataentra
Cliente
cocliente
nome
Cliveic
nroveiculo
placa
Ospecas
quantidade
precotot
Osmobra
preco
Peca
descricao
custounit
precovenda
Empregad
codemp
nome
1
Tipoveic
codveic
marca
tipo
Outpecas
Cdigo
Pecas
codbarra
qtest
Conta
datavenc
parcela
valor
Vendas
nrovenda
data
Itemvend
quantidade
precounit
rel-24
rel-1
Contarec
Contapag
Fabrican
codfabric
nome
rel-1
Codmobra
codmobra
descricao
Componen
componente
descricao
Pedido
nropedido
data
situao
Itens do pedido
quantidade
precounit
Compra
nrocompra
data
valor
Itemcomp
quantidade
precounit
Fornec
codfornec
nome
Ramo
codramo
descrico
quantvt tempo
Figura 3.14 - MOS-3 Modelo de Objetos do MAS Etapa 3
63
Durante a elaborao do MOS-3 percebeu-se que a classe Compras, do MOS-2,
englobava tambm os pedidos feitos ao fornecedor. Assim, resolveu-se acrescentar mais uma
classe ao MOS-3 que cobrisse esse aspecto, denominada Pedido. Foi tambm necessrio
acrescentar a classe Itens do pedido para tratar dos itens constantes do pedido. Os atributos que
antes constavam da classe Compras foram distribuidos entre as classes resultantes, Compra e
Pedido, de acordo com seu significado semntico. Isso pode ser observado comparando-se a
figura 3.13 com a figura 3.14. Nota-se tambm que foi acrescentado o relacionamento refere-se
a entre Compra e Pedido, j que a compra feita aps o pedido ter sido atendido pelo
fornecedor. Outros detalhes importantes tiveram que ser cuidados, por meio de minucioso exame
do cdigo fonte. Por exemplo, ao fazer a especializao deve-se examinar os relacionamentos
das subclasses com as demais classes, para descobrir se eles devem ser mantidos na subclasse ou
se podem ser transferidos para a superclasse. Assim, os relacionamentos rel-26 e rel-27 do
MOS-2 puderam ser fundidos no relacionamento rel-26 do MOS-3, j que peas trocadas na
ordem de servio podem ser tanto as adquiridas fora quanto as em estoque. Da mesma forma os
relacionamentos rel-22 e rel-23 do MOS-2 puderam ser fundidos no relacionamento rel-23
do MOS-3, j que ambos os tipos de pea possuem fabricante. J os relacionamentos rel-24 e
rel-8 foram mantidos ligados classe Pecas, pois peas vendidas no balco ou compradas do
fornecedor referem-se somente s peas em estoque.
Na quarta etapa do processo de detalhamento foi criado o MOS-4, mostrado na figura
3.15. Nele foram acrescentadas algumas entradas mais relevantes do sistema e os agentes
externos que com ele interagem, estabelecendo seus limites. Esses agentes so o atendente e o
gerente da empresa. O atendente necessrio porque o sistema no do tipo self-service.
Existe um atendente intermedirio, que faz os lanamentos no computador e recebe alguns
relatrios de sada. Outros relatrios mais sofisticados so entregues ao gerente, que os analisa e
toma suas decises. Como existem muitas operaes nesse sistema, foram explicitadas apenas as
mais relevantes. Por exemplo, conveniente explicitar o papel do atendente de abrir e fechar
uma ordem de servio. Todavia, ao surgir um novo tipo de veculo haveria necessidade de incluir
tempo de reparo e/ou valor de trabalho correspondente, o que seria feito pelo gerente. O mesmo
aconteceria quando aparecesse um fornecedor novo, um empregado novo, etc. Operaes desse
tipo no foram modeladas.
64
*
*
*
*
*
1
*
0..1
*
*
1 1
rel-8
rel-8a
*
1
rel-5
1 0..1
refere-se a
*
*
1
1
rel-7a
rel-7
*
*
ramoforn
*
*
*
*
*
*
veicomp
*
veipeca
*
*
pecacomp
* *
*
*
temprep
rel-34
vtrep
*
1
rel-31
rel-28
0..1
equivpec
*
*
1
rel-4
*
rel-23
* 1
1
rel-33
*
1
*
* 1
1
* rel-26
1
*
rel-3
rel-2
Ordserv
osnro
dataentra
Cliente
cocliente
nome
Cliveic
nroveiculo
placa
Ospecas
quantidade
precotot
Osmobra
preco
Peca
descricao
custounit
precovenda
Empregad
codemp
nome
1
Tipoveic
codveic
marca
tipo
Outpecas
Cdigo
Pecas
codbarra
qtest
Conta
datavenc
parcela
valor
Vendas
nrovenda
data
Itemvend
quantidade
precounit
rel-24
rel-1
Contarec
Contapag
Fabrican
codfabric
nome
rel-1
Codmobra
codmobra
descricao
Componen
componente
descricao
Pedido
nropedido
data
situao
Itens do pedido
quantidade
precounit
Compra
nrocompra
data
valor
Itemcomp
quantidade
precounit
Fornec
codfornec
nome
Ramo
codramo
descrico
quantvt tempo
:Atendente
:Atendente
:Atendente
:Gerente
:Atendente
lana
abre/fecha
lana
faz
quita
faz
Figura 3.15 - MOS-4 Modelo de Objetos do MAS Etapa 4
65
Na quinta etapa do processo de detalhamento foi elaborado o MOS-5, mostrado na figura
3.16. Esse modelo mostra algumas sadas do sistema, bem como os agentes externos que as
manuseiam. Por exemplo, o gerente acompanha o relatrio de ordens de servios pendentes e o
relatrio de peas com estoque crtico, o atendente utiliza a relao de clientes e o mecnico
recebe a ordem de servio impressa. Como pode ser visto na figura 3.10 existem inmeros
relatrios e impressos nesse sistema que dariam origem a classes no modelo de objetos.
Entretanto, por motivos de falta de espao, apenas alguns deles foram colocados no modelo,
principalmente os mais significativos para o sistema.
Figura 3.16 - MOS-5 Modelo de Objetos do MAS Etapa 5
Na sexta etapa do processo de detalhamento os nomes de classes, atributos e
relacionamentos foram mudados para outros mais significativos dentro do domnio de aplicao.
Foram tambm acrescentados alguns atributos s classes que tinham sido ignorados nos modelos
anteriores por questes prticas. O resultado dessas etapas est presente nos modelos
apresentados nas figuras 3.17 e 3.18, que juntos formam o Modelo de Objetos do Sistema
(MOS).
*
* *
1
Clientes
Ordserv
Cliveic
Peca
rel-1
rel-3
1
*
*
Relao de Pecas
Em ordem
alfabtica
Por cdigo de
barras
Por localizao
Por fabricante
Estoque crtico
Relatrio de Ordens
de servio
pendentes
:Gerente
usa
usa
*
*
Ordemde servio
impressa
usa
*
*
:Mecnico
Relao de Clientes
Em ordem
alfabtica
Por entidade
:Atendente
usa
*
acompanha
enviada a
utiliza
acompanha
66
*
*
*
*
*
1
*
0..1
*
*
1 1
uma
uma
*
1
gera
1 0..1
refere-se a
*
*
1
1
feito a
feita a
*
*
trabalha com
*
*
*
*
*
*
adapta-se a
*
adapta-se a
*
*
faz parte do
* *
*
*
temvalor
de trabalho
de acordo
com
feitopor
temtempo
de reparo de
acordo com
*
1
obedece
executadapor
0..1
equivalente a
*
*
1
de um
*
feitapor
* 1
1
gera
*
1
*
* 1
1
* uma
1
*
atendidopor
procura
Ordemde Servio
Nro da Ordem Serv.
Data de entrada doveic.
Defeitos apresentados
Preo total
Data de sada doveic.
Cliente
Cdigo
Nome
Endereo
Telefone
RG/ins.est.
DataNascto
Veculo de cliente
Nro sequencial
Placa
Pea da Ordemde Serv.
Quantidade
Preo
Mo-de-obra da
Ordemde Serv.
Preo
Pea
Descrio
Custo unitrio
Preo de venda
Empregado
Cdigo
Nome
Endereo
Especialidade
1
Tipo de veculo
Cdigo
Marca
Tipo
Pea adquirida fora
Cdigo
Local da compra
Pea do estoque
Cdigo de barra
Qtde emestoque
Localizao
Conta
Data de vencimento
Nro da parcela
Valor
Nro do cheque
Situao
Atendimentopor balco
Nro do Atendimento
Data
Valor Total
Pea vendida
Quantidade
Preo Unitrio
uma
gera
Conta a Receber
Duplicata emitida?
Nro da duplicata
Conta a Pagar
Fabricante
Cdigo
Nome
possui
Tipo de mo-de-obra
Cdigo
Descrio da mo-de-obra
Componente
Cdigo
Descrio
Pedido
Nro do Pedido
Data
Situao
Pea pedida
Quantidade
Preo unitrio
Compra
Nro da Compra
Data
Valor total
Nome do vendedor
Valor do ICMC
Pea comprada
Quantidade
Preo unitrio
Desconto unitrio
Fornecedor
Cdigo
Nome
Fax
Nome do vendedor
Ramo
Cdigo
Descrio
:Atendente
:Atendente
:Atendente
:Gerente
:Atendente
lana
abre/fecha
lana
faz
quita
faz
tempo quantvt
Figura 3.17 - MOS-6a Modelo de Objetos do MAS Etapa 6 Parte A
67
Figura 3.18 - MOS-6b Modelo de Objetos do MAS Etapa 6 Parte B
Para comprovar essa melhoria de nomes obtida no MOS-6, pode-se consultar a tabela 3.1,
apresentada na seo 3.4.4, que faz a correspondncia entre as classes do MAS e os arquivos do
MASA. A tabela 3.2 mostra alguns nomes de atributos que tambm foram alterados. Vale
ressaltar que algumas classes e relacionamentos foram includos nos modelos com o nome
definitivo, visto que quando da sua incluso j se conhecia mais sobre o domnio de aplicao.
Terminada a construo do MOS, o cdigo fonte dos procedimentos com anomalias
detectadas no passo dois pode ser analisado de forma a identificar os mtodos de cada classe que
seriam necessrios para resolver essas anomalias. A figura 3.19 mostra parte do MAS e os vinte e
quatro mtodos identificados na operao Ostela1. Esses mtodos foram identificados
examinando o cdigo fonte da operao do sistema legado e subdividindo em mtodos os trechos
que possuem anomalias. Cada mtodo atribudo classe qual faz referncia, como pode ser
observado na figura 3.19. Cabe ressaltar que, nessa etapa, os mtodos so apenas identificados,
mas no feita a separao fsica do cdigo. Essa separao cuidada durante a reengenharia
com mudana de orientao, que vista na seo 4.2.
*
* *
1
Cliente
Ordemde
Servio
Veculo de
Cliente
Pea do
estoque
possui
atendido
por
1
*
*
Relao de Pecas
Em ordem
alfabtica
Por cdigo de
barras
Por localizao
Por fabricante
Estoque crtico
Relatrio de Ordens
de servio
pendentes
:Gerente
usa
usa
*
*
Ordemde servio
impressa
usa
*
*
:Mecnico
Relao de Clientes
Em ordem
alfabtica
Por entidade
:Atendente
usa
*
acompanha
enviada a
utiliza
acompanha
68
Figura 3.19 - Parte do MAS e mtodos correspondentes
Para completar a elaborao do MAS, os Modelos de Ciclo de Vida e de Operaes
foram abstrados a partir dos respectivos modelos do MASA. A figura 3.20 mostra o Modelo de
Ciclo de Vida do MAS (MCVS) e a figura 3.21 mostra um dos esquemas do Modelo de
Operaes do MAS (MOpS), mais especificamente para a operao Abre_Ordem_de_Servio.
Comparando o MCVSA (figura 3.10) ao MCVS (figura 3.20), nota-se que os nomes das
operaes foram substitudos por outros mais significativos e as operaes foram agrupadas de
forma diferente, de modo que possam ser encontradas com mais facilidade de acordo com seu
significado semntico. Quanto ao Modelo de Operaes do MAS, foi feita a adaptao dos
nomes e atributos das classes de acordo com o novo Modelo de Objetos, preservando a
funcionalidade e interface do sistema. Exemplos da correspondncia entre o MAS e o MASA
podem ser vistos na seo 3.4.4.
69
Figura 3.20 - MCVS - Modelo de Ciclo de Vida do Sistema
3.4.4 - Mapeamento MAS/MASA
Graas ao nvel de detalhamento com que foi feita a transio do MASA para o MAS, a
realizao deste passo foi facilitada. Sua finalidade, conforme explicado na seo 3.2,
estabelecer a correspondncia entre o Modelo de Anlise do Sistema, que considera
principalmente o domnio de aplicao e no a implementao fsica atual e o Modelo de Anlise
do Sistema Atual, feito com base na estrutura de dados do sistema legado. Essa correspondncia
importante, pois no caso de no ser conduzida a reengenharia do sistema, ela ser utilizada
durante o processo de manuteno.
lifecycle Auto-eltrico e Mecnica:=
(Lanamento | Atualizao_arquivos | Impresso | Consulta )*
Lanamento =(abre_ordem_de_servio . [#Ordem_Servio_impressa]) | modifica_ord_serv |
elimina_ord_serv | (fecha_ordem_de_servio . [#Relat_servios_executados]) |
insere_atendimento_balco | altera_atendimento_balco | elimina_atendimento_balco
| insere_compra | altera_compra |elimina_compra | insere_pedido | altera_pedido |
elimina_pedido |insere_conta_a_pagar | insere_conta_a_receber |
altera_conta_a_pagar | altera_conta_a_receber | elimina_conta_a_pagar |
elimina_conta_a_receber | quita_conta_a_pagar | quita_conta_a_receber )
Atualizao_arquivos =( insere_peca | insere_cliente | insere_fabricante | insere_fornecedor |
insere_empregado | insere_tipo_veiculo | insere_valor_de_trabalho |
insere_tempo_de_reparo | insere_componente | insere_mao_de_obra |
altera_peca | altera_cliente | altera_fabricante | altera_fornecedor |altera_empregado |
altera_tipo_veiculo | altera_valor_de_trabalho | altera_tempo_de_reparo |
altera_componente | altera_mao_de_obra |elimina_peca | elimina_cliente |
elimina_fabricante | elimina_fornecedor | elimina_empregado | elimina_tipo_veiculo |
elimina_valor_de_trabalho | elimina_tempo_de_reparo | elimina_componente |
elimina_mao_de_obra | atualiza_tabela_sugestao_de_precos )
Impresso =(rel_ord_serv_pendentes | rel_ord_serv_do_ms | rel_pecas_estoque_critico
| rel_pecas_em_estoque | rel_precos_por_fabricante | rel_equivalencia_entre_pecas
| rel_pecas_por_componente | rel_pecas_adquiridas_fora | rel_pedidos_pendentes
| rel_pedidos_pendentes_por_fornecedor | rel_compras_ms | rel_itens_cancelados
| rel_vendas_ms | rel_contas_a_pagar | rel_contas_a_receber | rel_balanco_mensal
| rel_cliente_ord_alfabet | rel_cliente_por_entidade | rel_fornecedor_ord_alfabet
| rel_fornecedor_por_ramo | rel_fabricante | rel_empregado | rel_componentes
| rel_veiculos | rel_mao_de_obra | rel_sugestao_precos | rel_servicos_eletricos
| rel_servicos_mecanicos | cheques | duplicatas | ord_servico | termo_garantia
| recibo| cancelamento_protestos | carta_cancelamento | vales
| etiq_cod_barra_por_fornecedor | etiq_cod_barra_por_peca
| etiq_cod_barra_por_compra | etiq_cod_barra_pecas_miudas | etiq_por_estantes
| etiq_clientes | etiq_pessoa_juridica | etiq_pessoa_fisica | etiq_cli_por_entidade
| etiq_clientes_desejados | etiq_clientes_duplicatas | etiq_fornecedores )
Consulta =( cons_peca_letra_inicial | cons_peca_fabricante | cons_peca_codigo_barras |
cons_peca_codigo_original | cons_equivalencia_peca | cons_estatistica_custos |
cons_fornecedores | cons_vendas | cons_empregados | cons_compras |
cons_componentes | cons_clientes )
70
Operation : abre_ordem_de_servio
Description : " D entrada em uma ordem de servio "
Reads : Supplied : Data_entr : char , Orcam : int , Serv_a_exec : char ,
Dt_entrega : char , Hora_entrega : char
Changes : new cli : Cliente,
new os : Ordem de Servio ,
new veic : Veculo de Cliente
new mod : Tipo de Veculo
Sends : Oficina {Ordem_de_Servio_Impressa }
Result : " Uma new os foi criada
Um nmero nico de os foi gerado
os.Data Entrada foi iniciada com Data_entr
os.Oramento foi iniciada com Orcam
os.Servios a executar foi iniciada com Serv_a_executar
os.Data Entrega foi iniciada com Dt_entrega
os.Hora Entrega foi iniciada com Hora_entrega
Se o cliente ainda no estava cadastrado
ento um new cli foi criado
Se era a primeira vez que o veiculo estava sendo consertado
ento um new veic foi criado
Ordem_de_Servio_Impressa (Ordem de Servio) foi enviada oficina
Se o modelo de veculo ainda no estava cadastrado
ento um new mod foi criado"
Figura 3.21 - Esquema para a operao abre_ordem_de_servio do MOpS
A tabela 3.1 indica a correspondncia entre as classes do MOS e os arquivos do sistema
legado. Nela pode-se perceber os arquivos eliminados durante a abstrao, bem como as classes
includas durante a mesma. O processo de detalhamento efetuado com base em [Bra 98a] permite
que se saiba exatamente em que etapas foram eliminados ou includos cada um dos componentes
do MOS.
A tabela 3.2 mostra a correspondncia entre o MAS e o MASA para as classes Veculo de
Cliente e Ordem de Servio e seus atributos. Pode-se observar nessa tabela os atributos
eliminados durante a abstrao, mais especificamente durante a etapa 1 do processo de
detalhamento.
A tabela 3.3 mostra a correspondncia entre algumas operaes do MAS e do MASA.
Nesse caso, houve apenas uma melhora nos nomes das operaes. No houve incluso ou
excluso de operaes, pois a funcionalidade do sistema foi mantida.
71
Tabela 3.1 Correspondncia entre classe do MAS e arquivos do MASA
Classe do MAS Arquivo do
MASA
Atendimento por balco
Cliente
Componente
Compra
Conta
Conta a Pagar
Conta a Receber
Empregado
Fabricante
Fornecedor
Mo-de-obra da Ordem de Serv.
Ordem de Servio
Pea
Pea adquirida fora
Pea comprada
Pea da Ordem de Serv.
Pea do estoque
Pea pedida
Pea vendida
Pedido
Ramo
Tipo de mo-de-obra
Tipo de veculo
Veculo de cliente
-
-
-
-
-
-
-
Vendas
Contarec
Componen
Compras
-
Contapag
Contarec
Empregad
Fabrican
Fornec
Osmobra
Ordserv
-
Outpecas
Itemcomp
Ospecas
Pecas
-
Itemvend
-
Ramo
Codmobra
Tipoveic
Cliveic
Equivpec
Pecacomp
Ramoforn
Temprep
Veipeca
Veicomp
Vtrep
3.5 Consideraes Finais
A aplicao do Fusion/RE ao domnio de sistemas de informao mostrou que nesse
domnio h algumas facilidades, quanto engenharia reversa dos dados, decorrentes
principalmente do uso de tabelas normalizadas no sistema legado. Por outro lado, quanto aos
procedimentos, a abstrao dos mtodos foi facilitada, j que o sistema legado foi desenvolvido
em uma linguagem de nvel mais alto.
O detalhamento do passo de abstrao torna mais ameno o uso do Fusion/RE, que
anteriormente exigia um salto maior entre o passo de elaborao do Modelo de Anlise do
Sistema Atual e o do Modelo de Anlise do Sistema.
72
Tabela 3.2 Correspondncia entre classes/atributos do MAS e arquivos/campos do MASA
MAS MASA
Modelo de Objetos
Classe: Veculo de Cliente
Arquivo
Cliveic
Atributos Campos do Arquivo
-
-
Placa
Cidade
Quilometragem
Nro de meses
Nro sequencial
codcliente
codveiculo
placa
cidade
hskm
meses
nroveiculo
Modelo de Objetos
Classe: Ordem de Servio
Arquivo
Ordserv
Atributos Campos do Arquivo
Nro da Ordem Serv.
-
-
Data de entrada do veic.
Defeitos apresentados
Preo total
Data de sada do veic.
osnro
codcliente
nroveiculo
dataentra
servaex1, servaex2, servaex3
precotot
datacompra
Tabela 3.3 Correspondncia entre algumas operaes do MAS e do MASA
MAS MASA
Abre_Ordem_de_Servio
Fecha_Ordem_Serv
Insere_Compra
Insere_pea
Insere_pedido
Altera_pedido
Elimina_pedido
Lanamento_prim_parte
Lanamento_seg_parte
Insero_compra
Insero_pea
Insero_pedido
Alterao_pedido
Eliminao_pedido
Conforme se ver nos prximos captulos, essa engenharia reversa efetuada bsica tanto
para a reengenharia, descrita no captulo 4, quanto para o reconhecimento de padres, feito no
captulo 5.
73
Captulo 4 Reengenharia
4.1 Consideraes Iniciais
A engenharia reversa por si s j traz grandes benefcios quanto manutenibilidade do
sistema, j que so criados modelos em nveis mais altos de abstrao. Porm, para que esses
benefcios possam ser plenamente usufrudos, o cdigo fonte do sistema deve ser compatvel
com os modelos de anlise e projeto. Isso pode ser conseguido de duas formas: por segmentao
do sistema legado, mantendo a linguagem de programao original, ou por reengenharia com
mudana de linguagem. A primeira alternativa discutida na seo 4.2, na qual feita a
reengenharia com mudana de orientao e sem mudana de linguagem. A segunda alternativa
apresentada na seo 4.3, na qual a reengenharia com mudana de linguagem, pressupondo que a
de mudana de orientao j tenha sido feita, discutida. Na seo 4.4 apresentam-se as
consideraes finais deste captulo.
4.2 Reengenharia com mudana de orientao e sem mudana de linguagem
4.2.1 Abordagem proposta
Nesta seo prope-se uma abordagem para transformar cdigo originalmente orientado a
procedimentos para cdigo com as caractersticas da orientao a objetos. A linguagem de
programao mantida durante essa transformao. Essa abordagem foi tratada em [Pen 98a] e
ilustrada na figura 4.1. Aps a obteno dos modelos de anlise pelo Fusion/RE, dois passos
adicionais so executados: o projeto avante do sistema e a segmentao dos programas, descritos
a seguir.
No primeiro passo adicional elaborado o projeto avante do sistema, visando
reengenharia com mudana do paradigma de implementao, mas sem mudar a funcionalidade
do sistema. Nele so elaborados: o Grafo de Interao de Objetos, o Grafo de Visibilidade, a
Descrio de Classes e os Grafos de Herana.
74
Figura 4.1 - Abordagem proposta para reengenharia com mudana de orientao
O Grafo de Interao de Objetos construdo com base no Modelo de Operaes. Ele
mostra a passagem de mensagens entre os objetos, por intermdio dos mtodos, alm de
diferenciar entre a classe controladora da operao e as classes colaboradoras. Um pseudo-cdigo
escrito para o mtodo da classe controladora da operao, mostrando sua lgica e a seqncia
de chamada dos mtodos das classes colaboradoras. Note-se que o mtodo da classe controladora
(que implementa uma operao) interage com mais de um objeto, porm o faz por intermdio dos
mtodos das classes colaboradoras, com o que so evitadas as anomalias.
O Grafo de Visibilidade estabelece a comunicao entre as classes, delimitando quais
delas podem trocar mensagens e os tipos de mensagens a serem trocadas. Nos grafos de interao
de objetos assume-se que todos os objetos so mutuamente visveis, podendo trocar mensagens
entre si, o que restringido no Grafo de Visibilidade.
A Descrio de Classes contm documentao complementar ao modelo de objetos do
sistema. Assim, para cada classe so reunidas informaes que estavam espalhadas pelos vrios
elementos de documentao at agora produzidos. Do Grafo de Interao de Objetos so
retirados os mtodos; do Modelo de Objetos so extrados alguns atributos de dados e do Grafo
75
de Visibilidade os atributos objeto-valorados. So salientadas, para cada classe, todas as
interaes com as demais.
Os Grafos de Herana so um mecanismo pelo qual uma classe pode ser definida como
uma especializao de outra. Podem ser introduzidas novas classes nesta etapa.
Os procedimentos com anomalias podem agora ser examinados. O resultado desse exame
vai nortear a realizao do passo seguinte.
No segundo passo adicional feita a segmentao do sistema. Programas originalmente
monolticos e contendo anomalias so aqui desmembrados em mtodos, conforme definido nos
grafos de interao de objetos. Os programas so percorridos seqencialmente, identificando-se
os trechos relacionados a uma das classes identificadas no passo 3 do Fusion/RE. Quanto
maiores esses trechos, mais fcil ser a segmentao. Esses trechos sero a base para construo
de cada mtodo, devendo ser substitudos, no programa que corresponde operao, por uma
chamada de procedimento ou funo. Os mtodos obtidos devem ficar disponveis para serem
chamados pela operao. O ideal que sejam mtodos da classe correspondente, mas se a
linguagem de programao no suportar esse conceito, devero estar disponveis por outros
meios.
importante ressaltar que a segmentao do programa feita considerando o projeto do
sistema, desenvolvido no passo de projeto do Fusion, que foi conduzido como se o sistema fosse
ser reprogramado usando uma linguagem orientada a objetos. Isso facilita a segmentao, como
j foi observado, e elimina a dificuldade de identificao dos mtodos. Outra constatao de
que a segmentao no muda a linguagem de programao, no sendo ento verdadeiramente
orientada a objetos. Trata-se de um cdigo programado com estilo de tipos abstratos de dados e
no qual os mecanismos de especializao, generalizao e agregao podem ser simulados.
Entretanto, aps a segmentao, ele pode ser facilmente convertido para uma linguagem
orientada a objetos. Essa experincia foi feita por Sneed, transformando o cdigo legado de
COBOL para COBOL-OO [Sne 96].
Aps a segmentao pode-se proceder o teste do sistema segmentado, com o que se
assegura a conservao de sua funcionalidade. O cdigo segmentado pode servir como entrada
para uma transformao automtica de cdigo, conforme visto na seo 4.3. Entretanto, mesmo
que a mudana de linguagem no ocorra, muitos benefcios da orientao a objetos podero ser
colhidos durante a manuteno do sistema.
76
4.2.2 Estudo de Caso
Aps ter sido obtido o Modelo de Anlise do Sistema, pela aplicao do Fusion/RE, os
dois passos adicionais descritos na seo 4.2.1 so aplicados. Para realizao da experincia
descrita nesta seo foi utilizado o sistema legado cuja engenharia reversa descrita na seo 3.4.
Assim, a documentao de anlise orientada a objetos j existe e pode ser aqui utilizada.
Figura 4.2 - Exemplo de um Grafo de Interao de Objetos
77
No primeiro passo adicional, o Projeto Avante do Sistema executado, obtendo-se os
Grafos de Interao de Objetos, como o exemplificado na figura 4.2, os Grafos de Visibilidade,
as Descries de Classes e os Grafos de Herana. O Grafo de Interao de Objetos mostrado na
figura 4.2 referente operao Abre_Ordem_de_Servio. Ele mostra os mtodos que devem
ser invocados de cada classe para que a operao seja executada, destacando a ordem de chamada
desses mtodos. Os Grafos de Visibilidade, as Descries de Classes e os Grafos de Herana no
tm utilidade imediata para o que se pretende em seguida, que fazer a segmentao dos
programas, mantendo a linguagem de programao original. Como a linguagem Clipper no
possui recursos para implementar a visibilidade e a herana, esses modelos no foram totalmente
desenvolvidos.
Deve-se observar que o Grafo de Interao de Objetos mostrado na figura 4.2 possui
influncia direta da linguagem de programao em que o sistema legado foi desenvolvido. Por
exemplo, mtodos como Abrir_Arquivo e Fechar_Arquivo no seriam necessrios em certas
linguagens, mas foram considerados nesse grafo por se tratar da linguagem Clipper.
No segundo passo adicional, a Segmentao dos programas do sistema legado foi
executada. Os procedimentos correspondentes s operaes foram tratados um a um. A presena
de anomalias foi detectada durante a segunda fase do Fusion/RE e os mtodos foram
identificados na terceira fase e posteriormente detalhados no Grafo de Interao de Objetos. Isso
foi de grande valia, pois pde-se, de antemo, saber quais mtodos seriam esperados. Os
programas foram percorridos seqencialmente, reconhecendo os grupos de comandos
correlacionados, que lidavam com cada uma das classes identificadas no MAS. Os mtodos
foram fisicamente separados do corpo da operao, sendo substitudos por uma chamada a
procedimento ou funo. Na maioria das vezes houve a necessidade de criar parmetros de
entrada ou sada, para permitir que os resultados da execuo do mtodo pudessem ser usados
posteriormente por outros mtodos.
As limitaes da linguagem Clipper obrigaram a adoo de determinadas condutas. Por
exemplo, em Clipper no existe a possibilidade de criao de classes que encapsulem dados e
mtodos. Para contornar esse problema, para cada classe do modelo de objetos foram criados
dois arquivos: um contendo os dados (arquivo do tipo dbf) e outro contendo todos os mtodos
da classe (arquivo do tipo prg). Isso faz parte da simulao da orientao a objetos, que na
verdade a programao com tipos abstratos de dados. Seria tambm possvel simular a herana,
78
mesmo que parcialmente, mas isso no foi feito porque os benefcios no compensariam a
ilegibilidade causada ao cdigo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
* Nome do programa: OP_OS1.PRG
* Operacao de inclusao da abertura da Ordem de Servico
DO LOGOTIPO
DO ABRCLIEN // Abre_Arquivo_Cli (1)
DO ABRCLIVE // Abre_Arquivo_Veic (3)
DO ABRORDSE // Abre_Arquivo_OS (2)
DO ABRTIPVE // Abre_Arquivo_Tipv (4)
nord =0
codcli =0
gravou=.F.
nomecli=
DO OBTPROXO WITH nord // Obtm_Prximo_Num_OS
(5)
DO TELAOS1 WITH nord, codcli // Obtm_Data_OS (6)
IF LASTKEY() #27 .AND. codcli <>0
enc =.T.
DO PROCLI WITH codcli, enc // Escolhe_Cli (7)
IF .NOT. enc
DO NOVOCLI with codcli // Cria_Cli (8)
ELSE
DO AVISO WITH "Verifique os Dados do Cliente,
Modificando se Necessario"
ENDIF
ok ="N"
nomecli =SPACE(30)
DO WHILE ok ="N"
DO TELACLI WITH enc,nomecli // Obtem_Dados_Cli (9)
ok =CONFDADO( correto )
ENDDO
DO GRCLIEN // Grava_Cli (10)
DO TELALIM
passou =.T.
codvei =0
DO VERCLIVE WITH passou, nomecli // Busca_Veic (11)
Fim =.F.
IF .NOT. passou
Nrovei =0
. . .
@ 7, 25 SAY "Verificacao do(s) Veiculo(s) do Cliente"
@ 8, 25 SAY '""""""""""" """"" """""""""" "" """""""'
. . .
DO WHILE .NOT. fim
DO TELACLVE // Exibe_Tela_veic (12)
pert =" "
men ="Veiculo acima ainda Pertence ao Cliente? (S/N)
===> <>"
DO CONFDADO WITH pert, men
IF pert ="N"
DO APCLIVEI // Elimina_Veic (13)
ELSE
IF passou =.F.
serv =" "
men ="Serao Executados Servicos Nesse Veiculo?
(S/N) ===> <>"
DO CONFDADO WITH serv, men
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
IF serv ="S"
* achou o veiculo no qual sera feito o conserto
passou =.T.
ENDIF
ENDIF
ENDIF
. . .
ENDDO
ENDIF
ENDIF
aband =.F.
IF passou =.F.
* primeira vez que este veiculo do cliente e consertado
. . .
gr =.T.
DO LETIPVEI WITH gr // Obtm_Dados_Tipv (14)
IF gr
DO GRTIPVEI WITH codvei // Cria_Tipv (15)
ELSE
aband =.T.
ENDIF
ENDIF
IF .NOT. aband
. . .
ok ="N"
DO WHILE ok = "N"
DO LECLVEI // Obtm_Dados_Veic (16)
DO CONFDADO WITH ok, correto
ENDDO
DO LEORDSER // Obtm_Dados_Entr_OS (17)
grava =" "
DO CONFGRAV WITH grava
IF grava ="G"
DO GRCLIVEI WITH codcli, codvei, nrovei
// Cria_Veic (18)
DO NOVAORD // Cria_Entr_OS (19)
DO GRORDSER WITH nord, codcli, nrovei
// Grava_OS (20)
gravou =.T.
men ="Imprime 1a. Parte da Ordem de Servico? (S/N)
===> <>"
imp ="N"
DO CONFDADO WITH imp, men
IF imp ="S"
DO IMPOS1 with nord
ENDIF
ENDIF
ENDIF
ENDIF
nro_os=nord
// Varivel a ser passada como parmetro para op_os2
DO FECLIEN // Fecha_Arquivo_Cli (21)
DO FECLIVE // Fecha_Arquivo_Veic (23)
DO FECORDSE // Fecha_Arquivo_OS (22)
DO FECTIPVE // Fecha_Arquivo_Tipv (24)
RETURN
Figura 4.3 - Programa segmentado correspondente operao Abre_Ordem_de_Servio
A figura 4.3 mostra o programa segmentado correspondente operao
Abre_Ordem_de_Servio. Alguns trechos foram omitidos, estando representados por reti-
cncias. A figura 4.4 mostra o cdigo de alguns dos mtodos invocados no trecho de programa
79
segmentado da figura 4.3. O mtodo Obtproxo da figura 4.4 (a) invocado na linha 10 do pro-
grama segmentado (figura 4.3) e corresponde s linhas 10, 11, 12 e 17 do programa legado
(figura 3.6). O mtodo Novocli da figura 4.4 (b) invocado na linha 16 do programa segmen-
tado e corresponde s linhas 34, 35, 38 a 43 do programa legado. O mtodo Leordser da figura
4.4 (c) invocado na linha 71 do programa segmentado e corresponde s linhas 62, 63, 70, 71,
72, 74, 76, 77 e 78 do programa legado. O mtodo Grordser da figura 4.4 (d) invocado na
linha 76 do programa segmentado e corresponde s linhas 85 a 96 do programa legado.
*******************************
FUNCTION OBTPROXO()
***********************************************************
* metodo de ORDSERV para gerar proximo nro vago
de Ordem de Servico.
PARAMETERS nord
SELECT ORDSERV
SET ORDER TO 2
GOTO BOTTOM
vOsnro =OSNRO +1
nord =vOsnro
SET ORDER TO 1
RETURN NIL
(a)
***************************
FUNCTION NOVOCLI()
***********************************************************
* metodo de CLIENTE para criar novo registro de
Cliente e gerar um numero sequencial nico
PARAMETERS codcli
SELECT CLIENTES
SET ORDER TO 1
GOTO BOTTOM
vCodcliente =CODCLIENTE +1
vDatamov =DATE()
APPEND BLANK
REPLACE CODCLIENTE WITH vCodcliente
REPLACE DATAMOV WITH vDatamov
DO AVISO WITH "Digite os Dados do Novo Cliente"
codcli =vCodcliente
RETURN vCodcliente
(b)
*****************************
FUNCTION LEORDSER()
***************************************************************
* metodo de ORDSERV para ler dados da Ordem de Servico
@ 14, 30 SAY "Servicos a Executar"
@ 17, 7 GET vServaex1 PICT REPLICATE ("!",60)
@ 18, 7 GET vServaex2 PICT REPLICATE ("!",60)
@ 19, 7 GET vServaex3 PICT REPLICATE ("!",60)
@ 20, 7 SAY "Orcamento (S/N) :"
@ 20, 26 GET vOrcamento PICT "!" VALID vOrcamento $ "SN"
@ 21, 7 SAY "Prometido para as horas"
@ 21, 23 GET vDataprom PICT "@E" VALID vDataprom >=
vDataentra
@ 21, 37 GET vHoraprom PICT "!!!!!"
RETURN NIL
(c)
*******************************
FUNCTION GRORDSER()
**************************************************************************
* metodo de ORDSERV para gravar a nova Ordem de Servico
PARAMETERS nord, codcli, nrovei
v16Osnro =nord
v16Codcliente =codcli
v16Nroveiculo =nrovei
SELECT ORDSERV
REPLACE OSNRO WITH v16Osnro
REPLACE DATAENTRA WITH vDataentra
REPLACE CODCLIENTE WITH v16Codcliente
REPLACE NROVEICULO WITH v16Nroveiculo
REPLACE SERVAEX1 WITH vServaex1
REPLACE SERVAEX2 WITH vServaex2
REPLACE SERVAEX3 WITH vServaex3
REPLACE ORCAMENTO WITH vOrcamento
REPLACE DATAPROM WITH vDataprom
REPLACE HORAPROM WITH vHoraprom
RETURN NIL
(d)
Figura 4.4 - Alguns mtodos do Programa segmentado
Analisando alguns desses mtodos e comparando-os com o trecho do programa legado do
qual foram extrados, percebe-se que foi necessrio adotar algumas diretrizes para que a
80
segmentao fosse realizada. Por exemplo, adotou-se a conveno de que os nomes dos atributos
das classes seriam armazenados em variveis globais com a letra v precedendo o nome do
atributo. Foi necessrio tornar globais essas variveis para que outros mtodos, invocados pelo
mesmo objeto da classe, tivessem acesso a elas. Porm, aps segmentar uma parte do cdigo,
comearam a surgir variveis com mesmo nome, tanto referentes s chaves estrangeiras quanto a
nomes que coincidiam. Assim, alm do prefixo v, foi necessrio acrescentar um nmero que
identificasse unicamente cada atributo de classe. Para cada classe que precisasse de um nmero
para diferenciar seus atributos foi atribudo um nmero nico. Por exemplo, classe Ordserv
foi atribudo o nmero 16, enquanto que classe Cliente foi atribudo o nmero 26. Na figura
4.4 (d), que corresponde s linhas 85 a 96 do programa legado (figura 3.6), trs dos atributos
receberam o prefixo v16 (v16Osnro, v16Codcliente e v16NroVeiculo), enquanto que os
demais atributos receberam apenas o prefixo v, pois seus nomes no coincidem com nenhum
atributo de outras classes.
O resultado dessa experincia comprovou que os mtodos so muito numerosos e em
geral contm poucas linhas de cdigo. Porm, existe maior possibilidade de reutiliz-los devido
sua funcionalidade bem definida. A facilidade de manuteno tambm maior, pois sua
localizao fsica mais prxima em relao ao sistema legado, no qual trechos de programas
ficavam espalhados por toda parte e faziam acesso a diversas estruturas de dados.
4.3 Reengenharia com mudana de linguagem
Conforme mencionado na seo 4.1, a reengenharia com mudana de linguagem de
programao, alm de atualizar o cdigo para plataformas mais modernas, pode ser realizada
para dar continuidade ao processo de engenharia reversa. Isso faz com que o cdigo fique
sincronizado com a anlise e o projeto, melhorando, portanto, a manutenibilidade futura.
Aps ter sido realizada a engenharia reversa, a reengenharia com mudana de linguagem
pode ser feita manualmente ou auxiliada por uma ferramenta de transformao. A transformao
automtica de uma linguagem para outra, se feita de forma direta, na maioria das vezes gera
cdigo difcil de compreender e manter. A execuo prvia do processo de segmentao permite
que essa transformao seja mais amena, o cdigo gerado seja mais compreensvel e aproveite
melhor as caractersticas da orientao a objetos. Tal experimento foi feito usando a mquina
81
Draco-Puc [Pra 92] e objeto de um artigo publicado em co-autoria com Penteado e outros [Pen
98b]. Um resumo desse experimento relatado nas subsees que se seguem.
4.3.1 Sistema de Transformao utilizado
A mquina Draco baseada nas idias de construo de software por transformao
orientada a domnios. Um primeiro prottipo da mquina Draco foi construdo por Neighbors
[Nei 84]. Posteriormente, ela foi reconstruda na PUC-RJ [Pra 92], usando novas linguagens de
plataformas modernas de hardware e de software. Essa verso foi denominada Draco-Puc.
Pela estratgia proposta por Prado [Pra 92], possvel a reconstruo de um software
pelo porte direto do cdigo fonte para linguagens de outros domnios. Um domnio, de acordo
com a mquina Draco-Puc, constitudo de trs partes: um parser, um pretty-printer e um ou
mais transformadores.
Para a reimplementao automtica necessria a construo dos domnios da linguagem
origem e da linguagem destino, por intermdio de cinco atividades bsicas: construir parsers,
construir pretty-printers, construir um transformador da linguagem origem para a base de
conhecimento, construir um transformador da linguagem origem para a linguagem destino e
construir bibliotecas, conforme mostra a figura 4.5.
(3)
Construir transformador da
ling. Origem para KB
(2)
Construir
pretty-printers
Pargen
(1)
Construir
parsers
Parser da Lin-
guagem Origem
Parser da Lin-
guagem Destino
Base de
Conhecimento
Pretty-printer da
Ling. Origem
Pretty-printer da
Ling. Destino
Ppgen
OrigemToKB.tfm
TFMgen
(4)
Construir transfor-
mador da ling.
Origem para ling.
Destino
OrigemToDestino.tfm
TFMgen
(5)
Construir
bibliotecas
Bibliotecas
Sintaxe da
ling. Destino
Sintaxe da
ling. Origem
82
Figura 4.5 - Atividades bsicas para a construo dos domnios de origem e destino no Draco
Na atividade construir parsers obtm-se os parsers das gramticas livres de contexto
dos domnios origem e destino, a partir da definio dos seus analisadores lxicos e sintticos.
Essa atividade auxiliada pelo subsistema gerador de parsers do Draco, denominado Pargen.
As definies dos parsers so usadas como entrada nessa atividade. Ao lado das regras
gramaticais tm-se as aes semnticas (makenode, makeleaf, etc.) usadas para construo da
DAST (Draco Abstract Sintax Tree), que a linguagem interna usada pelo Draco nas
transformaes.
Na atividade construir pretty-printers o Draco gera automaticamente os pretty-printers
das linguagens origem e destino, usando seu sub-sistema Ppgen. Nessa gerao, parte-se das
definies das regras gramaticais das linguagens origem e destino e das primitivas de formatao
(.sim, .sp, etc.) colocadas ao lado das regras. Um pretty-printer trabalha como unparser que
exibe a DAST orientada pela sintaxe da linguagem, usando as primitivas de formatao.
Exemplo dessas primitivas so: a que estabelece a margem esquerda na coluna corrente (.lm), a
que exibe o n-simo smbolo da regra gramatical (.#n), etc.
A mquina Draco dispe de uma base de conhecimento (Knowledge Base (KB))
semelhante linguagem PROLOG para armazenar fatos e regras. Na atividade construir o
transformador da linguagem origem para a base de conhecimento procura-se percorrer a DAST
da linguagem de origem para reconhecer as suas diferentes estruturas, como os tipos de variveis
e funes, para gerar fatos na KB. O esquema KB que orienta a gerao dos fatos definido
previamente. Nessa atividade, o engenheiro de software faz uso do subsistema TFMgen do
Draco.
Na atividade construir o transformador da linguagem origem para a linguagem destino,
constri-se o transformador inter-domnio que faz o mapeamento semntico da linguagem
origem para a linguagem destino, utilizando os fatos armazenados na KB. O engenheiro de
software usa o sub-sistema TFMgen do Draco para gerar esse transformador.
Para completar o processo de transformao so construdas bibliotecas com classes da
linguagem origem e destino. Essas bibliotecas expressam, na linguagem destino, comandos da
linguagem origem.
Aps a construo dos domnios origem e destino, os programas escritos na linguagem
origem so submetidos ao Draco, que depois de uma srie de etapas produz o cdigo fonte na
83
linguagem destino. O cdigo escrito na linguagem origem inicialmente analisado pelo Draco
usando o parser produzido na atividade 1 citada anteriormente. Isso resulta na DAST com a
representao interna do cdigo original. Essa DAST ento submetida ao unparser, que a
formata de acordo com a sintaxe da linguagem origem, fazendo uso do pretty-printer da
linguagem origem, gerado na atividade 2. O cdigo obtido ento submetido ao transformador
construdo na atividade 3, que extrai os fatos para a base de conhecimento. Finalmente o cdigo
submetido ao transformador construdo na atividade 4 que, usando os fatos da base de
conhecimento e as bibliotecas, transforma-o para a linguagem destino.
4.3.2 Estudo de Caso
O sistema de oficina auto-eltrica e mecnica que passou pela engenharia reversa,
conforme mostrado na seo 3.4, e que sofreu segmentao, conforme mostrado na seo 4.2.2,
foi transformado de Clipper para J ava com o auxlio da mquina Draco. A figura 4.6 mostra, de
forma mais detalhada e especfica do que a figura 4.5, a construo dos domnios Clipper e J ava
[Pen 98b]. Cabe ressaltar que no participei diretamente nessa construo, tendo contribudo de
outras formas, seja dando indicaes de como criar as transformaes, seja fornecendo o cdigo
segmentado como entrada para a mquina Draco, ou ainda na validao do resultado produzido.
As cinco atividades referidas na seo 4.3.1 foram desenvolvidas. Na atividade construir
parser, denotada na figura 4.6 como parser constructing, foram construdos os parsers das
gramticas dos domnios Clipper e J ava, a partir da definio de seus analisadores lxicos e
sintticos. A linguagem destino, J ava, foi escolhida por ser orientada a objetos e bastante atual,
alm de ser portvel para qualquer plataforma de hardware ou software.
Na atividade construir pretty-printers, denotada na figura 4.6 como pretty-printers
constructing, o Draco gera automaticamente os pretty-printers Clipper e J ava pelo uso de seu
sub-sistema Ppgen. Isso feito a partir das definies das regras gramaticais do Clipper e do
J ava e de primitivas de formatao especiais, colocadas ao lado dessas regras gramaticais.
Na atividade construir o transformador da linguagem origem para a base de
conhecimento, denotada na figura 4.6 como ClipperToKB.tfm constructing, foi definido o
transformador ClipperToKb, capaz de percorrer a DAST Clipper, reconhecendo suas diferentes
estruturas e gerando fatos na KB. Conforme dito anteriormente, a construo desse tranformador
auxiliada pelo subsistema Tfmgen do Draco.
84
clipperTojava.tfm
Constructing
Libraries
of Clipper and
DataBase
classes
Clipper and Java PrettyPrinters
clipperToKB.tfmtransformer
Clipper and J ava Parsers
Tfmgen
Ppgen
Pargen
Draco-Puc
Machine
Software
Engineer
Libraries
Constructing
PrettyPrinters
Constructing
clipperToKB.tfm
Constructing
Definition of clipperTojava.tfm Transformer
Software
Engineer
Definition of clipperToKB.tfm Transformer
. . .
Transform
M d C Lhs: {{dast clipper.prog_head
Function [[ID function_name]]
() Use[[ID file_name]] Index to[[iden*
i d ]] [[body_structs*
b d ]] Return Nil
}}
Rhs: {{dast
j il i i class [[Identifier file_name]] extends Database
{ [[field_declaration* body]]
} }}
. . .
. . .
Transform
l Lhs: {{dast clipper.
i [[IID var_name]] =0
}}
Post-Match: {{dast
j il i i . . .
SET_LEAF_VALUE("method_name"
method_name);
KBAssertIfNew("variable([[var_name]]
[[method_name]], int, 0
)") }}
. . .
Global-End: dast
j il i i KBWrite(Utilitary.kb);
}}
. . .
%%
program : var_decl_star
parameter? .nl prog_head+
{$$=MakeNode("program1",$1,$2,$3
NULL); }
prog_head: prog_body
{$$=MakeNode
("prog_head1" , $1,
NULL) | '#' .sp diretiva.sp iden
l {$$=MakeNode
("prog_head2", $2, $3, NULL);
}. . .
if_stat :.lm(+2) 'IF' .sp expr .
l body_structs .nl (1)
%%
compilation_unit :
package_statement?
* .(.nl .slm, ..slm) type_declaration*
{
$$ M k N d (" il i i 1" $1 $2, $3, NULL); }
class_declaration : modifier*
' l ' .sp Identifier ( 'extends' .sp class_name
)?( 'implements' .sp interface_name++','
'{' .slm.lm(+2) field_declaration* .slm(-
2) '}'
{
$$ M k N d (" l d l i 1" $1, MakeLeaf($2), MakeLeaf($3), $4,
$5 $7, NULL); }
. . .
Draco Domains
Libraries
KB
Scheme
Draco-Puc
Machine
Draco-Puc
Machine
Draco-Puc
Machine Software
Engineer
Software
Engineer
PRETTYPRINTER CLIPPER
program1=#1 .NL #2 .NL #3 ;
prog_head1=#1 ;
. . .
if_stat1=.LM(+2) #1" " #2
SLM #3#4 #5 #6 ; (1)
body_structs1=.SLM .LM(+2) #1
SLM(-2) ;
body_struct1=" " " " " " #1 ;
PRETTYPRINTER JAVA
compilation_unit1=#1 #2 #3
package_statement1=#1 " " #2 ";"
. . .
method_declaration1 =.NL .NL
#1 " " #2 " " #3"(" #4 ")" #5#6 #7
throw_part1=#1 " " #2 ;
. . .
class Clipper{
privatestatic Screen Console=new
S () static void initDataBase( String
O C String user, String pwd ) {
String url =
"jdb db " ODBC . . .
static voidsay(int row, int col, String str)
{ if ((row>=0) && (col>=0) && (str !=
ll)) Console.say(row,col,str);
}. . .
class DataBase{
. . .
voidindexDBF(String index[],int size) {
for(int
i 0i I d i ) currentIndexLabel=(String)IndexLabel
elementAt(currentIndex-1
) . . .
catch(SQLException ex) {
Clipper.SQLError(ex); }
}
. . .
Tfmgen
Parser
Constructing
Definition of Clipper and Java parsers
clipperTojava.tfm
transformer
Definition of Database and Clipper Libraries
Clipper
Syntax and
Semantics
Clipper
Syntax and
Semantics
Syntax and
Semantics of
Clipper and J ava
KB
85
Figura 4.6 - Construo dos domnios Clipper e Java no Draco [Pen 98b]
public void OP_OS1()
{
int nord[] =new int[1];
int codcli[] =new int[1];
boolean gravou;
String nomecli[] =new String[1];
boolean encontrou[] =new boolean[1];
String ok[] =new String[1];
boolean passou[] =new boolean[1];
int codvei[] =new int[1];
boolean fim[] =new boolean[1];
int nrovei[] =new int[1];
String pert[] =new String[1];
String men[] =new String[1];
String serv[] =new String[1];
boolean aband;
boolean gr[] =new boolean[1];
String grava[] =new String[1];
String imp[] =new String[1];
int nro_os;
Utilitary.LOGOTIPO();
Clientes CLIENTES =new Clientes();
Cliveic CLIVEIC =new Cliveic();
Tipoveic TIPOVEIC =new Tipoveic();
nord[0] =0;
codcli[0] =0;
gravou =false;
nomecli[0] =" ";
OBTPROXO(nord);
TELAOS1(nord, codcli);
if (Clipper.lastKey() !=27 && codcli[0] !=0) {
encontrou[0] =true;
CLIENTES.PROCLI(codcli, encontrou);
if (!encontrou[0]) {
CLIENTES.NOVOCLI(codcli);
}
else{
Utilitary.AVISO("Verifique os Dados do
Cliente,
Modificando se Necessario");
}
ok[0] ="N";
nomecli[0] =Clipper.space(30);
while (ok[0].equals("N")) {
CLIENTES.TELACLI(encontrou, nomecli);
men[0] =Menuprin.correto[0];
Utilitary.CONFDADO(ok, men);
}
Utilitary.TELALIM();
passou[0] =true;
codvei[0] =0;
CLIVEIC.VERCLIVE(passou, nomecli);
fim[0] =false;
if (!passou[0]) {
nrovei[0] =0;
CLIVEIC.PROCCLIV(codcli, codvei, nrovei,
encontrou);
Utilitary.LIMPA();
if (encontrou[0]) {
Clipper.say(7, 25,
String.valueOf("Verificacao
do(s) Veiculo(s) do Cliente"));
TIPOVEIC.PROCTVEI(codvei);
TIPOVEIC.TELATVEI();
CLIVEIC.TELAVECA();
Clipper.say(13, 5, String.valueOf("Grupo:"));
while (!fim[0]) {
TIPOVEIC.PROCTVEI(codvei);
CLIVEIC.TELACLVE();
pert[0] =" ";
men[0] ="Veiculo ainda Pertence ao Cliente? (S/N) ===> <>";
Utilitary.CONFDADO(pert, men);
if (pert[0].equals("N")) {
CLIVEIC.APCLIVEI(); }
else {
if (passou[0] ==false) {
serv[0] =" ";
men[0] ="Serao Executados Servicos Nesse Veiculo? (S/N)
===> <>";
Utilitary.CONFDADO(serv, men);
if (serv[0].equals("S")) {
passou[0] =true;
}
}
}
CLIVEIC.AVANCCLV(codcli, fim);
Utilitary.LIMPA();
}
}
}
aband =false;
if (passou[0] ==false) {
Utilitary.TELALIM();
TIPOVEIC.TELA();
TIPOVEIC.TELATVEI();
gr[0] =true;
TIPOVEIC.LETIPVEI(gr);
if (gr[0]) {
TIPOVEIC.PRMARTIP(encontrou, codvei);
if (!encontrou[0]) {
TIPOVEIC.GRTIPVEI(codvei);
}
}
else{
aband =true;
}
}
if (!aband) {
TIPOVEIC.TELATVEI();
CLIVEIC.TELAVECA();
ok[0] ="N";
while (ok[0].equals("N")) {
CLIVEIC.LECLVEI();
Utilitary.CONFDADO(ok, Menuprin.correto);
}
LEORDSER();
grava[0] =" ";
Utilitary.CONFGRAV(grava);
if (grava[0].equals("G")) {
CLIVEIC.GRCLIVEI(codcli, codvei, nrovei);
NOVAORD();
GRORDSER(nord, codcli, nrovei);
gravou =true;
men[0] ="Imprime 1a. Parte da Ordem de Servico? (S/N) ===>
<>";
imp[0] ="N";
Utilitary.CONFDADO(imp, men);
if (imp[0].equals("S")) {
OP_IMPO1(nord);
}
}
}
}
nro_os =nord[0];
CLIENTES.closeDBF();
CLIVEIC.closeDBF();
closeDBF();
TIPOVEIC.closeDBF();
}
86
Figura 4.7 - Cdigo Java resultante da transformao, ref. operao Abre_Ordem_de_Servico
public void OBTPROXO(int nord[])
{
setOrder(2);
goLast();
ORDSERV.vOsnro =OSNRO +
1;
nord[0] =ORDSERV.vOsnro;
setOrder(1);
}
(a)
public void NOVOCLI(int codcli[])
{
setOrder(1);
goLast();
vCodcliente =CODCLIENTE +1;
vDatamov =Data.today();
appendBlank();
replace("CODCLIENTE", new
Integer(vCodcliente));
replace("DATAMOV", vDatamov);
Utilitary.AVISO("Digite os Dados
do
Novo Cliente");
codcli[0] =vCodcliente;
}
(b)
public void GRORDSER(int nord[], int codcli[],
int nrovei[])
{
v16Osnro =nord[0];
v16Codcliente =codcli[0];
v16Nroveiculo =nrovei[0];
replace("OSNRO", new Integer(v16Osnro));
replace("DATAENTRA", vDataentra);
replace("CODCLIENTE", new
Integer(v16Codcliente));
replace("NROVEICULO", new
Integer(v16Nroveiculo));
replace("SERVAEX1", vServaex1);
replace("SERVAEX2", vServaex2);
replace("SERVAEX3", vServaex3);
replace("ORCAMENTO", vOrcamento);
replace("DATAPROM", vDataprom);
replace("HORAPROM", vHoraprom);
}
(d)
public void LEORDSER()
{
Clipper.say(14, 30, String.valueOf("Servicos a Executar"));
Clipper.get(17, 7, String.valueOf(vServaex1), Clipper.replicate("!", 60));
Clipper.get(18, 7, String.valueOf(vServaex2), Clipper.replicate("!", 60));
Clipper.get(19, 7, String.valueOf(vServaex3), Clipper.replicate("!", 60));
Clipper.say(20, 7, String.valueOf("Orcamento (S/N) :"));
Clipper.get(20, 26, String.valueOf(vOrcamento), "!", GetField.SIGNAL_IN, String.valueOf("SN"));
Clipper.say(21, 7, String.valueOf("Prometido para as horas"));
Clipper.get(21, 23, String.valueOf(vDataprom), "@E", GetField.SIGNAL_GREQ, String.valueOf(vDataentra));
Clipper.get(21, 37, String.valueOf(vHoraprom), "!!!!!");
Menuprin.getReturn =Clipper.read();
vServaex1 =Menuprin.getReturn.isGot(17, 7) ? Menuprin.getReturn.elementAt(17, 7) : vServaex1;
vServaex2 =Menuprin.getReturn.isGot(18, 7) ? Menuprin.getReturn.elementAt(18, 7) : vServaex2;
vServaex3 =Menuprin.getReturn.isGot(19, 7) ? Menuprin.getReturn.elementAt(19, 7) : vServaex3;
vOrcamento =Menuprin.getReturn.isGot(20, 26) ? Menuprin.getReturn.elementAt(20, 26) : vOrcamento;
vDataprom =Menuprin.getReturn.isGot(21, 23) ? new Data(Menuprin.getReturn.elementAt(21, 23)) : vDataprom;
vHoraprom =Menuprin.getReturn.isGot(21, 37) ? Menuprin.getReturn.elementAt(21, 37) : vHoraprom;
}
(c)
Figura 4.8 - Alguns mtodos do programa transformado
Na atividade construir o transformador da linguagem origem para a linguagem destino,
denotada na figura 4.6 como clipperToJava.tfm Constructing, foi construdo o transformador
ClipperToJ ava, que faz o mapeamento semntico da linguagem Clipper para a linguagem J ava,
utilizando os fatos armazenados na KB. A construo desse tranformador tambm auxiliada
pelo subsistema Tfmgen do Draco.
Na atividade construir bibliotecas, denotada na figura 4.6 como Libraries
constructing, foram construdas bibliotecas de mapeamento do Clipper para o J ava, com o
87
objetivo de permitir que se expressem em J ava os comandos Clipper referentes a entrada e sada
de dados, gerenciamento de tela, impressora e banco de dados.
Isso tudo preparado, foi possvel efetuar a transformao, alimentando a mquina Draco
com o programa segmentado em Clipper e obtendo a transformao em J ava, seguindo o roteiro
apresentado no fim da seo 4.3.1. O resultado um programa com caractersticas de orientao
a objetos, obtidas graas ao processo de segmentao.
A figura 4.7 mostra o cdigo J ava resultante da transformao referente operao
Abre_Ordem_de_Servio, cujo cdigo segmentado em Clipper consta da figura 4.3. A figura 4.8
mostra os mtodos (em J ava) correspondentes aos mtodos em Clipper da figura 4.4.
Caso a segmentao no fosse efetuada, apesar do programa em J ava ser escrito numa
linguagem orientada a objetos, no se teria as vantagens da orientao a objetos, tais como o
reuso e a manutenibilidade propiciadas pelo encapsulamento. Esses programas podem ser
posteriormente inspecionados e modificados pelo engenheiro de software, se for o caso, para tirar
partido das heranas, agregaes, polimorfismo, etc.
4.4 Consideraes Finais
A reengenharia de um sistema originalmente procedimental, obtendo-se um sistema
orientado a objetos foi efetuada com xito. Foram explorados dois caminhos em seqncia. O
primeiro partiu do modelo de objetos obtido pela engenharia reversa e segmentou o cdigo
legado, mantendo a linguagem Clipper. O segundo fez a transformao automtica de cdigo
Clipper para J ava, partindo do cdigo segmentado. Em princpio, os cdigos produzidos pelos
dois caminhos tm a mesma facilidade de manuteno. A transformao para J ava mantm toda
a estrutura do programa segmentado, sendo, portanto, equivalente em termos de manuteno.
Entretanto, o cdigo J ava pode ser executado em qualquer plataforma de hardware ou software, o
que o torna muito mais portvel do que o cdigo Clipper.
Por outro lado, caso a empresa tenha pessoal especializado em Clipper e no necessite de
mudana de plataforma, mais conveniente utilizar o cdigo segmentado em Clipper. Desta
forma no ser necessrio contratar novo pessoal ou dar treinamento em novas linguagens. A
documentao de anlise e de projeto agora compatvel com o cdigo, o que facilita a
manuteno e eventual futura reengenharia com mudana de funcionalidade. Alm disso,
88
resultados obtidos pela engenharia reversa, engenharia avante e segmentao aumentam a
possibilidade de reuso, tanto de cdigo quanto de anlise e projeto.
89
Captulo 5 - Reconhecimento de Padres de Software
5.1 Consideraes Iniciais
Conforme mencionado na seo 1.1 existem padres de software em diversos nveis de
abstrao, desde a anlise, passando pelo projeto e at padres de cdigo. Neste trabalho, o
interesse maior por padres que possam ser empregados em sistemas de informao. A seo
5.2 descreve brevemente alguns desses padres, propostos por autores como Coad [Coa 92],
Boyd [Boy 98] e J ohnson [J oh 98]. Na seo 5.3 proposta uma estratgia para reconhecimento
de padres em modelos de objetos de sistemas legados. Na seo 5.4 feito um estudo de caso
usando como material o que foi preparado na seo 3.4. Na seo 5.5 so feitas as consideraes
finais deste captulo.
5.2 Padres recorrentes para Sistemas de Informao
Existem inmeros padres recorrentes no domnio de sistemas de informao, isto ,
padres que ocorrem repetidamente no seu desenvolvimento. Analisando alguns desses padres e
suas principais aplicaes, puderam ser escolhidos diversos deles que mais ocorrem em sistemas
como os por mim desenvolvidos na prtica profissional. Nesta seo so destacados apenas
aqueles que se aplicam ao caso em estudo discutido na seo 5.4, que so: o TypeObject [J oh
98], o Association-Object [Boy 98], o State across a collection e o Behaviour across a collection
[Coa 92]. Outros padres recorrentes foram mostrados na seo 2.5.2, como o Roles-played [Coa
92] e o Abstract Factory [Gam 93],
5.2.1 Padro Type-Object
Um dos padres encontrados em quase todos os sistemas de informao o Type-Object,
descrito por J ohnson [J oh 98] e mostrado na figura 5.1. Esse padro equivalente ao padro
Item-Description apresentado por Coad [Coa 92]. A verso escolhida foi a de J ohnson por ser
especificada em maior nvel de detalhe.
90
O problema resolvido por esse padro o de uma classe com diversos tipos, que podem
variar em tempo de execuo. A soluo agrupar os atributos comuns classe em Class e
criar uma outra classe TypeClass para conter os tipos. Os objetos da classe Class possuem
uma referncia a algum dos objetos da classe TypeClass. Pode tambm haver a referncia
inversa, embora J ohnson a considere facultativa.
Figura 5.1 - Padro Type-Object [Joh 98]
A figura 5.2 mostra o exemplo utilizado por J ohnson para ilustrar o padro Type-Object.
Em uma videolocadora, um filme possui atributos como ttulo e preo de locao e pode possuir
cpias em diversas fitas de vdeo, cada qual alugada para um cliente diferente. O padro
estabelece que Filme e Fita de vdeo so classes relacionadas, existindo uma referncia nos
objetos da classe Fita de vdeo ligando-os a um objeto da classe Filme.
Figura 5.2 - Exemplo do Type-Object [Joh 98]
Para mostrar a semelhana do Type-Object com o padro Item-description, esse ltimo
apresentado na figura 5.3. Um exemplo ilustrativo dado pelo autor [Coa 92] mostrado na figura
5.4, no qual fcil verificar tal semelhana.
Figura 5.3 - Padro Item-Description [Coa 92]
Figura 5.4 - Exemplo do Item-Description [Coa 92]
Filme
ttulo
preo de locao
Fita de vdeo
est alugada?
Locador()
1
*
Aeronave
Numero
DescrioAeronave
fabricante
modelo
velocidade_mdia_padro
* 1
TypeClass
typeAttribute
Class
attribute
* 1
Item
ItemDescription
1 *
91
5.2.2 Padro Association-Object
Outro padro bastante comum em sistemas de informao o Association-Object,
proposto por Boyd [Boy 98] e mostrado na figura 5.5. semelhante ao padro Time-Association,
descrito por Coad [Coa 92], embora Boyd o tenha apresentado de forma mais detalhada e
especfica para sistemas de informao.
Figura 5.5 - Padro Association-Object [Boy 98]
Esse padro usado sempre que exista uma associao dinmica entre dois objetos
estticos a qual deve ser cuidada pelo sistema. Em geral essa associao dura um certo tempo,
denotado pelos atributos Begin_date e End_date da classe Association e tem algum custo, tratado
pelo atributo Cost dessa mesma classe. Alm dos atributos em comum, a classe Association tem
um comportamento comum, presente nos mtodos Allocate_costs e Create_current_from_plan.
As classes STATIC-1 e STATIC-2 tambm possuem atributos e comportamento comuns.
A figura 5.6 mostra um exemplo de aplicao do padro Association-Object a um sistema
de alocao de salas a departamentos. As classes Sala e Departamento desempenham o papel
de Static-1 e Static-2, respectivamente. A classe Atribuio Sala-Depto figura como
Association. Ao departamento pode ser atribuda uma ou mais salas por perodos
predeterminados. Essa atribuio deve definir um percentual de alocao, calculando o custo da
alocao. Tanto uma sala quanto um departamento podem querer saber seus custos com
alocao. Assim, existem mtodos em ambas as classes para calcular os respectivos custos.
1
1
*
*
STATIC 1
Name
Description
Set
Get
STATIC 2
Name
Description
Set
Get
ASSOCIATION
Begin_Date
End_Date
Cost
Allocate_costs
Create_current_from_plan
Comportamento
Atributos
92
Figura 5.6 - Association-Object [Boy 98]
5.2.3 Padro State across a collection
O padro State across a collection foi proposto por Coad [Coa 92] para resolver um
problema comum em sistemas orientados a objetos: o de agregaes, nas quais a superclasse
possui atributos que so compartilhados pelas subclasses. A figura 5.7 mostra esse padro e a
figura 5.8 mostra um exemplo de aplicao, no qual a classe Venda desempenha o papel
Collection e a classe Item da Venda desempenha o papel de Member.
Figura 5.7 - Padro State across a collection [Coa 92]
5.2.4 Padro Behaviour across a collection
O padro Behaviour across a collection tambm foi proposto por Coad [Coa 92] para
resolver o problema de agregaes, mas no caso em que a superclasse possua mtodos
compartilhados pelas subclasses. A figura 5.9 mostra esse padro e a figura 5.10 mostra um
1 1
*
*
SALA
Nome
Descrio
Calc. custos da sala
Set
Get
DEPARTAMENTO
Nome
Descrio
Calc. custos do depto
Set
Get
Atribuio Sala-Depto
Data_inicial
Data_final
Percentual de alocao
Alocar custos
Criar atribuio
Collection
CollectionAttribute
Member
MemberAttribute
93
exemplo de aplicao para um sistema de chamadas telefnicas, no qual a classe Venda
desempenha o papel Collection e a classe Item da Venda desempenha o papel de Member.
Figura 5.8 - Exemplo do Padro State across a collection [Coa 92]
Figura 5.9 - Padro Behaviour across a collection [Coa 92]
Figura 5.10 - Exemplo do Padro Behaviour across a collection [Coa 92]
Venda
Nmero
Data/Hora
Item da Venda
Quantidade
Collection
CollectionService
Member
MemberService
Coleo de chamadas
telefnicas
SelecionarProxChamada
Chamada telefnica
Hora da chegada
Prioridade
Numero da origem
Rotear
Atribuir importncia
94
5.3 Uma estratgia para reconhecimento de padres
Modelos de objetos de diversos sistemas de informao foram inspecionados a fim de
neles reconhecer padres como os discutidos na seo 5.2. Entre esses foram utilizados um
sistema de biblioteca, um sistema de consultrio mdico e o sistema de oficina auto-eltrica e
mecnica apresentado na seo 3.4. Essa inspeo permitiu que algumas diretrizes bsicas
pudessem ser formuladas para o reconhecimento desses padres em modelos de objetos de
sistemas de informao. Essas diretrizes foram generalizadas e deram origem estratgia
apresentada nesta seo.
5.3.1 Padro Type-Object
O padro TypeObject, discutido na seo 5.2.1, freqentemente encontrado em sistemas
de informao. O seguinte algoritmo genrico deve ser seguido para tentar reconhecer esse
padro em um modelo de objetos existente:
1) todas as classes do modelo de objetos devem ser analisadas, em busca de relacionamentos
com cardinalidade um para muitos. Os pares de classes com tais caractersticas so
selecionados como candidatos a um Type-Object, no qual a classe que fica do lado um
candidata ao papel TypeClass e a classe do lado muitos candidata ao papel Class. As
demais classes so descartadas.
2) em ambas as classes do par candidato deve haver um atributo que identifique unicamente
cada objeto da classe e um outro atributo que o descreva. Os pares que no obedecerem a
essa regra podem ser descartados.
3) finalmente, o valor semntico do relacionamento dever ser analisado. Lendo-se o
relacionamento partindo de Class para TypeClass deve ser natural pensar em mtodos
como: a) dado um objeto da classe Class informe qual seu objeto correspondente na
classe TypeClass e b) atribua a um objeto da classe Class um objeto da classe
TypeClass. Lendo-se o relacionamento no sentido inverso, deve ser possvel pensar em um
mtodo que, dado um objeto da classe TypeClass, retorne todos os objetos da classe
Class. A existncia desses mtodos deve ser natural, no sentido de que eles so cabveis
dentro do domnio de aplicao, sendo fcil imaginar sua utilidade para algum.
95
Conforme j mencionado, esse algoritmo foi construdo com base na experincia prtica
de reconhecimento de padres em diversos sistemas de informao. Porm, possvel que outras
diretrizes sejam descobertas se forem analisadas outras aplicaes. possvel tambm que
algumas dessas diretrizes no se apliquem a todos os casos, apesar dos cuidados que foram
tomados ao fazer a generalizao.
5.3.2 Padro Association-Object
O padro Association-Object, discutido na seo 5.2.2, tambm comum em sistemas de
informao. Para identific-lo, pode-se usar o seguinte algoritmo:
1) todas as classes do modelo de objetos devem ser analisadas, em busca das que contenham um
ou mais atributos do tipo data. Essas classes so candidatas ao papel Association do
padro. As demais classes podem ser descartadas.
2) deve-se ento examinar, para todas as classes candidatas, os relacionamentos do tipo muitos
para um que elas tenham com outras classes. As classes do lado um devem ser estticas,
isto , devem representar itens tangveis do domnio, que contenham caractersticas inerentes
ao longo de seu tempo de vida. Essas classes so candidatas ao papel static-1 ou static-2.
3) se no existe relacionamento desse tipo, pode-se descartar a classe candidata.
4) se existe apenas um relacionamento desse tipo, mas existe uma classe agregada classe
candidata a Association e a partir dessa classe agregada existe um relacionamento como o
descrito no item 2, a classe candidata continua sendo examinada. Nesse caso, a classe do lado
um do primeiro relacionamento identificado assume o papel Static-1 e a classe
relacionada classe agregada assume o papel Static-2. Caso contrtio a classe candidata a
Association pode ser descartada.
5) se existem dois relacionamentos desse tipo, associam-se os papis Static-1 e Static-2 s
duas classes do lado um desses relacionamentos.
6) se existem mais de dois relacionamentos desse tipo, devem ser escolhidas duas classes para
os papis Static-1 e Static-2. Executam-se ento os demais passos e, caso o padro no
seja identificado, devem ser escolhidas outras duas classes at que todas as combinaes
possveis tenham sido exploradas.
7) por fim, o significado semntico deve ser analisado. Focalizando na classe candidata ao papel
Association, deve fazer sentido pensar que ela faz a ligao temporal entre as classes
96
candidatas a Static-1 e Static-2. Essa ligao deve, preferencialmente, envolver algum
custo e deve haver um mtodo na classe Association para criar e/ou desfazer a associao
entre as duas classes estticas.
As mesmas observaes feitas no padro Type-Object so vlidas aqui. Outros sistemas
talvez tenham comportamento diferente, que necessite de diretrizes adicionais ou no se
encaixem nas diretrizes aqui propostas.
5.3.3 Padro State across a Collection
O padro State across a Collection, discutido na seo 5.2.3, reconhecido usando-se o
seguinte algoritmo:
1) todas as classes do modelo de objetos devem ser examinadas em busca de classes que
possuam subclasses agregadas. Essas classes so candidatas ao papel Collection do padro,
enquanto que a subclasse agregada correspondente candidata ao papel Member. As
demais classses podem ser descartadas.
2) para todas as classes candidatas ao papel Collection deve-se examinar seus atributos em
busca daqueles que sejam comuns classe candidata ao papel Member. Se tal atributo
existe, o padro ocorre.
Esse padro aparece com freqncia em sistemas orientados a objeto em geral. Seu
reconhecimento torna-se fcil devido ao uso de agregao, que j meio caminho andado em
busca do padro. Se o engenheiro de software utilizou agregao para representar certa classe,
provavelmente foi devido ocorrncia de atributos ou mtodos compartilhados pela classe e
subclasse. Assim, a ocorrncia desse padro ou do padro Behaviour across a collection,
mostrado a seguir, garantida.
5.3.4 Padro Behaviour across a collection
O padro Behaviour across a Collection, discutido na seo 5.2.4, reconhecido
utilizando-se o seguinte algoritmo:
97
3) todas as classes do modelo de objetos devem ser examinadas em busca de classes que
possuam subclasses agregadas. Essas classes so candidatas ao papel Collection do padro,
enquanto que a subclasse agregada correspondente candidata ao papel Member. As
demais classses podem ser descartadas.
4) para todas as classes candidatas ao papel Collection deve-se examinar seus mtodos em
busca de pelo menos um que se aplique a todos os objetos da coleo como um todo. Se tal
mtodo existe, o padro ocorre.
Aqui valem as mesmas observaes feitas no padro State across a collection. Na
maioria das vezes a ocorrncia desse padro simultnea com a ocorrncia do State across a
collection, devido ao prprio conceito de agregao.
5.4 Estudo de Caso
5.4.1 Reconhecimento dos padres no modelo de objetos do sistema legado
Conforme mencionado na seo 5.3, a estratgia l proposta foi possvel graas
experincia de reconhecimento de padres em diversos sistemas de informao. Um desses
sistemas usado para exemplificar o reconhecimento de padres nesta seo. Trata-se do mesmo
sistema utilizado nos captulos 3 e 4, que referente a uma oficina auto-eltrica e mecnica de
veculos.
O MOS-6a, apresentado na figura 3.17, tomado como base para o reconhecimento de
padres. Os padres reconhecidos foram documentados no modelo de objetos, usando a notao
recomendada pela UML [Eri 98], mostrada na figura 5.11. O nome do padro colocado em uma
elipse com linha tracejada. As classes do sistema que correspondem instncia do padro so
colocadas em caixas retangulares. Setas tracejadas so desenhadas partindo da elipse para as
caixas retangulares, rotuladas com o nome do papel desempenhado pela classe instanciada.
A figura 5.12 mostra o modelo de objetos do sistema aps o reconhecimento de padres.
Sempre que um padro reconhecido, os relacionamentos que fazem parte desse padro so
removidos do modelo de objetos examinado.
98
Figura 5.11 - Notao usada para expressar padres em UML
Como pode ser observado na figura 5.12, foram reconhecidas duas instncias do Type-
Object, quatro instncias do Association-Object, cinco instncias do State across a collection e
cinco instncias do Behaviour across a collection. Esse reconhecimento descrito a seguir.
Inicialmente procurou-se pela ocorrncia do padro Type-Object. Todas as classes foram
examinadas em busca de relacionamentos do tipo muitos para um e foram selecionados os
seguintes candidatos ao papel Class: Atendimento por balco, Conta a Receber, Conta a Pagar,
Pea vendida, Veculo de cliente, Ordem de Servio, Pea da Ordem de Serv., Mo-de-obra da
Ordem de Serv., Pea, Compra, Pea comprada, Pedido e Pea pedida. Foi ento verificada a
existncia de um atributo identificador e outro descritor nos candidatos a Class e nos
respectivos candidatos a TypeClass. Dessa forma, foram descartados muitos dos candidatos,
tendo restado apenas os dois pares de candidatos a Class/ TypeClass: Veculo de cliente/Tipo
de Veculo e Pea/Fabricante. A maioria dos candidatos foi eliminada por no possuir um
identificador nico ou um atributo que os descrevessem. Foi ento analisado o valor semntico
do relacionamento e concluiu-se que os dois finalistas realmente formam uma ocorrncia do
Type-Object. natural pensar em mtodos como: dado um veculo de cliente informe qual seu
tipo; dado o veculo de placa XXX-1234 atribua a ele a marca/tipo Volkswagen-Parati; e
quais veculos da marca/tipo Fiat-Uno Mille foram consertados nos ltimos seis meses.
Partiu-se ento para a busca do padro Association-Object. Na primeira etapa foram
classificados, por conterem atributo do tipo data, as classes Atendimento por balco, Conta,
Ordem de Servio, Compra e Pedido. Foram ento examinados seus relacionamentos do tipo
muitos para um em busca de classes candidatas a Static-1 e Static-2. Para a classe
Atendimento por balco foram encontradas as classes Cliente e Empregado. Para a classe Conta,
por intermdio de suas classes herdeiras, foram encontradas as classes Atendimento por balco,
Ordem de Servio e Compra. Para a classe Ordem de Servio foi encontrada a classe Veculo de
cliente. Para as classes Compra e Pedido foi encontrada a classe Fornecedor.
Type Object
Type Class
Class
Veculo de Cliente
Tipo de Veculo
99
*
*
trabalha com
*
1
obedece a
Association
Static 1
Static 2
Collection
Association
Static 1
Static 2 Static 2
Static 1
Association
Static 1
uma
Static 2
Collection
Member
Collection
Type class
Class
*
0..1
*
*
1 1
uma
uma
*
1
gera
1
0..1
refere-se a
*
*
*
*
adapta-se a
*
adapta-se a
* *
faz parte do
* *
*
*
temvalor
de trabalho
de acordo
com
temtempo
de reparo de
acordo com
feita por
0..1
equivalente a
*
*
1
*
gera
1
*
* 1
1
* is a
1
*
atendido por
Ordemde Servio
Cliente
Veculo de cliente
Pea da Ordemde Serv. Mo-de-Obra da
Ordemde Serv.
Pea
Empregado
Tipo de veculo
Pea adquirida fora
Pea do estoque
Conta
Atendimento por balco
Pea vendida
gera
Conta a Receber
Conta a Pagar
Fabricante
possui
Tipo de mo-de-
obra
Componente
Pedido
Pea pedida
Compra
Pea comprada
Fornecedor
Ramo
Collection
Behavior aac/
State aac
Member
Type Object
Type class
Class
Type Object
Behavior aac/
State aac
Member
Behavior aac/
State aac
Member
Collection
Behavior aac/
State aac
Member
Behavior aac/
State aac
Association
Object
Association
Association
Object
Association
Object
Association
Object
quantvt tempo
Figura 5.12 - Reconhecimento de padres
100
A classe Atendimento por balco foi, portanto, classificada sem maiores problemas.
correto pensar que o Atendimento por balco faz uma associao temporal entre Cliente e
Empregado, isto , existe um atendimento registrando um cliente que foi atendido por um
empregado em uma determinada data. A classe Conta possui trs relacionamentos candidatos,
tendo que ser analisados aos pares. As trs demais possuem apenas um relacionamento candidato
e devem ser investigadas por possuirem classes agregadas. Ao analisar a classe Conta com os
possveis candidatos a Static-1 e Static-2, o valor semntico foi importante para a deciso de
descartar a possibilidade de ocorrncia do Association-Object. No faz sentido dizer que Conta
uma associao temporal entre Atendimento por balco e Ordem de Servio, ou entre Ordem de
Servio e Compra ou entre Atendimento por balco e Compra. A classe Ordem de Servio possui
uma classe agregada, Pea da Ordem de Servio, que por sua vez possui um relacionamento com
a classe esttica Pea. Assim pode-se eleger a classe Veculo de cliente como candidata a Static-
1 e Pea como candidata a Static-2. Pensando no valor semntico desse relacionamento,
correto que a Ordem de Servio faz uma associao temporal entre um veculo consertado e a
pea utilizada, sendo portanto classificado. O mesmo raciocnio foi utilizado para classificar
Compra/Fornecedor/Pea e Pedido/Fornecedor/Pea como ocorrncias do Association-
Object.
O modelo de objetos foi ento analisado em busca dos padres State across a collection e
Behaviour across a collection. As agregaes existentes foram classificadas: Atendimento por
balco/Pea vendida, Ordem de Servio/Pea da Ordem de Servio, Ordem de Servio/Mo-de-
obra da Ordem de Serv., Compra/Pea comprada e Pedido/Pea pedida. Em todas elas existe pelo
menos um atributo na classe candidata a Collection que comum classe correspondente
candidata a Member. Por exemplo, em Atendimento por balco, o atributo Data do
Atendimento tambm a Data em que a pea foi vendida. Tambm em todas as classes
candidatas existem mtodos, embora no estejam explicitamente presentes, que se aplicam
coleo como um todo. Por exemplo, na classe Compra, para calcular o Valor total necessrio
invocar os mtodos individuais de cada pea comprada. Dessa forma, as quatro agregaes
encontradas so ocorrncias simultaneamente dos padres State across a collection e Behaviour
across a collection.
101
5.4.2 Exemplo de implementao de padro
Aps ter sido feito o reconhecimento de padres, partiu-se para a reengenharia do sistema
legado, adotando-se os padres identificados. A funcionalidade do sistema legado foi mantida
durante a reengenharia, embora a interface tenha sido modernizada e adaptada ao estilo
Windows.
ilustrada nesta seo a implementao das duas instncias do padro Type-Object e de
uma das instncias do padro Association-Object no sistema estudado. Escolheu-se a linguagem
Delphi [Can 97, Can 98] para fazer a reengenharia do sistema, por ser uma linguagem
comumente utilizada em sistemas de informao comerciais.
Para facilitar a implementao de instncias do padro Type-Object proposto um
esqueleto de implementao para ele, que agiliza o reuso, bastando para tal particularizar o
esqueleto para cada caso particular. O mesmo poderia ser feito com os demais padres
recorrentes vistos na seo 5.2, o que sugerido como trabalho futuro.
O exemplo de implementao completo do padro Type-Object objeto de um
relatrio tcnico [Bra 98b], no qual constam as listagens de suas duas instanciaes, bem como
diretrizes para utilizar as facilidades do ambiente Delphi na particularizao do padro para cada
instncia.
5.4.2.1 Esqueleto de implementao do padro Type-Object
A figura 5.13 mostra o modelo de objetos do padro Type-Object para o domnio de
aplicao aqui abordado. Foram dados nomes genricos aos atributos e mtodos das classes
Class e TypeClass. Os mtodos que constam dessa figura foram obtidos aps a programao
de uma das instncias do Type-Object, que permitiu identificar quais mtodos seriam necessrios
para implementar as operaes relativas s classes envolvidas no padro. Os atributos
Identificador e Descritor, presentes em ambas as classes, so caractersticos do domnio de
sistemas de informao, no qual objetos estticos possuem uma chave primria para identific-
los e uma chave secundria para descrev-los de alguma forma. Essa foi uma das exigncias para
que o padro fosse reconhecido, conforme a segunda diretriz da seo 5.3.1. O atributo Tipo da
classe Class foi necessrio para fazer a ligao com a classe TypeClass, j que utilizada
uma base de dados relacional para prover a persistncia dos objetos.
102
Figura 5.13 - Modelo de Objetos detalhado do padro Type-Object
Com base nesses atributos e mtodos com nomes genricos, foi feito um esqueleto de
cdigo para a definio das classes do padro Type-Object. A definio das classes Class e
TypeClass ilustrada na figura 5.14 e o corpo de alguns mtodos consta da figura 5.15.
O padro CRUD [Yod 98], que um dos padres sugeridos para conectar objetos a
bases de dados relacionais descritos na seo 2.5, foi utilizado na implementao no que se refere
ao acesso base de dados do Delphi. Assim, mtodos especficos para acesso s tabelas de dados
foram isolados em uma camada. Esses mtodos s podem ser chamados pelos mtodos da
prpria classe. Os mtodos ilustrados na figura 5.13 so os mtodos de interface da classe, isto ,
os mtodos que podem ser invocados por quaisquer outras classes do sistema.
Para implementar a camada de acesso s tabelas da base de dados foi utilizado o recurso
DataModules (mdulos de dados) do Delphi. Um mdulo de dados contm um componente
para fazer referncia tabela em si e alguns componentes para efetuar as operaes bsicas, em
SQL, referentes insero, atualizao, excluso e recuperao de dados. Na verdade, um nico
objeto pode ser armazenado em mais de uma tabela e, nesse caso, o mdulo de dados representa
o objeto, contendo os componentes necessrios para relacion-lo com as respectivas tabelas.
Dessa forma, cada classe faz uso de um nico mdulo de dados, no qual se concentram as tabelas
necessrias para tornar seus objetos permanentes. No caso do padro Type-Object, como cada
uma das classes armazenada em uma nica tabela, so necessrios dois mdulos de dados, cada
qual fazendo referncia a uma das tabelas.
Class
Identificador
Descritor
Tipo
Salvar
Excluir
BuscaIdent
BuscaDescr
BuscaDescrTodos
ExisteIdent
ExisteDescr
GetIdentificador
GetDescritor
GetTipo
SetIdentificador
SetDescritor
SetTipo
Novo
TypeClass
Identificador
Descritor
Salvar
Excluir
BuscaIdent
BuscaDescr
BuscaDescrTodos
ExisteIdent
ExisteDescr
GetIdentificador
GetDescritor
SetIdentificador
SetDescritor
Novo
*
1
103
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
type // Definio da Classe Class do padrao Type_Object
AClass =class
public // Mtodos da interface
procedure Salvar;
function Excluir:Boolean;
function BuscaIdent(x:Integer):Boolean; // Busca objeto por ident
function BuscaDescr(x:String):Boolean; // Busca objeto por descr
procedure BuscaDescrTodos(x:String; ListaFinal: TListBox); // Busca todos objetos
c/descr
function ExisteIdent(x:Integer): Boolean; // verifica a existencia por ident
function ExisteDescr(x:String): Boolean; // verifica a existencia por descr
function GetIdentificador: Integer;
function GetDescritor: String;
function GetTipo: ATypeClass;
procedure SetIdentificador(x: Integer);
procedure SetDescritor(x: String);
procedure SetTipo(tip: ATypeClass);
function Novo: Integer;
private // Atributos Privados
Identificador: Integer;
Descritor: String;
UmTipo: ATypeClass;
// Mtodos que fazem acesso as tabelas do banco de dados
procedure AtribuirObjetoAParametro(x:TQuery);
procedure AtribuirModeloAObjeto(x:TQuery);
procedure Crie;
procedure Atualize;
procedure Elimine;
function CarregueIdent(x: Integer; atribuir:Boolean): Boolean;
function CarregueDescr(x:String; atribuir:Boolean): Boolean;
function CarregueDescrTodos(x: String; Lista: TListBox): Boolean;
function Ultimo: Integer;
end;
(a)
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
type // Definio da Classe TypeClass do padrao Type_Object
ATypeClass =class
public // Mtodos da interface
procedure Salvar;
function Excluir:Boolean;
function BuscaIdent(x:Integer):Boolean; // Busca por ident
function BuscaDescr(x:String):Boolean; // Busca por descr
procedure BuscaDescrTodos(x:String; ListaFinal: TListBox); // Busca por todos c/descr
function ExisteIdent(x:Integer): Boolean; // verifica a existencia por ident
function ExisteDescr(x:String): Boolean; // verifica a existencia por descr
function GetIdentificador: Integer;
function GetDescritor: String;
procedure SetIdentificador(x: Integer);
procedure SetDescritor(x: String);
function Novo: Integer;
private // Atributos Privados
Identificador: Integer;
Descritor: String;
// Mtodos que fazem acesso as tabelas do banco de dados
procedure AtribuirObjetoAParametro(x:TQuery);
procedure AtribuirModeloAObjeto(x:TQuery);
procedure Crie;
procedure Atualize;
procedure Elimine;
function CarregueIdent(x: Integer; atribuir:Boolean): Boolean;
function CarregueDescr(x:String; atribuir:Boolean): Boolean;
procedure CarregueTodos(Lista: TListBox);
function CarregueDescrTodos(x: String; Lista: TListBox): Boolean;
function Ultimo: Integer;
end;
(b)
Figura 5.14 - Esqueleto da declarao da classe Class do padro Type-Object
104
// Atribuir valor a Identificador
procedure AClass.SetIdentificador(x: Integer);
begin
Identificador:=x;
end;
(a)
// Fornecer o Descritor
function AClass.GetDescritor: String;
begin
GetDescritor:=Descritor;
end;
(b)
// Obter o ltimo identificador registrado na tabela
function AClass.Ultimo: Integer;
var max: Integer;
begin
max :=0;
with DataModuleClass.TabClass do
begin
First;
while not EOF do
begin
if Fields[0].AsInteger >max then
max :=Fields[0].AsInteger;
Next;
end;
end;
Ultimo:=max;
end;
(c)
// Salvar um objeto
procedure ATypeClass.Salvar;
begin
if (not BuscaIdent(Identificador)) and (not BuscaDescr(Descritor)) then
// Objeto da classe Class no cadastrado, inseri-lo na tabela
Crie
else
// Objeto da classe Class j cadastrado, atualizar atributos no-
chave
Atualize;
end;
(d)
Figura 5.15 - Esqueleto de alguns mtodos do padro Type-Object
O mdulo de dados referente classe Class exemplificado na figura 5.16. Ele possui
um componente TTable, que faz referncia tabela fsica; um componente TDataSource
usado para definir a origem dos dados; e cinco componentes Tquery: Insero, para insero
de registro na tabela; Atualizao, para gravar apenas os atributos no-chave da tabela;
Exclusao, para excluir um registro da tabela, dada sua chave primria; SelecionaPrim, para
recuperar registros pela chave primria; e SelecionaSec, para recuperar registros pela chave
secundria. Possui tambm um procedimento para fazer a gravao permanente dos dados ao
fechar a tabela.
105
Os mtodos que fazem o acesso s tabelas da base de dados podem ser vistos nas linhas
23 a 31 e 52 a 61 da figura 5.14, como mtodos privados (clusula private, em Delphi).
Analisando um desses mtodos, como por exemplo o mtodo Ultimo da classe AClass
(figura 5.15 (c)), pode-se notar a referncia efetuada ao mdulo de dados DataModuleClass da
classe Class. Graas utilizao do padro CRUD [Yod 98], esses so os nicos mtodos
que devem saber detalhes das tabelas da base de dados, tais como nome das tabelas, localizao,
nome e posio de campos, etc. Assim, se a base de dados sofrer alguma alterao, poucos
mtodos precisaro ser modificados.
type TdataModuleClass =class(TdataModule)
TabClass: TTable;
DataSource1: TDataSource;
Insercao: TQuery; // insere novo registro na tabela
Atualizacao: TQuery; // atualiza campos nao chave
Exclusao: TQuery; // exclui registro da tabela
SelecionaPrim: TQuery; // seleciona dado um identificador
SelecionaSec: TQuery; // seleciona dado um descritor
procedure TabClassBeforeClose(DataSet: TdataSet);
end;
var
DataModuleClass: TDataModuleClass;
. . .
Figura 5.16 - Esqueleto de um dos mdulos de dados do padro Type-Object
O cdigo SQL a ser executado para cada um dos componentes do mdulo de dados no
fica disponvel no cdigo fonte desse mdulo de dados, sendo armazenado na sua clusula
SQL. As figuras 5.17(a) e (b) ilustram o cdigo SQL para os componentes Insercao e
SelecionaPrim do mdulo de dados Class, respectivamente.
insert into "CLASS.db"
(IDENTIFICADOR_MODELO, DESCRITOR_MODELO, TIPO_MODELO)
values
(:IDENTIFICADOR, :DESCRITOR, :TIPO)
(a)
select * from "CLASS.db"
where IDENTIFICADOR_MODELO=:IDENTIFICADOR
(b)
Figura 5.17 - Cdigo SQL de alguns componentes do mdulo de dados Class
106
Esses esqueletos de cdigo podem ser utilizados em qualquer sistema no qual o padro
Type-Object seja identificado. Para tal, deve-se fazer a substituio dos nomes genricos para
nomes especficos da instncia encontrada, tanto na definio da classe quanto no mdulo de
dados correspondente. Um procedimento passo a passo de como essa substituio deve ser feita
utilizando os recursos do Delphi 3.0 dado em [Bra 98b].
5.2.4.2 Instanciao do padro Type-Object para Pea/Fabricante
A figura 5.18 mostra o modelo de objetos para a instncia do padro Type-Object,
reconhecida na seo anterior para o par de classes Pea/Fabricante. Nota-se que alguns
atributos foram acrescentados classe Pea em relao classe Class do padro, bem como os
mtodos para lidar com esses novos atributos.
Figura 5.18 - Modelo de Objetos de uma instncia do padro Type-Object
A definio das classes e dos mdulos de dados foi feita com base no esqueleto de cdigo
mostrado nas figuras 5.14 a 5.16. As figuras 5.19 e 5.20 mostram as declaraes das classes Pea
e Fabricante, respectivamente. A figura 5.21 mostra os mesmos mtodos da figura 5.15 agora
instanciados para as classes Pea e Fabricante. Alm de fazer a substituio de nomes genricos
para nomes especficos da instanciao, alguns mtodos de acesso s tabelas devem ser revisados
Pea
Cdigo
Descricao
Fabricante
Custo
Preo
Salvar
Excluir
BuscaCod
BuscaDescr
BuscaDescrTodos
ExisteCod
ExisteDescr
GetCodigo
GetDescricao
GetFabricante
GetCusto
GetPreco
SetCodigo
SetDescricao
SetFabricante
SetCusto
SetPreco
Novo
Fabricante
Codigo
Nome
Salvar
Excluir
BuscaCod
BuscaNome
BuscaNomeTodos
ExisteCod
ExisteNome
GetCodigo
GetNome
SetCodigo
SetNome
Novo
*
1
107
para adaptarem-se ao caso instanciado. Quando outros atributos so adicionados classe, deve
ser feita a incluso de algumas linhas nos mtodos responsveis por atribuir os valores dos
objetos aos parmetros da SQL e vice-versa. Devem tambm ser includos os mtodos para
atribuir e recuperar o valor de um atributo (Set e Get, respectivamente).
type // Definio da Classe Peca
Peca =class
public // Mtodos da interface
procedure Salvar;
function Excluir:Boolean;
function BuscaCod(x:Integer):Boolean; // Busca objeto por cod
function BuscaDescr(x:String):Boolean; // Busca objeto por descr
procedure BuscaDescrTodos(x:String; ListaFinal: TListBox); // Busca todos objetos
c/descr
function ExisteCod(x:Integer): Boolean; // verifica a existencia por cod
function ExisteDescr(x:String): Boolean; // verifica a existencia por descr
function GetCodigo: Integer;
function GetDescricao: String;
function GetTipo: Fabricante;
function GetCusto: Currency;
function GetPreco: Currency;
procedure SetCodigo(x:Integer);
procedure SetDescricao(x:String);
procedure SetCusto(c1:Currency);
procedure SetPreco(p1:Currency);
procedure SetTipo(tip:Fabricante);
function Novo: Integer;
private // Atributos Privados
Codigo: Integer;
Descricao: String;
UmTipo: Fabricante;
Custo: Currency;
Preco: Currency;
// Mtodos que fazem acesso as tabelas do banco de dados
procedure AtribuirObjetoAParametro(x:TQuery);
procedure AtribuirModeloAObjeto(x:TQuery);
procedure Crie;
procedure Atualize;
procedure Elimine;
function CarregueCod(x:Integer; atribuir:Boolean): Boolean;
function CarregueDescr(x:String; atribuir:Boolean): Boolean;
function CarregueDescrTodos(x:String; Lista:TListBox): Boolean;
function Ultimo: Integer;
end;
Figura 5.19 - Cdigo em Delphi referente declarao da classe Pea
A figura 5.22 mostra o cdigo referente ao mdulo de dados criado para fazer acesso
tabela Peca. Ele foi criado com base no mdulo de dados genrico mostrado na figura 5.16,
fazendo a devida adaptao de nomes e incluso de novos atributos para o caso especfico. Deve-
se ressaltar que essa mudana de nomes requer alguns cuidados especiais no ambiente Delphi,
como por exemplo: desativar a propriedade Active do componente TTable antes de informar
o nome da base de dados, ativando-a novamente logo em seguida; modificar a propriedade
Name do componente TDataModule antes de efetuar a mudana automtica dos demais
108
nomes; e colocar o nome da base de dados em todos os componentes TQuery de forma manual,
embora possa ser usado o recurso da tecla Shift para agilizar essa colocao. Ainda que esse
procedimento possa parecer um tanto complicado, a adaptao de um mdulo de dados no leva
mais do que cinco minutos. Conforme j foi dito anteriormente, o procedimento passo a passo
para efetuar essa mudana de forma racional est detalhado em [Bra 98b]. Um exemplo de como
o mdulo de dados DataModulePeca utilizado pelo mtodo Ultimo da classe Peca pode
ser visto na figura 5.21 (c).
type // Definio da Classe Fabricante
Fabricante =class
public // Mtodos da interface
procedure Salvar;
function Excluir:Boolean;
function BuscaCod(x:Integer):Boolean; // Busca por cod
function BuscaNome(x:String):Boolean; // Busca por nome
procedure BuscaNomeTodos(x:String; ListaFinal: TListBox); // Busca por todos c/nome
function ExisteCod(x:Integer): Boolean; // verifica a existencia por cod
function ExisteNome(x:String): Boolean; // verifica a existencia por nome
function GetCodigo: Integer;
function GetNome: String;
procedure SetCodigo(x: Integer);
procedure SetNome(x: String);
function Novo: Integer;
private // Atributos Privados
Codigo: Integer;
Nome: String;
// Mtodos que fazem acesso as tabelas do banco de dados
procedure AtribuirObjetoAParametro(x:TQuery);
procedure AtribuirModeloAObjeto(x:TQuery);
procedure Crie;
procedure Atualize;
procedure Elimine;
function CarregueCod(x:Integer; atribuir:Boolean): Boolean;
function CarregueNome(x:String; atribuir:Boolean): Boolean;
function CarregueNomeTodos(x: String; Lista: TListBox): Boolean;
procedure CarregueTodos(Lista: TListBox);
function Ultimo: Integer;
end;
Figura 5.20 - Cdigo em Delphi referente declarao da classe Fabricante
As figuras 5.23 (a) e (b) mostram o cdigo SQL executado pelos componentes Insercao
e SelecionaPrim, respectivamente, quando eles so invocados por algum mtodo. Nota-se que,
em relao ao esqueleto de cdigo mostrado na figura 5.17, foram acrescentados os outros dois
atributos da classe, bem como os parmetros correspondentes, alm de mudar os nomes dos
atributos comuns de acordo com as colunas da tabela fsica. Na implementao das tabelas
adotou-se a conveno de colocar o sufixo _MODELO nos nomes das colunas das tabelas,
para diferenci-los dos nomes dos atributos na classe correspondente.
109
// Atribuir valor a Codigo
procedure Peca.SetCodigo(x: Integer);
begin
Codigo:=x;
end;
(a)
// Fornecer o Descricao
function Peca.GetDescricao: String;
begin
GetDescricao:=Descricao;
end;
(b)
// Obter o ltimo identificador registrado na tabela
function Peca.Ultimo: Integer;
var max: Integer;
begin
max :=0;
with DataModulePeca.TabPeca do
begin
First;
while not EOF do
begin
if Fields[0].AsInteger >max then
max :=Fields[0].AsInteger;
Next;
end;
end;
Ultimo:=max;
end;
(c)
// Salvar um objeto
procedure Fabricante.Salvar;
begin
if (not BuscaCod(Codigo)) and (not BuscaNome(Nome)) then
// Objeto da classe no cadastrado, inseri-lo na tabela
Crie
else
// Objeto da classe j cadastrado, atualizar atributos no-chave
// Atualize; opcao desativada, pois nao existem mais atributos alem dos atributos chave
end;
(d)
Figura 5.21 - Cdigo em Delphi referente a alguns mtodos do padro reconhecido
type TDataModulePeca =class(TDataModule)
TabPeca: TTable;
DataSource1: TDataSource;
Insercao: TQuery;
Atualizacao: TQuery;
Exclusao: TQuery;
SelecionaPrim: TQuery;
SelecionaSec: TQuery;
procedure TabPecaBeforeClose(DataSet: TdataSet);
end;
var
DataModulePeca: TDataModulePeca;
. . .
Figura 5.22 - Mdulo de dados da classe Pea
110
insert into "PECA.db"
(CODIGO_MODELO, DESCRICAO_MODELO, FABRICANTE_MODELO, CUSTO_MODELO,
PRECO_MODELO)
values
(:CODIGO, :DESCRICAO, :TIPO, :CUSTO, :PRECO)
(a)
select * from "PECA.db"
where CODIGO_MODELO=:CODIGO
(b)
Figura 5.23 - Cdigo SQL de alguns componentes do mdulo de dados Peca
A figura 5.24 ilustra a interface para cadastro de peas no sistema exemplo. Essa interface
foi elaborada de forma padronizada, de maneira que possa ser facilmente reutilizada. Alm disso,
o usurio se habitua com seus diversos botes, facilitando o uso e o treinamento.
A figura 5.25 mostra alguns trechos do cdigo relativo interface da figura 5.24. Nele
pode-se observar os seguintes fatos: a utilizao das classes do padro pelo formulrio (linha 5);
a declarao dos objetos da classe (linhas 18 e 19); a instanciao dos objetos das classes Pea
e Fabricante sempre que o formulrio de cadastro de pea ativado (linhas 24 e 25); as
chamadas de mtodos (linhas 27, 28 e 35); e a liberao de memria ocupada pelos objetos
sempre que o formulrio desativado (linhas 42 e 43).
111
Figura 5.24 - Interface da operao de cadastro de peas
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// Formulrio para Cadastro de Peas
unit f_peca;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, ClassePeca, ClasseFabricante, Mask;
type
TFormPeca =class(TForm)
CodigoVisao: TEdit;
DescricaoVisao: TEdit;
ListaFabricantesVisao: TListBox;
FabricanteVisao: TMaskEdit;
. . .
Salvar: TButton;
Sair: TButton;
. . .
procedure SalvarClick(Sender: TObject);
. . .
end;
var
FormPeca: TFormPeca;
p: Peca;
tp:Fabricante;
implementation
{$R *.DFM}
procedure TFormPeca.FormActivate(Sender: TObject);
begin
p:=Peca.Create;
tp:=Fabricante.Create;
LimparControles(True);
tp.BuscaNomeTodos('',ListaFabricantesVisao);
p.SetTipo(tp);
end;
procedure TFormPeca.SalvarClick(Sender: TObject);
begin
if (CompareStr(Trim(DescricaoVisao.Text),'')<>0) then
begin
AtribuirVisaoAObjeto;
p.Salvar;
end
else
ShowMessage('No possvel salvar placa em branco!');
end;
. . .
procedure TFormPeca.FormDeactivate(Sender: TObject);
begin
p.free;
tp.free;
end;
end.
Figura 5.25 - Trecho de cdigo referente ao formulrio de cadastro de peas
112
5.4.2.3 Instanciao do padro Type-Object para Veculo de Cliente/Tipo de Veculo
A figura 5.26 mostra o modelo de objetos para a outra instncia do padro Type-Object,
tambm reconhecida na seo anterior, para o par de classes Veculo de Cliente/Tipo de
Veculo. O cdigo com a declarao dessas classes est na figura 5.27 e os mesmos mtodos da
figura 5.15 instanciados a esse caso esto na figura 5.28.
Figura 5.26 - Modelo de Objetos da outra instncia do padro Type-Object
Ao analisar o modelo da figura 5.13 percebe-se que, alm da semelhana no nvel mais
alto de abstrao que levou generalizao, h tambm uma semelhana entre as classes Class
e TypeClass. Isso pode levar construo de uma superclasse de nvel de abstrao maior,
englobando os atributos e mtodos comuns a essas duas classes. Ento, a instanciao para os
dois casos pode ser feita usando herana. Na verdade houve uma tentativa de fazer essa
superclasse em Delphi, mas surgiram problemas na instanciao de listas (listbox) e das tabelas
da base de dados. Como esses problemas no puderam ser resolvidos a tempo de serem includos
nesta dissertao, fica como sugesto para trabalhos futuros incluir mais essa generalizao.
Comparando a figura 5.19 com a figura 5.27 (a), a figura 5.20 com a 5.27 (b) e a figura
5.21 com a 5.28, pode-se perceber que o reuso quase total, devendo apenas ser mudado o nome
da classe e de seus atributos. Seus mtodos podem ter o nome mudado, embora no seja
necessrio.
Veculo de Cliente
Nro Sequencial
Placa
Tipo
Cliente
Salvar
Excluir
BuscaCod
BuscaPlaca
BuscaPlacaTodos
BuscaClienteTodos
ExisteCod
ExistePlaca
GetNroSequencial
GetPlaca
GetTipo
GetCliente
SetNroSequencial
SetPlaca
SetTipo
SetCliente
Novo
Tipo de Veculo
Codigo
Descricao
Salvar
Excluir
BuscaCod
BuscaDescr
BuscaDescrTodos
ExisteCod
ExisteDescr
GetCodigo
GetDescr
SetCodigo
SetDescr
Novo
*
1
113
type // Definio da Classe Veiculo
Veiculo =class
public // Mtodos da interface
procedure Salvar;
function Excluir:Boolean;
function BuscaCod(x:Integer):Boolean; // Busca objeto por cod
function BuscaPlaca(x:String):Boolean; // Busca objeto por placa
procedure BuscaPlacaTodos(x:String; ListaFinal: TListBox); // Busca todos objetos c/placa
procedure BuscaClienteTodos(x:Integer; ListaFinal: TListBox); // Busca todos objetos por cliente
function ExisteCod(x:Integer): Boolean; // verifica a existencia por cod
function ExistePlaca(x:String): Boolean; // verifica a existencia por placa
function GetNroSequencial: Integer;
function GetPlaca: String;
function GetCliente: Cliente;
function GetTipo: TipoDeVeiculo;
procedure SetNroSequencial(x: Integer);
procedure SetPlaca(x: String);
procedure SetTipo(tip: TipoDeVeiculo);
procedure SetCliente(cli: Cliente);
function Novo: Integer;
private // Atributos Privados
NroSequencial: Integer;
Placa: String;
UmTipo: TipoDeVeiculo;
UmCliente: Cliente;
// Mtodos que fazem acesso as tabelas do banco de dados
procedure AtribuirObjetoAParametro(x:TQuery);
procedure AtribuirModeloAObjeto(x:TQuery);
procedure Crie;
procedure Atualize;
procedure Elimine;
function CarregueCod(x: Integer; atribuir:Boolean): Boolean;
function CarreguePlaca(x:String; atribuir:Boolean): Boolean;
function CarreguePlacaTodos(x: String; Lista: TListBox): Boolean;
function CarregueClienteTodos(x:Integer; Lista: TListBox):Boolean;
function Ultimo: Integer;
end;
(a)
type // Definio da Classe TipoDeVeiculo
TipoDeVeiculo =class
public // Mtodos da interface
procedure Salvar;
function Excluir:Boolean;
function BuscaCod(x:Integer):Boolean; // Busca por cod
function BuscaMarcaTipo(x:String):Boolean; // Busca por marca
procedure BuscaMarcaTipoTodos(x:String; ListaFinal: TListBox); // Busca por todos c/marca
function GetCodigo: Integer;
function GetMarcaTipo: String;
procedure SetCodigo(atr1: Integer);
procedure SetMarcaTipo(atr2: String);
function Novo: Integer;
private // Atributos Privados
Codigo: Integer;
MarcaTipo: String;
// Mtodos que fazem acesso as tabelas do banco de dados
procedure AtribuirObjetoAParametro(x:TQuery);
procedure AtribuirModeloAObjeto(x:TQuery);
procedure Crie;
procedure Atualize;
procedure Elimine;
function CarregueCod(x: Integer): Boolean;
function CarregueMarcaTipo(x: String): Boolean;
procedure CarregueTodos(Lista: TListBox);
function CarregueMarcaTipoTodos(x: String; Lista: TListBox): Boolean;
function Ultimo: Integer;
end;
(b)
Figura 5.27 - Cdigo em Delphi da declarao das classes Veculo e Tipo de Veculo
// Atribuir valor a NroSequencial
114
procedure Veiculo.SetNroSequencial(x: Integer);
begin
NroSequencial:=x;
end;
(a)
// Fornecer o Placa
function Veiculo.GetPlaca: String;
begin
GetPlaca:=Placa;
end;
(b)
// Obter o ltimo identificador registrado na tabela
function Veiculo.Ultimo: Integer;
var max: Integer;
begin
max :=0;
with DataModuleVeiculo.TabVeiculo do
begin
First;
while not EOF do
begin
if Fields[0].AsInteger >max then
max :=Fields[0].AsInteger;
Next;
end;
end;
Ultimo:=max;
end;
(c)
// Salvar um objeto
procedure TipoDeVeiculo.Salvar;
begin
if (not BuscaCod(Codigo)) and (not BuscaMarcaTipo(MarcaTipo)) then
// Objeto da classe Class no cadastrado, inseri-lo na tabela
Crie
else
// Objeto da classe Class j cadastrado, atualizar atributos no-chave
// Atualize; nao existem mais atributos alem dos atributos chave
end;
(d)
Figura 5.28 - Cdigo em Delphi referente a alguns mtodos da segunda instncia do padro
Neste trabalho optou-se por adaptar os nomes dos mtodos de busca, atribuio e
recuperao, de acordo com os atributos identificador e descritor de cada classe. No entanto,
se toda a equipe de desenvolvimento estiver habituada ao uso do padro, pode ser desejvel
manter o nome genrico para facilitar a manuteno do sistema. Por exemplo, ao fazer uma
busca pela chave primria, o desenvolvedor pode achar mais fcil utilizar sempre o mtodo
BuscaIdent do que ter que lembrar o nome do atributo para decidir-se por BuscaCod,
BuscaNro, etc. Alis, quando utilizada a herana os nomes dos mtodos so nicos nas
classes e subclasses, podendo sobrepor-se apenas o seu contedo.
5.4.2.4 Instanciao do Padro Association-Object para Ordem de Servio
115
A figura 5.29 mostra o modelo de objetos contendo as classes e relacionamentos
necessrios para implementar a operao Abre_Ordem_de_Servio. Essa operao foi utilizada
como exemplo nas sees 4.2 e 4.3, nas quais houve reengenharia com mudana de orientao e
com mudana automtica de linguagem para J ava, respectivamente. Nesta seo essa mesma
operao sofre reengenharia com mudana de linguagem, adotando os padres reconhecidos.
Figura 5.29 - Modelo de Objetos para a operao Abre_Ordem_de_Servio
Na Abertura da Ordem de Servio, efetuada quando o cliente leva o veculo para ser
consertado, esto envolvidas as classes Cliente, Veculo de Cliente, Tipo de Veculo e
Ordem de Servio, como pode ser visto na figura 5.29 e tambm nas figuras 3.9, 3.19 e 4.2.
Dessas classes, Veculo de Cliente desempenha o papel Static-2 no padro Association-
Object, mas j foi implementada na seo 5.4.2.3, juntamente com a classe Tipo de Veculo,
por fazerem parte do padro Type-Object. A classe Ordem de Servio desempenha o papel
Association, conforme visto na seo 5.4.1. A classe Cliente precisa ser implementada
*
1
*
1
Veculo de Cliente
Nro Sequencial
Placa
Tipo
Cliente
Salvar
Excluir
BuscaCod
. . .
Tipo de Veculo
Codigo
Descricao
Salvar
Excluir
BuscaCod
. . .
Cliente
Cdigo
Nome
Endereco
CEP
Cidade
Estado
Telefone
Salvar
Excluir
BuscaCod
BuscaNome
BuscaNomeTodos
ExisteCod
ExisteNome
GetCodigo
GetNome
GetEndereco
GetCEP
GetCidade
GetEstado
GetTelefone
SetCodigo
SetNome
SetEndereco
SetCEP
SetCidade
SetEstado
SetTelefone
Novo
Ordemde Servio
NroOrdemServ
DataEntrada
Defeitos
PreoTotal
DataSada
Veculo
Salvar
Excluir
BuscaNroOS
ExisteNroOS
GetNroOrdemServ
GetDataEntrada
GetDefeitos
GetPreoTotal
GetDataSada
GetVeiculo
SetNroOrdemServ
SetDataEntrada
SetDefeitos
SetPreoTotal
SetDataSada
SetVeiculo
Novo
*
1
116
devido funcionalidade da operao Abre_Ordem_de_Servio. O papel Static-1
desempenhado pela classe Pea, por intermdio da classe Pea da Ordem de Serv., conforme
j explicado na seo 5.4.1. A classe Pea s usada no Fechamento da Ordem de Servio,
quando o veculo acabou de ser consertado e as peas e mo-de-obra so cadastradas. Como o
interesse aqui, para fins de comparao, pela operao Abre_Ordem_de_Servio, o padro
Association-Object implementado ento de forma parcial, deixando de tratar da parte que lida
com a classe Static-1.
A classe Cliente foi implementada com base no esqueleto da classe Class, mostrada
na figura 5.14 (a), j que possui caractersticas semelhantes s classes do padro Type-Object: um
atributo identificador e um atributo descritor (Codigo e Nome, respectivamente). Os
mtodos tambm puderam ser aproveitados, fazendo apenas a adaptao de nomes e incluso dos
demais atributos da classe Cliente.
Para implementao da classe OrdemDeServico, apesar de no haver tanta semelhana
quanto nos outros casos, foi tambm utilizado o esqueleto da classe Class. Diversos mtodos
tiveram que ser eliminados, j que OrdemDeServio no possui um atributo descritor. Porm,
o processo de reuso foi vlido, tendo havido um rendimento bem maior do que se a classe tivesse
sido construda a partir do zero. A figura 5.30 mostra a definio dessa classe e as figuras 5.31
(a) e (b) mostram o corpo de alguns de seus mtodos. Os mtodos mostrados na figura 5.31 (a)
correspondem ao mtodo OBTPROXO, cujo cdigo segmentado consta na figura 4.4 (a) e cujo
cdigo transformado para J ava consta na figura 4.8 (a). Os mtodos mostrados na figura 5.31 (b)
correspondem ao mtodo GRORDSER, cujo cdigo segmentado consta na figura 4.4 (d) e cujo
cdigo transformado para J ava consta na figura 4.8 (d). O mtodo GRORDSER foi
desmembrado em quatro mtodos para isolar o acesso s tabelas da base de dados pelo uso do
padro CRUD, conforme explicado na seo 5.4.2.1.
Alguns mtodos que foram necessrios devido s caractersticas da linguagem Clipper
no possuem o correspondente na implementao em Delphi, como, por exemplo, os mtodos
para abertura e fechamento de arquivos e os mtodos para leitura de dados de interface. Em
Delphi, no existe um mtodo que implemente a lgica da operao Abre_Ordem_de_Servio.
Em vez disso, o formulrio de entrada da Ordem de Servio que faz a chamada dos mtodos e
sua sincronizao, de acordo com a lgica desejada. Esse formulrio de entrada tambm faz a
leitura de dados por intermdio de componentes visuais. A abertura e o fechamento dos arquivos
117
da base de dados so de responsabilidade do mdulo de dados de cada classe, sendo programados
pelo desenvolvedor em tempo de projeto.
type // Definio da Classe Ordem de Servico
OrdemDeServico =class
public // Mtodos da interface
procedure Salvar;
function Excluir:Boolean;
function BuscaNroOS(x:Integer):Boolean; // Busca objeto por NroOS
function ExisteNroOS(x:Integer): Boolean; // verifica a existencia por NroOS
function GetNroOrdemServ: Integer;
function GetDataEntrada: TDateTime;
function GetDefeitos: String;
function GetPrecoTotal: Currency;
function GetDataSaida: TDateTime;
function GetVeiculo: Veiculo;
procedure SetNroOrdemServ(x: Integer);
procedure SetDataEntrada(x: TDateTime);
procedure SetDefeitos(x: String);
procedure SetPrecoTotal(x: Currency);
procedure SetDataSaida(x: TDateTime);
procedure SetVeiculo(x: Veiculo);
function Novo: Integer;
private // Atributos Privados
NroOrdemServ: Integer;
DataEntrada: TDateTime;
Defeitos: String[80];
PrecoTotal: Currency;
DataSaida: TDateTime;
UmVeiculo: Veiculo;
// Mtodos que fazem acesso as tabelas do banco de dados
procedure AtribuirObjetoAParametro(x:TQuery);
procedure AtribuirModeloAObjeto(x:TQuery);
procedure Crie;
procedure Atualize;
procedure Elimine;
function CarregueNroOS(x: Integer; atribuir:Boolean): Boolean;
function Ultimo: Integer;
end;
Figura 5.30 - Definio da classe OrdemDeServio
A figura 5.32 mostra a tela de abertura do sistema, no momento em que a opo de
Abertura da Ordem de Servio requisitada pelo usurio, por intermdio de um menu. A figura
5.33 mostra a interface para Abertura da Ordem de Servio. Deve-se observar que a disposio
dos botes na parte inferior da janela semelhante das demais operaes do sistema, como a
mostrada na figura 5.24. Trs botes foram adicionados: Cliente..., para permitir que o usurio
faa a busca de clientes j cadastrados com maior rapidez, inclua novos clientes ou modifique
dados de um determinado cliente; Novo Veculo..., para incluso de um novo veculo, se for o
caso; e Eliminar Veculo, para eliminar os veculos da lista que no pertenam mais ao cliente.
118
// Obter um novo nro de objeto
function OrdemDeServico.Novo: Integer;
begin
Novo:=Ultimo+1;
end;
// Obter o ltimo nro de ordem de servio registrado
function OrdemDeServico.Ultimo: Integer;
var max: Integer;
begin
max :=0;
with DataModuleOrdemDeServico.TabOrdemDeServico do
begin
First;
while not EOF do
begin
if Fields[0].AsInteger >max then
max :=Fields[0].AsInteger;
Next;
end;
end;
Ultimo:=max;
end;
(a)
// Salvar um objeto
procedure OrdemDeServico.Salvar;
begin
if (not ExisteNroOS(NroOrdemServ)) then
// Objeto no cadastrado, inseri-lo na tabela
Crie
else
// Objeto j cadastrado, atualizar atributos no-chave
Atualize;
end;
// Criar novo registro
procedure OrdemDeServico.Crie;
begin
AtribuirObjetoAParametro(DataModuleOrdemDeServico.Insercao);
DataModuleOrdemDeServico.Insercao.ExecSQL;
end;
// Atualizar registro
procedure OrdemDeServico.Atualize;
begin
AtribuirObjetoAParametro(DataModuleOrdemDeServico.Atualizacao);
DataModuleOrdemDeServico.Atualizacao.ExecSQL;
end;
// Atribuir objeto aos parametros de busca
procedure OrdemDeServico.AtribuirObjetoAParametro(x:TQuery);
begin
with x do
begin
ParamByName('NroOrdemServ').AsInteger:=NroOrdemServ;
ParamByName('DataEntrada').AsDateTime:=DataEntrada;
ParamByName('Defeitos').AsString:=Defeitos;
ParamByName('DataSaida').AsDateTime:=DataSaida;
ParamByName('PrecoTotal').AsCurrency:=PrecoTotal;
ParamByName('CodigoVeiculo').AsInteger:=UmVeiculo.GetNroSequencial;
end;
end;
(b)
Figura 5.31 - Alguns mtodos da classe OrdemDeServio
119
Figura 5.32 - Interface do sistema mostrando um dos menus
Figura 5.33 - Interface da operao de Abertura da Ordem De Servio
120
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
unit f_ordemdeservico; // Formulrio para Cadastro de Veiculos de
Cliente
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
ClasseVeiculo, ClasseTipoDeVeiculo, ClasseCliente, ClasseOrdemDeServico,
StdCtrls, Mask;
type
TformAberturaOrdemDeServico =class(TForm)
NroOrdemServVisao: TEdit;
PlacaVisao: TEdit;
Buscar: TButton;
NovaOS: TButton;
Salvar: TButton;
Sair: TButton;
Excluir: TButton;
ClienteVisao: TEdit;
BotaoCliente: TButton;
BotaoVeiculo: TButton;
DataEntradaVisao: TMaskEdit;
MarcaVisao: TEdit;
DefeitosVisao: TMemo;
ListaVeiculosVisao: TListBox;
Eliminarveiculo: TButton;
. . .
procedure SalvarClick(Sender: TObject);
procedure LimparControles;
procedure AtribuirVisaoAObjeto;
procedure AtribuirObjetoAVisao;
procedure FormActivate(Sender: TObject);
procedure BuscarClick(Sender: TObject);
procedure NovaOSClick(Sender: TObject);
procedure SairClick(Sender: TObject);
procedure FormDeactivate(Sender: TObject);
procedure ExcluirClick(Sender: TObject);
procedure BotaoClienteClick(Sender: TObject);
procedure BotaoVeiculoClick(Sender: TObject);
procedure ClienteVisaoExit(Sender: TObject);
procedure ListaVeiculosVisaoClick(Sender: TObject);
procedure EliminarveiculoClick(Sender: TObject);
end;
. . .
procedure TformAberturaOrdemDeServico.NovaOSClick(Sender: TObject);
begin
LimparControles;
NroOrdemServVisao.Text:=IntToStr(os.Novo);
os.SetNroOrdemServ(StrToInt(NroOrdemServVisao.Text));
DataEntradaVisao.text:=DateTimeToStr(date);
DataEntradaVisao.SetFocus;
end;
procedure TformAberturaOrdemDeServico.BotaoClienteClick(Sender: TObject);
begin
FormCliente.NomeVisao.Text:=ClienteVisao.Text;
FormCliente.FormActivate(self);
FormCliente.Buscar.Click;
FormCliente.ShowModal;
ClienteVisao.Text:=FormCliente.NomeVisao.Text;
end;
procedure TFormAberturaOrdemDeServico.ClienteVisaoExit(Sender: TObject);
begin
if ((ClienteVisao.Text <>'') and (c.BuscaNome(ClienteVisao.Text+'%'))) then
begin
ClienteVisao.Text:=c.GetNome;
v.BuscaClienteTodos(c.GetCodigo,ListaVeiculosVisao);
end;
end;
. . .
Figura 5.34 - Trechos do cdigo referente ao formulrio de Abertura da Ordem De Servio
A figura 5.34 mostra trechos do cdigo referentes ao formulrio de abertura da Ordem de
Servio. Conforme citado anteriormente, esse formulrio corresponde operao
121
Abre_Ordem_de_Servio. A lgica envolvida na operao ditada pelos eventos possveis em
cada um dos componentes do formulrio. Por exemplo, nas linhas 40 a 47 da figura 5.34 est o
mtodo executado quando o usurio ativa o boto Nova OS e nas linhas 48 a 55 est o mtodo
referente ativao do boto Cliente. No primeiro caso, o mtodo Novo da classe
OrdemDeServico invocado (linha 43) e os componentes do formulrio so atualizados para
refletir a nova ordem de servio. No segundo caso, outro formulrio de entrada de dados
ativado (linhas 50 a 53) e, ao retornar desse, faz-se a atualizao do componente que mostra o
nome do cliente (linha 54).
Conforme pode ser observado nas linhas 24 a 38, existem mtodos associados ativao
de todos os botes do formulrio e tambm mtodos associados navegao por alguns dos
componentes de entrada de dados. Por exemplo, quando o usurio digita o nome do cliente e
avana para outro componente, gerado o evento Exit, que dispara o mtodo
ClienteVisaoExit (linha 36). Esse mtodo d o tratamento adequado a esse evento, mostrado
nas linhas 56 a 63, que basicamente trata de verificar a existncia de tal cliente e buscar seus
veculos cadastrados, colocando-os na lista de veculos do cliente.
5.5 Consideraes Finais
A ocorrncia de diversas instncias do mesmo padro no sistema aumenta
significativamente o reuso, acelerando o processo de reengenharia. A estratgia proposta
centrada na importncia de saber identificar a ocorrncia de padres, para poder tirar proveito
deles. O cdigo resultante do uso de padres claro e de fcil entendimento.
As diversas experincias de implementao efetuadas mostraram que o tempo gasto para
instanciar o padro Type-Object significativamente menor do que se ele fosse programado a
partir do zero. Em cerca de quarenta minutos pode-se ter uma instncia do padro programada e
em condies de ser executada.
Algumas classes participam de mais de um padro, como a Veiculo de cliente, que
desempenha o papel Class no padro Type-Object e o papel Static-2 no padro Association-
Object. Nesse caso, aps implementar um dos padres j se tem a classe programada, o que
facilita a implementao do outro padro no qual ela ocorre.
122
CAPTULO 6 Concluses Finais e Sugestes para novas pesquisas
6.1 Consideraes Iniciais
Foi proposta nesta dissertao uma abordagem para reengenharia de sistemas, com uso de
padres de software para maximizar o reuso e melhorar a manutenibilidade. Algumas atividades
intermedirias foram desenvolvidas. A engenharia reversa do sistema legado foi efetuada, tendo
sido proposto um detalhamento do passo de abstrao do Modelo de Anlise do Sistema. A
reengenharia com mudana de orientao foi realizada, transformando o sistema originalmente
procedimental em um sistema com caractersticas da orientao a objetos. A reengenharia com
mudana de linguagem de programao foi feita, transformando o cdigo fonte de Clipper para
J ava. Foi, ento, estabelecida uma estratgia para reconhecimento de alguns padres recorrentes
de sistemas de informao, a partir do modelo de objetos produzido na engenharia reversa.
Finalmente, foi executada a reengenharia com uso de padres de software, utilizando a
linguagem Delphi.
Na seo 6.2 so feitas as concluses gerais de todo o trabalho desenvolvido. Na seo
6.3 so apresentadas as contribuies deste trabalho e na seo 6.4 esto as sugestes para novas
pesquisas.
6.2 Concluses Gerais
A engenharia reversa forneceu a documentao de anlise orientada a objetos necessria
para a reengenharia pretendida e para o reconhecimento de padres.
A realizao da reengenharia com mudana de orientao do paradigma de
desenvolvimento do sistema obteve xito. Um sistema originalmente desenvolvido com
orientao procedimental foi transformado segundo o paradigma da orientao a objetos, sem
mudana de funcionalidade ou linguagem de programao. Com isso, obteve-se maior
compatibilidade entre o modelo de anlise obtido pelo Fusion/RE e o cdigo fonte. Se somente a
engenharia reversa tivesse sido efetuada, haveria maior dificuldade em associar o cdigo aos
componentes do modelo de anlise.
123
A realizao da reengenharia com mudana automtica de linguagem tornou possvel a
integrao do processo geral Fusion/RE com a mquina Draco-Puc, pelo acrscimo de dois
passos novos ao Fusion/RE e pela construo dos elementos necessrios na mquina Draco-Puc
para que ela pudesse trabalhar com outros domnios. A reconstruo de software para que ele
possa ser executado em novas plataformas de hardware e software permite sua melhora sem
perder a funcionalidade. A abordagem utilizada acrescenta a isso melhor documentao do
sistema em nveis mais altos de abstrao, essencial para uma boa manutenibilidade. O cdigo
Clipper poderia ter sido transformado para J ava sem a segmentao prvia, mas dessa forma o
cdigo resultante no tiraria proveito dos recursos de orientao a objetos, resolvendo apenas o
problema de portabilidade. A fase de segmentao que garante as caractersticas do sistema
resultante.
A identificao de padres no modelo de anlise obtido pela engenharia reversa tornou
possvel a implementao em Delphi com maior racionalidade. A estratgia para reconhecimento
de padres proposta mostrou-se eficiente nos casos em que foi aplicada.
A comparao do sistema legado em Clipper com os sistemas obtidos aps a
reengenharia (Sistema Segmentado Clipper, Sistema transformado para J ava e Sistema em
Delphi com uso de padres), mostrada na tabela 6.1.
Todos os sistemas obtidos pela reengenharia so mais fceis de manter em relao ao
cdigo legado, mas existe uma vantagem marcante do cdigo que usa padres de software.
Quanto legibilidade, o cdigo transformado automaticamente para J ava deixa um pouco a
desejar. Da forma como foi definida a transformao de comandos de Clipper para J ava, a
maioria
das funes Clipper foi implementada como um mtodo em J ava. O cdigo resultante parece ser
uma mistura do Clipper e do J ava, no sendo compreendido facilmente nem por um programador
Clipper, nem por um programador J ava. As vantagens da reengenharia para J ava foram quanto
portabilidade, j que essa linguagem independente de plataforma, ao passo que as outras no, e
quanto ao tempo gasto na transformao, que insignificante aps a segmentao e construo
dos domnios apropriados. Deve-se observar que parte dos problemas notados podem ser
resolvidos com a definio de outras estratgias de transformao, com base na experincia e
aprendizado obtidos com este primeiro experimento.
O reuso superior no sistema que usa padres, j que so reusados desde os conceitos de
anlise e projeto at os detalhes de implementao. Todas as formas de reengenharia implicam
124
em custos. Porm, a segmentao parece ser mais vivel economicamente, pois pode ser feita aos
poucos, utilizando o prprio pessoal habituado linguagem Clipper.
Tabela 6.1 Comparao dos resultados
Caracterstica Sistema Legado
em Clipper
Sistema Segmentado
em Clipper
Sistema transfor-
mado para Java
usando Draco-Puc
Sistema em Delphi,
com uso de padres
Legibilidade Boa, pois o programa
est estruturado
Boa, embora os
parmetros includos
na segmentao
aumentem o grau de
acoplamento
Boa, pois a
transformao
mantm a estrutura
do cdigo segmenta-
do, apesar do cdigo
no ser tpico de um
programa em J ava.
Excelente, devido aos
nomes mnemnicos e
estruturao
permitida pelo uso de
classes.
Manuteno Dificultada devido s
anomalias
Facilitada, pois os
mtodos ficam
agrupados no arquivo
de cada classe
Facilitada, apesar da
legibilidade do
cdigo no ser boa
Facilitada, pois a
estrutura do sistema
uniformizada
Reuso Limitado a sistemas
com funcionalidade
semelhante
Bom, devido ao
grande nmero de
mdulos com
funcionalidade bem
definida
Bom, devido ao
grande nmero de
mdulos com funcio-
nalidade bem defini-
da, apesar do proble-
ma de legibilidade
Muito bom, pois
abrange desde a
anlise, projeto at a
implementao das
classes, mdulos de
dados e formulrios
Esforo para
reengenharia
- Pode ser feita de for-
ma gradual, focali-
zando primeiramente
os mdulos de manu-
teno mais crtica.
No h necessidade
de mudana de
pessoal.
O maior custo est na
fase de segmentao
e na construo dos
domnios origem e
destino. Uma ferra-
menta de auxlio
poderia diminuir esse
custo. H necessida-
de de pessoal espe-
cializado para uso
dessa tcnica.
Deve haver um custo
no treinamento do
pessoal no uso de
padres e, se for o
caso, no uso de uma
linguagem orientada
a objetos.
Portabilidade Especfico para
plataforma DOS
Especfico para
plataforma DOS
Independente de
plataforma de
hardware ou software
Especfico para
plataforma Windows
Interface com o
usurio
Pobre Pobre Pobre Rica
Usabilidade Regular Regular Regular Boa
Desempenho timo timo Bom Bom
Quanto interface com o usurio, o sistema legado apresenta uma interface pobre,
baseada em janelas do ambiente DOS, sem muitos recursos para facilitar sua operao. O
sistema segmentado mantm essa interface, assim como o sistema transformado para J ava. Desta
forma, a reengenharia para Delphi a nica que fez a modernizao da interface, oferecendo ao
usurio todos os recursos dos ambientes atuais. Deve-se ressaltar que a mudana de interface
125
pode tambm ser feita no sistema em J ava, para aproveitar melhor seus recursos, mas essa
mudana deve ser feita manualmente, aps o processo de transformao. A interface influi
tambm na usabilidade, que pode ser melhorada empregando os recursos das linguagens
modernas, tais como botes, listas, ajuda sensvel ao contexto, etc.
O desempenho dos sistemas, em termos de tempo de execuo, foi testado em mquinas
Pentium 233 Mhz com Windows 95. Obteve-se melhor resultado nos sistemas Clipper do que
nos sistemas J ava e Delphi. Isso principalmente devido ao fato de que aplicaes DOS so bem
mais enxutas em relao a aplicaes WINDOWS.
A experincia de reuso efetuada durante este trabalho extremamente compensadora.
Quando comparado ao reuso que tenho feito dentro de minha prtica profissional, conforme
mencionado na seo 1.2, sua eficincia fica ainda mais evidente. Unidos s vantagens oferecidas
pela orientao a objetos, os padres aceleram o processo de desenvolvimento, por embutirem
solues para problemas na maioria das vezes comuns, mas cuja freqncia de ocorrncia
acarreta tempo substancial de desenvolvimento.
6.3 Contribuies deste trabalho
Alm de alcanar o objetivo de reconhecimento de padres de software teis no reuso,
ampliao de funcionalidade e manuteno de sistemas, vrios subprodutos originaram-se deste
trabalho: o detalhamento da abstrao do modelo de anlise do sistema, a abordagem para
mudana de orientao do sistema como preparao para a mudana automtica de linguagem e
os esqueletos de classes para a implementao do padro Type-Object.
A contribuio mais significativa o fornecimento de uma estratgia para
reconhecimento de padres especficos de sistemas de informao, tanto na engenharia reversa
de sistemas legados quanto na engenharia avante de sistemas. O uso de padres implica em
aumento de produtividade, maior uniformidade na estrutura do software e reduo da
complexidade, pois blocos construtivos podem ser usados na elaborao de sistemas maiores. A
estratgia geral proposta pode ser seguida por outros engenheiros de software durante a
engenharia reversa ou avante de sistemas. Por meio dessa estratgia o reuso poder ser expandido
a nveis mais altos de abstrao, ao invs de se manter puramente no nvel do cdigo. Na
engenharia reversa esses padres podem ser reconhecidos aps a recuperao do Modelo de
Objetos do Sistema. Na engenharia avante esses padres podem ser reconhecidos aps o projeto
126
do sistema e utilizados na implementao. A realizao da reengenharia com mudana de
linguagem adotando os padres reconhecidos permitiu a visualizao dos padres depois de
programados em uma linguagem comercial, o Delphi no caso. Com isso, pde-se avaliar a
melhoria da manutenibilidade do sistema que possui padres refletidos no cdigo fonte.
O detalhamento da abstrao do modelo de anlise do sistema reforou o mtodo
Fusion/RE, facilitando sua aplicao a sistemas de informao. A transio do Modelo de
Objetos do Sistema Atual, construdo com influncia da implementao atual, para o Modelo de
Objetos do Sistema, que deve refletir o domnio de aplicao num nvel de abstrao mais alto,
complexa. O detalhamento sugerido ameniza essa transio, diminuindo o salto que era antes
dado entre um modelo e outro.
O estabelecimento de uma abordagem para mudana de orientao do paradigma de um
sistema, de procedimental para orientado a objetos, por intermdio da segmentao, torna
possvel a reengenharia de mudana de orientao sem mudana de linguagem de programao.
Sistemas importantes para as empresas, mas com alto custo de manuteno, podem passar por
esse processo e ter facilitada sua manuteno. A segmentao elimina as anomalias no cdigo
fonte, tornando-o um cdigo programado pelo conceito de tipos abstratos de dados. Isso feito
em continuidade ao trabalho de Penteado [Pen 96], no qual as anomalias so detectadas durante a
engenharia reversa pelo Fusion/RE e os mtodos necessrios para resolver essas anomalias so
indicados de forma textual, no chegando a ser implementados no cdigo. O cdigo segmentado
Clipper tambm utilizado como entrada para a transformao automtica pela mquina Draco-
Puc, que nesse experimento o transforma para a linguagem J ava. Se a transformao fosse feita
sem a segmentao prvia, o cdigo resultante no traria as vantagens da orientao a objetos.
O fornecimento de esqueletos das classes para servirem como base para implementao,
em Delphi, do padro Type-Object, facilita o uso desse padro. Desenvolvedores podem ter um
ponto de partida que os estimule ao uso de padres de software e ao desenvolvimento de uma
biblioteca com os padres usados com mais freqncia. A linguagem Delphi, comumente
utilizada em sistemas de informao comerciais, provou ser adequada para a implementao de
padres, embora a literatura consultada no mencione esse fato.
6.4 Sugestes para futuras pesquisas
127
O processo de segmentao foi executado de forma manual, auxiliado somente por um
editor de textos. Inicialmente esse processo consumiu bastante tempo mas, depois de adquirir
alguma experincia, houve um aumento na eficincia. Isso explicado pelo carter repetitivo das
tarefas envolvidas na segmentao. Assim, uma possvel pesquisa poderia ser a construo de
uma ferramenta de auxlio computadorizado segmentao. Tarefas tais como a identificao de
anomalias, isolamento de trechos em mtodos (slices), etc. poderiam ser facilitadas por tal
ferramenta, eliminando muito do trabalho tedioso e repetitivo. Acredita-se que a interveno do
engenheiro de software seja fundamental durante o processo de segmentao, no sendo possvel,
portanto, a segmentao totalmente automtica.
O reconhecimento de padres a partir dos modelos de anlise do sistema tambm foi feito
de forma manual, embora existam diversas indicaes de que alguns padres pudessem ser
descobertos com o auxlio de uma ferramenta especificamente projetada para tal. O
conhecimento do domnio de aplicao essencial no reconhecimento de padres de anlise, mas
a construo sinttica tambm pode ajudar, descartando classes sem chance de se encaixar no
padro. A ferramenta poderia auxiliar na anlise da construo sinttica.
Aps o reconhecimento dos padres, sua utilizao em futuros desenvolvimentos poderia
ser mais encorajada se eles ficassem disponveis em um repositrio. Esse repositrio de padres
poderia englobar classes prontas, pr-programadas em diversas linguagens, que poderiam ser
usadas facilmente instanciando-se o padro para a aplicao especfica, de forma similar aos
esqueletos apresentados na seo 5.4.2.1.
A implementao dos esqueletos de classes para o padro Type-Object poderia evoluir
para um framework que englobasse diversos padres recorrentes, facilitando ainda mais seu
reuso em novas aplicaes.
128
Bibliografia
[Arm 98] Armstrong, M. N.; Trudeau, C. Evaluating Architectural Extractors. In: IEEE
Working Conference on Reverse Engineering, 5., Honolulu, Hawai, EUA, outubro
de 1998. Anais. LosAlamitos-CA, EUA, IEEE Computer Society, p. 30-39.
[Ben 92] Benedusi, P.; Cimitile, A; Carlini, U. Reverse Engineering Processes, Design
Document Production and Structure Charts. J . Systems Software, V.19, p. 225-245,
1992.
[Ben 96] Benedusi, P. Improving reverse engineering models with test-case related
knowledge. Information and Software Technology, V.38, p.711-718, 1996.
[Big 89] Biggerstaff, Ted. J . Design Recovery for Maintenance and Reuse. Computer-IEEE,
p. 36-49, julho 1989.
[Big 94] Biggerstaff, Ted J .; Mitbander, Bharat G.; Webster, Dallas E. Program
Understanding and the Concept Assignment Problem. Communications of the
ACM, V.37, n5, maio 1994.
[Bos 97] Bosch, J an. Design Patterns as Language Constructs. Disponvel a partir da Wide
World Web <URL:http://st-www.cs.uiuc.edu/users/patterns/papers>, 1997.
[Boy 98] Boyd, L. Business Patterns of Association Objects. In: Martin, R.C.; Riehle, D.;
Buschmann, F. Pattern Languages of Program Design 3. Reading, MA, Addison-
Wesley, 1998, p. 395-408.
[Bra 86a] Braga, Rosana T.V. Construo pelo mtodo de Jackson de um prottipo em Dbase
II do sistema de processamento de Concurso de Jornal especificado por Jackson.
So Carlos, USP, 1986. (Relatrio apresentado FAPESP, dentro do plano de bolsa
de iniciao cientfica referente ao processo 85/0405-9)
[Bra 86b] Braga, Rosana T.V. Aplicao de um instrumento de apoio por computador ao
mtodo Gane. So Carlos, USP, 1986. (Relatrio apresentado FAPESP, dentro do
plano de bolsa de iniciao cientfica referente ao processo 85/0405-9)
[Bra 90] Braga, Rosana T.V. Manual de Uso do Sistema de Oficina Auto-eltrica e
Mecnica. So Carlos, 1990. (Documento de Trabalho)
[Bra 98a] Braga, Rosana T.V.; Masiero, Paulo C. Detalhamento do passo de abstrao do
modelo de anlise do mtodo Fusion/RE. So Carlos, USP, maro de 1998.
(Relatrio Tcnico do ICMSC-USP, 70)
[Bra 98b] Braga, Rosana T.V.; Germano, Ferno S.R.; Masiero, Paulo C. Experimentos para
implementao do padro Type-Object em linguagem Delphi. So Carlos, USP,
1998. (Relatrio Tcnico do ICMSC-USP, em elaborao)
129
[Bud 96] Budinsky, F.J , et al. Automatic code generation from design patterns. IBM Systems
J ournal, V. 35, n 2, p. 151-171, 1996.
[Bus 97] Buschmann, Frank, et al. Pattern-Oriented Software Architecture. European
Conference on Object-Oriented Programming, 11., Finland, J unho 1997. Anais.
Finland.
[Cam 97] Campo, Marcelo; Price, R.T. Automated Recognition of Design Patterns for
Framework Understanding. (Comunicao particular), 1997.
[Can 97] Cantu, Marco. Dominando o Delphi 2. So Paulo, Makron Books, 1997.
[Can 98] Cantu, Marco; Gooch, Tim; Lam, J ohn F. Delphi Developers Handbook. Alameda-
CA, Sibex, 1998.
[Chi 90] Chikofsky, Elliot J .; Cross, J ames H. Reverse Engineering and Design Recovery: a
Taxonomy. IEEE Software, p. 13-17, janeiro 1990.
[Coa 92] Coad, Peter. Object-Oriented Patterns. Communications of the ACM, V. 35, n9, p.
152-159, setembro 1992.
[Col 94] Coleman D. et al. Object Oriented Development - The Fusion Method. Prentice
Hall, 1994.
[Cop 92] Coplien, J .O. Advanced C++ Programming Styles and Idioms. Reading-MA,
Addison-Wesley, 1992.
[Eri 98] Eriksson, H.; Penker, M. UML Toolkit. New York, Wiley Computer Publishing,
1998.
[Fer 95] Ferreira, Aurlio B.H. Dicionrio Aurlio Bsico da Lngua Portuguesa. So Paulo,
Editora Nova Fronteira, 1995.
[Fin 97] Finnigan, P. J . et al. The Software bookshelf. IBM Systems J ournal, V. 36, n 4, p.
564-593, 1997.
[Fow 97] Fowler, M. Analysis Patterns. Menlo-Park-CA, Addison-Wesley, 1997.
[Fow 98] Fowler, M.; Scott, K. UML Distilled Applying the standard object modeling
language. Reading, Massachusetts, Addison-Wesley, 1998.
[Gal 95] Gall, Harald C., Klsh, Ren R.; Mittermeir, Roland T. Architectural
Transformation of Legacy Systems. International Conference on Software
Engineering, 11., Abril 1995. (Technical Report n CS95-418)
[Gal 96] Gall, Harald C., Klsh, Ren R.; Mittermeir, Roland T. Application Patterns in Re-
Engineering: Identifying and Using Reusable Concepts. International Conference
on Information Processing and Management of Uncertainty in Knowledge-Based
Systems, 6., J ulho 1996. Anais. p. 1099-1106.
130
[Gam 93] Gamma, E.; Helm, R.; J ohnson,R.; Vlissides, J . Design Patterns - Abstraction and
Reuse of Object-Oriented Design. LNCS, n 707, p. 406-431, julho de 1993.
[Gam 95] Gamma, E.; Helm, R.; J ohnson, R.; Vlissides, J . Design Patterns - Elements of
Reusable Object-Oriented Software. Reading-MA, Addison-Wesley, 1995.
[Gan 83] Gane, Chris, Sarson, Trish. Anlise Estruturada de Sistemas, Rio de J aneiro, Livros
Tcnicos e Cientficos Editora S. A., 1983.
[Hai 96] Hainaut, J -L et al. Structure Elicitation in Database Reverse Engineering. In:
Working Conference on Reverse Engineering (WCRE), 3., Monterey-California,
1996. Anais. IEEE, 1996, p. 131-140.
[Hai 96a] Hainaut, J -L. Ajuda on-line do DB-MAIN - Demo Version 2.01. 1996. (Manual
tcnico)
[J ac 83] J ackson, M. System Development. Englewood Cliffs-NJ , Prentice-Hall International
Inc., 1983.
[J ac 91] J acobson, Ivar e Lindstrom, Fredrik. Re-engineering of old systems to an object-
oriented architecture. In: Conference on Object Oriented Programming Systems,
Languages and Applications (OOPSLA). Anais. 1991, p. 340-350.
[J oh 98] J ohnson, R.; Woolf, B. Type Object. In: Martin, R.C.; Riehle, D.; Buschmann, F.
Pattern Languages of Program Design 3. Reading-MA, Addison-Wesley, 1998, p.
47-65.
[Klo 96] Klsh, Ren R. Reverse Engineering: Why and How to Reverse Engineer Software.
In: California Software Symposium (CSS), California, EUA, abril de 1996. Anais.
University of Southern California, 1996, p. 92-99.
[Kra 96] Krmer, Christian; Prechelt, Lutz. Design Recovery by Automated Search for
Structural Design Patterns in Object-Oriented Software. In: Working Conference
on Reverse Engineering (WCRE), 3., Monterey-CA, EUA, 1996. Anais. IEEE,
1996, p. 208-215.
[Mar 94] Markosian, Lawrence, et al. Using na Enabling Technology to Reengineer Legacy
Systems. Communications of the ACM, V.37, n5, p. 58-70, maio 1994.
[Mar 98] Martin, R.C.; Riehle, D.; Buschmann, F. (eds.) Pattern Languages of Program
Design 3, Reading-MA, Addison-Wesley, 1998.
[May 95] Mayrhauser, Anneliese von; Vans, A. M. Program Comprehension During
Software Maintenance and Evolution. Computer-IEEE, p.44-55, agosto 1995.
[May 96] Mayrhauser, Anneliese von; Vans, A. M. Identification of Dynamic Comprehension
Processes During Large Scale Maintenance. IEEE Transactions on Software
Engineering, V.22, n 6, junho 1996.
131
[Mas 88] Masiero, Paulo C.; Germano, Fernao S.R. JSD as an Object Oriented Design
Method. Software Engineering Notes, V.13, n 3, julho 1988.
[Nei 84] Neighbors, J .M. The Draco Approach to Constructing Software from Reusable
Components. IEEE Transactions on Software Engineering, V.SE-10, n 5, p. 564-
77, 1984.
[Nin 94] Ning, J im Q.; Engberts, A.; Kozaczynsku, W. Automated Support for Legacy Code
Understanding. Communications of the ACM, V.37, n 5, p. 50-57, maio 1994.
[Oli 91] Oliveira, J acqueline A.; Braga, Rosana T.V. Documentao Tcnica do Sistema de
Oficina Auto-eltrica e Mecnica. So Carlos, 1991 (Documento de Trabalho)
[Pen 95] Penteado, R.D., Germano, F.; Masiero, P.C. Engenharia Reversa Orientada a
Objetos do Ambiente StatSim: Mtodo Utilizado e Resultados Obtidos, In:
Simpsio Brasileiro de Engenharia de Software, 9., Recife-PE, 1995. Anais. Recife,
UFPE, 1995. p. 345-351.
[Pen 96] Penteado, R.D. Um mtodo para Engenharia Reversa Orientada a Objetos. So
Carlos, 1996. 251p. Tese (Doutorado) - Instituto de Fsica de So Carlos,
Universidade de So Paulo.
[Pen 96a] Penteado, R.D., Germano, F.; Masiero, P.C. An Overall Process Based on Fusion to
Reverse Engineer Legacy Code. In: Working Conference on Reverse Engineering,
3., Monterey-CA, 1996. Anais. IEEE, 1996, p. 179-188.
[Pen 96b] Penteado, R.D., Germano, F.; Masiero, P.C. Melhoria na Manutenibilidade de
Software Legado com Base em Engenharia Reversa. In: Conferncia Internacional
de Tecnologia de Software - Qualidade de Sofware, 7., Curitiba-PR, 1996. Anais.
Curitiba, PUC-PR, p. 155-169.
[Pen 98a] Penteado, Rosangela D.; Braga, Rosana T.V.; Masiero, Paulo C. Improving the
Quality of Legacy Code by Reverse Engineering. In: International Conference of
Information Systems Analysis and Synthesis, 4., Orlando-FL, EUA, julho de 1998.
Anais. Orlando-FL, EUA, International Institute of Informatics, p. 364-370.
[Pen 98b] Penteado, Rosangela D.; Masiero, Paulo C.; Prado, Antonio F.; Braga, Rosana T.V.
Reengineering of Legacy Systems Base on Transformation Using the Object
Oriented Paradigm. In: IEEE Working Conference on Reverse Engineering, 5.,
Honolulu-HI, EUA, outubro de 1998. Anais. LosAlamitos-CA, EUA, IEEE
Computer Society, p. 144-153.
[Pra 92] Prado, A.F. Estratgia de Reengenharia de Software Orientada a Domnios. Rio
de J aneiro, 1992. 333p. Tese (Doutorado) Pontifcia Universidade Catlica do Rio
de J aneiro.
[Pre 95] Pressman, Roger S. Engenharia de Software. So Paulo, Makron Books, 1995.
[Rek 85] Rekoff, M. G. On Reverse Engineering. IEEE Transactions on Systems, Man and
Cybernetics, V.SMC-15, n 2, p. 244-252, Maro-Abril 1985.
132
[Ric 90] Rich, Charles; Wills, Linda M. Recognizing a Programs Design: A Graph-Parsing
Approach. IEEE Software, p. 82-89, J aneiro 1990.
[Rob 91] Robson, D.J .; Bennet, K.H.; Cornelius, B.J .; Munro, M. Approaches to Program
Comprehension. J .Systems Software, V.14, p. 79-84, fevereiro 1991.
[Sag 95] Sage, Andrew P. Systems Engineering and Systems Management for Reengineering,
J ournal Systems Software, V.30, p. 3-25, 1995.
[Sem 95] Semmel, R. D. e Winkler, R. P. Integrating Reengineered Databases to Support
Data Fusion. J ournal Systems Software, V.30, p. 127-135, 1995.
[Shn79] Shneiderman, Ben; Mayer, Richard Syntatic/Semantic Interactions in Programmer
Behavior: A Model and Experimental Results. International J ournal of Computer
and Information Sciences, V.8, n 3, p. 219-238, 1979.
[Sne 95] Sneed, Harry M.; Nvry, Erika. Extracting Object-Oriented Specification from
Procedurally Oriented Programs, In: Working Conference on Reverse Engineering
(WCRE), 2., Toronto, Canada, 1995. Anais. IEEE, 1995, p. 217-226.
[Sne 95a] Sneed, Harry M. Planning the Reengineering of Legacy Systems. IEEE Software, p.
24-34, janeiro 1990.
[Sne 96] Sneed, Harry M. Object-Oriented COBOL Recycling. In: Working Conference on
Reverse Engineering (WCRE), 3., Monterey-CA, EUA, 1996. Anais. IEEE, 1996,
p. 169-178.
[Sol 84] Soloway, Elliot; Ehrlich, Kate. Empirical Studies of Programming Knowledge.
IEEE Transactions on Software Engineering, V.SE-10, n 5, p. 595-609, setembro
1984.
[Vli 95] Vlissides, J ohn. Reverse Architecture, Position Paper for Software Architectures
Seminar, Schloss Daghstuhl, Germany, disponvel a partir da Wide World Web
<URL:http://st-www.cs.uiuc.edu/users/patterns/papers/>, agosto 1995.
[Wel 95] Welch, Lonnie R. et al. Reengineering Computer-Based Systems for Enhanced
Concurrency and Layering. J ournal Systems Software, V.30, p. 45-70, 1995.
[Wil 95] Wilkening, D. E.; Loyall, J . P.; Pitarys, M.J . e Littlejohn, K. A Reuse Approach to
Software Reengineering. J ournal Systems Software, V.30, p. 117-125, 1995.
[Won 95] Wong, Kenny; et al. Structural Redocumentation: A case Study. IEEE Software, p.
46-54, janeiro 1995.
[Yod 98] Yoder, J .W.; J ohnson, R.E.; Wilson, Q.D. Connecting Business Objects to
Relational Databases. Conference on the Pattern Languages of Programs, 5.,
Monticello-IL, EUA, 1998. Anais. St.Louis, Missouri, EUA, agosto de 1998.
(Relatrio Tcnico n WUCS-98-25 da Universidade de Washington).