ESCOLA SUPERIOR ABERTA DO BRASIL - ESAB CURSO DE … · principais características, facilitando,...
57
ESCOLA SUPERIOR ABERTA DO BRASIL - ESAB CURSO DE PÓS-GRADUAÇÃO LATO SENSU EM ENGENHARIA DE SISTEMAS LEILANE FERREIRA RIBEIRO MODELAGEM DE SOFTWARE UTILIZANDO UML: ANÁLISE COMPARATIVA ENTRE AS FERRAMENTAS ASTAH UML E UMBRELLO UML MODELLER VILA VELHA (ES) 2012
Transcript of ESCOLA SUPERIOR ABERTA DO BRASIL - ESAB CURSO DE … · principais características, facilitando,...
ESCOLA SUPERIOR ABERTA DO BRASIL - ESAB
CURSO DE PÓS-GRADUAÇÃO LATO SENSU EM ENGENHARIA DE SISTEMAS
LEILANE FERREIRA RIBEIRO
MODELAGEM DE SOFTWARE UTILIZANDO UML:
ANÁLISE COMPARATIVA ENTRE AS FERRAMENTAS ASTAH UML E UMBRELLO UML MODELLER
VILA VELHA (ES)
2012
LEILANE FERREIRA RIBEIRO
MODELAGEM DE SOFTWARE UTILIZANDO UML: ANÁLISE COMPARATIVA ENTRE AS FERRAMENTAS ASTAH UML
E UMBRELLO UML MODELLER
Monografia apresentada ao Curso de Pós-Graduação em Engenharia de Sistemas da Escola Superior Aberta do Brasil como requisito para obtenção do título de Especialista em Engenharia de Sistemas, sob orientação do Prof. Me. Jessé Gomes dos Santos
VILA VELHA (ES)
2012
LEILANE FERREIRA RIBEIRO
MODELAGEM DE SOFTWARE UTILIZANDO UML: ANÁLISE COMPARATIVA ENTRE AS FERRAMENTAS ASTAH UML
E UMBRELLO UML MODELLER
Monografia aprovada em de de 2012.
Banca Examinadora
________________________________
________________________________
________________________________
VILA VELHA (ES)
2012
DEDICATÓRIA
Dedico este trabalho ao meu noivo, Saulo, por tudo que ele representa pra mim!
AGRADECIMENTOS
Agradeço a todos aqueles que direta ou indiretamente me ajudaram na
concretização desse trabalho.
“Sucesso é conseguir aquilo que você quer.
Felicidade é querer aquilo que você
conseguiu.”
(Autor desconhecido)
RESUMO
A modelagem é uma das atividades da engenharia de software que proporcionam a implementação de um bom software. Os modelos são uma simplificação da realidade e são construídos para que o sistema que será desenvolvido seja melhor compreendido. Por meio destes modelos múltiplas visões do sistema podem ser obtidas. Por isso, uma linguagem de modelagem, tal como a UML, é essencial para a construção e o entendimento de bons modelos. Esse processo de modelagem de software é normalmente apoiado por ferramentas CASE. Atualmente, existe um grande número destas ferramentas no mercado e é difícil julgar quais delas apóiam melhor a UML. Com base nisto, a finalidade deste trabalho é de facilitar a modelagem de sistemas orientados a objetos usando a linguagem de modelagem UML. Para tanto, foram comparadas as ferramentas CASE de modelagem de software, Astah UML e Umbrello UML Modeller. A análise comparativa apresentada vai permitir que o desenvolvedor faça uma verificação e avaliação das suas principais características, facilitando, desse modo, a sua escolha.
Palavras chaves: Modelagem. Ferramenta CASE. UML.
LISTA DE QUADROS
Quadro 1: Descrição dos critérios utilizados para análise. ........................................ 42
Quadro 2: Comparação de acordo com a documentação. ........................................ 44
Quadro 3: Comparação de acordo com a licença. .................................................... 45
Quadro 4: Comparação de acordo com as plataformas suportadas. ........................ 46
Quadro 5: Comparação de acordo com os idiomas suportados. ............................... 46
Quadro 6: Comparação de acordo com a versão da UML. ....................................... 47
Quadro 7: Comparação de acordo com os diagramas da UML. ............................... 47
Quadro 8: Comparação de acordo com os tipos de arquivos gráficos gerados. ....... 48
Quadro 9: Comparação de acordo com a exportação para código fonte. ................. 49
Quadro 10: Comparação de acordo com a engenharia reversa. ............................... 49
Quadro 11: Comparação de acordo com a exportação de dados para o padrão XMI.
.................................................................................................................................. 50
Quadro 12: Recursos adicionais. .............................................................................. 51
Quadro 13: Quadro geral de comparações entre as características das ferramentas.
.................................................................................................................................. 53
LISTA DE FIGURAS
Figura 1: Visões de um sistema de software. ............................................................ 21
Figura 2: Os diagramas da UML. .............................................................................. 24
Figura 3: Diagramas Estruturais da UML .................................................................. 25
Figura 4: Diagramas Comportamentais da UML. ...................................................... 25
Figura 5: Ferramenta Astah UML. ............................................................................. 38
Figura 6: Ferramenta Umbrello UML Modeller. ......................................................... 40
LISTA DE SIGLAS
CASE Computer-Aided Software Engineering
CSV Comma-separated values
EMF Metarquivo Avançado
EPS PostScript encapsulado
GPL General Public License
HTML HyperText Markup Language
IDE Integrated Development Environment
IDL Interactive Data Language
JPEG Junta Photographic Experts Group
KDE K Desktop Environment
OMT Object Modeling Technique
OOSE Object-oriented software engineering
OMG Object Management Group
PNG Portable network graphics
PPM Portable Pixmap
PHP Personal Home Page
RTF Rich Text Format
SVG Scalable Vector Graphics
TCL Tool Command Language
UML Unified Modeling Language
XBM X BitMap
XPM X PixMap
XMI XML Metadata Interchange
XML Extensible Markup Language
XQL XML Query Language
XSL EXtensible Stylesheet Language
SUMÁRIO
1 INTRODUÇÃO ....................................................................................................... 13
2 MODELAGEM DE SISTEMAS DE SOFTWARE .................................................... 18
3 A LINGUAGEM DE MODELAGEM UNIFICADA – UML ........................................ 20
3.1 DIAGRAMAS DA UML ........................................................................................ 23
3.1.1 Diagrama de Caso de Uso ............................................................................... 26
3.1.2 Diagrama de Classes ....................................................................................... 27
3.1.3 Diagrama de Objetos........................................................................................ 27
3.1.4 Diagrama de Pacotes ....................................................................................... 28
3.1.5 Diagrama de Componentes .............................................................................. 29
3.1.6 Diagrama de Implantação ................................................................................ 29
3.1.7 Diagrama de Máquina de Estados ................................................................... 30
3.1.8 Diagrama de Atividades ................................................................................... 30
3.1.9 Diagrama de Seqüência ................................................................................... 31
3.1.10 Diagrama de Colaboração .............................................................................. 31
3.1.11 Diagrama de Temporização ........................................................................... 32
3.1.12 Diagrama de Visão Geral da Interação .......................................................... 33
3.1.13 Diagrama de Estrutura Composta .................................................................. 33
4 FERRAMENTAS DE MODELAGEM DE SOFTWARE ........................................... 35
4.1 ASTAH* ............................................................................................................... 37
4.2 UMBRELLO UML MODELLER ........................................................................... 38
5 ANÁLISE COMPARATIVA ..................................................................................... 41
5.1 CRITÉRIOS PARA COMPARAÇÃO ................................................................... 41
5.2 APLICAÇÃO DOS CRITÉRIOS ........................................................................... 42
5.2.1 Documentação ................................................................................................. 43
5.2.2 Licença ............................................................................................................. 44
5.2.3 Plataformas suportadas (Portabilidade) ........................................................... 45
5.2.4 Idiomas suportados .......................................................................................... 46
5.2.5 Especificação da UML suportada ..................................................................... 46
5.2.6 Diagramas da UML suportados ........................................................................ 47
5.2.7 Exportação para arquivos gráficos ................................................................... 47
5.2.8 Exportação para código fonte ........................................................................... 48
5.2.9 Engenharia Reversa ......................................................................................... 49
5.2.10 Exportação de dados para o padrão XMI ....................................................... 50
5.2.11 Recursos Adicionais ....................................................................................... 51
5.3 RESULTADOS OBTIDOS ................................................................................... 52
6 CONCLUSÕES ...................................................................................................... 54
REFERÊNCIAS ......................................................................................................... 56
13
1 INTRODUÇÃO
Exposição do assunto: Para o desenvolvimento de um software apto a satisfazer as
necessidades dos seus usuários, que tenha qualidade, através de uma arquitetura
sólida que permita modificações, de forma rápida, eficiente e com o mínimo de
retrabalho, é necessário o emprego de modelagem (TOSING, 2008).
A modelagem é uma das principais atividades que auxiliam na implementação de
um bom software. Os modelos são uma simplificação da realidade e são construídos
para comunicar a estrutura e o comportamento desejados do sistema, para
visualizar e controlar sua arquitetura e compreender melhor o sistema que será
desenvolvido.
A modelagem de software utiliza vários modelos para projetar um determinado
sistema, esses modelos gráficos simbolizam os artefatos de software utilizados e
seus inter-relacionamentos. Um modelo é criado para facilitar o entendimento de
sistemas complexos. Podem abranger planos detalhados, assim como planos mais
gerais com uma visão panorâmica do sistema.
Os modelos são construídos para que o sistema que será desenvolvido seja melhor
compreendido. Construir o modelo de um sistema não é uma tarefa fácil, vários
aspectos devem ser considerados, como a organização da empresa, os processos,
as informações existentes, os recursos envolvidos, dentre outros.
Por meio dos modelos, é possível obter diversas visões do sistema, dessa forma a
complexidade do sistema é dividida facilitando sua compreensão e atuando como
meio de comunicação entre os desenvolvedores do projeto. Deste modo, uma
linguagem de modelagem padronizada, como a UML, é essencial para construção e
entendimento de bons modelos.
14
O processo de modelagem de software é geralmente apoiado pelo uso de
ferramentas CASE. Uma ferramenta CASE é o nome dado ao software utilizado para
apoiar as atividades de processo de software, como a engenharia de requisitos, o
projeto, o desenvolvimento de programas e os testes.
O uso de software de apoio à modelagem é muito importante por duas razões, uma
porque os modelos começarão a ficar tão longos que a folha de papel ficará
pequena, e a outra porque é uma ótima maneira de verificar as associações entre os
modelos. Para isso é essencial avaliar os benefícios das ferramentas e suas
limitações, para que problemas posteriores sejam evitados no processo de
desenvolvimento.
Neste contexto, o propósito deste trabalho é de facilitar a modelagem de sistemas
orientados a objetos usando a linguagem de modelagem UML. Para isso, foram
comparadas as ferramentas CASE de modelagem de software, Astah UML e
Umbrello UML Modeller. Dessa forma, foi possível demonstrar por meio dos
resultados qual ferramenta é mais completa e adequada para cada aspecto
comparado.
Problema de pesquisa: É possível realizar uma comparação entre as ferramentas de
modelagem de software, Astah UML e Umbrello UML Modeller?
Justificativa para escolha do tema: Possuir um bom modelo de software é a maneira
mais eficiente de comunicação entre os desenvolvedores que trabalham no projeto e
os seus clientes. Um bom modelo é extremamente importante para os projetos de
software, pois ele dará uma visão geral que permitirá codificar o sistema da maneira
certa na primeira vez.
O processo de criação de modelos é apoiado por ferramentas de modelagem de
software, cujo principal objetivo é separar o projeto da codificação do sistema.
Existem várias ferramentas de modelagem, algumas que suportam a UML e outras
que apóiam uma metodologia particular que atende a um determinado tipo de
projeto.
15
Visto que existe um grande número de ferramentas CASE no mercado e que seja
necessário conhecer quais delas apóiam melhor a UML, a análise comparativa entre
ferramentas oferecida por este trabalho vai permitir que o desenvolvedor faça uma
verificação e avaliação das suas principais características, facilitando, desse modo,
a sua escolha.
Objetivo geral: O objetivo geral deste trabalho é facilitar o processo de modelagem
de sistemas utilizando a linguagem de modelagem unificada - UML através de uma
analise comparativa das principais características das ferramentas Astah UML e
Umbrello UML Modeller, a fim de gerar informações que auxiliem na escolha de uma
delas.
Objetivos específicos:
Pesquisar as características das ferramentas Astah UML e Umbrello UML
Modeller.
Definir um conjunto de critérios para realizar a comparação entre as ferramentas.
Fazer uma análise comparativa entre os dados coletados.
Confrontar as informações coletadas a fim de facilitar a escolha da melhor opção
para a modelagem de software utilizando UML entre as ferramentas analisadas.
Delimitação do trabalho: Devido ao grande número de características presentes nas
ferramentas de modelagem de software, Astah UML e Umbrello UML Modeller, fez-
se necessária a delimitação do escopo da análise comparativa. Visto isso, este
trabalho analisa os seguintes aspectos das ferramentas:
Documentação.
Licença.
Plataformas suportadas.
Idiomas suportados.
Especificação da UML suportada.
Diagramas da UML suportados.
Exportação para arquivos gráficos.
Exportação para código fonte.
Engenharia Reversa.
16
Exportação de dados para o padrão XMI.
Metodologia de pesquisa: Para o desenvolvimento do trabalho foram feitas
pesquisas de caráter exploratório e bibliográfico, com objetivos de obter informações
suficientes sobre as ferramentas que seriam utilizadas no trabalho. A pesquisa
realizada parte do estudo da modelagem de sistemas de software orientados a
objetos para fornecer uma análise de ferramentas CASE que auxiliam nesse
processo.
Este trabalho pode ser definido como uma pesquisa descritiva, pois é fundamentado
na observação, apontamento e análise dos dados coletados por meio de
levantamento bibliográfico e testes realizados em ferramentas de software.
Quanto aos procedimentos, a pesquisa pode ser qualificada como um estudo de
caso, pois duas ferramentas de modelagem de software foram escolhidas para
realização de testes.
Estrutura do trabalho: Este trabalho encontra-se estruturado da seguinte forma:
Capítulo 2 – Modelagem de Sistemas de Software - Aborda aspectos relacionados à
teoria estudada para o desenvolvimento do trabalho.
Capítulo 3 – A Linguagem de Modelagem Unificada – UML - Descreve a linguagem
de modelagem unificada e fornece uma visão geral de seus diagramas.
Capítulo 4 – Ferramentas de Modelagem de Software – Faz uma explanação sobre
ferramentas CASE e são apresentadas as ferramentas de modelagem ASTAH UML
E UMBRELLO UML MODELLER.
Capítulo 5 – Análise Comparativa - Apresenta a análise comparativa realizada entre
as ferramentas de modelagem de software apresentadas no capítulo 4 e os
resultados obtidos.
17
Capítulo 6 – Conclusão - Apresenta as conclusões obtidas ao término do
desenvolvimento desse trabalho, bem como possíveis propostas para trabalhos
futuros.
18
2 MODELAGEM DE SISTEMAS DE SOFTWARE
Para o desenvolvimento de qualquer sistema de software é preciso que se faça um
planejamento inicial. Essa necessidade nos leva ao conceito de modelo, que pode
ser visto como a representação idealizada de um software a ser construído e
normalmente revelam apenas as características essenciais de um sistema. De
acordo com Blaha e Rumbaugh (2008) um modelo é uma abstração de algo com a
finalidade de entendê-lo antes de construí-lo.
Com a utilização de modelos os custos do desenvolvimento podem ser reduzidos, já
que é menos custoso identificar erros e fazer correções ainda nos modelos de
sistema. O gerenciamento da complexidade pode ser simplificado, pois a partir dos
modelos os desenvolvedores podem fazer estudos e prever comportamentos do
sistema. Além de facilitar também a comunicação entre as pessoas envolvidas na
construção do sistema (ANDRADE, 2007).
Os modelos de software são construídos para uma visualização do sistema a ser
desenvolvido, possibilitando uma melhor compreensão e entendimento e segundo
Blaha e Rumbaugh (2008) servem para entender um problema antes de
implementá-lo. Podem ser utilizados também para especificação e documentação do
software. Quando o modelo é utilizado para especificação fornece uma descrição
precisa do que será desenvolvido pelos programadores. A documentação obtida
através de modelos precisa refletir o que foi desenvolvido e servirá como base para
as atividades de manutenção.
De acordo com Booch, Rumbaugh e Jacobson (2006), alguns princípios devem ser
seguidos:
A escolha do modelo a ser construído tem grande influência em como um
problema é atacado e como uma solução é apresentada.
Todo modelo pode ser expresso em vários níveis de exatidão.
Os melhores modelos estão atrelados à realidade.
19
Nenhum modelo único é suficiente. Todo sistema complexo possui uma melhor
abordagem através de um conjunto de modelos independentes.
De acordo com Bezerra (2007), a modelagem de sistemas de software consiste na
utilização de notações gráficas e textuais para construção de modelos para
representar as partes essenciais de um sistema, considerando varias perspectivas.
Já que, embora um diagrama consiga expressar diversas informações, ainda é
preciso adicionar informações na forma de texto para explicar ou definir certas
partes do diagrama. Ele também está de acordo com o paradigma de orientação a
objetos, que pode diminuir a diferença semântica entre realidade que será modelada
e os modelos a serem construídos.
De acordo com Alan Kay, um dos pais do paradigma da orientação a objetos, esse
paradigma figura um sistema de software como uma coleção de agentes interligados
chamados objetos. Cada objeto é responsável por realizar tarefas específicas. E a
interação entre diversos objetos é responsável por realizar uma tarefa
computacional.
Foi no final da década de 1990 que este paradigma atingiu sua maturidade. Nessa
década surgiram varias propostas de modelagem utilizando o paradigma da
orientação a objetos. E por isso, percebeu-se a necessidade de uma notação de
modelagem que pudesse se tornar um padrão para a modelagem de sistemas,
sendo aceita e amplamente utilizada (BEZERRA, 2007).
Em 1996 surgiu então a UML (Unified Modeling Language), que unificou notações e
diagramas já existentes em diferentes técnicas de modelagem e foi aprovada para
ser um padrão da indústria de software (ANDRADE, 2007).
20
3 A LINGUAGEM DE MODELAGEM UNIFICADA – UML
UML é a abreviação de Linguagem de Modelagem Unificada (Unified Modeling
Language), uma linguagem visual para modelar sistemas que utilizam os conceitos
de orientação a objetos (LARMAN, 2007).
Segundo Bezerra (2007), a construção da UML teve muitos contribuintes, mas os
principais autores do processo foram Grady Booch, James Rumbaugh e Ivar
Jacobson. No processo de definição da UML, procurou-se o melhor das
características das notações preexistentes, principalmente das técnicas Booch
Method, OMT (Object Modeling Technique) e OOSE (Object-Oriented Software
Engineering).
A UML define uma notação que é uma união de diversas notações preexistentes,
removendo alguns elementos e adicionando outros com o objetivo de transformá-la
numa notação mais expressiva. A UML foi aprovada pelo OMG (Object Management
Group) em 1997 e desde então, tem tido grande aceitação pela comunidade de
desenvolvedores de sistemas (ANDRADE, 2007).
A UML é uma linguagem visual que define elementos gráficos para modelar
sistemas orientados a objetos. Através destes elementos pode se construir
diagramas que representem diversas perspectivas de um sistema. A extensibilidade
da sintaxe e da semântica dos elementos da UML permite que ela seja adaptada às
características específicas de cada projeto (BEZERRA, 2007).
Guedes (2007) afirma que a UML é uma linguagem de modelagem, e não uma
linguagem de programação, e que o seu objetivo é ajudar os engenheiros de
software a estabelecer as características do software, dentre as quais estão seus
requisitos, sua estrutura lógica, seu comportamento e a dinâmica de seus
processos. E, cumpre destacar que a UML também não é um processo de
desenvolvimento de software e não está ligada a nenhum de forma exclusiva, se
21
tornando totalmente independente, podendo ser utilizada por muitos processos de
desenvolvimento diferentes.
Segundo Ramos (2006), a UML é uma linguagem que serve para especificar,
construir, visualizar e documentar os artefatos de sistemas de software. Além disso,
é independente de linguagens de programação, de ferramentas CASE e dos
processos de desenvolvimento. Assim, permite adotar diferentes metodologias
mantendo a utilização de uma única linguagem de modelagem.
Durante o desenvolvimento de um sistema de software complexo, é necessário que
seus desenvolvedores possam analisar e estudar esse sistema a partir de diferentes
perspectivas. Os autores da UML sugerem que um sistema seja descrito em cinco
visões interdependentes, cada visão enfatizando aspectos diferentes desse sistema
(BEZZERA, 2007). A figura 1 mostra essas cinco visões ou perspectivas de um
sistema de software.
A visão do caso de uso compreende os casos de uso que descrevem o
comportamento do sistema do modo como é visto pelos seus usuários finais,
analistas e equipe de teste (ANDRADE, 2007). Essa visão não especifica a
organização do sistema de um software, mas sim descreve as funcionalidades que o
sistema irá fornecer. Com a UML, os aspectos estáticos dessa visão são descritos
em diagramas de caso de uso e os aspectos dinâmicos em diagramas de interação,
Figura 1: Visões de um sistema de software. Fonte: Bezerra (2007).
22
diagramas de estados e diagramas de atividades. Essa visão direciona o
desenvolvimento das outras visões do sistema.
A visão de projeto descreve como será fornecida a funcionalidade de um sistema.
Mostra a estrutura estática e as dinâmicas que ocorrem na aplicação. Essa
perspectiva proporciona um suporte para os requisitos funcionais do sistema, ou
seja, os serviços que o sistema irá fornecer aos seus usuários finais. Utilizando a
UML, os aspectos estáticos dessa visão são capturados em diagramas de classes e
de objetos, enquanto os aspectos dinâmicos são capturados em diagramas de
interações, de estados e diagramas de atividades (BOOCH; RUMBAUGH;
JACOBSON, 2006).
A visão de implementação mostra os módulos do sistema e suas dependências.
Essa visão envolve o gerenciamento da configuração das versões do sistema,
composta por componentes e arquivos de alguma maneira independentes, que
podem ser reunidos de diferentes formas para a produção de um sistema executável
(ANDRADE, 2007). Com a UML, os aspectos estáticos dessa visão são mostrados
em diagramas de interações, de estados e de atividades.
A visão de processo dá ênfase às características de concorrência, sincronização e
desempenho do sistema. Abrange as threads e os processos que formam os
mecanismos de concorrência e de sincronização do sistema. Os aspectos estáticos
e dinâmicos dessa visão são descritos pelos mesmos tipos de diagramas da visão
de projeto, mas o foco é voltado para as classes ativas que representam threads e
processos (BOOCH; RUMBAUGH; JACOBSON, 2006).
De acordo com Andrade (2007) a visão de implantação especifica a distribuição
física do sistema e os recursos que o sistema ira utilizar. Descreve toda a estrutura
onde o sistema é instalado. Essa visão direciona principalmente a distribuição, o
fornecimento e a instalação das partes que constituem o sistema físico. Com a UML,
os aspectos estáticos dessa visão são descritos em diagramas de implantação e os
aspectos dinâmicos são capturados em diagrama de interações, de estados e de
atividades.
23
Cada uma dessas cinco visões pode ser considerada isoladamente, permitindo que
diferentes participantes dirijam seu foco para os aspectos da arquitetura do sistema
que mais interessam. Dependendo das características e da complexidade do
sistema, nem todas as visões precisam ser desenvolvidas, além disso, podem ser
ordenadas por grau de relevância (ANDRADE, 2007).
3.1 DIAGRAMAS DA UML
Diagramas são ferramentas gráficas utilizadas para permitir a visualização do
sistema sob várias perspectivas. A UML utiliza a notação dos seus diversos
diagramas para descrever os vários aspectos da modelagem (ANDRADE, 2007).
Com a UML é possível modelar todas as visões de um sistema através dos diversos
diagramas fornecidos por ela. Cada representação gráfica tem seu significado e
também uma forma de ser utilizada (BEZERRA, 2007).
Melo (2011) afirma que na UML 2.0 existem treze tipos de diagramas, que são
classificados em diagramas estruturais e diagramas comportamentais. O primeiro
mostra as características imutáveis do sistema. Enquanto o segundo mostra as
reações do sistema a requisições e sua evolução no tempo.
O objetivo de existir esse número de diagramas é fornecer múltiplas visões do
sistema a ser modelado, permitindo analisar e modelar sob diversos aspectos, e
dessa forma tentar alcançar a completitude da modelagem, permitindo que cada
diagrama complemente os outros. Cada diagrama analisa o sistema, ou parte dele,
sob uma determinada óptica (GUEDES, 2011).
Cada tipo de diagrama da UML captura uma perspectiva diferente do sistema e um
determinado elemento pode existir em múltiplos diagramas, apesar de haver apenas
uma definição daquele elemento no modelo em questão. De acordo com Guedes
24
(2011) a utilização de diversos diagramas permite que falhas sejam descobertas,
diminuindo assim a probabilidade da ocorrência de erros futuros. A figura 2 mostra
todos os diagramas da UML agrupados de acordo com sua classificação.
Os diagramas estruturais tratam o aspecto estrutural do ponto de vista do sistema e
das classes. São para visualizar, especificar, construir e documentar os aspectos
estáticos de um sistema, ou seja, a representação de seu esqueleto e estruturas
estáveis (OMG, 2006).
De acordo com Andrade (2007), a função dos diagramas estruturais é mostrar as
características do sistema que não mudam ao longo do tempo. Os aspectos
estáticos de um sistema de software envolvem a existência e a colocação de itens
como classes, interfaces, colaborações, componentes. A figura 3 a seguir, ilustra os
diagramas comportamentais da UML.
Figura 2: Os diagramas da UML. Fonte: Bezerra (2007). Nota: Adaptado pelo autor.
25
Os diagramas de comportamento têm o objetivo de descrever o sistema
computacional modelado quando em execução, isto é, uma modelagem dinâmica do
sistema. São usados para visualizar, especificar, construir e documentar os aspectos
dinâmicos de um sistema que é a representação das partes que são modificadas ao
longo da execução, como por exemplo, o fluxo de mensagens ao longo do tempo e a
movimentação física de componentes em uma rede (OMG, 2006).
Esses diagramas estão ilustrados na figura 4 a seguir.
Figura 3: Diagramas Estruturais da UML Fonte: Bezerra (2007). Nota: Adaptado pelo autor.
Figura 4: Diagramas Comportamentais da UML. Fonte: Bezerra (2007). Nota: Adaptado pelo autor.
26
Nas próximas seções serão apresentadas as definições gerais de cada um dos
diagramas apresentados na figura 2.
3.1.1 Diagrama de Caso de Uso
De acordo com Bezerra (2007) um caso de uso representa uma determinada
funcionalidade de um sistema conforme percebida externamente. Representa
também os agentes externos que interagem com o sistema. Porém, não revela a
estrutura e o comportamento interno do sistema. O diagrama fornece uma visão
estática e externa do funcionamento do sistema, seria como se um pessoa o
observasse sob uma perspectiva de fora, como se estivesse assistindo seu
funcionamento sem participar dele, apenas identificando atores, relacionamentos,
tarefas, generalizações e associações entre os elementos do sistema.
O diagrama de caso de uso descreve a visão externa do sistema e suas
funcionalidades, representando em alto nível de abstração. Não é importante nesse
momento compreender como o sistema implementa o caso de uso ou como ocorre o
funcionamento interno. O objetivo desse diagrama não é especificar o sistema ou o
programa, mas sim o que o software deve atender, e o que o usuário espera dele
(ANDRADE, 2007).
Esse diagrama oferece uma visão geral do sistema, mas suas descrições reais são
feitas através de texto, pois os modelos visuais não são capazes de fornecer toda a
informação necessária. A descrição do conteúdo de um caso de uso é feita
textualmente e torna-se parte da documentação. Tal documento deve definir os
requisitos solicitados pelo cliente e descrever suas funcionalidades. Através de uma
descrição detalhada é possível tomar conhecimento dos envolvidos no caso de uso,
quais os passos do fluxo principal, as exceções que podem ocorrer e outros casos
de uso incluídos no fluxo (HAMILTON; MILES, 2006).
27
Guedes (2001) afirma que o diagrama de casos de uso é o diagrama mais geral e
informal da UML, sendo utilizado normalmente nas fases de levantamento e análise
de requisitos do sistema e podendo servir de base para outros diagramas.
3.1.2 Diagrama de Classes
O diagrama de classes é possivelmente o diagrama mais utilizado e um dos mais
importantes da UML. Serve de apoio para a maioria dos demais diagramas
(GUEDES, 2011).
É um diagrama que mostra um conjunto de classes, interfaces, e colaborações e
seus relacionamentos. O diagrama de classes é utilizado na construção do modelo
de classes desde o nível de análise até o nível de especificação. Segundo Bezerra
(2007), esse é o diagrama da UML mais rico em termos de notação.
Um diagrama de classes ilustra as especificações para as classes de software e de
interface de uma aplicação. Este diagrama mostra definições para entidades de
software, e não conceitos do mundo real (LARMAN, 2007).
Produz a descrição mais próxima da estrutura do código de um programa, ou seja,
mostra o conjunto de classes com seus atributos e métodos e os relacionamentos
entre classes. Classes e relacionamentos constituem os elementos básicos do
diagrama de classes (SILVA, 2007).
3.1.3 Diagrama de Objetos
De acordo com Guedes (2011), o diagrama de objetos está amplamente associado
28
ao diagrama de classes. Podendo ser visto como uma instância de tal diagrama,
assim como os objetos são instâncias de classes. Tal qual o diagrama de classe, o
diagrama de objeto são estruturas estáticas.
Bezerra (2007) diz que, um diagrama de objetos exibe uma fotografia do sistema em
um determinado momento, exibindo ligações formadas entre objetos conforme
interação entre eles e de acordo com valores de atributos.
3.1.4 Diagrama de Pacotes
Em UML, um pacote é o mecanismo de agrupamento. É usualmente utilizado para
agrupar classes em unidades de nível mais alto, mas pode também ser aplicado a
qualquer elemento do modelo (BOOCH; RUMBAUGH; JACOBSON, 2006).
O diagrama de pacotes é um diagrama estrutural e seu objetivo é representar os
subsistemas englobados por um sistema de forma a determinar as partes que o
compõem (GUEDES, 2011). O termo diagrama de pacotes é utilizado para
descrever um diagrama que mostra pacotes de classes e as dependências entre
eles.
Este diagrama oferece uma visão do sistema como um todo, sob tal perspectiva que
se possa observar todos os subsistemas que o compõem. Tem como proposta
apresentar a modelagem estrutural do sistema em divisões lógicas e suas interações
em alto nível (SILVA, 2007).
29
3.1.5 Diagrama de Componentes
Booch, Rumbaugh e Jacobson (2006) narram que um diagrama de componentes
mostra a organização e as dependências entre os vários componentes de um
sistema. Um componente representa um módulo físico do código. As dependências
entre os componentes mostram como mudanças em um componente podem causar
mudanças em outros componentes.
Este diagrama fornece uma visão modelada entre os módulos do próprio código
fonte, bibliotecas e formulários, arquivos de banco de dados e demais arquivos de
sistema. Além de determinar como cada um desses elementos estará disposto na
organização do sistema e como interagem entre si (GUEDES, 2011).
3.1.6 Diagrama de Implantação
O diagrama de implantação representa a configuração e a arquitetura do sistema em
que estarão ligados os respectivos componentes. Booch, Rumbaugh e Jacobson
(2006) dizem que este diagrama exibe a configuração dos nós de processamento
em tempo de execução e os componentes que neles existem. Neste diagrama
também pode ser representada toda a estrutura de hardware e requisitos mínimos
onde o sistema será executado.
Ainda na visão de Booch, Rumbaugh e Jacobson (2006) este diagrama modela a
visão estática da implantação de um sistema. Dado um determinado sistema de
software, o diagrama de implantação vai expressar o conjunto de hardware e toda a
tecnologia física relacionada com a instalação do sistema. Os diagramas de
implantação também podem ser usados para especificar os módulos do sistema que
deverão ser instalados no cliente.
30
3.1.7 Diagrama de Máquina de Estados
Os diagramas de máquina de estados, ou diagrama de estados como era chamado
em versões anteriores da UML, registram as mudanças sofridas por um objeto em
um contexto de um determinado processo. Este diagrama é utilizado para a
modelagem dos aspectos dinâmicos de um sistema (BOOCH; RUMBAUGH;
JACOBSON, 2006).
É uma técnica utilizada para descrever o comportamento de um sistema. Um estado
é uma situação na vida de um objeto durante a qual ele satisfaz alguma condição ou
realiza alguma atividade. Este diagrama descreve todos os estados possíveis em
que um objeto pode estar e como o estado do objeto muda como resultado de
eventos que o atingem (BEZERRA, 2007).
Guedes (2011) afirma que o diagrama de máquina de estados demonstra o
comportamento de um elemento por meio de um conjunto finito de transições de
estado, ou seja, uma máquina de estados. Podendo ser utilizado para expressar o
comportamento de uma parte do sistema, ou para expressar o protocolo de uso de
parte de um sistema.
3.1.8 Diagrama de Atividades
O diagrama de atividades mostra a execução das ações e as transições que são
ativadas pela conclusão de outras ações ou atividades. Uma atividade pode ser
descrita como um conjunto de ações e um conjunto de atividades (SILVA, 2007).
De acordo com Guedes (2011) o diagrama de atividade descreve os passos que
serão percorridos para a conclusão de uma atividade específica, podendo esta ser
31
representada por um método, um algoritmo, ou por um processo completo. Este
diagrama concentra-se na representação do fluxo de controle de uma atividade.
Um diagrama de atividades pode ser visto como um tipo especial de diagrama de
estados, onde são representados os estados de uma atividade, em vez de um
objeto. Ao contrário dos diagramas de estados, que são orientados a eventos, o
diagrama de atividade é orientado a fluxos de controle (BEZERRA, 2007).
3.1.9 Diagrama de Seqüência
Consiste em um diagrama que tem o objetivo de mostrar como as mensagens entre
os objetos são trocadas no decorrer do tempo para a realização de uma operação.
De acordo com Larman (2007), um diagrama de seqüência é uma figura que mostra
os eventos gerados pelos agentes externos, sua ordem e os eventos entre os
sistemas, para um cenário especifico de um caso de uso.
Guedes (2011) diz que o diagrama de seqüência dá ênfase à ordenação temporal
em que as mensagens são trocadas entre os objetos de um sistema. Entende-se por
mensagens os serviços solicitados de um objeto a outro, e as respostas
desenvolvidas para as solicitações. Permite também a representação de mensagens
concorrentes assíncronas (mensagens que são processadas em paralelo sem um
tempo definido para a sua realização).
3.1.10 Diagrama de Colaboração
Guedes (2011) afirma que o diagrama de colaboração era chamado assim até a
32
versão 1.5 da UML, tendo seu nome modificado para diagrama de comunicação a
partir da versão 2.0.
O diagrama de colaboração também tem o objetivo de mostrar as mensagens
trocadas entre objetos, a diferença entre o diagrama de seqüência está na ênfase
dada as interações entre esses objetos. Enquanto no diagrama de seqüência a
ênfase está na ordem temporal das mensagens, o diagrama de colaboração enfatiza
os relacionamentos que há entre os objetos que participam do cenário representado
(BOOCH; RUMBAUGH; JACOBSON, 2006).
O diagrama de colaboração dá ênfase à ordenação estrutural em que as mensagens
são trocadas entre os objetos de um sistema. Segundo Bezerra (2007), os
diagramas de seqüência e colaboração são equivalentes entre si. É possível
transformar um diagrama de colaboração em um diagrama de seqüência equivalente
e vice-versa.
E Guedes (2011) completa que este diagrama está amplamente associado ao
diagrama de seqüência, um complementando o outro.
3.1.11 Diagrama de Temporização
O diagrama de temporização foi incluído a partir da UML 2.0 e apresenta o
comportamento dos objetos e sua interação em uma escala de tempo, focalizando
as condições que mudam no decorrer desse período. Descreve a interação e a
evolução de estados, e consiste em monitorar as restrições temporais do sistema
(MELO, 2011).
Para Guedes (2011) o diagrama de temporização ou de tempo apresenta a
mudança no estado ou condição de uma instância de uma classe ou seu papel
33
durante um período. Utilizado para mostrar a mudança no estado de um objeto no
tempo em resposta a eventos externos.
3.1.12 Diagrama de Visão Geral da Interação
Este diagrama é uma combinação de diagrama de atividade e diagrama de
seqüência. De acordo com Melo (2011) e Guedes (2011) o diagrama de visão geral
é uma variação do diagrama de atividades, que ilustra o fluxo de controle geral do
sistema ou processo de negócio. Este diagrama permite capturar de uma
perspectiva estática os fluxos de interação entre os componentes do sistema, de
forma geral, do funcionamento global do sistema, de forma similar ao modelo
expresso pelo diagrama de atividades, que mostra o fluxo de um subsistema, ou de
uma dada funcionalidade em questão.
3.1.13 Diagrama de Estrutura Composta
Este diagrama mostra a estrutura interna dos elementos da modelagem estrutural,
com o objetivo de se obter uma visão detalhada de sua estrutura. É um dos novos
diagramas propostos na UML 2.0, voltado a detalhar elementos de modelagem
estrutural, como classes, pacotes e componentes, descrevendo sua estrutura
interna. Na visão de Guedes (2011), este diagrama pode ser utilizado para
descrever uma colaboração em que um conjunto de instâncias colaboram entre si
para realizar uma tarefa.
Para Melo (2011) este diagrama visa mostrar a composição de estruturas
complexas ou projetos de componentes, simplificando o relacionamento de
composição. Deste modo um diagrama de classes será exibido dentro de uma
34
classe, contendo a classe-todo com suas classes-partes ligadas através de
conectores.
35
4 FERRAMENTAS DE MODELAGEM DE SOFTWARE
Ferramenta CASE (Computer-Aided Software Engineering ou Engenharia de
Software Auxiliada por Computador) é o nome dado ao software utilizado para
apoiar as atividades de processo de software, como a engenharia de requisitos, o
projeto, o desenvolvimento de programas e os testes (GUEDES, 2011). Estas
ferramentas armazenam as informações de uma forma própria, como textos,
imagens, gráficos, possibilitando a integração com o usuário.
Segundo Silva e Videira (2008) uma ferramenta CASE não é mais do que um
produto informático destinado a suportar uma ou mais atividades de engenharia de
software, relacionadas com uma ou mais metodologias de desenvolvimento.
Sommerville (2011), diz que são sistemas de software que têm a intenção de
fornecer apoio automatizado para atividades do processo de desenvolvimento de um
software.
Embora não exista um padrão definido para categorização das ferramentas CASE,
Manhani e Schimiguel (2010) afirmam que elas podem ser divididas em 3 tipos:
Upper CASE - ferramentas especializadas na fase de concepção do software, ou
seja, ferramentas de análise e especificação e/ou modelação de requisitos.
Lower CASE - utilizadas na fase de implementação, ferramentas de desenho
técnico, de edição e compilação de código e de testes.
I-CASES ou Integrated Cases - simultaneamente Lower e Upper CASE,
funcionando integradamente, são ferramentas que cobrem todo o ciclo de vida do
software, desde os requisitos do sistema até o controle final da qualidade.
A introdução dos conceitos da orientação a objetos veio de alguma forma
revolucionar o mercado das ferramentas CASE, quer porque uma parte das
ferramentas tradicionais teve que se "reinventar" e incorporar novas técnicas de
modelagem integradas com as abordagens estruturadas já existentes ou porque
36
surgiram no mercado novas ferramentas que suportam exclusivamente este
paradigma (SILVA; VIDEIRA, 2008). Neste contexto, assume particular destaque a
UML, que vem assumindo um papel crescente ao nível das notações de
modelagem. Hoje em dia, praticamente todas as ferramentas que estão no mercado
de uma forma mais significativa incorporam algum suporte para a UML.
A maioria das ferramentas CASE especializa-se, sobretudo numa tarefa específica
do processo de desenvolvimento de software. Algumas se concentram na
disponibilização de funcionalidades relevantes para a fase de concepção como a
elaboração de diversos diagramas, enquanto outras estão particularmente
direcionadas para a fase de implementação, desenvolvimento visual, geração de
código ou apoio à realização de testes (SILVA; VIDEIRA, 2008).
De acordo com Martins (2010), é na fase de projeto do desenvolvimento de um
sistema que ocorre a descrição precisa de como deverá ser o software e seu
funcionamento. O modelo especificado deve ser claramente definido, de modo que o
sistema evite passar por correções no decorrer de seu desenvolvimento.
Várias técnicas podem ser usadas para auxiliar nesta tarefa, em especial o uso da
UML. A UML padroniza diagramas, permitindo uma melhor visualização geral do
projeto e da comunicação entre os objetos. Assim, antes mesmo de começar
efetivamente a programação, pode-se ver se a esquematização do sistema está
correta e de acordo com o que foi levantado previamente na análise de requisitos
(MARTINS, 2010).
Neste contexto, este trabalho apresentará as ferramentas Astah* e Umbrello UML
Modeller, que são ferramentas CASE de apoio à criação de diagramas para projetos
de software, como diagramas de classe, de casos de uso, entre outros.
37
4.1 ASTAH*
Astah* é uma ferramenta CASE que visa auxiliar o processo de modelagem de um
sistema, é um editor de diagramas UML que incorpora outros recursos de acordo
com a distribuição utilizada. É sucessora do JUDE, ferramenta que foi
descontinuada em 2010. E assim como o Jude, esta ferramenta possui versões
Community e Professional.
Com o Astah* é possível realizar uma modelagem de dados complexa. É uma IDE
criada com Java e de uso fácil, apresenta os dados para o usuário de forma clara e
ainda possuí a vantagem de seu layout ser bem intuitivo. É possível trabalhar com
vários diagramas e depois de feita toda a modelagem exportar tudo para um arquivo
Java, HTML ou exportar cada diagrama em forma de imagem. O Astah* é utilizado
para fazer modelos UML dos artefatos desenvolvidos no decorrer do
desenvolvimento do projeto.
Essa ferramenta possui uma versão gratuita, a ASTAH Community, e está disponível
comercialmente em três versões distintas, ASTAH UML, ASTAH Professional e
ASTAH SHARE, com suas determinadas funções e especialidades definidas cujas
diferenças se situam ao nível das funcionalidades disponibilizadas. Existe ainda a
distribuição Astah UML Pad que é uma versão gratuita para ser utilizada em iPad’s.
Para a realização deste trabalho foi utilizada a versão 6.5.1 da distribuição Astah
UML, pois esta é uma versão específica para trabalhar com os diagramas da UML. A
figura 5 exibe a tela inicial da ferramenta Astah UML.
38
4.2 UMBRELLO UML MODELLER
O Umbrello UML Modeller é uma ferramenta de modelagem UML, e como tal seu
principal propósito é auxiliá-lo na análise e desenho de seus sistemas.
Especialmente durante as fases de análise e desenho, essa ferramenta auxilia a
obter um produto de alta qualidade.
Auxilia o processo de desenvolvimento de software através do uso do padrão
industrial da Linguagem de Modelagem Unificada (UML), permite criar diagramas
para o desenvolvimento e documentação de sistemas. Apesar de não implementar a
UML 2.0, essa ferramenta possui um excelente manual que além de auxiliar na sua
utilização, ensina muito sobre a UML.
Figura 5: Tela inicial da ferramenta Astah UML. Fonte: Ferramenta Astah UML (2012).
39
Faz parte do projeto KDE e seu desenvolvimento foi iniciado por Paul Hensgen
como um de seus projetos Universitários. O nome original do aplicativo era
Modelador UML. Paul fez todo o desenvolvimento até o final de 2001 quando o
programa atingiu sua versão 1.0. Essa versão já oferecia muitas funcionalidades,
mas após o projeto ter sido revisado pela Universidade, outros desenvolvedores
puderam juntar-se e iniciaram fazendo contribuições importantes para o Modelador
UML.
Paul retirou-se da equipe de desenvolvimento em 2002, mas como um Software
Livre e de Código Aberto, o programa continua a melhorar e evoluir, e está sendo
mantido por um grupo de desenvolvedores de diferentes partes do mundo. Em
Setembro de 2002, o projeto mudou seu nome de Modelador UML, para Umbrello
UML Modeller.
O desenvolvimento do Umbrello UML Modeller assim como as discussões sobre
para onde o programa deve progredir nas versões futuras é aberto e ocorre na
Internet.
Para a análise feita neste trabalho foi utilizada a versão 2.6.5 do Umbrello UML
Modeller. Na figura 6 é possível visualizar a tela inicial desta ferramenta.
40
Figura 6: Tela inicial da ferramenta Umbrello UML Modeller. Fonte: Ferramenta Umbrello UML Modeller (2012).
41
5 ANÁLISE COMPARATIVA
Apresentam-se neste capítulo, os critérios selecionados para comparação, as
comparações realizadas e os resultados obtidos.
5.1 CRITÉRIOS PARA COMPARAÇÃO
Para comparar as ferramentas analisadas neste trabalho foi preciso definir quais
critérios seriam utilizados. A definição dos critérios foi feita tendo por base uma
pesquisa bibliográfica sobre o tema.
Os critérios selecionados para análise foram:
1. Documentação
2. Licença
3. Plataformas suportadas
4. Idiomas suportados
5. Especificação da UML suportada
6. Diagramas da UML suportados
7. Exportação para arquivos gráficos
8. Exportação para código fonte
9. Engenharia Reversa
10. Exportação de dados para o padrão XMI
O quadro 1 fornece a descrição para cada um dos critérios utilizados neste
trabalho.
42
CRITÉRIOS
NOME DESCRIÇÃO
Documentação Pesquisa feita nos sites das ferramentas sobre a documentação existente.
Licença Verificar quais são as licenças de uso de software utilizadas pelas ferramentas.
Plataformas suportadas (Portabilidade) Verificar em quais plataformas as ferramentas podem ser utilizadas.
Idiomas suportados Verificação de quais idiomas cada ferramenta oferece.
Especificação da UML suportada Identificar qual a versão da UML que as ferramentas escolhidas dão suporte.
Diagramas da UML suportados Verificar quais são os diagramas da UML suportados por cada ferramenta.
Exportação para arquivos gráficos Verificar se a ferramenta oferece exportação dos diagramas para arquivos de imagem.
Exportação para código fonte Verificar se o usuário poderá gerar código fonte para a aplicação que está sendo desenvolvida.
Engenharia Reversa Verificação se a ferramenta oferece suporte à engenharia reversa.
Exportação de dados para o padrão XMI Verificar se a ferramenta oferece exportação de dados para o padrão XMI.
Quadro 1: Descrição dos critérios utilizados para análise. Fonte: Elaboração Própria (2012).
A partir das respostas aos critérios listados no quadro 1 é possível contrapor as
soluções propostas pelas ferramentas a fim de se determinar qual delas é a melhor
opção para ser utilizada observando cada aspecto analisado.
5.2 APLICAÇÃO DOS CRITÉRIOS
A análise comparativa das ferramentas para modelagem de software utilizando UML,
Astah UML e Umbrello UML Modeller, foi feita com base nos critérios de comparação
descritos no quadro 1 no tópico anterior.
43
Neste tópico serão relatadas as comparações das ferramentas de acordo com os
critérios estabelecidos.
5.2.1 Documentação
O objetivo deste critério é verificar se existe uma preocupação quanto à
documentação do software e como a mesma é disponibilizada.
A documentação de um software tem o objetivo de divulgar e deixar claro o que faz
o sistema, como utilizá-lo, as suas vantagens, operação e requisitos para
funcionamento além de orientar o usuário na operação do software.
A qualidade da documentação pode ser baseada em três características
fundamentais: completeza, precisão e clareza. A completeza garante que nenhuma
informação que dificulte a compreensão do usuário estará faltando. Para uma
documentação precisa, é necessário que esta seja revisada por no mínimo duas
pessoas. E o seu conteúdo deve ser de fácil identificação, localização e
organização. Além de ser completo e conciso, garantindo sua clareza.
Pode-se afirmar que uma documentação terá qualidade quando estiver adequada ao
usuário que avalia e relata sua satisfação.
As duas ferramentas analisadas possuem boa documentação disponível no site. O
Astah UML possui um fórum ativo no site, no entanto sua documentação e tutoriais
só estão disponíveis em inglês. Podem ser encontrados no site
http://astah.net/tutorials.
O manual de uso do Umbrello UML Modeller é bastante completo e oferecendo
além da explicação de utilização da ferramenta, uma visão geral da UML. Está
disponível no site http://docs.kde.org/stable/en/kdesdk/umbrello/index.html.
44
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Documentação Possui boa documentação, porém em inglês.
Possui excelente documentação.
Quadro 2: Comparação de acordo com a documentação. Fonte: Dados da Pesquisa (2012).
5.2.2 Licença
Uma licença de software é uma definição de ações autorizadas ou proibidas na
esfera do direito de autor de um programador de software de computador
concedidas ou impostas aos usuários deste software.
A ferramenta Astah* possui diversas distribuições, uma versão gratuita e outras
distribuições que são pagas. Para o desenvolvimento deste trabalho foi utilizada a
distribuição Astah UML, que é uma versão paga, cuja licença por um ano custa
$50,00 por computador pessoal.
A ferramenta Umbrello UML Modeller faz parte do projeto KDE e é liberada sob a
licença GPL - General Public Licence, que é a designação da licença para software
livre.
Em termos gerais, a GPL baseia-se em quatro liberdades:
1. A liberdade de executar o programa para qualquer propósito.
2. A liberdade de estudar como o programa funciona e adaptá-lo para as suas
necessidades.
3. A liberdade de redistribuir cópias de modo que você possa ajudar ao seu
próximo.
4. A liberdade de aperfeiçoar o programa, e liberar os seus aperfeiçoamentos, de
modo que toda a comunidade se beneficie deles.
45
Com a garantia destas liberdades, a GPL permite que os programas sejam
distribuídos e reaproveitados, mantendo, porém, os direitos do autor por forma a não
permitir que essa informação seja usada de uma maneira que limite as liberdades
originais. A licença não permite, por exemplo, que o código seja apoderado por outra
pessoa, ou que sejam impostos sobre ele restrições que impeçam que seja
distribuído da mesma maneira que foi adquirido.
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Licença 1 ano / 1 PC = $50,00 GNU General Public Licence
Quadro 3: Comparação de acordo com a licença. Fonte: Dados da Pesquisa (2012).
5.2.3 Plataformas suportadas (Portabilidade)
Uma plataforma é o padrão de um processo operacional ou de um computador. É
uma expressão utilizada para denominar a tecnologia empregada em determinada
infra-estrutura de Tecnologia da Informação, garantindo facilidade de integração dos
diversos elementos dessa infra-estrutura. A portabilidade de um programa de
computador é a sua capacidade de ser compilado ou executado em diferentes
arquiteturas (seja de hardware ou de software).
O objetivo deste critério é identificar para quais sistemas operacionais as
ferramentas estão disponíveis.
A ferramenta Astah UML pode ser utilizada nos sistemas operacionais Windows,
Mac OS X e Linux. Já a ferramenta Umbrello UML Modeller está disponível para as
plataformas GNU/Linux, FreeBSD e Solaris.
46
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Plataformas suportadas (Portabilidade)
Windows, Mac OS X e Linux GNU/Linux, FreeBSD e Solaris
Quadro 4: Comparação de acordo com as plataformas suportadas. Fonte: Dados da Pesquisa (2012).
5.2.4 Idiomas suportados
A ferramenta Astah UML suporta dois idiomas: inglês e japonês. E a Umbrello UML
Modeller está disponível para os idiomas: Chinês (Tradicional), Inglês, Português
(Brasil e Portugal) e Espanhol.
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Idiomas suportados Inglês e japonês Chinês (Tradicional), Inglês, Português (Brasil e Portugal) e Espanhol.
Quadro 5: Comparação de acordo com os idiomas suportados. Fonte: Dados da Pesquisa (2012).
5.2.5 Especificação da UML suportada
O Astah UML suporta todas as funcionalidades da UML 1.4 e muitos dos recursos
da UML 2.0. As notações podem ser alternadas entre UML 1.4 e 2.0 nas
configurações da ferramenta.
Umbrello UML Modeller 2.6.5 atende a especificação da UML 1.* e não implementa
a UML 2.0.
47
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Especificação da UML suportada
UML 2.0 UML 1.*
Quadro 6: Comparação de acordo com a versão da UML. Fonte: Dados da Pesquisa (2012).
5.2.6 Diagramas da UML suportados
Este critério tem o objetivo de verificar em cada ferramenta quais diagramas da UML
estão disponíveis.
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Diagramas da UML suportados
Diagrama de Classe Diagrama de Caso de Uso Diagrama de Seqüência Diagrama de Estado Diagrama de Atividade Diagrama de Componente Diagrama de implantação Diagrama de Estrutura
Composta Diagrama de Comunicação /
Colaboração Diagrama de Pacotes Diagrama de Objetos
Diagrama de Classe
Diagrama de Caso de Uso Diagrama de Seqüência Diagrama de Estado Diagrama de Atividade Diagrama de Componente Diagrama de Colaboração Diagrama de Distribuição
Quadro 7: Comparação de acordo com os diagramas da UML. Fonte: Dados da Pesquisa (2012).
5.2.7 Exportação para arquivos gráficos
Com o Astah UML é possível exportar cada diagrama em forma de imagem. Os
seguintes arquivos gráficos estão disponíveis: JPEG, PNG, EMF e SVG.
48
O Umbrello UML Modeller permite copiar os objetos de um diagrama como figuras
de modo que seja possível inseri-las em outro tipo de documento. Permite também
exportar um diagrama completo como uma imagem. As extensões disponíveis são:
EPS, JPEG, PNG, PPM, SVG, XBM e XPM.
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Exportação para arquivos gráficos
JPEG, PNG, EMF e SVG. EPS, JPEG, PNG, PPM, SVG, XBM e XPM.
Quadro 8: Comparação de acordo com os tipos de arquivos gráficos gerados. Fonte: Dados da Pesquisa (2012).
5.2.8 Exportação para código fonte
O objetivo desse critério é verificar se o usuário poderá gerar código fonte para a
aplicação que está sendo desenvolvida a partir dos modelos já criados e para quais
linguagens de programação isso é possível.
No Astah UML é possível exportar código fonte nas linguagens Java, C++ e C#
facilmente a partir dos modelos criados.
O Umbrello UML Modeller pode gerar código fonte a partir de várias linguagens de
programação, baseadas no seu modelo UML para auxiliá-lo no início com a
implementação do seu projeto. O código gerado consiste de declarações de classe,
com seus métodos e atributos de modo que seja possível preencher as lacunas
fornecendo a funcionalidade das operações de classes.
O Umbrello UML Modeller 2.6.5 vem com suporte à geração de código fonte para as
seguintes linguagens de programação: ActionScript, Ada, C++, C#, CORBA IDL, D,
Java, JavaScript, MySQL (SQL), Pascal, Perl, PHP, PHP5, PostgresSQL (SQL),
Python, Ruby, TCL, Vala e Esquema XML.
49
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Exportação para código fonte Java, C++ e C#.
ActionScript, Ada, C++, C#, CORBA IDL, D, Java, JavaScript, MySQL (SQL), Pascal, Perl, PHP, PHP5, PostgresSQL (SQL), Python, Ruby, TCL, Vala e Esquema XML.
Quadro 9: Comparação de acordo com a exportação para código fonte. Fonte: Dados da Pesquisa (2012).
5.2.9 Engenharia Reversa
Realizar a engenharia reversa de um software significa analisar um determinado
sistema e criar representações dele em um nível mais alto de abstração. É também
entendida como voltar atrás no ciclo de desenvolvimento do software.
A engenharia reversa é muito útil para transformar código em um modelo, quando
não exista modelo anteriormente, e também para ressincronizar um modelo com o
código no final de uma iteração.
Astah UML permite a importação apenas em código Java. A engenharia reversa em
C++ está disponível através do uso de um plug-in.
O Umbrello UML Modeller importa código fonte de seus projetos existentes para
auxiliá-lo a construir o modelo de seus sistemas, analisando seu código e
importando as classes encontradas nele. A versão 2.6.5 pode importar código nas
seguintes linguagens de programação: ADA, C++, IDL, Java, Pascal e Phyton.
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Engenharia Reversa Java. ADA, C++, IDL, Java, Pascal e Phyton.
Quadro 10: Comparação de acordo com a engenharia reversa. Fonte: Dados da Pesquisa (2012).
50
5.2.10 Exportação de dados para o padrão XMI
O padrão XMI do Object Management Group (OMG) é um dos desenvolvimentos
mais recentes na comunidade de desenvolvedores UML. XMI é um formato de
intercâmbio que tem potencial para permitir o compartilhamento transparente de
modelos entre as ferramentas de desenvolvimento.
Por exemplo, em vez de escrever scripts dentro de uma ferramenta de modelagem
UML para criar relatórios, o usuário pode exportar o modelo em desenvolvimento
utilizando XMI e importar o modelo em uma ferramenta especializada em relatório.
XMI utiliza XML para representar as informações do modelo. Muitas soluções XML
estarão imediatamente disponíveis, tais como folhas de estilo XSL para
apresentação baseada em browser e ferramentas de consulta XQL para a
capacidade de pesquisa.
Astah UML não disponibiliza a exportação dos diagramas para o formato XMI.
A ferramenta Umbrello UML Modeller possui esse recurso e já oferece a opção de
salvar os diagramas criados no formato padronizado XMI.
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Exportação de dados para o padrão XMI
Não oferece recurso. Oferece esse recurso.
Quadro 11: Comparação de acordo com a exportação de dados para o padrão XMI. Fonte: Dados da Pesquisa (2012).
51
5.2.11 Recursos Adicionais
O Astah UML facilita o trabalho em equipe, oferecendo recursos para fazer
mesclagem de arquivos do projeto e permitindo a exclusão mútua de arquivos
através do seu bloqueio. Além disso, facilita a troca de informações entre a equipe,
pois mesmo que nem todos possuam o software instalado, é possível exportar os
diagramas para HTML, CSV e RTF.
Outro recurso disponível é o uso de Mind Map ou Mapa da Mente. É um diagrama
usado para representar palavras, idéias, tarefas ou outros itens ligados e dispostos
em torno de uma palavra chave ou idéia central. Utilizado pelas corporações como
ferramenta de gestão estratégica, sua utilização no projeto de softwares é
perfeitamente adaptável e muito útil. Essa ferramenta converte modelos UML para
Mapas da Mente e vice-versa
O Umbrello UML Modeller é capaz de importar arquivos do Rose (Rose model files).
A Rational Rose é uma ferramenta CASE que auxilia nos processos de construção
de um software profissional.
Permite ainda que os códigos fonte sejam visualizados e pode realizar Refatoração.
Além disso, disponibiliza a criação de pastas lógicas para melhor organizar o
modelo, especialmente para grandes projetos. Estas pastas podem ser aninhadas, e
é possível mover objetos arrastando-os de uma pasta e soltando-os em outra.
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Recursos Adicionais
Mapa Mental: Permite conversão UML para Mapa mental.
Equipe: mesclagem de arquivos e exclusão mútua.
Exporta diagramas para RTF, HTML, CSV.
Importa arquivos do Rose (Rose model files).
Visualizador de Código Fonte.
Refatoração.
Pastas Lógicas.
Quadro 12: Recursos adicionais. Fonte: Dados da Pesquisa (2012).
52
5.3 RESULTADOS OBTIDOS
Após análise realizada entre as ferramentas foi possível gerar o quadro 13, no qual
estão reunidas as características consideradas para o desenvolvimento deste
trabalho.
CRITÉRIO ASTAH UML UMBRELLO UML MODELLER
Documentação Possui boa documentação, porém em inglês.
Possui excelente documentação.
Licença 1 ano / 1 PC = $50,00 GNU General Public Licence
Plataformas suportadas (Portabilidade)
Windows, Mac OS X e Linux GNU/Linux, FreeBSD e Solaris
Idiomas suportados Inglês e japonês Chinês (Tradicional), Inglês, Português (Brasil e Portugal) e Espanhol.
Versão da UML suportada UML 2.0 UML 1.*
Diagramas da UML suportados
Diagrama de Classe Diagrama de Caso de Uso Diagrama de Seqüência Diagrama de Estado Diagrama de Atividade Diagrama de Componente Diagrama de implantação Diagrama de Estrutura
Composta Diagrama de Comunicação /
Colaboração Diagrama de Pacotes Diagrama de Objetos
Diagrama de Classe
Diagrama de Caso de Uso Diagrama de Seqüência Diagrama de Estado Diagrama de Atividade Diagrama de Componente Diagrama de Colaboração Diagrama de Distribuição
Exportação para arquivos gráficos
JPEG, PNG, EMF e SVG. EPS, JPEG, PNG, PPM, SVG, XBM e XPM.
Exportação para código fonte Java, C++ e C#.
ActionScript, Ada, C++, C#, CORBA IDL, D, Java, JavaScript, MySQL (SQL), Pascal, Perl, PHP, PHP5, PostgresSQL (SQL), Python, Ruby, TCL, Vala e Esquema XML.
Engenharia Reversa Java. ADA, C++, IDL, Java, Pascal e Phyton.
Exportação de dados para o padrão XMI
Não oferece recurso. Oferece esse recurso.
53
Recursos Adicionais
Mapa Mental: Permite conversão UML para Mapa mental.
Equipe: mesclagem de arquivos e exclusão mútua.
Exporta RTF, HTML, CSV.
Importa arquivos do Rose (Rose model files).
Visualizador de Código Fonte.
Refatoração.
Pastas Lógicas.
Quadro 13: Quadro geral de comparações entre as características das ferramentas. Fonte: Dados da Pesquisa (2012).
Analisando o quadro acima é possível concluir que as duas ferramentas analisadas
oferecem ótimos recursos para a modelagem de sistemas de software.
Com base nesta comparação é possível que o usuário selecione qual ferramenta é a
melhor opção com relação a cada um dos critérios, visto que a escolha final da
ferramenta a ser utilizada depende das características do projeto e cabe ao usuário
escolher a mais adequada.
54
6 CONCLUSÕES
Atualmente, existem várias ferramentas de apoio a modelagem de software
utilizando a linguagem de modelagem UML. A utilização de modelos UML visa uma
padronização do processo de modelagem bem como uma melhor estruturação do
software, o que facilita a comunicação entre os membros da equipe de
desenvolvimento e também com o cliente.
Com a crescente demanda de produtos de software, diversas ferramentas CASE
que oferecem suporte às diversas fases do processo de software foram surgindo.
Sendo assim a escolha de uma ferramenta apropriada e que atenda os objetivos do
usuário pode se tornar difícil, e com isso vem a pergunta: É possível comparar
ferramentas de modelagem de software, a fim de decidir qual delas é a melhor?
A fim de facilitar a avaliação dessas ferramentas, este trabalho mostrou uma análise
comparativa entre duas ferramentas de modelagem bem conceituadas no mercado
de software. Foram escolhidas as ferramentas Astah UML e Umbrello UML Modeller
e foi definido um conjunto de critérios baseados em requisitos funcionais, não
funcionais e normas de qualidade para a realização da avaliação.
Foram exibidas e confrontadas as principais funcionalidades da ferramenta Astah
UML e Umbrello UML Modeller com o objetivo de auxiliar o usuário a obter
informações sobre cada ferramenta para que, com base nestas informações seja
possível escolher a que melhor atenda as suas necessidades.
A análise mostrou que não existem diferenças tão marcantes entre as ferramentas, a
escolha entre uma delas vai depender do critério analisado, visto que em alguns
aspectos uma se destaca mais que a outra. No que diz respeito aos idiomas
suportados e licença da ferramenta, a Umbrello UML Modeler apresenta melhores
características, já que tem suporte para mais idiomas e a sua licença é GNU General
Public Licence, ou seja, é gratuita.
55
Em relação à documentação, ambas são muito boas. Mas vale ressaltar que o
manual da Astah UML só é encontrado em inglês. Enquanto o manual da Umbrello
UML Modeler é em português, bastante completo e oferece ainda uma visão geral
da UML.
Quanto a plataformas e versão da UML suportada a melhor escolha seria a
ferramenta Astah UML, pois ela funciona nos ambientes Windows, Mac OS X e
Linux e suporta a versão mais recente da UML.
Quanto ao critério de diagramas da UML suportados, a ferramenta Astah UML pode
ser considerada melhor por oferecer um maior número de diagramas e dar suporte a
UML 2.0. Já quanto ao aspecto de exportação de diagramas para arquivos gráficos e
para código fonte a melhor ferramenta seria a Umbrello UML Modeler por oferecer
todas as opções que a Astah UML oferece e ainda conter mais opções além dessas.
Para realizar a engenharia reversa a Umbrello UML Modeler é melhor do que a
Astah UML, pois esta só oferece na linguagem Java enquanto a primeira oferece
esse recurso nas linguagens ADA, C++, IDL, Java, Pascal e Phyton. E quanto à
exportação de dados para o padrão XMI somente a ferramenta Umbrello UML
Modeler oferece esse recurso.
Após a avaliação dessa análise comparativa, é recomendável que o usuário
estabeleça prioridades aos critérios utilizados de acordo com suas necessidades.
Para isso podem ser atribuídos valores para os critérios que indicará em que grau a
ferramenta atende aquele critério. Assim a ferramenta que melhor atender as
necessidades é a que obtiver mais pontos.
O surgimento de novas ferramentas e a constante atualização das mesmas motiva a
realização de trabalhos futuros para complementação deste, abrangendo outras
características das ferramentas avaliadas, elaborando novos critérios ou a extensão
da avaliação realizada para um maior número de ferramentas.
56
REFERÊNCIAS
BEZERRA, E.. Princípios de análise e projeto de sistemas com UML. Rio de Janeiro: Elsevier, 2007. BLAHA, M.; RUMBAUGH, J.. Modelagem e projetos baseados em objetos com UML 2. 2. ed. Rio de Janeiro: Elsevier, 2006. BOOCH, G.; RUMBAUGH, J.; JACOBSON, I.. UML: guia do usuário. Rio de Janeiro: Campus, 2006. ANDRADE, C. A. V.. Metodologia de Análise de Sistemas. 8° Módulo. ESAB – Escola Superior Aberta do Brasil: Vila Velha, 2007. GUEDES, G. T. A.. Uml 2: Uma Abordagem Prática. 2. ed. São Paulo: Novatec, 2011. ______. Uml 2: Guia Prático. São Paulo: Novatec, 2007. HAMILTON, K.; MILES, R.. Learning UML 2.0. O’Reilly, 2006. LARMAN, C.. Utilizando UML e padrões. 3. ed. Porto Alegre: Bookman, 2007. MANHANI, D. M. da S.; SCHIMIGUEL, J.. Ferramentas case para modelagem de banco de dados. Codificando .net e-magazine. Rio de Janeiro, ano 4, v. 14, 01 fev. 2010. MARTINS, D. M. S. et al. Projeto de software com astah*. Engenharia de software magazine. Rio de Janeiro, ano 3, v. 30, 11 mar. 2010. MELO, A. C.. Desenvolvendo Aplicações com UML 2.2. 3. ed. Rio de Janeiro: Brasport, 2011. OMG. Unified Modeling Language: infrastructure. 2006.
57
SILVA, A. M. R. da; VIDEIRA, C. A. E.. UML, metodologias e ferramentas case. 2. ed. Lisboa: Centro Atlântico, 2008. 2 v. SILVA, R. P. e. UML 2 em Modelagem Orientada a Objetos. Florianópolis: Visual Books, 2007. SOMMERVILLE, I.. Engenharia de software. 9. ed. São Paulo: Addison Wesley, 2011. TONSIG, S. L.. Engenharia de software: Análise e Projeto de Sistemas. 2. ed. Rio de Janeiro: Ciência Moderna, 2008.
![[UML] UML, Metodologias e Ferramentas CASE us](https://static.fdocumentos.com/doc/165x107/5571f34149795947648dbd59/uml-uml-metodologias-e-ferramentas-case-us.jpg)
