Metodologia para desenvolvimento de software reconfigurável apoiada por ferramentas de... por Frank José Affonso - Versão HTML

ATENÇÃO: Esta é apenas uma visualização em HTML e alguns elementos como links e números de página podem estar incorretos.
Faça o download do livro em PDF, ePub para obter uma versão completa.

U N I V E R S I D A D E D E S Ã O P A U L O

ESCOLA DE ENGENHARIA DE SÃO CARLOS

PROGRAMA DE PÓS-GRADUAÇÃO EM ENGENHARIA ELÉTRICA

METODOLOGIA PA

P RA DESENVOLV

L IMENTO DE SOFTWA

W RE RECONFIGURÁVEL APOIADA POR

FERRAMENTA

T S DE IMPLEMENTA

T ÇÃO: UMA APLICAÇÃO EM AMBIENTE DE EXECUÇÃO

DISTRIBUÍDO E RECONFIGURÁVEL

ALUNO:

FRANK JOSÉ AFFONSO

Tese de doutorado apresentada ao Programa

de Pós-Graduação em Engenharia Elétrica

como parte dos requisitos para obtenção do

título de Doutor em Engenharia Elétrica

ORIENTADOR:

PROF. DR. EVANDRO LUIS LINHARI RODRIGUES

SÃO CARLOS - SP

2009

AUTORIZO A REPRODUÇÃO E DIVULGAÇÃO TOTAL OU PARCIAL DESTE

TRABALHO, POR QUALQUER MEIO CONVENCIONAL OU ELETRÔNICO,

PARA FINS DE ESTUDO E PESQUISA, DESDE QUE CITADA A FONTE.

Ficha catalográfica preparada pela Seção de Tratamento

da Informação do Serviço de Biblioteca – EESC/USP

Affonso, Frank José

A257m Metodologia para desenvolvimento de software

reconfigurável apoiada por ferramentas de implementação :

uma aplicação em ambiente de execução distribuído e

reconfigurável / Frank José Affonso ; orientador Evandro

Luis Linhari Rodrigues –- São Carlos, 2009.

Tese (Doutorado-Programa de Pós-Graduação em

Engenharia Elétrica e Área de Concentração Processamento

de Sinais e Instrumentação) –- Escola de Engenharia de

São Carlos da Universidade de São Paulo, 2009.

1. Reconfiguração de software. 2. Ambiente de execução

reconfigurável. 3. Reúso. 4. Adaptação. I. Título.

Pode ser que um dia deixemos de nos falar...

Mas, enquanto houver amizade,

Faremos as pazes de novo.

Pode ser que um dia o tempo passe...

Mas, se a amizade permanecer,

Um do outro se há-de lembrar.

Pode ser que um dia nos afastemos...

Mas, se formos amigos de verdade,

A amizade nos reaproximará.

Pode ser que um dia não mais existamos...

Mas, se ainda sobrar amizade,

Nasceremos de novo, um para o outro.

Pode ser que um dia tudo acabe...

Mas, com a amizade construiremos tudo

novamente,

Cada vez de forma diferente.

Sendo único e inesquecível cada momento

Que juntos viveremos e nos lembraremos para

sempre.

Há duas formas para viver a sua vida:

Uma é acreditar que não existe milagre.

A outra é acreditar que todas as coisas são um

milagre.

Albert Einstein

Dedico este trabalho

aos meus pais, Antonio e Odila, ao meu irmão Alex e

à minha querida esposa Cátia

Agradecimentos

Agradeço a Deus, por ter me guiado até o caminho do doutorado e por te me dado forças

para que eu chegasse até aqui.

Agradeço ao Prof. Dr. Evandro Luis Linhari Rodrigues, pela oportunidade de fazer um

doutorado, pela orientação, pela conduta no desenvolvimento deste trabalho, pela amizade

conquistada nesses anos, pela compreensão e paciência nos bons e maus momentos. Meu

sincero e eterno agradecimento.

Agradeço a meus pais, pelo esforço feito a vida toda para eu chegasse até aqui, pelo

incentivo e força nesses anos. Não sei o que seria de mim sem vocês. Ao meu irmão Alex, pelo

incentivo, preocupação e palavras de apoio durante esses anos.

Agradeço aos amigos do Laboratório de Visão Computacional II, Clayton, Celso, Aline,

Ednilson, Evandra e a todos que por ali passaram esses anos.

Agradeço a todas as amizades formadas nesses anos, não citarei nomes para não

esquecer de alguém.

Agradeço ao amigo Ednilson, pelo companheirismo e trabalhos realizados nesses anos,

sua participação e contribuição no desenvolvimento deste trabalho.

Agradeço aos funcionários da pós-graduação SEL/EESC/USP.

Agradeço a todos que me ajudaram chegar até aqui.

Agradeço a todos que, direta ou indiretamente, contribuíram para a realização deste

trabalho.

Finalmente, agradeço, em especial, à minha esposa Cátia, pelo apoio, compreensão e

incentivo nos bons e maus momentos.

Meu muito obrigado.

Resumo

AFFONSO, F. J. Metodologia para desenvolvimento de software reconfigurável apoiada

por ferramentas de implementação: uma aplicação em ambiente de execução distribuído e

reconfigurável, 2009. 190 f. Tese (Doutorado) – Escola de Engenharia de São Carlos,

Universidade de São Paulo, São Carlos, 2009

O desenvolvimento de software reconfigurável é uma abordagem que requer padrões nas

atividades e nos artefatos produzidos ao longo da elaboração de um projeto de software. Além

disso, também prevê uma conduta sistemática do pessoal envolvido, para que as diretrizes de

uma metodologia sejam executadas e os benefícios por ela previstos sejam alcançados. Neste

trabalho, uma metodologia para o desenvolvimento de software reconfigurável foi elaborada

para apoiar essa abordagem de desenvolvimento. Como forma de auxiliar as atividades

existentes nesta metodologia e padronizar as atividades por ela previstas, minimizando a

participação de seres humanos (desenvolvedores), foi confeccionada uma ferramenta composta

por um conjunto de subsistemas capazes de gerar, de maneira automática, informações

necessárias, para que a padronização dos procedimentos possa ser realizada e,

consequentemente, que a reconfiguração e reutilização dos artefatos ocorram de maneira

natural. Essa ferramenta atua em um ambiente distribuído e organizado pelos domínios de

atuação e a reutilização/reconfiguração pode ocorrer em artefatos confeccionados para atuar em

domínio específico, mas que podem ser adaptados/reutilizados em outros.

Palavras-chaves: reconfiguração, reúso, componentes de software, metodologia, ferramenta.

Abstract

AFFONSO, F. J. Methodology to Reconfigurable Software Development supported by

implementation tools: an application in distributed and reconfigurable execution

environment, 2009. 190 f. Thesis (Doctoral) – Escola de Engenharia de São Carlos,

Universidade de São Paulo, São Carlos, 2009

The reconfigurable software development is an approach that requires patterns in the activities

and in the artifacts produced during the development of a software project. It also requires a

systematic conduct of the staff involved in the methodology guidelines, so that the benefits

provided can be achieved. In this work, a methodology for the reconfigurable software

development was proposed to support this approach. As a way to assist the activities in this

methodology and standardize the required activities, minimizing the involvement of humans

(developers), a tool was proposed that consists in a set of subsystems capable of generating, in

an automatic manner, information needed so that the standardization of information can be

performed, therefore, that the reconfiguration and reuse of artifacts could be occur in a natural

way. This tool operates in a distributed environment organized by areas of expertise, and

reuse/reconfiguration can occur in artifacts constructed to operate in specific domains, but it can

be adapted/reused in others.

Keywords: reconfiguration, reuse, software component, methodology, tool.

Lista de Figuras

Figura 1: Arquitetura dos pacotes UML (UML, 2009).................................................................29

Figura 2: Organização dos padrões de projeto (GAMMA et al, 1994) (STELTING &

MAASSEN, 2002).........................................................................................................................32

Figura 3: Diagrama de classe do padrão Proxy (STELTING & MAASSEN, 2002)...................33

Figura 4: Weaver do AspectJ adaptado de (GRADERICKI, & LESIECKI, 2003)......................36

Figura 5: Processo de identificação e fusão de funcionalidades...................................................52

Figura 6: Estrutura de uma aplicação RMI-IIOP (JAVA-RMI-IIOP, 2009).................................55

Figura 7: Arquitetura de serviços SOA (KRAFZIG et al, 2005)..................................................58

Figura 8: Solicitação de serviços na especificação SOA adaptado de (W3C-SOA, 2009)..........59

Figura 9: Estrutura de aplicações reflexivas (LISBÔA, 1997).....................................................67

Figura 10: Protocolo de Meta-Objetos (FERNANDES, 2009)....................................................67

Figura 11: Fluxo de comunicação entre objetos e meta-objetos (FERNANDES, 2009).............68

Figura 12: Adaptação de componentes, adaptado de (WEISS, 2001)..........................................69

Figura 13: Adaptação de componentes por empacotamento (KIM, 2001)...................................72

Figura 14: Estrutura do XRMI (CHEN, 2002)..............................................................................79

Figura 15: Processo de recuperação e armazenamento de objetos...............................................83

Figura 16: Processo de comunicação entre sistemas via XML.....................................................92

Figura 17: Arquitetura de Software em Camadas.........................................................................93

Figura 18: Metodologia de Desenvolvimento de Software Reconfigurável................................97

Figura 19: Modelo de desenvolvimento de componentes adaptado de (CATALYSIS, 2009).....99

Figura 20: Modelo de desenvolvimento com separação de interesses.......................................100

Figura 21: Detalhando os repositórios de armazenamento de informações...............................104

Figura 22: Metodologia de Desenvolvimento Reconfigurável (continuação)............................107

Figura 23: Desenvolvimento de artefatos em linha de montagem..............................................110

Figura 24: Ambiente de Execução Reconfigurável.....................................................................115

Figura 25: ReflectTools® em execução.......................................................................................119

Figura 26: Tela para importar projetos Eclipse/ Netbeans...........................................................119

Figura 27: Wizard para importar projetos....................................................................................120

Figura 28: Ferramenta ReflectTools® com projeto em execução...............................................121

Figura 29: Processo de mapeamento JAVA para xsd..................................................................123

Figura 30: Projeto após realização do mapeamento JAVA para xsd...........................................124

Figura 31: Ferramenta para manipulação do Banco de dados....................................................125

Figura 32: Enviar método para repositório (Coletando informações)........................................127

Figura 33: Enviar método para repositório (Inserindo informações nos repositórios remotos) 128

Figura 34: Modelo de classe para repositório de métodos..........................................................129

Figura 35: Wizard de consulta de artefatos remotos...................................................................131

Figura 36: Resultado da consulta no repositório de método.......................................................132

Figura 37: Wizard de compilação e execução.............................................................................134

Figura 38: Subsistema de mapeamento de objetos.....................................................................135

Figura 39: Metamodelo para geração de regras de classificação................................................137

Figura 40: Mapeamento de regras para xml (resumido).............................................................138

Figura 41: Estrutura do repositório de regras..............................................................................139

Figura 42: Subsistema de reconfiguração...................................................................................142

Figura 43: Desenvolvimento sem comprometimento com organização de código....................153

Figura 44: Desenvolvimento utilizando o framework de persistência........................................154

Figura 45: Objeto em linha de montagem...................................................................................154

Figura 46: Lista de classe e trecho de documentação JAVADOC..............................................156

Figura 47: Listagem de classe e o reúso entre os núcleos...........................................................157

Figura 48: Estrutura da aplicação utilizando reconfiguração.....................................................163

Lista de Tabelas

Tabela 1: Características CORBA e RMI......................................................................................64

Tabela 2: Lista de sistema e classes lógicas geradas...................................................................152

Lista de Abreviaturas e Siglas

AGC

Agente Gerenciador de Configuração

API

Application Programming Interface

CASE

Computer-Aided Software Engineering

CORBA

Common Object Request Broker Architecture

CWM

Common Warehouse MetaModel

DC

Dynamic Classloader

DSBC

Desenvolvimento de Software Baseado em Componentes

DSR

Desenvolvimento de Software Reconfigurável

DSW

Descrição de Serviço Web

EJB

Enterprise JavaBeans

HTML

HyperText Markup Language

HTTP

HyperText Transfer Protocol

IC

Inteligência Computacional

IDE

Integrated Development Environment

IDL

Interface Definition Language

JAVASSIST JAVA Programming Assistant

JDK

JAVA Development Kit

JNDI

JAVA Name and Directory Interface

JSE

JAVA Standard Edition

JSP

JavaServer Pages

JVM

JAVA Virtual Machine

MDSR

Metodologia para Desenvolvimento de Software Reconfigurável

MOF

Meta-Object Facility

OCL

Object Constraint Language

OMG

Object Management Group

OO

Orientado a Objetos

OP

Objeto Proxy

OR

Objeto Real

ORB

Object Request Broker

PMO

Protocolo de Meta Objetos

POA

Programação Orientada a Aspectos

POC

Programação Orientada a Componentes

RC

Reflexão Computacional

RF

Requisitos Funcionais

RNF

Requisitos Não Funcionais

RMI

Remote Method Invocation

RMI-IIOP

Remote Method Invocation over Inter-Orb Protocol

RNA

Redes Neurais Artificiais

RNF

Requisitos Não Funcionais

SGML

Standard Generalized Markup Language

SHs

Sistemas Híbridos

SOA

Service Oriented Architecture

SOAP

Simple Object Access Protocol

SR

Sistemas Reflexivos

UML

Unified Modeling Language

WSD

Web Service Description

WSDL

Web Service Description Language

XML

eXtensible Markup Language

XRMI

eXtended JAVA RMI

Sumário

Capítulo 1 - Introdução..................................................................................................................17

1.1. Contextualização................................................................................................................17

1.2. Formulação do Problema da Pesquisa...............................................................................19

1.3. Objetivos............................................................................................................................21

1.4. Relevância da Pesquisa......................................................................................................23

1.5. Organização do Trabalho...................................................................................................24

Capítulo 2 - Assuntos Relacionados..............................................................................................27

2.1. Considerações Iniciais.......................................................................................................27

2.2. Engenharia de Software ....................................................................................................28

2.2.1. Técnicas de Modelagem............................................................................................28

2.2.2. Padrões de Projeto......................................................................................................31

2.2.3. Técnicas de Programação..........................................................................................34

2.2.3.1. Programação Orientada a Aspectos........................................................................35

2.2.3.2. Programação Orientada a Componentes................................................................36

2.2.4. Recurso de Integração................................................................................................37

2.2.5. A Linguagem JAVA....................................................................................................39

2.2.6. Processo de Software.................................................................................................39

2.3. Inteligência Computacional ..............................................................................................41

2.3.1. Agentes de Software..................................................................................................42

2.3.2. Sistemas Híbridos Inteligentes..................................................................................45

2.3.3. Recursos de Implementação para IC.........................................................................47

2.3.3.1. O Framework DROOLS....................................................................................47

2.4. Tecnologias de Distribuição...............................................................................................49

2.4.1. Invocação Remota de Métodos......................................................................................50

2.4.1.1. A Engenharia de Software no Desenvolvimento Distribuído...........................51

2.4.1.2. Carregamento dinâmico de objetos e Classloader............................................52

2.4.2. Invocação Remota de Métodos sobre IIOP....................................................................54

2.4.3. Desenvolvimento orientado a serviços...........................................................................56

2.5. Considerações Finais.........................................................................................................60

Capítulo 3 - Reconfiguração de Software.....................................................................................65

3.1. Considerações Iniciais.......................................................................................................65

3.2. Computação Reflexiva.......................................................................................................66

3.3. Técnicas de Reconfiguração..............................................................................................69

3.4. A API JAVA Reflect............................................................................................................80

3.5. O Framework JAVASSIST................................................................................................84

3.6. Considerações Finais.........................................................................................................85

Capítulo 4 - Metodologia para Desenvolvimento de Software Reconfigurável...........................89

4.1. Considerações Iniciais.......................................................................................................89

4.2. Metodologia para Desenvolvimento de Software Reconfigurável...................................91

4.2.1. Arquitetura de Software e Ambientes Computacionais............................................92

4.2.2. Diretrizes da MDSR...................................................................................................95

4.3. Considerações Finais........................................................................................................111

Capítulo 5 - Ambiente de Execução Reconfigurável..................................................................113

5.1. Considerações Iniciais.....................................................................................................113

5.2. Ambiente de Execução Reconfigurável...........................................................................114

5.2.1.A Ferramenta ReflectTools® e seus subsistemas......................................................116

5.2.1.1. ReflectTools® - Instanciando os repositórios de informação...........................118

5.2.1.2. ReflectTools® - Consultando os repositórios de informação e gerando objetos

remotos de maneira automática....................................................................................130

5.2.1.3.Subsistemas.......................................................................................................134

5.3. Considerações Finais.......................................................................................................144

Capítulo 6 - Avaliação dos Resultados........................................................................................147

6.1. Considerações Iniciais.....................................................................................................147

6.2. Os Núcleos de Desenvolvimento e os Sistemas Desenvolvidos.....................................148

6.2.1.Estudo de Caso 1.......................................................................................................148

6.2.2.Estudo de Caso 2.......................................................................................................158

6.2.3.Estudo de Caso 3.......................................................................................................164

6.2.4.Estudo de Caso 4.......................................................................................................167

6.3. Considerações Finais.......................................................................................................171

Capítulo 7 - Conclusão e Trabalhos Futuros...............................................................................173

7.1. Considerações Iniciais.....................................................................................................173

7.2. Conclusões Obtidas..........................................................................................................174

7.3. Trabalhos Futuros............................................................................................................176

7.4. Limitações e Dificuldades...............................................................................................178

7.5. Lista de trabalhos publicados..........................................................................................179

Referências...................................................................................................................................183

CAPÍTULO 1

Introdução

1.1. CONTEXTUALIZAÇÃO

Atualmente tem-se notado novas tendências no desenvolvimento de software, que deixa

de ser direcionado a sistemas restritos, a domínios específicos e baixo número de usuários,

passando a atingir diversos domínios e quantidade elevada de usuários. Esse cenário pode ser

facilmente encontrado em empresas e instituições governamentais que possuem sistemas

antigos, de boa funcionalidade, e que desejam disponibilizá-los para plataformas de softwares

mais atuais, ou que desejam atender uma quantidade elevada de usuários como a Web.

As situações apresentadas evidenciam as mudanças de requisitos de softwares para os

quais foram projetados (MAES, 1987). As novas tendências podem ser consideradas como uma

nova abordagem de desenvolvimento, enquanto que a segunda, migração de sistemas, pode ser

solucionada por um processo de reengenharia (PRESSMAN, 2006) de sistemas com, ou sem,

mudança de plataforma e/ou interface. Para ambos os casos, um novo conceito de Engenharia

de Software pode ser aplicado, que se chama integração de serviços via web services (ERL,

2004) (ERL, 2005). Pode-se entender web service como um middleware que permite encapsular

18

Capítulo 1 - Introdução

uma ou mais funcionalidades de um sistema e disponibilizá-la(s) na forma de serviços com

interfaces de acesso bem definidas.

No que se refere à aplicação de um processo de reengenharia pode-se dizer que toda

inovação tecnológica causa impacto entre os desenvolvedores por estarem acostumados a um

conjunto delimitado de tecnologias e possuírem conhecimento sobre o sistema que mantinham

(PRESSAN, 2006) (SOMMERVILLE, 2008) (PFLEEGER, 2004). Em contrapartida, a

integração de sistemas via web services tende a preservar esse conhecimento, apenas exigindo

que uma camada de software seja construída para realizar a troca de mensagens com os sistemas

clientes (ERL, 2004) (ERL, 2005). Além disso, vale ressaltar que o desenvolvimento de novas

aplicações distribuídas e voltadas para Web também podem utilizar a padronização de troca de

mensagens via web services (ERL, 2005).

Quanto ao desenvolvimento de software utilizando tecnologias atuais, são abordados

vários modelos, técnicas e ferramentas direcionadas ao desenvolvimento de aplicações

distribuídas ou para Web. No entanto, tem-se notado que tecnologias de desenvolvimento e

ferramentas de apoio estão direcionadas ao tipo de sistema que se pretende desenvolver,

fazendo com que o desenvolvedor utilize um conjunto delas no desenvolvimento de um sistema.

Dessa forma, acaba-se atribuindo uma carga elevada de conhecimento, em diversas ferramentas,

aos desenvolvedores de software e analistas (KUCHARMA, 2004) (NAKAGAWA, 2006)

(PREVITALI, 2007).

Outro problema emergente neste contexto é a mudança de requisitos de sistemas, pois a

mutação com eles ocorrida ao longo do tempo, seja por novas necessidades dos usuários ou por

novas tendências tecnológicas a serem incorporadas no desenvolvimento e/ou na execução de

software, é consideravelmente significativa (FERNANDES & LISBÔA, 2001) (FORMAN &

FORMAN, 2004) (GIARRATANO & RILEY, 1998) (HEINEMAN, 1999). Diante disso, existe

um interesse em associar ao software alguma “capacidade de raciocínio”, de modo que ele

Capítulo 1 - Introdução

19

possa ser capaz de coletar as informações do meio ao qual está inserido, processá-las e tomar

alguma decisão para que sua execução não seja interrompida (GIARRATANO & RILEY, 1998)

(WATSON, 1997) (WATSON, 2009).

1.2. FORMULAÇÃO DO PROBLEMA DA PESQUISA

Desde os primórdios da computação, a Engenharia de Software vem enfrentando

problemas quanto à existência de métodos e ferramentas que auxiliem os engenheiros de

software desde a fase de obtenção de requisitos até a implementação do sistema (NAKAGAWA,

2006) (PRESSMAN, 2006). Atualmente é grande o número de ferramentas de apoio

direcionadas à solução destes problemas, no entanto, tem-se observado que poucas atendem

plenamente as necessidades dos desenvolvedores, devido às mutações existentes nas tendências

de desenvolvimento de sistemas (PRESSMAN, 2006) (SOMMERVILLE, 2008) (PFLEEGER,

2004). Quando atendem, existe o problema relacionado ao custo elevado que inviabiliza sua

aquisição por empresas de pequeno e médio porte. Diante do cenário apresentado podem ser

citadas suites de desenvolvimento como Eclipse (ECLIPSE, 2009), Netbeans (NETBEANS,

2009), IBM- Rational (IBM-RATIONAL, 2009), entre outras. As duas primeiras são

consideradas as mais populares IDEs ( Integrated Development Environment) na comunidade

por serem freeware e Open Source. A última é uma suite completa, porém proprietária.

Além do contexto apresentado, outros fatores são de grande relevância neste trabalho,

tais como: a necessidade de muitas aplicações serem direcionadas a Web ou distribuídas numa

rede (local ou não) e a constante mudança nas necessidades dos clientes dessas aplicações. Este

último sugere que as aplicações possam ser modificadas em tempo de execução, sendo assim,

este trabalho tem como objeto de estudo os problemas emergentes da reconfiguração de

sistemas (MAES, 1987), tanto no que se refere ao código de execução (WEISS, 2001) (BEDER,

2001) quanto ao armazenamento de dados (EGE, 1999a) (EGE, 1999b).

20

Capítulo 1 - Introdução

A reconfiguração de sistemas quando realizada de maneira local exige alguns cuidados

de seus gerenciadores (MAES, 1987), no entanto, em aplicações distribuídas (CHEN, 2002),

estes cuidados aumentam consideravelmente, pois vários objetos podem estar sendo acessados

por diferentes clientes ao mesmo tempo. Assim, antes de realizar qualquer modificação, seu

estado deve ser salvo para que as execuções anteriores sejam preservadas.

Quanto à conformidade que deve existir entre o código da aplicação e o armazenamento

de dados, nota-se a equivalência de operações, pois quando uma característica é modificada,

incorporada ou retirada de um objeto, a mesma deve ser realizada na fonte de armazenamento,

no banco de dados.

Os aspectos apresentados estão direcionados ao desenvolvimento de aplicações

distribuídas reconfiguráveis. Além destes, uma consideração técnica quanto à implementação é

factível neste momento: o conhecimento prévio que um desenvolvedor deve possuir para

implementar um sistema distribuído. Tecnologias como RMI ( Remote Method Invocation)

(SUN-RMI, 2009) e implementações CORBA ( Common Object Request Broker Architecture)

(OMG, 2009), têm propósitos semelhantes, recursos de distribuição distintos e conhecimento

técnico diferenciado. Dessa forma, pode-se dizer que existe uma divergência quanto aos

recursos de implementação e conhecimento de implementação, sendo as aplicações com

recursos da especificação CORBA mais complexas, porém com mais recursos de distribuição e

gerenciamento de serviços.

Após realizar a contextualização sobre reconfiguração e seus aspectos relevantes para o

gerenciamento das adaptações em diferentes ambientes (locais, distribuído e Web), julga-se

necessário apresentar a maneira como é realizado o desenvolvimento deste tipo de aplicação

utilizando a metodologia (Capítulo 4) e o ambiente de execução (Capítulo 5). Antes de detalhar

o processo de desenvolvimento, vale ressaltar que a metodologia, a ferramenta e o ambiente de

execução, desenvolvidos neste trabalho, atuam em paralelo às ferramentas Eclipse e Netbeans.

Capítulo 1 - Introdução

21

A ferramenta proposta neste trabalho atua de maneira complementar, implementando os

mecanismos necessários para oferecer suporte à reconfiguração.

Inicialmente o engenheiro de software inicia o desenho dos modelos de lógica e de

dados na IDE de sua escolha (Eclipse ou Netbeans). Em seguida, o projeto será importado para

a ferramenta desenvolvida neste trabalho. A partir dessa etapa, informações referentes à

classificação dos artefatos desenvolvidos são geradas por ela e inseridas nos repositórios de

informações, conforme previsto no ambiente de execução reconfigurável (Capítulo 5).

Dessa forma, quando novos artefatos forem sendo desenvolvidos, maiores são as

chances de reutilização, pois mais ampla é a base de artefatos. Essa reutilização pode ocorrer de

duas formas: (1) total: quando os artefatos existentes (execução ou “adormecidos”) atendem

plenamente os requisitos de pesquisa; ou (2) parcial: quando pequenas adaptações são

realizadas para adequar o artefato encontrado ao solicitado.

Sobre a reutilização total, pode-se dizer que a ferramenta tem a capacidade de localizar

o melhor artefato em execução e encaminhá-lo para execução e, ainda, de “resgatar” o artefato

no repositório de código, compilá-lo e inseri-lo no ambiente de execução. A reutilização parcial

ocorre quando mecanismos de herança são utilizados para inserir novas características aos

artefatos existentes, criando um novo artefato, que é inserido no ambiente de execução.

1.3. OBJETIVOS

Este trabalho tem por objetivo propor uma Metodologia para o Desenvolvimento de

Software Reconfigurável (MDSR) para sistemas desktop (locais), Web e distribuídos (Chamada

de Métodos Remotos e Serviços Web). Além disso, esta metodologia prevê a criação de um

Ambiente de Execução Reconfigurável (AER) composto por vários domínios de

desenvolvimento. Cada um deles possui um conjunto de repositórios de código para reutilização

e reconfiguração/adaptação dos artefatos (classes, componentes e serviços) produzidos ao longo

22

Capítulo 1 - Introdução

do tempo.

Outro objetivo deste trabalho é a implementação de uma ferramenta, pois a metodologia

proposta prevê que um conjunto de passos que devem ser realizados de maneira automática,

tanto na fase de desenvolvimento quanto na recuperação de informações para

reconfiguração/adaptação dos artefatos de software.

A implementação desta ferramenta, para gerenciar a MDSR e o AER, não está

relacionada ao desenvolvimento de um software tradicional, sua finalidade é atuar de maneira

cooperativas às IDEs: Eclipse e Netbeans. Sua finalidade está direcionada a um conjunto de

subsistemas (métodos) capazes de gerenciar: (1) a reconfiguração/adaptação dos artefatos

existentes nos repositórios e no ambiente de execução; e (2) a geração das regras de

classificação dos artefatos de software. Além disso, oferece como benefício a automatização e

padronização (geração e recuperação) das informações, minimizando a participação humana na

manipulação das informações geradas ao longo do processo de desenvolvimento.

Ainda sobre a implementação da ferramenta, destaca-se a implementação de um

subsistema, responsável por gerenciar a reconfiguração dos artefatos em tempo de execução.

Este subsistema possui “objetos tutores”, cuja finalidade é interceptar todas as solicitações

vindas das aplicações clientes e verificar se elas podem ser atendidas. Em caso negativo,

modificações são inseridas no artefato de sua responsabilidade que, posteriormente, é

compilado e inserido no ambiente de execução. Os “objetos tutores” também podem direcionar

a solicitação de um cliente para um outro objeto em execução, tornando a execução mais

dinâmica.

Finalmente, esta metodologia oferece aos desenvolvedores facilidades no

desenvolvimento de aplicações distribuídas utilizando a tecnologia RMI, associada aos aspectos

dinâmicos de manipulação de objetos da especificação CORBA. Essas facilidades tendem a

minimizar o esforço e tempo dos desenvolvedores com este tipo de tecnologia de distribuição.

Capítulo 1 - Introdução

23

1.4. RELEVÂNCIA DA PESQUISA

Este trabalho de pesquisa é relevante no contexto do estudo realizado no processo de

desenvolvimento de aplicações distribuídas e/ou para Web, pois diretrizes para condução deste

processo foram criadas. Além disso, destaca-se o apoio de ferramentas que conduzem esse

processo e favorecem o aumento na produtividade de desenvolvimento.

Destaca-se também, a padronização no desenvolvimento de aplicações conforme

premissas da Engenharia de Software, pois os sistemas passam a ser: documentados, modelados

e armazenados em repositórios de código. Além disso, destaca-se a padronização empregada no

desenvolvimento, em que abordagens como Desenvolvimento Orientado a Objetos,

Desenvolvimento Orientado a Componentes e Desenvolvimento Orientado a Aspectos, são

adotadas pelas organizações e, consequentemente, observa-se mudanças na cultura de

desenvolvimento e melhorias no gerenciamento de projetos.

O desenvolvimento dos tutores na reconfiguração de software mostra-se como um novo

recurso no desenvolvimento de software, pois são responsáveis por interpretar as mudanças

ocorridas no ambiente de execução e adaptar o software em “tempo de execução”. Para que isso

ocorra, o apoio de ferramentas na etapa de desenvolvimento é fundamental para a padronização

de código (classes e dados), pois facilitam a identificação das características e funcionalidades

que se pretende alterar/adaptar.

As contribuições aqui mencionadas referem-se aos novos sistemas a serem

desenvolvidos e àqueles antigos que devem ser integrados; também é realizada a padronização

na interface de comunicação, em relação ao meio externo via web services. Dessa forma, a

proposta de padronização no desenvolvimento de aplicações distribuídas e integração das

existentes, mostra-se ser de grande interesse tanto pela comunidade científica quanto pelas

corporações públicas e privadas.