Case As principais ferramentas no ciclo de desenvolvilento de software1

Prévia do material em texto

CASE: AS PRINCIPAIS 
FERRAMENTAS NO CICLO DE 
DESENVOLVIMENTO DE 
SOFTWARES 
W
B
A
04
46
_v
1.
0
2
Andre Olimpio
Londrina 
Editora e Distribuidora Educacional S.A. 
2020
CASE: AS PRINCIPAIS FERRAMENTAS NO CICLO 
DE DESENVOLVIMENTO DE SOFTWARES
1ª edição
3
2020
Editora e Distribuidora Educacional S.A.
Avenida Paris, 675 – Parque Residencial João Piza
CEP: 86041-100 — Londrina — PR
e-mail: editora.educacional@kroton.com.br
Homepage: http://www.kroton.com.br/
Presidente
Rodrigo Galindo
Vice-Presidente de Pós-Graduação e Educação Continuada
Paulo de Tarso Pires de Moraes
Conselho Acadêmico
Carlos Roberto Pagani Junior
Camila Braga de Oliveira Higa
Carolina Yaly
Giani Vendramel de Oliveira
Henrique Salustiano Silva
Juliana Caramigo Gennarini
Mariana Gerardi Mello
Nirse Ruscheinsky Breternitz
Priscila Pereira Silva
Tayra Carolina Nascimento Aleixo
Coordenador
Henrique Salustiano Silva
Revisor
Marcilyanne Moreira Gois
Editorial
Alessandra Cristina Fahl
Beatriz Meloni Montefusco
Gilvânia Honório dos Santos
Mariana de Campos Barroso
Paola Andressa Machado Leal
Dados Internacionais de Catalogação na Publicação (CIP)
__________________________________________________________________________________________ 
Olimpio, Andre
O46c CASE: as principais ferramentas no ciclo desenvolvimento 
 de softwares / Andre Olimpio – Londrina: Editora e Distribuidora Educacional 
S.A. 2020.
 44 p.
 ISBN 978-65-87806-09-9
1. Ferramentas. 2. Desenvolvimento I. Olimpio, Andre. II. ,Título. 
 
CDD 005
____________________________________________________________________________________________
Jorge Eduardo de Almeida CRB: 8/8753
© 2020 por Editora e Distribuidora Educacional S.A.
Todos os direitos reservados. Nenhuma parte desta publicação poderá ser 
reproduzida ou transmitida de qualquer modo ou por qualquer outro meio, 
eletrônico ou mecânico, incluindo fotocópia, gravação ou qualquer outro tipo de 
sistema de armazenamento e transmissão de informação, sem prévia autorização, 
por escrito, da Editora e Distribuidora Educacional S.A.
4
SUMÁRIO
Ferramentas para o desenvolvimento de softwares _________________ 05
Ferramentas para modelagem de um Sistema de Software _________ 22
Ferramentas CASE para gerenciamento de projeto de desenvolvimento 
de software _________________________________________________________ 40
Ferramentas para automação de testes de software ________________ 56
CASE: AS PRINCIPAIS FERRAMENTAS NO CICLO DE 
DESENVOLVIMENTO DE SOFTWARES
5
Ferramentas para o 
desenvolvimento de softwares
Autoria: André Olímpio
Leitura crítica: Marcilyanne Gois
Objetivos
• Identificar os diferentes tipos de ferramentas 
existentes no mercado atual para desenvolvimento 
de sistemas de software. 
• Entender o conceito de levantamento de requisitos 
de software e aplicá-los por meio de ferramentas 
específicas. 
• Identificar uma ferramenta de desenvolvimento de 
interfaces gráficas com os usuários de um sistema 
de software. 
• Constatar a necessidade de se utilizar ferramentas 
específicas no gerenciamento de um sistema de 
banco de dado.
6
1. Introdução
Um software é um conjunto de funcionalidades distintas que foram 
escritas através de uma linguagem de programação, apoiado em uma 
estrutura lógica muito bem definida, que tem como principal objetivo 
resolver uma situação do mundo real. Tanto que nos dias atuais é muito 
comum utilizar-se da palavra solução para definir um software.
Nesse sentido, os softwares atuais são bastante complexos, seja em 
sua estrutura de programação ou no conjunto de variáveis que este 
administra, pois, os problemas a serem resolvidos, em sua grande 
maioria, requerem conceitos interdisciplinares, ou seja, as variáveis 
são provenientes de diferentes áreas, cabendo ao software identificar, 
processar e manipular cada uma delas, com o intuito de atingir um 
objetivo comum. É claro que, devido a toda essa complexidade e a 
quantidade de itens a serem gerenciados paralelamente, fica impossível 
para um ser humano dar conta de tudo sem ajuda. Assim, surgiram 
ferramentas específicas para auxiliar os profissionais de Tecnologia 
da Informação no desenvolvimento de sistemas de software das quais 
se utilizam de técnicas e recursos avançados que proporcionam o 
alcance dos melhores resultados possíveis. Essas ferramentas são 
chamadas de CASE, uma sigla em inglês que significa Computer Aided 
Software Engineering, em português, Engenharia de Software Auxiliada 
por Computador. Logo, são softwares que, como o próprio nome diz, 
ajudarão esses profissionais na estruturação e documentação de todos 
os ativos por ele desenvolvidos.
Com base nos argumentos apresentados, é importante ressaltar que 
essas ferramentas foram criadas para facilitar o trabalho do profissional 
de TI, criando um ambiente no qual o software a ser desenvolvido é 
definido e estruturado em pontos de vistas diferentes antes do processo 
de sua codificação, com intuito de garantir a qualidade, minimizar 
o esforço, aumentar a produtividade, permitir a reutilização de 
7
componentes, gerando documentos robustos e completos, necessários 
para compreensão e estruturação de todo esse processo.
1.1 As ferramentas CASE no processo de 
desenvolvimento de software
Uma ferramenta CASE pode ser classificada em três tipos: upper case, 
lower case e integrated case.
Upper CASE é um conjunto de aplicações utilizadas na fase de concepção 
do software, ou seja, durante a análise e especificação ou modelação 
de requisitos. Lower CASE seria uma ou mais aplicações que são 
utilizadas nas fases de implementação (criação, edição e compilação do 
código-fonte) e de testes. Por fim, a Integrated CASE, também chamado 
de I-CASE, refere-se à utilização conjunta dos outros dois conceitos 
(WERLICH, 2018, p. 37).
A programação de computadores, por sua vez, é definida como a 
escrita de um código-fonte de uma aplicação, utilizando uma linguagem 
específica, de maneira lógica e ordenada, com o objetivo de resolver 
um problema do mundo real. Esse código poderá ser testado, reescrito, 
manipulado e mantido por profissionais denominados programadores 
ou desenvolvedores de software. Esse programa, no entanto, deverá 
passar por um processo de compilação, transformando o código-fonte 
em algo legível para o computador, conhecido como linguagem de 
máquina. Após esse processo, ele será exibido na tela para o usuário 
em ambiente de execução. Além disso, é possível que esse código seja 
escrito por duas ou mais linguagens de programação diferentes.
Uma linguagem de programação é como se fosse um idioma, pois 
possui características próprias, sendo direcionadas para ambientes 
e objetivos distintos. Isso acontece, por exemplo, em uma linguagem 
desenvolvida para aplicações executadas em ambiente web como 
um sistema de loja virtual ou então para ambiente mobile, como um 
8
aplicativo de gerenciamento de arquivos multimídia (áudio e vídeo). Em 
outras palavras, atualmente, existem estruturas voltadas para resolução 
de problemas de diferentes naturezas. Nesse cenário, é permitido aos 
desenvolvedores utilizar a criatividade para gerar programas cada vez 
mais robustos e eficientes. Porém, segundo Sommerville (2019), mesmo 
tendo particularidades, as linguagens são iguais em sua essência, já que 
a estrutura lógica é a mesma para todas. Desse modo, fazem parte desta 
estrutura conceitos como: verificação condicional, laços de repetição, 
rotinas e sub-rotinas, comandos de entrada e saída de dados, além de 
armazenamento não permanente de dados (variáveis).
Ao longo do tempo, os problemas a serem resolvidos por um software 
ficaram mais amplos e mais complexos. Segundo Neto (2016), os 
primeiros programas criados resolviam problemas simples como efetuar 
um cálculo matemático de uma expressão de primeiro grau ou ordenar 
uma sequência numérica finita. Com a evolução tecnológica, por sua 
vez, as exigências dos usuários aumentaram de forma exponenciale, 
consequentemente, a complexidade dos problemas acompanharam 
esta evolução se tornando extremamente complexos e desafiadores. 
Um desenvolvedor nos dias atuais deve criar um sistema que esteja 
integrado a outros via uma API (Application Programming Interface ou 
Interface de Programação de Aplicação) tendo que gerenciar terabytes 
de dados em tempo real e com centenas de usuários acessando o 
sistema simultaneamente. Além disso, o software precisa oferecer 
confiabilidade nas informações exibidas na tela, ser seguro nos 
cumprimentos dos requisitos funcionais e não funcionais, e apresentar 
alta performance nas respostas às solicitações do usuário.
Porém, nada disso seria possível se não houvesse uma tecnologia 
robusta para sustentar essa demanda. Segundo Artero (2016), as 
ferramentas de desenvolvimento foram obrigadas a acompanhar 
esta evolução, deixando de ser meros digitadores de código-fonte e 
se tornando verdadeiros ambientes integrados de desenvolvimento, 
unindo diversas tecnologias e linguagens em uma única arquitetura.
9
Em programação existem dois ambientes: design mode e runtime 
mode. O design mode, é conhecido como modo de desenvolvimento 
ou lado do desenvolvedor, trata-se de um ambiente onde o código-
fonte e toda estruturação interna do software são produzidos. Somente 
os responsáveis pela programação deste sistema tem acesso a este 
modo, ou seja, o usuário final da aplicação não o visualiza e tampouco 
o manipula. Já o runtime mode, conhecido como modo de execução ou 
lado do usuário, refere-se ao ambiente no qual corresponde a todos os 
elementos que são visualizados na tela do computador após a execução 
do código-fonte da aplicação inicializada no design mode. Assim, toda 
ferramenta de desenvolvimento, por mais simples que seja, apresenta 
uma funcionalidade da qual realiza o processo de execução dessa 
aplicação.
1.2 Arquitetura de um sistema de software
Uma aplicação é permeada por itens que são essenciais para atender 
a todos os requisitos do sistema. A Figura 1 ilustra a arquitetura que é 
composta pela aplicação propriamente dita, computadores, dispositivos 
móveis, servidores, software de gerenciamento de banco de dados, o 
usuário final e profissionais de TI:
10
Figura 1– Componentes da arquitetura de um sistema de software
Usuário
Final
Desenvolvedor / 
Programador
DBA
Administrador do 
Banco de Dados
Servidor de 
Banco de Dados
Aplicação
(Desktop / Web / 
Mobile)
SGBD
 
 
Fonte: elaborada pelo autor.
O usuário final é aquele que irá acessar o conteúdo disponibilizado 
pela aplicação através de um componente físico, podendo ser 
um computador pessoal, um smartphone ou um notebook. Esses 
componentes recebem o nome de dispositivos de acesso, pois é por eles 
que o usuário poderá manipular e interagir diretamente com o software.
O código-fonte de uma aplicação é escrito por meio de uma ou mais 
linguagens de programação, dependendo do grau de complexidade e, 
principalmente, sua aplicabilidade. Nos dias atuais, no entanto, é muito 
comum que um software esteja integrado a outros sistemas, pois para 
resolver um problema é necessário que haja essa conectividade. Essa 
aplicação pode estar direcionada para ser executada em diferentes 
ambientes como web, mobile ou desktop. As ferramentas do tipo Lower 
CASE são utilizadas para estruturar o código da aplicação.
Por sua vez, uma aplicação para ambiente web é acessada através 
de um browser (navegador), que é uma ferramenta requisitada para 
acessar sites disponibilizados na Internet. Os browsers mais conhecidos 
atualmente são: Microsoft Internet Explorer, Mozilla Firefox, Apple Safari 
e Google Chrome. As linguagens de programação mais utilizadas para 
11
desenvolver aplicações para esse tipo de ambiente são: JavaScript, PHP, 
ASP, Java, Python e Ruby.
Uma aplicação para ambiente desktop é aquela na qual o usuário 
precisa instalar fisicamente o software em seu equipamento através de 
um programa instalador, que pode ser acessado em uma mídia digital 
como um CD, um dispositivo de armazenamento de dados como um 
pen drive ou efetuando um download. As linguagens mais conhecidas 
para desenvolvimento desse tipo de aplicação são: Java, C#, C++, Python, 
Delphi e Visual Basic.
Já uma aplicação para ambiente mobile é executada em dispositivos 
móveis como smartphones e tablets. Esse tipo de software precisa ser 
instalado diretamente no dispositivo e, ainda, levando em consideração 
o sistema operacional do aparelho. A maneira mais comum de fazer esta 
instalação é através do download em lojas virtuais disponibilizadas pelas 
empresas que administram seus sistemas operacionais, sendo que as 
mais famosas são: a Google Play Store, do Android e a Apple Store, do 
iOS. As linguagens mais conhecidas para desenvolvimento de aplicações 
para esse tipo de ambiente são: Java, C#, Swift e Python.
Um SGBD (Sistema de Gerenciamento de Banco de Dados) é o software 
responsável por fazer a administração de um banco de dados, 
estando fisicamente alocado em um servidor. Esse software será o 
intermediário entre o banco e a aplicação, garantindo, entre outros 
fatores, a segurança dos dados. Assim, a aplicação acessará os dados 
armazenados no servidor de forma remota, já que ambos farão parte 
de uma rede. Segundo Werlich (2018), as ferramentas do tipo Upper 
CASE são utilizadas para fazer a modelagem de um banco de dados e, 
também, toda estruturação do código-fonte da aplicação.
Entre os profissionais envolvidos nesta arquitetura, está o desenvolvedor 
ou programador, sendo fundamental que esse profissional conheça os 
conceitos que formam o ciclo de desenvolvimento de software para 
12
conseguir implementá-lo em sua essência, já que cada etapa apresenta 
características e conhecimentos específicos que interligados formam a 
solução do problema identificado no início deste ciclo.
O DBA (Database Administrator) é o administrador do sistema de banco 
de dados, um profissional fundamental para a arquitetura, pois é o 
responsável por gerenciar, manter e estruturar os dados, que são o 
bem mais importante nesse contexto. Afinal de contas, é a partir deles 
que a informação será disponibilizada para o usuário da aplicação. Vale 
lembrar que toda e qualquer informação é definida como um conjunto 
organizado de dados que apresente um significado inerente (ELMASRI; 
NAVATHE, 2019).
1.3 Levantamento de requisitos
O ciclo de desenvolvimento de um sistema de software é dividido em 
etapas que estão interligadas entre si. De acordo com Artero (2016), 
elas são sequenciais e seus resultados podem influenciar nas atividades 
realizadas nas etapas subsequentes, ou seja, um erro cometido pode ter 
consequências e efeitos refletidos em todo o processo a partir da etapa 
onde ocorre.
Esse ciclo permite, inclusive, que uma etapa possa ter suas atividades 
refeitas ou, até mesmo, voltar às etapas anteriores, possibilitando que 
correções sejam realizadas, mudanças sejam agregadas, garantindo um 
bom nível de qualidade do produto final entregue. Após a conclusão 
de cada etapa, é fundamental que alguma entrega do sistema seja 
realizada. Essa entrega pode ser uma funcionalidade, uma interface, 
um documento, algo que possa ser mensurado e apresentado para o 
solicitante desse sistema. A figura a seguir representa as etapas desse 
ciclo.
13
Figura 2 – Etapas do ciclo de desenvolvimento de software
 
 
Fonte: elaborada pelo autor.
A etapa de levantamento e análise de requisitos é considerada, por 
muitos profissionais, a etapa mais importante do ciclo. Nela são 
realizadas todas as definições necessárias para o cumprimento do 
objetivo do software. Essas definições, por sua vez, são chamadas 
de requisitos, que são todas as especificações abstraídas durante a 
interpretação do problema. Um requisito precisa ser claramente descrito 
para não causar ambiguidades ou interpretações diferentes das quais 
ele realmente representa.
O levantamento e análise de requisitos é fundamental para o sucesso 
de um software.Logo, cabe ao desenvolvedor fazer uma pesquisa 
detalhada para identificar e classificar todos os itens necessários para 
definir os pontos a serem alcançados, pois cada ponto deste será 
14
uma funcionalidade do sistema. De acordo com Pressman (2016), um 
requisito pode ser conceituado como toda e qualquer característica 
desejada para que um sistema computacional venha resolver com base 
em problemas do mundo real, sendo divididos em duas categorias: 
funcional e não funcional.
Requisito funcional: corresponde as funções que o software deverá 
executar para solucionar um problema específico, por exemplo: efetuar 
o cálculo de uma expressão matemática, gerar um relatório em formato 
PDF contendo o gráfico de crescimento mensal de uma organização 
ou uma autenticação de acesso de um usuário ao sistema através do 
método de validação de senha.
Requisitos não funcional: corresponde as estruturas de recursos, 
ambientes e demais informações que incidem no desempenho, 
usabilidade, confiabilidade, segurança, disponibilidade, manutenção e 
tecnologias envolvidas no desenvolvimento do software, por exemplo: 
o ambiente físico adequado para instalação de computadores, as 
atualizações realizadas no sistema operacional e nas ferramentas 
de desenvolvimento ou uma norma técnica utilizada para garantir a 
confiabilidade do processo de teste de software (PRESSMAN, 2016, p. 
141).
Segundo Sommerville (2019), é importante também ressaltar que 
um requisito é a principal referência para se aferir qualidade de um 
software, pois cada requisito precisa ser mensurado e, a partir disso, 
o desenvolvedor consegue identificar se o mesmo foi devidamente 
atendido. Assim, a qualidade pode ser conceituada em conformidade 
com os requisitos.
Para garantir está conformidade e mensurar se uma especificação 
foi devidamente atendida, há diversas ferramentas CASE que são 
facilitadoras e ajudam o desenvolvedor a cumprir o processo de 
levantamento de requisitos. Entre elas, no mercado atual, destacam-
15
se Utdalls RE-Tools (2016), Atlassian Jira (2017) e Visure Requirements 
Management Tool (2018).
O Utdalls RE-Tools (2016) é uma ferramenta que permite efetuar a 
captura de requisitos através de um conjunto de funcionalidades 
baseadas em múltiplas referências, como: modelagem para requisitos 
não funcionais, modelagem de software orientada a agentes (conceitos, 
notações, técnicas e diretrizes metodológicas), modelagem de processos 
de negócios e modelagem formal de objetivos. Ele oferece suporte 
para UML (Unified Modeling Language em português Linguagem de 
Modelagem Unificada), permitindo a geração de códigos em linguagem 
JAVA a partir de diagramas de classes, casos de uso, sequência e 
máquina de estados.
O Atlassian Jira (2017) é uma ferramenta que identifica e mapeia 
os requisitos de negócios, com a finalidade de colaborar com os 
stakeholders (todas as partes envolvidas e impactadas direta ou 
indiretamente por um projeto), garantir que as tarefas estejam 
conectadas a qualquer requisito de captura de dados, fornecendo 
entregas de alta qualidade. Além disso, essa ferramenta facilita a 
visualização a ligação entre requisitos de negócios e os problemas 
do mundo real, fazendo um rastreio de todas as tarefas que estejam 
relacionadas diretamente a esses requisitos. Assim, é possível também 
criar e visualizar uma estrutura de hierarquia de requisitos.
O Visure Requirements Management Tool (2018) é uma ferramenta 
robusta para gerenciamento do ciclo de vida de um software, e é muito 
utilizada em ambientes regulamentados como o setor aeroespacial, 
gerência de energia elétrica, dispositivos médicos e setor automotivo. 
Ela tem como principais características: a padronização de processos, 
a formalização de uma estrutura de especificação de requisitos 
comuns, a gerência de alterações durante o ciclo de vida do software 
e uma possível reutilização desses requisitos. Além disso, ela permite 
integração com outras ferramentas deste segmento, como o Atlassian 
16
Jira (2017) e com aplicativos do Microsoft Office. No entanto, ela não 
possui versão gratuita, porém é possível fazer o download de uma 
versão de testes disponível no site oficial da empresa Visure Solutions.
Todas essas ferramentas utilizam o conceito de ALM (Application Lifecycle 
Management), que é o gerenciamento do ciclo de vida de um sistema 
de software, desde a sua concepção até o momento em que houver a 
descontinuidade do mesmo, conforme o Quadro 1.
Quadro 1 – Ferramentas ALM
Ferramenta Licença Plataforma Versão de testes
Utdalls RE-Tools Opensource Multiplataforma Não
Atlassian Jira Proprietária Multiplataforma Sim
Visure 
Requirements 
Management Tool
Proprietária Windows Sim
Fonte: elaborada pelo autor.
1.4 Interfaces com o usuário final
A modelagem de interfaces com usuário final também é conhecida como 
prototipagem UX, sendo um processo de criação de um protótipo da 
estrutura visual do sistema, baseando-se nos requisitos definidos. Esse 
protótipo simula a aparência e a funcionalidade do software, permitindo 
que clientes e desenvolvedores pré-visualizem os componentes da 
interface. O termo UX significa User eXperience, ou experiência do usuário, 
o protótipo também é chamado de wireframe. Entre as ferramentas 
CASE de prototipagem, por sua vez, destacam-se o Axure RP (2019) e o 
Sketch (2020), conforme o Quadro 2.
A ferramenta Axure RP (2019) é muito popular neste segmento. Ela 
permite a criação de wireframes clicáveis e interativos que possibilitam 
17
uma abstração muito clara e bem abrangente de como será a versão 
final da interface. Assim, ela permite a criação de protótipos de baixa 
ou de alta fidelidade com os requisitos do sistema, variando de 
acordo com a necessidade do desenvolvedor, sendo possível modelar 
tipos diferentes de interfaces, desde websites mais simples até 
estruturas mais robustas como um game. Além disso, ela possibilita o 
compartilhamento do projeto para que haja uma colaboração remota 
em tempo real.
O Sketch (2020), no entanto, é uma ferramenta bastante interessante 
por ser bem simples de ser utilizada, sendo muito popular entre os 
desenvolvedores, mesmo que direcionada para usuários do Mac OS. 
Além da facilidade de uso, esse software apresenta uma interface muito 
intuitiva e uma lista de plug-ins que o deixam bem robusto. Entre estes 
plug-ins é possível destacar o Sketch Mirror, que permite visualizar uma 
prévia bem completa de uma aplicação para ambiente de dispositivos 
móveis.
O quadro as seguir ilustra a diferenças entre as ferramentas CASE para 
interface com usuário:
Quadro 2 –Ferramentas de prototipagem UX
Ferramenta Licença Plataforma Versão de testes
Axure RP Proprietária
Windows, 
MacOS
Sim
Trial para 30 dias 
de uso.
Sketch Proprietária MacOS
Sim
Trial para 30 dias 
de uso.
Fonte: elaborada pelo autor.
18
1.5 Banco de dados
A modelagem de um banco de dados, porém, é um dos processos mais 
fundamentais no desenvolvimento de um sistema de software, pois 
trata-se de uma estrutura na qual todos os dados serão armazenados 
para serem gerenciados e manipulados através da aplicação. Segundo 
Elmasri e Navathe (2019), diferentemente do que muitas pessoas 
possam pensar, não se codifica primeiro a aplicação, mas o banco de 
dados. Além disso, antes de implementar este banco, é necessário 
fazer sua estruturação através de modelos específicos, como o modelo 
entidade-relacionamento. Entre as principais ferramentas CASE para 
esse tipo de modelagem destacam-se: o DB-Main (2017), o DBDesign 
(2016) e ERwin (2017).
O DB-Main (2017) é uma ferramenta de modelagem que gerencia os 
processos existentes em um projeto de banco de dados, como: análise 
de requisitos, modelo entidade-relacionamento (conceitual, lógico e 
físico), normalização, integração e otimização de esquemas de dados 
e, também, a geração de códigos escritos em SQL (Structure Query 
Language), linguagem padrão para gerenciamento de banco de dados, a 
partir dos modelos.
O DB Design (2016)é uma ferramenta que permite modelar, criar e 
fazer a manutenção de um sistema de banco de dados em um único 
ambiente. Ele permite a compatibilidade direta com SGBD, como o 
MySQL, um dos mais populares e utilizados no mercado atual neste 
segmento. Por ser de código aberto, ele pois possui uma comunidade 
bastante ativa na qual permite compartilhamento de experiências 
entre os desenvolvedores, sendo que eles podem relatar bugs e sugerir 
atualizações/correções de funcionalidades.
O ERwin (2017), por fim, é uma ferramenta CASE para modelagem que 
simplifica bastante o processo de estruturação de um banco de dados. 
19
Além de permitir que o desenvolvedor defina as necessidades e normas 
corporativas de um modelo, ele gera um modelo prático a ser facilmente 
implementado no SGBD do qual estiver conectado. Sendo, também, 
utilizado para modelar bancos de dados de grande porte que são 
chamados de data warehouse.
Com isso, é importante ressaltar que essas ferramentas listadas 
são para modelagem de banco de dados do tipo relacional, que são 
utilizadas para armazenamento de dados formatados e estruturados. 
O quadro a seguir ilustra a diferenças entre as ferramentas CASE para 
modelagem de dados:
Quadro 3 – Ferramentas para modelagem de banco de dados
Ferramenta Licença Plataforma Versão de testes
DB Main Proprietária Windows, MacOS Freeware
DB Design Opensource Multiplataforma Não
ERwin Proprietária Windows
Sim
Trial para 30 dias 
de uso.
Fonte: elaborada pelo autor.
1.6 Programação orientada a objetos
A programação orientada a objetos (POO) é uma maneira robusta, 
elegante e altamente eficiente de se escrever o código-fonte de uma 
aplicação. Esse processo consiste em fazer com que unidades básicas, 
chamadas objetos, sejam programados com base em ações internas 
(métodos) e externas (eventos) das quais compõem uma estrutura 
primitiva (classe), que é a referência da qual um objeto é criado. 
Atualmente, muitas linguagens de programação utilizam o conceito de 
POO, como Java, C#, PHP e C++.
20
Para se fazer uma modelagem de sistemas utilizando conceitos de 
orientação a objetos, portanto, utiliza-se ferramentas com suporte 
a UML (Unified Modeling Language, em português, Linguagem de 
Modelagem Unificada), que é o padrão internacional para modelagem 
de software, no qual apresenta diversos diagramas que representam 
um sistema através de diversas perspectivas. Entre eles, há o diagrama 
de classes, que é apontado como o principal da UML e, também, é a 
base para a criação e manipulação de um objeto. Logo, nesse cenário, 
destacam-se as seguintes ferramentas: o Visual Paradigm (2018), o 
LucidChart (2008) e o Poseidon.
O Visual Paradigm (2018) é uma ferramenta CASE para modelagem de 
sistemas baseada em UML, que permite a criação de diagramas e a 
geração de códigos automaticamente a partir do diagrama de classes, 
além de fornecer a possibilidade de se fazer engenharia reserva. Há 
duas versões dessa ferramenta, uma gratuita mais enxuta, que é 
chamada de community, e outra mais completa, que é paga. Ambas 
estão disponíveis para download no site oficial do projeto.
O LucidChart (2008) é uma plataforma proprietária baseada na Web, 
usada para permitir que os usuários colaborem no desenho, revisão 
e compartilhamento de gráficos e diagramas. Por ser um website, é 
executado em navegadores compatíveis com HTML5, uma linguagem 
de marcação de hipertexto que é a base de código dos sites da Internet 
atual. 
O Poseidon, por sua vez, é uma ferramenta bem interessante, leve e 
com interface bem intuitiva, geração de documentação e exportação de 
diagramas para arquivos externos. Ele oferece, também, a engenharia 
reversa para JAVA e a integração com interface de desenvolvimento de 
código-fonte.
O quadro a seguir ilustra as diferenças entre as ferramentas CASE para 
modelagem de sistemas de software utilizando a UML:
21
Quadro 4 – Ferramentas para modelagem de código orientado a 
objetos
Ferramenta Licença Plataforma
Versão de 
testes
Visual Paradigm Proprietária Multiplataforma
Não.
Versão 
community
LucidChart Proprietária
Browsers 
compatíveis com 
HTML5
Não
Poseidon Opensource Multiplataforma Não
 
Fonte: elaborada pelo autor.
Referências Bibliográficas
ARTERO, M. A. Gestão de projetos de software. Londrina: Editora e Distribuidora 
Educacional S.A., 2016.
ELMASRI, R.; NAVATHE, S. B. Sistemas de banco de dados. 7. ed. São Paulo: 
Pearson Education do Brasil, 2019.
FABRIS, P. P. G.; PERINI, L. C. Processos de software. Londrina: Editora e 
Distribuidora Educacional S.A., 2014.
NETO, R. M. Engenharia de software. Londrina: Editora e Distribuidora Educacional 
S.A., 2016.
SOMMERVILLE, I. Engenharia de software. 10. ed. São Paulo: Pearson Education do 
Brasil, 2018.
PRESSMAN, R. S. Engenharia de software: uma abordagem profissional. 8. ed. 
Porto Alegre: AMGH, 2016.
WERLICH, C. Modelagem de dados. Londrina: Editora e Distribuidora Educacional 
S.A., 2018.
22
Ferramentas para modelagem de 
um Sistema de Software
Autoria: André Olímpio
Leitura crítica: Marcilyanne Gois
Objetivos
• Identificar os diferentes tipos de ferramentas 
existentes no mercado atual para modelagem de 
softwares.
• Entender o conceito de modelagem de softwares e 
aplicá-lo através de ferramentas específicas.
• Compreender a importância e a relevância de 
se modelar um sistema de software antes de 
implementá-lo. 
• Entender o funcionamento das seguintes 
ferramentas CASE: Microsoft Visio, Astah, IDE Eclipse 
e Netbeans.
23
1. Introdução
O processo de desenvolvimento de um sistema de software é composto 
por seis etapas: levantamento e análise de requisitos, modelagem, 
implementação, testes, implantação e manutenção. Para atingir o sucesso 
neste processo e, consequentemente, alcançar o objetivo de obter um 
produto de software, é fundamental que todas essas etapas sejam 
cumpridas de forma íntegra e completa. Porém, infelizmente, é possível 
encontrar profissionais que tendem a não cumprir alguns desses 
passos em sua essência, negligenciando algumas etapas, o que pode 
comprometer diretamente as entregas do processo.
Segundo Okuyama, Gonsales e Miletto (2014), provavelmente a etapa 
mais negligenciada é a modelagem. Isso se explica por dois motivos: 
primeiro, devido à complexidade das ações realizadas nesta etapa, 
pois modelar um sistema de software requer a utilização de conceitos 
de complexos, a criação de diagramas específicos, a representação do 
sistema em diferentes pontos de vista e abstrações, tudo isso sem levar 
em consideração que é um processo muito trabalhoso de ser realizado, 
exigindo muito esforço da equipe de desenvolvimento; o segundo 
motivo é focado no tempo, de acordo com Sommerville (2018), alguns 
profissionais acreditam que é muito mais vantajoso empregar mais 
esforço e tempo na implementação do que na modelagem, ou seja, na 
codificação do que na estruturação. Nesse sentido, é importante frisar 
que esta etapa é fundamental para o ciclo, pois é nela em que todas 
as métricas, diretrizes e parametrização são feitas, em uma abstração 
bem ampla do software, podendo inclusive antecipar situações de 
risco, evitar situações de erro e identificar possíveis problemas lógicos, 
como diferenças de tipos entre componentes codificados na aplicação e 
atributos do banco de dados.
24
1.1 O processo de modelagem
O processo de modelagem, por sua vez, consiste em estruturar 
um software através de diretrizes específicas, permitindo uma 
ampla abstração a partir de diversas perspectivas. Além disso, 
esse processo pode ser conceituado como um processo de criação 
de modelos abstratos para auxiliar na extração dos requisitos do 
sistema, na sua descrição para os profissionais envolvidos em seu 
ciclo de desenvolvimento, para documentação da estrutura e das 
funcionalidades desse sistema.
Assim, segundo Fabris e Perini (2014), a partir de perspectivas diferentes, 
é possível criar diversos modelos padronizados para representar o 
sistema a ser implementado, levandoem consideração o ambiente que 
este será executado após a conclusão do processo de implantação, 
conforme a figura a seguir:
Figura 1 – Perspectivas para criação de modelos de software 
Fonte: elaborada pelo autor.
25
Desse modo, a modelagem está relacionada aos aspectos externos de 
um software e não somente à sua visão interna. O desenvolvimento de 
diagramas permite aos profissionais de TI obter uma ampla abstração 
do sistema antes mesmo de implementá-lo, o que permite a criação de 
uma espécie de roteiro para a programação do software, traçando uma 
linha de raciocínio, um direcionamento na forma de codificar.
Uma maneira muito eficiente de criar esses roteiros é através de 
diagramas da UML (Unified Modeling Language), que é o padrão mundial 
para modelagem de sistemas adotado em todas as ferramentas CASE 
desse segmento. Esse padrão consiste em uma linguagem universal 
de estrutura de um sistema de software, que é utilizado, identificado 
e compreendido por todos os profissionais envolvido no processo de 
desenvolvimento.
Segundo Pressman (2016), a principal vantagem é que, ao padronizar 
a modelagem, os profissionais de tecnologia da informação do mundo 
todo entenderão a estruturação de um software sem se preocupar com 
idiomas, linguagens de programação ou, até mesmo, conceitos culturais 
de uma determinada região, pois os diagramas seguem componentes 
universais com o mesmo significado em qualquer parte do planeta. Isso 
ocorre pelo fato de que esses componentes são os elementos visuais 
que formam um diagrama, e por serem gráficos são representados 
por cores, figuras geométricas ou polígonos matemáticos, sendo cada 
um deles com significado específico. Assim, basta ao desenvolvedor 
saber identificar o significado de cada elemento dentro do contexto do 
diagrama e o que ele representa.
Mesmo apresentando um padrão internacionalmente reconhecido, é 
permitido aos desenvolvedores ter a flexibilidade de fazer adaptações 
e customizações voltadas às necessidades exigidas pelo software a ser 
implementado. Os modelos gráficos são normalmente empregados 
através de três formas distintas:
26
• Para facilitar a discussão e o entendimento sobre o sistema;
• Para documentar o sistema.
• Para descrever detalhadamente o sistema de forma que está 
modelagem seja utilizada como base para sua implementação.
1.2 UML
A construção de diagramas exige uma linguagem de modelagem que 
inclua elementos visuais que podem expressar conceitos técnicos, 
por meio de uma notação simples e ao mesmo tempo poderosa 
para esses elementos. Os modelos mais robustos, por sua vez, são 
comprovadamente os que adotam as vantagens da orientação a objetos, 
até mesmo, porque a maioria das linguagens de programação existentes 
atualmente se baseiam neste conceito, o que facilita a integração entre 
a modelagem e o código-fonte a ser desenvolvido, na etapa seguinte do 
ciclo de desenvolvimento de um sistema de software.
     Entre os anos de 1970 e 1980, foram desenvolvidos os primeiros 
métodos para modelar e especificar sistemas orientados a objetos, 
criando um padrão que perdura até os dias atuais. Esse período ficou 
conhecido como “a guerra dos métodos”, já que vários profissionais 
apresentavam conceitos próprios nos quais conseguiam modelar 
de forma abrangente um sistema. Nesse contexto, vale lembrar que 
desde essa época já se argumentava a importância de se estruturar 
um software antes de sua implementação. Assim, após vários estudos 
realizados, ficou comprovada que um sistema precisa ser analisado e 
visualizado em diferentes perspectivas antes de se iniciar o processo 
de codificação, com o intuito era gastar mais tempo estruturando e 
menos tempo retrabalhando um código. A ideia é extremamente válida 
e aprovada por muitos profissionais da área, mas, ainda assim, ainda 
sofria resistência de outros, devido à questão de produtividade e tempo, 
já que se acreditava que uma equipe deixaria de ser produtiva ao se 
27
dedicar tempo demais no processo de estruturação de um software 
(HUMBLE; FARLEY, 2013).
O tempo provou que essa forma de pensar estaria equivocada, já que 
a probabilidade de se gastar ainda mais tempo tendo que reescrever 
códigos ou de não conseguir entregar uma funcionalidade por completo, 
por não ter entendido corretamente o problema. Assim, na década 
de 1990, iniciou um período de mudança de paradigma, pois devido 
à complexidade cada vez maior dos problemas a serem resolvidos 
através de sistemas computacionais, a necessidade de se fazer uma 
modelagem mais robusta era mais evidente. De acordo com Pressman 
(2016), haviam profissionais que estavam migrando para este conceito e 
outros que ainda se mostravam relutantes, pois eles acreditavam que a 
maneira “tradicional” de se programar ainda era suficiente, não havendo 
motivos para mudanças.
Ainda segundo Pressman (2016), as ferramentas CASE foram as grandes 
responsáveis por forçar essa mudança de paradigma, já que visam 
facilitar o processo de modelagem e ampliar o poder de abstração, 
gerando mais possibilidades ao software e, principalmente, de 
reforçar aos desenvolvedores a necessidade de “pensar fora da caixa”, 
idealizando o software de uma forma mais ampla e robusta.
Neste momento, entram em cena três personagens que são 
fundamentais para a estruturação de um software, sendo eles: Grandy 
Booch, Ivar Jacobson e James Rumbaugh, conhecidos como “Três amigos”. 
Cada um deles possuíam seus próprios métodos de modelagem. Booch 
apresentava um método que tinha seu próprio nome, o de Jacobson 
chamava “OOSE” e o de Rumbaugh era o OMT. Os três modelos eram 
bons, mas eles perceberam a possibilidade de uni-los, criando uma 
abordagem robusta e completa, absorvendo o melhor dos modelos. A 
partir deste momento, criou a UML, um modelo padrão de estruturação 
de um sistema de software que se tornou referência em todo mundo e 
largamente utilizado até os dias atuais (PRESSMAN, 2016).
28
O termo UML significa Unified Modeling Language, em português significa 
“Linguagem de Modelagem Unificada”, que atualmente encontra-se na 
versão 2.5 e apresenta 14 diagramas que representam o sistema em um 
ponto de vista diferente. Porém, a primeira versão da UML foi publicada 
em outubro de 1994, quando Booch e Rumbaugh, que na época 
trabalhavam na mesma empresa, unificaram seus métodos que eram 
aceitos mundialmente. Apenas em 1995 o modelo OOSE de Jacobson 
foi incorporado aos outros dois. Assim, há ferramentas CASE que são 
utilizadas para criar esses diagramas, como o Astah e o Microsoft 
Visio, que são voltadas para modelagem. Além disso, existem algumas 
ferramentas de desenvolvimento que tem integrado o recurso de 
criação de diagramas através de plug-ins específicos, como o NetBeans e 
o Eclipse.
Segundo Pressman (2016), os 14 diagramas atuais da UML são divididos 
em três categorias: estruturais, comportamentais e de interação, sendo:
• Estruturais: classes, objetos, componentes, pacotes, instalação ou 
implantação, perfil e estruturas compostas.
• Comportamentais: casos de uso, máquina de estados e atividade.
• De interação: sequência, interação, colaboração ou comunicação 
e tempo.
29
Figura 2 – Classificação dos diagramas da UML
Fonte: https://upload.wikimedia.org/wikipedia/commons/e/e9/Uml_diagram.png. Acesso 
em: 13 maio. 2020.
1.2.1 Diagrama de classes
O diagrama de classes é o principal da UML, que é uma modelagem 
totalmente baseada na orientação a objetos e, de acordo esse 
conceito, uma classe é a estrutura base de um objeto. Ou seja, é uma 
representação do sistema no ponto de vista dele mesmo, ou seja, de 
dentro para fora.
Desse modo, uma classe é formada por atributos e métodos, sendo 
considerada completa quando apresentar ambos conceitos e parcial 
quando apresentar apenas um. Um atributo é o termo que se refere 
à todas as características existentes em uma classe, já um método é 
toda e qualquer ação realizada por essa classe. Neste diagrama, ainda, 
https://upload.wikimedia.org/wikipedia/commons/e/e9/Uml_diagram.png%2030
são utilizados alguns outros conceitos importantes, como: herança, 
associação, agregação, composição e multiplicidade.
A herança é um princípio no qual uma classe pode herdar características 
de uma ou mais classes ancestrais e, ainda, permite que ele possua 
suas próprias características. No entanto, há duas grandes vantagens 
em se utilizar esse conceito no processo de desenvolvimento de um 
software. Primeiro, ele deixa a estrutura e toda codificação mais 
organizada. Segundo, evita que ocorram duplicações desnecessárias 
de código, otimizando todo processo e facilitando a manutenção do 
sistema. As ferramentas CASE, como o Astah e o Netbeans apresentam 
uma funcionalidade que permite que códigos em linguagem Java sejam 
criados automaticamente a partir do diagrama de classes, assim, tudo o 
que foi modelado neste diagrama é gerado integralmente na codificação 
(OKUYAMA; GONSALES; MILETTO, 2014).
Quando se aplica o conceito de herança, portanto, cria-se uma espécie 
de árvore genealógica de classes, em que cada nível representa uma 
geração. Assim, outros dois conceitos são instituídos: generalização e 
especialização. O primeiro indica visualizar está árvore de baixo para 
cima, onde cada nível acima é mais geral, mais abrangente. Já o segundo 
é exatamente o contrário, ou seja, a visualização da árvore de cima 
para baixo, assim cada nível é mais específico e menos abrangente 
que o anterior. A partir desses fatores que surgem os termos classes, 
superclasses e subclasses. Uma superclasse é a mais geral de todas, não é 
nenhuma outra anterior a ela. Já uma subclasse é qualquer uma que foi 
originada de outra classe ancestral.
A associação é a ligação entre duas ou mais classes, relacionando-
as entre si. Já a multiplicidade se refere ao relacionamento entre os 
objetos gerados a partir das classes associadas entre si. Essa ligação 
é representada por valores como: 0 (zero) e 1 (um) ou por intervalos, 
como: 1 para N, 0 para N, N para N ou quaisquer outros valores mais 
específicos.
31
A agregação é um tipo especial de associação na qual demonstra 
que as informações de uma classe (chamada de todo) precisam ser 
complementadas por outras contidas em uma ou mais classes (parte). 
Uma composição é semelhante, representando a relação todo-parte, no 
entanto, uma classe todo é responsável por criar e destruir suas partes, 
assim uma parte não pode se associar a mais de um todo.
A figura a seguir ilustra a representação gráfica destes conceitos que 
compõem o diagrama de classes:
Figura 3 – Representação dos conceitos do diagrama de classes
Fonte: elaborada pelo autor.
1.2.2 Diagrama de casos de uso
O diagrama de casos de uso é o diagrama mais geral da UML. Ele 
representa o sistema no ponto de vista do usuário, ou seja, de fora 
para dentro. Já um caso de uso representa uma ação a ser realizada no 
32
software e não ações realizadas pelo usuário, sendo a representação de 
uma funcionalidade desse sistema.
Esse diagrama, portanto, é composto basicamente por três 
componentes: ator, caso de uso e associação. O ator se refere à 
uma pessoa, um equipamento ou um outro sistema que interagirá 
diretamente com o software a ser desenvolvido. O caso de uso é toda e 
qualquer ação realizada pelo sistema, que deve ser escrita no diagrama 
através de um verbo no infinitivo. Já a associação é a ligação entre 
ator e caso de uso. Assim, como no diagrama de classes, ferramentas 
CASE como o Netbeans e o Eclipse permitem a criação de códigos em 
linguagem Java a partir deste diagrama.
Mesmo sendo o diagrama mais geral dos existentes na UML, ele 
também possui recursos específicos e mais refinados. A herança, 
portanto, pode ser realizada tanto para o caso de uso em si quanto para 
os atores, sendo definida na representação dos atores e suas respectivas 
interações com o sistema, conforme a Figura 4.
Figura 4 – Herança em um diagrama de Casos de Uso
33
Fonte: elaborada pelo autor.
Na Figura 4, podemos visualizar que o Ator 1 pode realizar duas ações 
no sistema e, através do conceito da herança, o Ator 2 pode realizar três 
ações, sendo que as duas primeiras são herdadas no Ator 1.
Além disso, há duas formas de identificarmos o relacionamento 
entre dois ou mais casos de usos existentes no diagrama, sendo elas 
denominadas como: include e extends.
Uma ação do tipo include indica que ela sempre será realizada pelo 
sistema quando outra ação anterior for executada pelo sistema, como 
o registro de uma venda e a emissão de comprovante dessa venda, que 
sempre será realizada pelo sistema toda vez em que a ação de registro 
for executada. Uma ação include é realizada de forma automática, 
sem que haja a solicitação do usuário. Já uma ação do tipo extends é 
semelhante a include, diferindo pelo fato de que o caso de uso somente 
será realizado após a execução de uma ação anterior em situações 
especiais. Por exemplo, o bloqueio de acesso de um usuário ao sistema 
quando ele digitar a senha errada por três vezes consecutivas.
1.2.3 Diagrama de sequência
O diagrama de sequência é uma representação dinâmica do sistema 
a ser desenvolvido, ou seja, o software em execução. Ele consiste na 
visualização gráfica do passo a passo das ações executadas no sistema 
e, também, os possíveis retornos de cada uma dessas ações.
Esse diagrama deve ser desenvolvido para cada caso de uso existente 
na modelagem, porém somente para os que estejam vinculados 
diretamente a um ator. Ou então, para cada situação do caso de uso, 
34
ou seja, todas as possibilidades existentes de retorno para cada ação do 
sistema. Nesse contexto, vale ressaltar que não é possível desenvolver 
o diagrama de sequência sem que os de casos de uso e de classes 
estejam prontos, pois ele utiliza os elementos empregados nestes dois 
anteriores.
Figura 5 – Diagrama de sequência
Fonte: ribkhan/iStock.com.
1.3 ASTAH
O ASTAH se trata de uma ferramenta CASE largamente utilizada por 
profissionais de TI para modelagem de sistemas de software, sendo uma 
ferramenta bastante robusta que permite facilmente criar diagramas da 
UML (WERLICH, 2018).
Inicialmente, ela era chamada de JUDE, que é um acrônimo de 
“Java and UML Developers Environment”, que em português significa 
“Ambiente para Desenvolvedores UML e Java”. Uma de suas principais 
35
características é a integração total com a linguagem de programação 
JAVA, o que garante a portabilidade com a JVM (máquina virtual) para 
desenvolvimento de códigos fonte, permitindo inclusive a transformação 
de diagramas da UML para estruturas Java de forma automática, sendo 
uma ferramenta multiplataforma, que possui uma versão completa que 
é paga. Além disso, há também uma versão para comunidade, voltada à 
fins acadêmicos, que está disponível no site oficial do projeto.
Figura 6 – Diagrama de classes utilizando Astah
Fonte: elaborada pelo autor.
O Astah, portanto, possui uma versão chamada Community que pode ser 
baixada gratuitamente do site oficial do produto (astah.net).
1.4 Microsoft Visio
Essa é uma ferramenta para ambiente Windows utilizada para criação 
de vários tipos de diagramas, como organogramas, fluxogramas, 
36
modelagem de dados, UML, layout de redes, plantas baixas, mapas 3D e 
cartazes (FABRIS; PERINI, 2014).
Essa ferramenta está instalada como extensão do pacote Microsoft 
Office, oferecendo uma biblioteca de templates e modelos para vários 
tipos de gráficos, com a finalidade de ajudar o desenvolvedor no 
processo de modelagem de um sistema de software. Ela tem como 
principais características: simplicidade de uso através de uma interface 
bastante amigável, integração total com os demais aplicativos do pacote 
Office, flexibilidade de manipulação dos componentes e qualidade visual 
dos objetos de tela. Essas características tornam o Visio uma excelente 
ferramenta para criação de aplicações rápidas, rascunhos e também 
diagramas de uso pessoal ou profissional.
Figura 7–Diagrama de classes utilizando Microsoft Visio
Fonte: elaborada pelo autor.
O Visiopossui licença paga, podendo ser adquirido através do site oficial 
da Microsoft.
37
1.5 NetBeans
Essa ferramenta é opensource, multiplataforma, que permite 
aos desenvolvedores de sistemas de software criar códigos escritos em 
linguagens, como: Java, JavaScript, HTML5, PHP, C/C++, Groovy e Ruby.
O Netbeans é uma IDE, uma sigla em inglês: Integrated Development 
Environment, em português, “Ambiente de Desenvolvimento Integrado”, 
que nada mais é que uma interface que permite criar códigos fontes em 
diferentes linguagens de programação e modelagem de sistemas através 
de diagramas da UML. Ela permite a funcionalidade de se conectar 
com um SGBD, assim, o desenvolvedor poderá criar e manipular um 
banco de dados sem a necessidade de se instalar softwares específicos 
(BERTAGNOLLI; FRANCO; MACHADO, 2016).
O desenvolvido em linguagem JAVA e devido a máquina virtual JVM, 
essa ferramenta pode ser executada em qualquer sistema operacional, 
oferecendo ferramentas de primeira classe para o desenvolvimento de 
aplicativos para web, desktop e dispositivos móveis, além de ambiente 
corporativo utilizando recursos mais robustos como EJB (Enterprise Java 
Beans – um container do lado do servidor que permite conectividade 
com sistemas de grande porte), JAVA EE (Enterprise Edition – para 
criação de aplicações para ambiente corporativo) e JAVAFX (plataforma 
para software multimídia a serem executados em diferentes dispositivos 
como aparelho de TV, Blu-ray player e console de videogame). 
38
Figura 8 – Diagrama de classes utilizando Netbeans IDE
Fonte: elaborada pelo autor.
O acesso a versão completa da ferramenta pode ser feito através do 
site oficial da Apache Software Foundation que a disponibiliza para 
download.
1.6 Eclipse
Assim como o NetBeans, o Eclipse é uma IDE opensource, 
multiplataforma, que permite a criação de códigos fontes para 
diferentes linguagens de programação. Além disso, também, é possível 
criar diagramas da UML através da instalação de um plug-in específico. 
Ele apresenta uma estrutura de interface limpa e organizada através 
de várias janelas diferentes com um elevado grau de customização. 
Além disso, permite trabalhar com pré-visualizações do projeto em 
desenvolvimento, para que possa ver como a aplicação será vista sem a 
necessidade compilar (BERTAGNOLLI; FRANCO; MACHADO, 2016).
39
Figura 9 – Diagrama de classes utilizando Eclipse IDE
Fonte: elaborada pelo autor.
Por fim, sua versão completa está disponível para download no site 
oficial da empresa Eclipse Foundation.
Referências Bibliográficas
BERTAGNOLLI, S. C.; FRANCO, M. H. I.; MACHADO, R. P. Desenvolvimento de 
software III: programação de sistemas Web orientada a objetos em Java. Porto 
Alegre: Bookman, 2016.
FABRIS, P. P. G.; PERINI, L. C. Processos de software. Londrina: Editora e 
Distribuidora Educacional S.A., 2014.
HUMBLE, J.; FARLEY, D. Entrega contínua: somo entregar software de maneira 
rápida e confiável. Porto Alegre: Bookman, 2013.
SOMMERVILLE, I. Engenharia de software. 10. ed. São Paulo: Pearson Education do 
Brasil, 2018.
PRESSMAN, R. S. Engenharia de software: uma abordagem profissional. 8. ed. 
Porto Alegre: AMGH, 2016.
OKUYAMA, F. Y.; GONSALES, A. D.; MILETTO, E. M. Desenvolvimento de software I: 
conceitos básicos. Porto Alegre: Bookman, 2014.
WERLICH, C. Modelagem de dados. Londrina: Editora e Distribuidora Educacional 
S.A., 2018.
40
Ferramentas CASE para 
gerenciamento de projeto de 
desenvolvimento de software
Autoria: André Olímpio
Leitura crítica: Marcilyanne Gois
Objetivos
• Identificar os diferentes tipos de ferramentas 
existentes no mercado atual para modelagem de 
softwares.
• Entender o conceito gerenciamento de projetos de 
desenvolvimento de sistema de software e aplicá-lo 
através de ferramentas específicas.
• Modelar um projeto de desenvolvimento de sistema 
de software.
• Entender o funcionamento das seguintes 
ferramentas CASE: Microsoft Visual Studio Team 
System, Github e Redmine.
41
1. Ferramentas CASE para gerenciamento de 
projeto de desenvolvimento de software
A gestão de projetos é um conjunto de práticas, métodos e ferramentas 
que possibilitam a organização de tarefas, identificando a sequência de 
execução e as dependências existentes entre essas tarefas, apoiando 
a alocação de recursos e tempo, além de permitir o rastreamento da 
execução das atividades e medição do progresso relativo ao que foi 
definido no plano de projeto (PÁDUA FILHO, 2019, p. 83).
Segundo Humble e Farley (2013), uma quantidade significativa 
das atividades atuais é orientada às equipes e envolve múltiplas 
organizações, sendo essas características determinantes de tarefas 
futuras no ambiente de projeto. Assim, lidar com equipes e com 
ambiente corporativo diverso, visando desenvolvimento de sistemas 
de software, requer habilidades que combinam arte e ciência, sempre 
visando cumprir com todas as especificações definidas na etapa inicial 
do projeto.
Nesse sentido, é possível afirmar que, segundo Humble e Farley 
(2013), existem três pilares nos quais a gestão de projetos se apoia e é 
embasada:
• Ter foco em requisitos e na satisfação do cliente.
• Fazer com que a equipe de desenvolvimento trabalhe de forma 
produtiva e colaborativa.
• Administrar os recursos de tempo, humanos e financeiros do 
projeto.
A gestão de projetos de software compreende na necessidade 
de gerenciar atividades que visam assegurar que o sistema a ser 
desenvolvido seja entregue cumprindo o prazo pré-determinado e, 
42
também, que esteja de acordo com os requisitos definidos pelo cliente. 
Essa necessidade se deve ao fato de que o processo de desenvolvimento 
esteja sempre sujeito às restrições de qualidade, tempo e orçamento. 
Além disso, segundo Sommerville (2018), devido à natureza flexível de 
um software e a tendência de mudanças, uma boa prática é adotar um 
processo padronizado para administrar toda a ampla arquitetura e a 
implementação das funcionalidades do sistema, com a finalidade de que 
ambas sejam adequadamente tratadas.
Neste cenário, as ferramentas CASE são apontadas como componentes 
essenciais para auxiliar os profissionais de Tecnologia da Informação a 
realizarem o trabalho de administração e implementação do software.
Atualmente, há várias ferramentas que podem ser utilizadas na gestão 
de projetos de software, que focam no gerenciamento em si, controle 
de versões das funcionalidades e implementações, administração 
de processo de testes, monitoramento das tarefas realizadas pelos 
integrantes da equipe de desenvolvimento e garantia da qualidade das 
atividades realizadas em cada etapa existente no processo (HIRAMA, 
2011).
1.1 GitHub
O GitHub (2008) é uma plataforma de hospedagem de códigos 
com controle de versão usando o Git (2005), ou seja, sistema distribuído 
de controle de versões que permite que os dados fiquem armazenados 
em repositórios que apresentam um histórico completo de todas as 
revisões e alterações feitas em um arquivo. Logo, ele é amplamente 
utilizado por programadores para divulgação de seus trabalhos ou 
para que outros usuários contribuam com o projeto, além de facilitar a 
comunicação através de recursos disponibilizados pela arquitetura.
Assim, o repositório é criado on-line e permite que o desenvolvedor 
compartilhe da maneira que achar mais conveniente. Neste repositório 
43
é possível criar ramificações (branch) de partes menores do código-
fonte do projeto, reagrupar (merges) as ramificações após a realização 
das alterações necessárias, criar cópias (clones) para download e 
serem utilizadas em diferentes estações de trabalho, fazer atualização 
local (pull), enviar as alterações realizadas local para o servidor web 
(push) e também fazer um clone (fork) no próprio ambiente web. 
Logo, essa estrutura foi construída com a finalidade de permitir que 
sejam realizadas alterações no código-fonte de um software de forma 
simultânea por diferentes programadores, eliminando totalmente a 
possibilidade de conflitos ouredundâncias (GIT HOW TO, 2019).
Quadro 1 – Comandos do Git
Comandos Descrição
git branch nome_branch Criar branch.
git merge nome_branch Reagrupar branch. 
git pull Atualizar uma aplicação 
localmente.
git push Enviar versões atualizadas 
para o servidor web.
git clone local_origem:local_
destino
Criar clone de um 
repositório.
Fonte: elaborado pelo autor.
A Figura 1 ilustra um repositório hospedado on-line no GitHub (2008).
44
Figura 1–Tela do site do GitHub.com
Fonte: elaborada pelo autor.
Uma ferramenta CASE bastante utilizada para se trabalhar localmente 
com repositórios disponibilizados on-line é o GitHub Desktop (2010), 
que é uma extensão do serviço web, permitindo aos desenvolvedores 
trabalhar com clones em suas máquinas e, posteriormente, fazendo 
o upload, atualizando o projeto, de forma colaborativa, já que 
é possível que vários profissionais trabalhem ao mesmo tempo 
no desenvolvimento de software, sem a necessidade de estarem 
fisicamente no mesmo ambiente, ou seja, de forma remota.
A tela inicial do GitHub Desktop mostra todos os repositórios existentes 
localmente na máquina, além de visualizar todos os arquivos que foram 
modificados, a fim de que eles possam ser enviados para o repositório 
master presente do servidor web, conforme a Figura 2.
45
Figura 2 -Tela inicial do GitHub Desktop
Fonte: elaborada pelo autor.
A Figura 3, por sua vez, mostra o histórico de mudanças feitas no 
repositório desde a clonagem, permitindo ao desenvolvedor identificar 
e visualizar detalhadamente as ações realizadas e o estado do arquivo a 
partir de cada uma das alterações.
Figura 3–Tela de histórico de versões do GitHub Desktop
Fonte: elaborada pelo autor.
46
A Figura 4 ilustra todos os repositórios hospedados no servidor web do 
GitHub da conta a qual a ferramenta está vinculada e que podem ser 
selecionados para que sejam clonados na máquina local.
Figura 4–Tela de clonagem de repositórios do GitHub Desktop
Fonte: elaborada pelo autor.
O GitHub Desktop é uma ferramenta poderosa e muito eficiente para o 
controle de versionamento de um software, além da administração do 
trabalho colaborativo dos profissionais envolvidos no desenvolvimento 
do sistema.
1.2 Visual Studio Team System (VSTS)
Conhecido como Azure DevOps (2005), Visual Studio Team System é 
uma ferramenta CASE robusta utilizada no gerenciamento do ciclo 
de vida de aplicativos (ALM) e projetos de software. Administrado 
47
pela Microsoft, ele permite o controle de versão de código-
fonte com portabilidade à serviços do GitHub, elaboração de 
relatórios, gerenciamento de requisitos, estruturação automatizada de 
código, administração de recursos de testes, além de fazer controle de 
tarefas e canais de estruturas de pipeline de dados. O VSTS abrange 
todo o ciclo de vida de um software, habilitando recursos do DevOps 
e pipeline de dados, que no Azure são utilizados como back-end para 
diversos ambientes de desenvolvimento integrado (IDE).
O termo DevOps pode ser definido como um conjunto de práticas que 
combina o desenvolvimento de software (Dev) com operações realizadas 
em um ambiente de tecnologia da informação (Ops), visando garantir 
a automação e monitoramento em todas as etapas da construção 
do software, fornecendo entregas contínuas de incrementos deste 
sistema com alto padrão de qualidade (FABRIS; PERINI, 2014).
O Azure DevOps é uma plataforma que disponibiliza serviços de 
gerenciamento de projetos voltados para tecnologia da informação 
em ambiente on-line. Esses serviços são chamados de WebApps, 
que são aplicativos semelhante aos que são instalados fisicamente 
em computadores desktop, notebooks ou dispositivos móveis, com 
a diferença de serem criados e entregues diretamente pela Web. De 
acordo com Pressman (2016), eles são leves, rápidos e bem confiáveis, 
além disso, têm a particularidade de funcionar em qualquer navegador.
O Azure DevOps cria uma estrutura na qual o projeto de software é 
administrado em todas suas etapas através de uma única interface, 
conforme mostra a Figura 5.
48
Figura 5 –Tela inicial do Microsoft Azure DevOps
Fonte: elaborada pelo autor.
O controle e monitoramento das tarefas existentes no projeto de 
desenvolvimento do software através de quadros (boards), permite criar um 
amplo panorama de cada uma dessas tarefas, conforme mostra a Figura 6.
Figura 6 –Tela de quadros (boards) do Microsoft Azure DevOps
Fonte: elaborada pelo autor.
49
A Figura 7, por sua vez, ilustra uma interface que permite vincular o 
projeto atual com um repositório hospedado no GitHub (2018), além de 
oferecer a possibilidade de se utilizar seus comandos principais como 
pull, merge, fork e push.
Figura 7–Tela de repositórios do Microsoft Azure DevOps
Fonte: elaborada pelo autor.
O termo Pipeline de dados são canais criados para garantir o fluxo de 
informações geradas a partir de entradas específicas nas quais os 
dados contidos serão devidamente processados e enviados para outro 
processo. O fluxo do pipeline é dividido em três etapas distintas: o data 
engineering, que é responsável por fazer a coleta dos dados, remover 
inconsistências e inseri-los no ambiente de armazenamento variado 
(data lake); o data preparation, que é um processo de refinamento 
e enriquecimento de dados, adicionando as regras de negócio 
para disponibilizar uma base consistente para o próximo fluxo; e o 
analytics, que é um processo onde são feitas as análises sobre todos os 
dados tratados na etapa anterior (NOGUEIRA, 2018).
50
Ao criar uma estrutura de pipeline de dados neste projeto, o Azure 
DevOps apresenta uma interface bastante clara e amigável para 
gerenciar as entradas e saídas existentes nesta estrutura, fornecendo 
inclusive a possibilidade de editar a mesma em ambientes de 
programação como o Visual Studio e o Eclipse.
Além disso, o Microsoft Azure possui uma estrutura de pipeline 
através de um serviço em nuvem, no qual permite criar e testar 
automaticamente projetos de código e disponibilizá-los para outros 
usuários. Assim, é possível fazer uma combinação entre os conceitos 
de integração contínua (CI – continuous integration) e entrega contínua 
(CD – continuous delivery) para testar e criar de forma constante e 
consistente o código-fonte, que podem ser escritos em diferentes 
linguagens de programação como Python, Java, C#, JavaScript e PHP.
Figura 8 –Tela de pipeline do Microsoft Azure DevOps
Fonte: elaborada pelo autor.
51
O Azure Boards faz um gerenciamento de projetos de software, 
fornecendo um conjunto robusto de recursos, incluindo o suporte 
nativo para métodos como Scrum e Kanban, além de estrutura gráfica 
personalizável e integração com relatórios. Logo, ele permite iniciar 
com rapidez e facilidade o rastreamento de histórias de usuários (user 
stories), gerenciamento de controle de itens de lista de pendências, 
tarefas, recursos e bugs associados ao projeto.
O Azure Repos é um conjunto de ferramentas de controle de versão 
utilizado para projetos de software de grande ou pequeno porte, que 
auxilia a rastrear as alterações feitas no código-fonte ao longo do 
tempo, através de uma funcionalidade que gera um relatório gráfico 
de todos os arquivos existentes no projeto. Assim, o controle de versão 
salva esse screenshot de forma permanente para que seja recuperado 
posteriormente, caso seja necessário.
O Azure Test Plans trata-se de um conjunto de componentes que 
permitem a realização de testes em um ambiente próprio, gerando 
resultados através de gráficos e relatórios de controle de código-fonte, 
com objetivo de gerar qualidade e permitir colaboração em todo o 
processo de desenvolvimento. 
1.3 Redmine
O EasyRedmine (2018), é uma ferramenta CASE para gerenciamento 
de projetos baseados em serviços web e correção de bugs. Apresenta 
módulos como calendário (schedule) para administração de 
cronogramas e gráficos de Gantt para ajudar na representação visual 
dos projetos e seus prazos de entrega (deadlines). Permite também o 
gerenciamentosimultâneo de múltiplos projetos.
O código-fonte do Redmine é escrito com base no framework Ruby 
on Rails, que é um conjunto de bibliotecas utilizadas para aumentar 
a velocidade e a facilidade de criação de websites orientados a banco 
52
de dados, ou seja, aplicações baseadas em estruturas pré-definidas 
com conectividade com a maioria dos bancos de dados existentes 
no mercado. Além disso, ele apresenta total integração com serviços 
disponibilizados no GitHub.
O Redmine é a combinação entre um novo design customizável e 
uma estrutura de plugins e recursos que tornam a gestão de projetos 
mais agradável, eficiente e produtiva, melhorando a comunicação e 
a experiência do usuário, além de proporcionar economia de tempo 
na obtenção de resultados. Essa ferramenta é extensível a plugins de 
recursos de métodos ágeis, de finanças e serviços de CRM (Customer 
Relationship Management), que são interfaces que permitem a gestão 
do relacionamento com o cliente (PÁDUA FILHO, 2019).
A Figura 9 mostra a interface inicial do EasyRedmine:
Figura 9 –Tela inicial do site EasyRedmine.com
Fonte: elaborada pelo autor.
Portanto, essa ferramenta é bastante robusta, oferecendo ao 
desenvolvedor uma visão ampla de todos as tarefas realizadas nas 
53
diferentes etapas do processo de desenvolvimento de um sistema de 
software. Segundo Humble e Farley (2013), um dos maiores desafios 
existentes na gestão de projetos é o monitoramento eficiente das 
tarefas realizadas e consequentemente seu controle de qualidade. O 
EasyRedmine consegue, através de uma única interface, listar dados 
importantes com relação a cada tarefa do processo, como os integrantes 
que a acessam e que são responsáveis, a progressão de execução em 
tempo real, a quantidade de tempo produtivo (billable time) e o status 
atual desta tarefa, conforme é ilustrado na figura a seguir:
Figura 10 –Tela de gerenciamento de tarefas (management task) do 
site EasyRedmine.com
Fonte: elaborada pelo autor.
O gerenciamento do cronograma, por sua vez, permite definir as datas 
de início e fim das tarefas existentes no processo, classificar cada uma 
destas tarefas em categorias específicas, definir no calendário o horário 
de execução e gerar lembretes, conforme é ilustrado na Figura 11, a 
seguir:
54
Figura 11 –Tela de cronograma (schedule) do site EasyRedmine.com
Fonte: elaborada pelo autor.
O desenvolvimento de um sistema de software é um projeto, é 
como tal, ele apresenta um grande número de variáveis que devem 
ser tratadas pelos profissionais de TI envolvidos neste processo. As 
ferramentas CASE servem para auxiliar estes profissionais a monitorar 
e controlar a execução de cada tarefa existente no projeto, afim de elas 
estejam de acordo com os requisitos previamente definidos e que as 
funcionalidades do sistema estejam de acordo com esses requisitos, 
atingindo todos os objetivos estipulados.
Referências Bibliográficas
FABRIS, P. P. G.; PERINI, L. C. Processos de Software. Londrina: Editora e 
Distribuidora Educacional S.A., 2014.
HIRAMA, K. Engenharia de software: qualidade e produtividade com tecnologia. 
Rio de Janeiro: Elsevier, 2011.
55
HUMBLE, J.; FARLEY, D. Entrega contínua: como entregar software de maneira 
rápida e confiável. Porto Alegre: Bookman, 2013.
NOGUEIRA, J. H. M. Engenharia de software: métodos orientados a objetos e ágeis. 
Fortaleza, CE: Amazon KDP, 2018.
SOMMERVILLE, I. Engenharia de software. 10. ed. São Paulo: Pearson Education do 
Brasil, 2018.
PÁDUA FILHO, W. P. Engenharia de software: projetos e processos. 4. ed. Rio de 
Janeiro: LTC, 2019. .
PRESSMAN, R. S. Engenharia de software: uma abordagem profissional. 8. ed. 
Porto Alegre: AMGH, 2016.
EasyRedmine: gerenciador on-line de projetos de software. Easy Software Ltd, 
2018. Disponível em: http://www.easyredmine.com. Acesso em: 5 maio 2020.
Git How to: Tutorial guiado de GIT. 2019. Disponível em: http://www.githowto.
com/pt-Br. Acesso em: 12 maio 2020.
GITHUB: Controle de versionamento de software. GitHub Inc., 2008. Disponível 
em: http://www.github.com. Acesso em: 3 maio 2020.
Visual Studio Team System: Gerenciador de projetos de software. Microsoft, 
2005. Disponível em: http://azure.microsoft.com. Acesso em: 3 maio 2020.
56
Ferramentas para automação de 
testes de software
Autoria: André Olímpio
Leitura crítica: Marcilyanne Gois
Objetivos
• Identificar os diferentes tipos de ferramentas 
existentes no mercado atual para modelagem de 
softwares.
• Entender o conceito gerenciamento de projetos de 
desenvolvimento de sistema de software e aplicá-lo 
através de ferramentas específicas.
• Compreender a estrutura do ciclo de liberação de 
um sistema de software.
• Entender o funcionamento das seguintes 
ferramentas CASE: Selenium IDE, Apache JMeter, 
Appium, Cucumber e Robotium.
57
1. Ciclo de liberação e automação de testes de 
software
O processo de efetuar testes em um sistema de software se refere à 
investigação de cada componente e sua funcionalidade existente, a fim 
de fornecer informações sobre qualidade, em relação ao contexto do 
qual esse software deve operar, tendo relação direta com os conceitos 
de verificação e validação.
Segundo Pressman (2016), testar um software é a ação de varrer o 
sistema no intuito de encontrar possíveis falhas e corrigi-las. Em geral, 
os testes devem ser realizados por profissionais ou por um grupo 
específico de usuários finais, devendo englobar as etapas do processo 
de desenvolvimento do software, envolvendo ações que vão desde o 
levantamento de requisitos até a execução dos testes.
Segundo Sommerville (2018), no gerenciamento de software os testes 
são necessários para verificação de que todos os requisitos foram 
implementados e se as necessidades do cliente foram devidamente 
atendidas. Por sua vez, esses testes podem apontar que alterações 
corretivas são necessárias de ser realizadas, propondo à equipe de 
desenvolvimento a atualização do código-fonte da aplicação. Após isso, o 
software estaria apto a ser entregue aos usuários do mesmo, conforme 
ilustra a figura a seguir:
58
Figura 1 – Representação das etapas finais do ciclo de 
desenvolvimento de software
Fonte: elaborada pelo autor.
A implementação é o momento no qual o código-fonte da aplicação 
é construído por meio de uma ou mais linguagens de programação. 
Em seguida, testes pontuais são realizados em todo este processo, 
como verificar se uma rotina está funcionando corretamente. Após 
a conclusão da implementação, testes mais robustos são realizados, 
principalmente no ponto de vista do usuário final da aplicação. E, por 
fim, o software é entregue para ser implantado no ambiente do usuário.
59
Durante a realização dos testes, as tarefas realizadas são focadas 
no cumprimento dos requisitos realizados nas funcionalidades do 
sistema. Após concluídos os testes, o software se encontra liberado 
para que possa ser instalado no ambiente do usuário. Essa liberação, 
também conhecida como release, é o momento de lançamento de uma 
nova versão oficial do produto de software. Cada vez que um produto 
de software é criado ou modificado, a equipe de desenvolvimento 
decide sobre como distribui-lo a seus usuários. O sistema é produzido, 
identificado e liberado sob uma versão de programa, que é a 
identificação que garante que este sistema seja diferente a qualquer 
outra versão anterior ou posterior.
Além disso, há um processo chamado controle de versionamento, 
que tem por característica principal fazer o gerenciamento de ações 
corretivas e de atualizações realizadas em um sistema de software. Por 
sua vez, essas ações são classificadas em duas categorias: corretiva e de 
agregação de novos recursos, sendo que cada tipo indica a nomenclatura 
utilizada para definir a versão do software (HUMBLE; FARLEY, 2013).
Mesmo após a realização dos testes, um software poderá sofrer 
alterações quando forem necessárias. As versões de testes são 
classificadas como alfa e beta, conforme o ambiente no qual estes são 
executados duranteo processo de desenvolvimento do sistema de 
software.
Durante a execução de teste de versão alfa, os desenvolvedores 
verificam o código-fonte construído, os componentes da interface 
com o usuário, conectividade com outros sistemas e banco de dados. 
O objetivo é fazer uma verificação completa do software em dois 
ambientes: front-end e back-end.
Já o teste beta é realizado por um grupo específico, que analisa o 
software através do ponto de vista do usuário final, com o objetivo de 
analisar as funcionalidades do sistema e cumprimento dos requisitos.
60
Além disso, há, ainda, outros tipos de testes que são realizados em um 
sistema de software, entre os quais destacam-se: funcional e gama. O 
teste funcional se refere às ações nas quais tem por objetivo identificar 
se a aplicação consegue atender plenamente os requisitos funcionais 
definidos no início do processo de desenvolvimento. Já o teste gama é 
uma verificação de uma aplicação considerada como mal testada em 
ambiente de desenvolvimento, cabendo ao usuário final realizar os 
devidos testes e oferecer feedback ao fabricante do software.
1. Selenium
O Selenium se trata de uma ferramenta CASE que apresenta um 
ambiente integrado de desenvolvimento para scripts de testes 
automatizados, que permite gravar, editar e depurar os testes para 
aplicações desenvolvidas para plataforma Web. Esse ambiente inclui 
o Selenium Core, que gera uma arquitetura para gravar e reproduzir 
os testes, reproduzindo situações reais nas quais os testes serão 
executados. Ele permite automatizar os testes de sistema, sendo que a 
ferramenta também simplifica os testes de regressão, já que a qualquer 
momento pode-se realizar um mesmo teste nas novas versões do 
sistema.
O Selenium (2004) apresenta uma interface gráfica bastante simplificada 
e de fácil entendimento pelo usuário, que permite a escrita de scripts de 
maneira gráfica com apenas um clique do mouse sobre o elemento e 
adicionar o evento. Originalmente, o script é gerado em HTML, podendo 
ser exportado para linguagens como C#, PHP e Java. Veja na figura a 
seguir a interface do Selenium:
61
Figura 2 – Interface do Selenium IDE
Fonte: elaborada pelo autor.
Essa ferramenta apresenta três versões distintas: Selenium WebDriver, 
Selenium IDE e Selenium Grid.
Com o WebDriver é possível criar suítes de testes para automação de 
regressão robustos e baseados em navegador, dimensionar e distribuir 
scripts em aplicações web, criar uma coleção de ligações específicas do 
idioma para acionar um navegador do jeito que deve ser dirigido. Essa 
versão é indicada para testes mais elaborados e para usuários que sejam 
familiarizados com a ferramenta.
O Selenium IDE é utilizado para criar scripts para reprodução de erros, 
ajudar em testes exploratórios auxiliados pela automação de recursos 
e fazer testes básicos, permitindo exportar os scripts e editá-los 
62
posteriormente para se realizar testes mais elaborados. Ele apresenta 
também um complemento para os navegadores Google Chrome (2008) 
e Mozilla Firefox (2004), que fará a gravação e reprodução simples de 
interações com o navegador.
O Selenium Grid, por fim, permite distribuir e executar testes em várias 
máquinas, além de gerenciar vários ambientes a partir de um ponto central, 
facilitando a execução de testes em uma vasta combinação de navegadores 
e sistemas operacionais.
1.1 Apache JMeter
Apache JMeter é uma ferramenta CASE que realiza testes de carga e de 
estresse em recursos estáticos ou dinâmicos existentes em um sistema 
de software. O JMeter (1999) é desenvolvido pela empresa Apache e faz 
parte do projeto Jakarta, que é um “guarda-chuva” para diversas aplicações 
criadas em linguagem Java.
Segundo a Apache Foundation, empresa fabricante da ferramenta, ele 
foi originalmente projetado para realizar testes em aplicações voltadas 
para ambiente Web, mas desde então passou a cobrir diversas outras 
tecnologias de software cliente/servidor, como conexões de bancos de 
dados JDBC (Java DataBase Connectivity), serviços de mensagens JMS (Java 
Message Service) e serviços de diretórios LDAP (Lightweight Directory Access 
Protocol).
Para a realização de testes, o JMeter disponibiliza diversos tipos 
de requisições e seus respectivos resultados. Além de apresentar 
controladores lógicos, como ciclos e controles condicionais que são 
utilizados na construção de planos de testes funcionais. Ele disponibiliza, 
também, um controle de threads (processos de um sistema operacional 
que é dividido em duas ou mais partes que são executadas paralelamente) 
para configurar a quantidade de vezes que cada thread será executado 
63
e o intervalo entre cada execução. Essa configuração é muito utilizada na 
realização de testes de estresse.
Os componentes no JMeter são recursos que podem ser utilizados para 
criar rotinas de testes para aplicações e de performance. Segundo Fabris 
e Perini (2014), testar a performance de um software objetiva encontrar 
o limite de processamento de dados no melhor desempenho deste 
sistema. Neste teste, portanto, é avaliada a capacidade de resposta em 
determinados cenários e configurações, sendo uma ferramenta opensource 
que permite desenvolver melhorias e customizações para atender melhor 
o projeto a ser testado, como criar plug-ins para gerar relatórios, além 
daqueles que a ferramenta já oferece. Além disso, ele oferece um processo 
de instalação bem simples, podendo ser configurado para qualquer sistema 
operacional. Por ser desenvolvido em linguagem Java, o JMeter requer que 
o JRE (Java Runtime Environment) para ser executado.
A interface com o usuário é bastante simples, intuitiva e disponibilizada em 
diferentes idiomas, inclusive em português. A figura a seguir demonstra 
está interface:
64
Figura 3 – Interface do Apache JMeter
Fonte: elaborada pelo autor.
Mesmo sendo gratuito, o JMeter apresenta muitos recursos para efetuar 
testes completos em projetos de software, como:
• Componentes que auxiliam na gestão dos scripts de teste e no 
controle de cenários aplicados, facilitando sua manutenção.
• Componentes para configurações de ambientes de testes para 
execução em servidores e em outros terminais.
• Componentes para auxiliar nas avaliações das respostas recebidas 
para as requisições enviadas aos servidores.
Além disso, essa ferramenta apresenta também controles de gravação 
de scripts que ajudam a economizar tempo no desenvolvimento do 
projeto de software; componentes para extrair a expressão regular 
que auxilia a coleta de dados dos resultados retornados para realizar 
65
validações durante o processo de testes; variáveis de script de teste 
para deixar o teste o mais próximo do cenário real onde o sistema será 
implantado; objetos para criar e executar testes funcionais e em banco 
de dados.
1.2 Appium
É uma ferramenta CASE opensource utilizada para executar scripts de 
automação e testar aplicativos nativos, aplicações Web para dispositivos 
móveis e sistemas híbridos para sistemas operacionais Android (2008) 
ou Apple iOS (2007) utilizando drivers de conectividade em ambiente 
web.
O Appium (2011) é uma multiplataforma que permite escrever testes 
em diferentes sistemas operacionais utilizando a mesma API (Application 
Programming Interface), uma rotina que permite conectividade do 
software com diferentes tecnologias. Essa característica garante a 
reutilização de código entre os testes realizados nestas plataformas.
Além disso, ele apresenta uma interface simples, visualizando a 
estrutura de comandos de prompt (estilo MS-DOS e Linux), na qual 
permite a criação de um servidor (local ou remoto) no qual serão 
executados os planos de testes, que poderão ser compartilhados em um 
ambiente de rede, distribuindo os resultados em máquinas diferentes. A 
Figura 4 ilustra a interface do Appium:
66
Figura 4 – Interface do Appium
Fonte: elaborada pelo autor.
Essa ferramenta, por sua vez, foi projetada para atender às necessidades 
de automação mobile, fazendo testes de