Modelo de Maturidade de Software

Prévia do material em texto

MODELO DE MATURIDADE DE SOFTWARE 1 
Apresentação ................................................................................................................................ 6 
Aula 1: Problemas no desenvolvimento de software ................................................................... 8 
 ............................................................................................................................. 8 Introdução
 ................................................................................................................................ 9 Conteúdo
Hardware ou software? .................................................................................................... 9 
O contexto do desenvolvimento de software ............................................................. 9 
Problemas persistentes ................................................................................................... 10 
Crise do software ............................................................................................................. 12 
Características do software ........................................................................................... 13 
Mitos do software ............................................................................................................ 15 
Atividade proposta .......................................................................................................... 17 
........................................................................................................................... 17 Referências
 ......................................................................................................... 17 Exercícios de fixação
Chaves de resposta ..................................................................................................................... 20 
 ..................................................................................................................................... 20 Aula 1
Exercícios de fixação ....................................................................................................... 20 
Aula 2: Introdução à engenharia de software ............................................................................. 23 
 ........................................................................................................................... 23 Introdução
 .............................................................................................................................. 24 Conteúdo
Software ............................................................................................................................. 24 
Software: arte ou engenharia? ...................................................................................... 24 
Definição de software ..................................................................................................... 25 
Evolução do software ...................................................................................................... 25 
Classificação do software ............................................................................................... 27 
Definição de engenharia de software .......................................................................... 28 
Objetivo e características da engenharia de software ............................................. 30 
Fatores que afetam a prática da Engenharia de software ....................................... 30 
Tecnologia em camadas ................................................................................................ 31 
Atividade proposta .......................................................................................................... 32 
........................................................................................................................... 32 Referências
 ......................................................................................................... 32 Exercícios de fixação
Chaves de resposta ..................................................................................................................... 36 
 ..................................................................................................................................... 36 Aula 2
 
 MODELO DE MATURIDADE DE SOFTWARE 2 
Exercícios de fixação ....................................................................................................... 36 
Aula 3: Modelos de ciclo de vida de software ............................................................................ 39 
 ........................................................................................................................... 39 Introdução
 .............................................................................................................................. 40 Conteúdo
Ciclo de vida de software ............................................................................................... 40 
Principais modelos de ciclo de vida de software ...................................................... 41 
Modelo cascata ................................................................................................................ 41 
Modelo V ........................................................................................................................... 42 
Modelo incremental ........................................................................................................ 43 
Modelo evolutivo ............................................................................................................. 44 
Modelo iterativo e incremental ..................................................................................... 45 
Modelos de ciclo de vida mais utilizados .................................................................... 45 
Modelos de ciclo de vida mais utilizados .................................................................... 45 
Prototipação ..................................................................................................................... 46 
Modelo espiral .................................................................................................................. 47 
Rational Unified Process (RUP) ...................................................................................... 47 
Atividade proposta .......................................................................................................... 49 
........................................................................................................................... 49 Referências
 ......................................................................................................... 50 Exercícios de fixação
Chaves de resposta ..................................................................................................................... 54 
 ..................................................................................................................................... 54 Aula 3
Exercícios de fixação ....................................................................................................... 54 
Aula 4: Processo de desenvolvimento de software .................................................................... 56 
 ........................................................................................................................... 56 Introdução
 .............................................................................................................................. 57 Conteúdo
Fundamentos da medição de software ....................................................................... 57 
Medição e modelos/normas de qualidade de um software .................................... 57 
ISO e a tecnologia da informação ................................................................................59 
Princípios de gestão da qualidade ................................................................................ 61 
Visões da qualidade de software .................................................................................. 62 
Padrões de qualidade de software ............................................................................... 62 
ISO 9001:2000 e ISO 1207 ............................................................................................. 63 
ISO/IEC 12207: histórico ................................................................................................. 64 
Medição de software e melhorias em processos ...................................................... 65 
Atividade proposta .......................................................................................................... 65 
........................................................................................................................... 65 Referências
 
 MODELO DE MATURIDADE DE SOFTWARE 3 
 ......................................................................................................... 66 Exercícios de fixação
Chaves de resposta ..................................................................................................................... 69 
 ..................................................................................................................................... 69 Aula 4
Exercícios de fixação ....................................................................................................... 69 
Aula 5: Maturidade de software – Método GQM – Goal Question Metric ................................ 71 
 ........................................................................................................................... 71 Introdução
 .............................................................................................................................. 72 Conteúdo
Método GQM .................................................................................................................... 72 
Definição das métricas GQM ......................................................................................... 72 
Abordagem GQM ............................................................................................................. 74 
Objetivos da medição ..................................................................................................... 74 
Práticas eficazes de aplicação GQM ............................................................................ 75 
Benefícios do GQM .......................................................................................................... 76 
Implementação ................................................................................................................ 77 
Fase de planejamento ..................................................................................................... 77 
Etapas do GQM ................................................................................................................ 79 
Desvantagens do GQM ................................................................................................... 81 
Refinamento das metas .................................................................................................. 81 
Atividade proposta .......................................................................................................... 82 
........................................................................................................................... 82 Referências
 ......................................................................................................... 82 Exercícios de fixação
Chaves de resposta ..................................................................................................................... 86 
 ..................................................................................................................................... 86 Aula 5
Exercícios de fixação ....................................................................................................... 86 
Aula 6: Modelos de medição de software PSM e CMM.............................................................. 89 
 ........................................................................................................................... 89 Introdução
 .............................................................................................................................. 90 Conteúdo
PSM (Practical Software Measurement) ....................................................................... 90 
Utilização do PSM ............................................................................................................ 91 
Modelos do PSM ............................................................................................................... 91 
Modelo de informação ................................................................................................... 91 
Conjunto de medidas do PSM ....................................................................................... 92 
SW-CMM (Capability Maturity Model for Software) .................................................. 94 
CMMI .................................................................................................................................. 95 
Níveis de maturidade do SW-CMM .............................................................................. 96 
Atividade proposta ........................................................................................................ 102 
 
 MODELO DE MATURIDADE DE SOFTWARE 4 
......................................................................................................................... 103 Referências
 ....................................................................................................... 103 Exercícios de fixação
Chaves de resposta ................................................................................................................... 106 
 ................................................................................................................................... 106 Aula 6
Exercícios de fixação ..................................................................................................... 106 
Aula 7: Modelos de maturidade de processos de software CMMI e MP-BR ............................ 109 
 ......................................................................................................................... 109 Introdução
 ............................................................................................................................ 110 Conteúdo
Fundamentos do CMMI (Capability Maturity Model Integration) .......................... 110 
Qualidade – MPS.BR ...................................................................................................... 110 
CMMI ................................................................................................................................ 111 
CMMI-DEV ....................................................................................................................... 112 
Representação contínua .............................................................................................. 115 
Representação por estágios ........................................................................................ 116 
CMMI-DEV – representação por estágios ................................................................. 117 
Atividade proposta ........................................................................................................ 121 
.........................................................................................................................121 Referências
 ....................................................................................................... 121 Exercícios de fixação
Chaves de resposta ................................................................................................................... 126 
 ................................................................................................................................... 126 Aula 7
Exercícios de fixação ..................................................................................................... 126 
Aula 8: ISSO/IEC – Qualidade de software ................................................................................ 129 
 ......................................................................................................................... 129 Introdução
 ............................................................................................................................ 130 Conteúdo
Fundamentos da Norma ISO/IEC 9126 ...................................................................... 130 
ISO/IEC 9126-1 - Modelo de qualidade ..................................................................... 130 
Métricas de qualidade interna e externa ................................................................... 131 
Medição do produto de software: ISO 9126–2.4 ..................................................... 131 
Medição do produto de software: seleção de métricas ......................................... 132 
Métricas de qualidade ................................................................................................... 136 
ISO/IEC 9126-4 - Métricas de qualidade em uso ..................................................... 138 
Qualidade no ciclo de vida do software .................................................................... 139 
Atividade proposta ........................................................................................................ 139 
......................................................................................................................... 139 Referências
 ....................................................................................................... 139 Exercícios de fixação
Chaves de resposta ................................................................................................................... 143 
 
 MODELO DE MATURIDADE DE SOFTWARE 5 
 ................................................................................................................................... 143 Aula 8
Exercícios de fixação ..................................................................................................... 143 
Conteudista ............................................................................................................................... 146 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 6 
 
No início da computação, o desenvolvimento de um software era realizado de 
forma improvisada, sem regras claras, processos sistemáticos ou metodologias 
bem definidas. Essa falta de padronização no desenvolvimento de softwares 
nos levou à uma série de problemas, como por exemplo, software sem 
documentação, dentre outros. 
 
Tivemos que repensar a forma de desenvolvimento de software e a 
necessidade de definirmos uma área na Computação responsável pela definição 
de técnicas e métodos apropriados para o desenvolvimento de software. À 
partir dessa necessidade surge a área de Engenharia de Software à qual define 
os modelos de ciclo de vida para o desenvolvimento de software, padrões, 
normas e modelos de maturidade, dentre outros. 
 
Assim sendo, é importante que os profissionais da área de Computação 
conheçam a Engenharia de Software e particularmente os Modelos de 
Maturidade de Software que fornecem informações para orientar as empresas 
em todo o processo de desenvolvimento de um software. Os modelos orientam 
na escolha dos melhores métodos e técnicas disponíveis, ajudam na formulação 
de uma estratégia de melhoria a longo prazo, direcionada aos objetivos do 
negócio e por avanços graduais nas práticas de seus processos. 
 
Objetivos: 
Esta disciplina tem como objetivos apresentar: 
 1. Os problemas existentes no desenvolvimento de software; 
 2. A área de Engenharia de Software; 
 
 MODELO DE MATURIDADE DE SOFTWARE 7 
 3. Ciclos de vida de desenvolvimento de Software; 
 4. Processos de desenvolvimento de Software; 
 5. Modelos de maturidade de software. 
 
 
 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 8 
Introdução 
Esta aula tem como tema central apresentar aos alunos as dificuldades 
relacionadas ao desenvolvimento de um software. É importante conhecer esses 
problemas para que, posteriormente, possamos entendê-los bem e saibamos 
como resolvê-los. No decorrer do curso, serão apresentadas as técnicas 
necessárias para que essas adversidades não ocorram e, assim, possamos 
desenvolver software seguindo as boas práticas utilizadas no mercado. 
 
Hoje em dia, ainda sofremos com os problemas decorrentes do 
desenvolvimento de software sem métodos ou técnicas bem definidos e bem 
estabelecidos. Devemos entender também que a criação de técnicas e métodos 
obedecia a um processo normal de desenvolvimento de uma área de 
conhecimento, na qual os seus fundamentos ainda estavam sendo 
estabelecidos. 
 
Muitas empresas (pequenas, médias e, principalmente, as grandes 
organizações) utilizam muitos sistemas antigos que são executados em seus 
sistemas computacionais. Estes sistemas são críticos para as organizações, 
tendo em vista que foram desenvolvidos no início da computação, quando as 
técnicas e métodos praticamente não existiam. Desta forma, é primordial que 
possamos entender bem os problemas ocorridos para que não sejam repetidos 
no desenvolvimento de novos sistemas. 
 
Objetivo: 
1. Apresentar o contexto do desenvolvimento de um software e os principais 
problemas existentes, além de conhecer o que foi a crise do software; 
2. Entender as características do software e seus mitos para que estes não 
sejam propagados. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 9 
Conteúdo 
Hardware ou software? 
Vamos começar a nossa aula com uma pergunta simples: qual é o elemento 
mais importante no desenvolvimento de um software: o hardware ou o 
software? 
 
Acredito que muitos tenham respondido o software; entretanto, essa não foi a 
resposta padrão durante muito tempo, contabilizando desde o início do 
desenvolvimento de sistemas. Por um longo período, o hardware era o 
componente principal, era o elemento essencial para o qual todas as atenções 
estavam voltadas. 
 
Porém, esse cenário mudou e, agora, vamos entender bem como isso ocorreu e 
por que ocorreu, estudando o contexto do desenvolvimento de um software e 
os problemas que geraram a crise deste elemento. 
 
O contexto do desenvolvimento de software 
No início da computação, o elemento-chave era o hardware. Havia uma 
preocupação muito grande com o projeto e o uso deste componente. Naquela 
época, o hardware era muito caro e, por isso, o armazenamento nos 
dispositivos de memória secundária deveriam ser muito bem pensados e 
medidos. Foi nessa época que o termo “escovar bits” foi cunhado, devido ao 
alto valor de armazenamento dos dados. Entretanto, no início dos anos 80, foi 
divulgado um importante artigo na Business Week Magazine falando sobre a 
importância do software, cujo título era: “Software: the new driving force”. 
 
A partir desse artigo, os pesquisadores começaram a perceber a importância do 
software para o desenvolvimento de sistemas. Outros artigos foram lançados 
como vertentes positivas à utilização do software, como: The ThirdWave 
(Toffler, A., 1980); Information Society (Naisbitt, J., 1982). Eletronic 
Community (Stoll, C., 1989). 
 
 MODELO DE MATURIDADE DE SOFTWARE 10 
Assim como as vertentes positivas, tivemos também as negativas ao uso do 
software: Resisting the Virtual Life (Brook, J.); The Future Does Not Compute 
(Talbot, S.). 
 
Dessa forma, o software ultrapassou o hardware como a chave do sucesso para 
muitos sistemas baseados em computador. Hoje, o principal desafio é melhorar 
a qualidade e reduzir o custo de soluções baseadas em computador, pois a 
economia de todos os países do mundo depende cada vez mais de software, 
visto que este componente serve de base para: modernas investigações 
científicas; resolução de problemas de engenharia; controlar sistemas de 
transporte, medicina, telecomunicações, etc. As pessoas aplicam software em 
praticamente tudo no dia a dia, como: no trabalho, no conforto, na segurança, 
no entretenimento, na comunicação, entre outros. 
 
Problemas persistentes 
Ainda existem alguns problemas no uso e desenvolvimento de software, como: 
 
Avanços de hardware que continuam a se intensificar, mas não existe 
capacidade de construção de software que possa usufruir desses avanços. 
 
Os engenheiros de software precisam trabalhar bastante para produzir software 
com alta confiabilidade e qualidade. 
 
Pouca habilidade de construção de novos programas e de construção rápida 
que atenda a todos os requisitos dos usuários. 
 
Pouca habilidade de manutenção devido a projetos ruins e ausência de 
recursos. 
 
A habilidade para construção de software é insuficiente para suprir a demanda 
por novas aplicações. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 11 
Sociedade dependente da construção de software totalmente confiável, o que 
pode causar verdadeiras catástrofes. 
 
Um dos grandes problemas ainda é a manutenção de software. As empresas 
gastam um valor muito alto para prestar assistência em seus sistemas, o que 
impacta nos custos de acordo com a etapa em que a alteração no software 
ocorrerá, conforme a figura: 
 
 
 
Percebemos que, depois que o software é entregue ao cliente final, qualquer 
tipo de alteração demanda um alto custo para sua manutenção. Precisamos 
analisar bem qualquer tipo de alteração no software para que as mudanças não 
tenham custos proibitivos. Quanto mais cedo uma alteração for realizada no 
desenvolvimento de um software, menor será o seu custo. 
 
Também possuímos uma fábrica de desenvolvimento de software em fase de 
envelhecimento, pois há milhares de aplicações de software críticas que se 
encontram em dramática necessidade de renovação. Existem muitas aplicações 
críticas, tais como: 
 
• Sistemas de informação escritos há 20 anos, em que a menor modificação 
pode fazer com que todo o sistema falhe; 
 
 MODELO DE MATURIDADE DE SOFTWARE 12 
• Aplicações de engenharia em projetos críticos que ninguém tem 
conhecimento detalhado sobre a estrutura interna de seus programas; 
 
• Sistemas embutidos que exibem comportamento estranho, mas que não 
podem ser tirados de operação porque não há nada para substituí-los. 
 
Um estudo realizado pelo governo dos Estados Unidos em relação ao software 
produzido constatou que: 
 
• 2 % funcionavam muito bem; 
• 3 % funcionariam com poucas correções; 
• 45 % entregues, mas nunca foram usados com sucesso; 
• 20 % usados, mas extremamente modificados ou abandonados; 
• 30 % pagos, mas nunca foram terminados e/ou entregues. 
 
Essa análise foi o primeiro indício que uma grave crise do software estaria por 
vir. 
 
Crise do software 
A crise do software refere-se aos seguintes problemas: 
 
As estimativas de prazo e de custo são frequentemente imprecisas, visto que: 
• Não se dedica tempo para coletar dados sobre o processo de 
desenvolvimento de software; 
 
• Os projetos de desenvolvimento de software normalmente são efetuados 
apenas com um vago indício das exigências do cliente. 
 
A quantidade e a produtividade de pessoas da área de software não têm 
acompanhado a demanda por seus serviços. 
 
 MODELO DE MATURIDADE DE SOFTWARE 13 
• Sem nenhuma indicação sólida de produtividade, não se pode avaliar com 
precisão a eficácia de novas ferramentas, métodos ou padrões e, até mesmo, 
formações de pessoas. 
 
A qualidade de software, às vezes, é menor que a adequada. 
 
• Apenas recentemente começaram a surgir conceitos quantitativos e 
qualitativos sólidos de garantia de qualidade do processo e do produto de 
software. 
 
O software existente é muito difícil de manter. 
 
• A tarefa de manutenção devora o orçamento destinado ao software; 
 
• A facilidade de manutenção normalmente não é enfatizada como um critério 
importante nos projetos. 
 
Características do software 
Nesta parte do curso, discutiremos as características e os mitos relacionados ao 
desenvolvimento do software, que possui algumas características que devem 
ser muito bem analisadas. São estas: 
 
1. O software é desenvolvido ou projetado por engenharia, não manufaturado 
no sentido clássico, como o hardware. 
 
• Em ambas atividades, a alta qualidade pode ser conseguida mediante um 
bom projeto e alta capacitação de pessoas; porém, com contextos 
diferenciados; 
 
• Os custos de software são concentrados na engenharia; 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 14 
• No início de 1985, o conceito de software factory foi introduzido na literatura; 
porém, isto não implica que a manufatura de hardware e o desenvolvimento de 
software sejam equivalentes; 
 
• Fábricas de software recomendam o uso de ferramentas automatizadas e 
recursos humanos capacitados. 
 
2. Software não se “desgasta” com o uso, mas se deteriora. 
 
• Com o passar do tempo, o hardware se desgasta com os males ambientais, 
como poeira, vibração, temperatura, entre outros; 
 
• O software não é sensível a esses males ambientais; porém, durante sua vida, 
o software sofre manutenção, onde, frequentemente, são introduzidos novos 
defeitos, o que acaba deteriorando o produto. 
 
3. Curva de falha para o hardware 
 
• O gráfico mostra que muitas peças podem ser criadas com defeito 
(mortalidade infantil); porém, a maioria sofre desgastes com o passar do tempo 
e serão substituídas. 
 
4. Curva de falha para o software 
 
• A curva de falhas do software não deveria sofrer nenhum erro, pois ela não 
se desgasta com os males ambientais. Porém, ela sofre manutenção, o que 
pode introduzir falhas em seu código. 
 
5. A maioria dos produtos de software é feita sob encomenda ao invés de ser 
montada a partir de componentes existentes, que podem ser executáveis e não 
executáveis, como código e documentação, respectivamente. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 15 
• Hardware é projetado e desenvolvido com a reutilização de componentes; 
 
• Infelizmente, muitos desenvolvedores de software, na maioria das vezes, não 
desenvolvem dessa forma; 
 
• Devemos reparar um software da mesma forma que consertarmos um 
equipamento de hardware, trocando suas peças ou seus componentes. 
 
Mitos do software 
Muitas causas da atual aflição podem remeter-se à mitologia, que surgiu 
durante os primórdios do desenvolvimento de software. Esses mitos, que 
propagaram desinformação e confusão, são divididos em: administrativos ou de 
gerência e dos profissionais. Conheça-os: 
 
1. Mito administrativo I 
 
Já temos um livro repleto de padrões e procedimentos para a construção de 
softwares. Isso não oferecerá ao meu pessoal tudo o que eles precisam saber? 
Realidade: 
 
Seráque o manual é usado? 
 
Os profissionais sabem que ele existe? 
 
Ele reflete a prática moderna de desenvolvimento de software? 
 
Ele é completo? 
 
Está voltado para melhorar o prazo de entrega, mantendo o foco na qualidade? 
 
2. Mito administrativo II 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 16 
Meu pessoal tem ferramentas de desenvolvimento de software de última 
geração; afinal, compramos os mais novos computadores. 
 
Realidade: 
 
É preciso muito mais do que os mais recentes computadores para se fazer um 
desenvolvimento de software de alta qualidade. 
 
3. Mito do profissional I 
 
A única coisa a ser entregue em um projeto bem-sucedido é o programa 
funcionando. 
 
Realidade: 
 
O programa funcionando é só uma parte. Uma boa documentação incluindo 
requisitos, projeto das estruturas de dados, especificação de testes, análise de 
riscos, etc. é o alicerce para um projeto bem sucedido e serve como guia de 
manutenção. 
 
4. Mito do profissional II 
 
A engenharia de software nos fará criar documentação volumosa e 
desnecessária, que, certamente, nos atrasará. 
 
Realidade: 
 
A Engenharia de Software não se relaciona à criação de documentos, refere-se 
à criação de qualidade. 
 
Melhor qualidade leva à redução de retrabalho e menor retrabalho resulta em 
tempos de entrega mais rápidos. 
 
 MODELO DE MATURIDADE DE SOFTWARE 17 
Atividade proposta 
Discuta sobre os mitos relacionados ao desenvolvimento de software, 
abordando se alguns deles ainda são percebidos nos dias atuais nas 
organizações. 
 
Chave de resposta: Infelizmente, alguns dos mitos discutidos ainda são 
observados no mercado de trabalho, principalmente nas organizações que 
ainda não adotaram as práticas e métodos preconizados pela engenharia de 
software. 
 
 
Material complementar 
 
Para saber mais sobre a crise do software, leia o texto disponível 
em nossa biblioteca virtual. 
 
 
Referências 
PFLEEGER, Shari Lawrence. Engenharia de Software: Teoria e Prática. 2ª 
Edição. São Paulo: Pearson (Livros Universitários), 2003. 
PRESSMAN, Roger S. Engenharia de Software: uma abordagem profissional. 
7ª Edição. São Paulo: MCGRAW-HILL BRASIL, 2011. 
SOMMERVILLE, Ian. Engenharia de Software. 9ª Edição. São Paulo: 
PEARSON (LIVROS UNIVERSITÁRIOS), 2011. 
 
Exercícios de fixação 
Questão 1 
Dentre as opções abaixo, assinale o principal elemento utilizado nos dias atuais 
para o desenvolvimento de um software? 
a) Hardware 
b) Memória 
c) Poder computacional 
 
 MODELO DE MATURIDADE DE SOFTWARE 18 
d) Software 
e) Legislação 
 
Questão 2 
Dentre as opções, assinale a que representa o principal desafio para as 
soluções baseadas em computador. 
a) Aumentar a produtividade e o custo. 
b) Reduzir o custo e a qualidade. 
c) Aumentar o custo e diminuir a produtividade. 
d) Reduzir o custo e a produtividade. 
e) Aumentar a qualidade e reduzir o custo. 
 
Questão 3 
Qual é a opção que representa um dos problemas que persistem no uso e 
desenvolvimento de softwares? 
a) Grande habilidade de manutenção dos sistemas. 
b) Sociedade dependente da construção de software confiável. 
c) Pouco trabalho para que os engenheiros de software construam sistemas 
confiáveis. 
d) Habilidade suficiente para atender a demanda de novos sistemas. 
e) Poucos avanços do hardware. 
 
Questão 4 
Sabemos que a manutenção de software é um dos grandes problemas que 
impactam nos custos de desenvolvimento. Assim sendo, qual etapa possui um 
impacto maior nos custos de manutenção? 
a) No contrato fechado com o cliente 
b) A definição 
c) Depois da entrega 
d) Na discussão inicial do software 
e) O desenvolvimento 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 19 
Questão 5 
Dentre as alternativas abaixo, assinale a que não se refere a um problema 
encontrado na crise do software. 
a) Baixa qualidade do software 
b) Difícil manutenção do software 
c) Quantidade e a produtividade das pessoas 
d) Alta qualidade do software 
e) Estimativas de prazo e custo imprecisas 
 
Questão 6 
De acordo com as características de um software, a sua alta qualidade pode ser 
conseguida com: 
a) Uma boa interação entre hardware e software 
b) Ferramentas de alta qualidade 
c) Prazos bem definidos 
d) Um bom projeto e alta capacitação de pessoas 
e) Ferramentas e bom projeto 
 
Questão 7 
A frase “software não se ‘desgasta’ com o uso, mas se deteriora” significa que: 
a) O software não sofre mudanças. 
b) As mudanças não são percebidas. 
c) O software sofre manutenção, o que pode gerar defeitos. 
d) São poucas as mudanças sofridas. 
e) Muda de acordo com o defeitos do hardware. 
 
Questão 8 
Dentre as alternativas abaixo, todas são componentes de software, exceto: 
a) Manual de operação 
b) Ferramentas de desenvolvimento 
c) Instruções de programas 
d) Documentos de desenvolvimento 
 
 MODELO DE MATURIDADE DE SOFTWARE 20 
e) Atas de reunião 
 
Questão 9 
Dentre as opções abaixo, assinale a que representa um mito administrativo. 
a) Possuímos um livro completo de padrões, e isso é suficiente. 
b) Precisamos somente de ótimos programadores. 
c) O foco é somente produzir código rápido. 
d) Gerar documentação atrasa o desenvolvimento. 
e) Devemos entregar somente o programa funcionando. 
 
Questão 10 
Dentre as opções abaixo, assinale a que representa um mito profissional. 
a) Precisamos de boas ferramentas. 
b) Precisamos somente de ótimos computadores. 
c) O foco é somente em hardware. 
d) Possuímos um livro completo de padrões, e isso é suficiente. 
e) Devemos entregar somente o código funcionando. 
 
Aula 1 
Exercícios de fixação 
Questão 1 - D 
Justificativa: Os pesquisadores perceberam que o software é mais importante 
do que o hardware, pois é o software que será gerado no desenvolvimento de 
um sistema para utilizar os recursos disponíveis em um hardware. 
 
Questão 2 - E 
Justificativa: Segundo a aula apresentada, atualmente, o principal desafio é 
melhorar a qualidade do produto de software e diminuir os custos necessários 
para o seu desenvolvimento. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 21 
Questão 3 - B 
Justificativa: A sociedade depende, cada vez mais, da construção de softwares 
que sejam confiáveis, pois, de outra forma, poderemos ter grandes catástrofes. 
 
Questão 4 - C 
Justificativa: Depois que o software é entregue ao cliente final, qualquer tipo de 
alteração demanda uma modificação no projeto que está pronto. Todas as 
mudanças devem ser muito bem analisadas. Quanto mais cedo uma alteração 
for realizada, menor será o impacto nos custos do software; quanto mais tarde 
a mudança, maior será o custo. 
 
Questão 5 - D 
Justificativa: A crise do software refere-se a um conjunto de problemas, como a 
qualidade do software, produtividade, problemas na manutenção e em relação 
a prazos e custos. Um dos problemas era a baixa qualidade do software, e não 
a sua alta qualidade. 
 
Questão 6 - D 
Justificativa: Precisamos investir na formação de recursos humanos e ter um 
bom projeto. Somente boas ferramentas não garantem um software de 
qualidade. 
 
Questão 7 - C 
Justificativa: O software sempre terá modificações, que, possivelmente, 
introduzirão novos defeitos. 
 
Questão 8 - B 
Justificativa: Todo e qualquer documento é um componente de software, bem 
como os códigos gerados pelo seu desenvolvimento. 
 
 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 22 
Questão 9 - A 
Justificativa: De acordo com o texto, somente o primeiro item representaum 
mito administrativo. 
 
Questão 10 - E 
Justificativa: De acordo com o texto, somente o último item representa um mito 
administrativo. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 23 
Introdução 
Esta aula tem como tema central apresentar uma das principais áreas da 
Computação, a área da Engenharia de Software. Esta é uma área recente que 
deve ser utilizada para o desenvolvimento, operação e manutenção de 
software. 
 
Entender a Engenharia de Software é essencial para um bom desenvolvimento 
de software, pois o desenvolvimento de software ao longo dos anos, durante 
muito tempo, foi realizado sem a utilização de técnicas, métodos, metodologias 
ou de processos bem definidos. 
 
Muitos problemas surgiram devido a essa falta de padrões no desenvolvimento. 
Problemas esses que ainda impactam nos orçamentos das Organizações, os 
quais foram amplamente discutidos na aula anterior. 
 
Objetivo: 
1. Conhecer a definição de software, a sua evolução e classificação; 
2. Estudar a definição da Engenharia de Software, seus objetivos e 
características e entender o seu uso como uma tecnologia em camadas. 
 
 
 
 
 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 24 
Conteúdo 
Software 
Vamos começar a nossa aula com uma pergunta simples: a Engenharia de 
Software é uma engenharia ou uma arte? 
 
Certamente muitos responderam que é uma engenharia, tão somente. Mas 
vamos tentar entender como a relação engenharia e arte funciona bem para a 
Engenharia de Software. 
 
Software: arte ou engenharia? 
Com o passar do tempo foram desenvolvidas técnicas e métodos para a 
programação, análise e projeto de software. Essas técnicas foram amplamente 
testadas e incorporadas nas organizações, tornando-se as melhores práticas em 
computação nos dias atuais. Mas hoje uma questão importante é se 
desenvolvemos software utilizando somente as técnicas disponíveis ou se 
precisamos também envolver a arte no desenvolvimento. Vamos entender 
melhor o que precisamos saber para desenvolver software. 
 
Cientistas de computação e pesquisadores em engenharia de software estudam 
sistemas computacionais e teorias sobre como tornar o software mais produtivo 
e eficientes. Isso é a Engenharia no desenvolvimento. E eles também projetam 
sistemas computacionais e escrevem programas para realizar tarefas nesses 
sistemas. O que é uma arte no desenvolvimento de software. 
 
Então desenvolver software é uma engenharia e uma arte também. Para 
desenvolver software precisamos conhecer as funções do computador e as 
teorias, as quais estão descritas nos fundamentos da ciência da computação. 
Precisamos também conhecer o problema, as necessidades dos clientes e as 
técnicas e ferramentas da Engenharia de Software. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 25 
Definição de software 
Um conceito muito importante que todos devem saber é o de software, o que é 
realmente um software e quais são os seus componentes. Um Software é 
composto das seguintes partes: 
 
Software 
Instruções: são os programas de computador que quando executadas 
produzem a função e o desempenho desejados; 
 
Estruturas de dados: possibilitam que os programas manipulem 
adequadamente os dados que estão sendo tratados; 
 
Documentos: os quais descrevem a operação e o uso dos programas. 
 
Portanto, software é muito mais do que somente instruções, do que somente 
código. Ele é composto por um elemento muito importante que são as 
documentações. Quando compramos um software devemos receber toda a 
documentação necessária sobre ele, como: nota fiscal, licença de uso, manual 
de operação, manual de instalação e configuração, dentre outros. 
 
Evolução do software 
Vamos entender agora como ocorreu a evolução do software desde o 
surgimento da computação, no final da década de 1940 e início da década de 
1950. A evolução do software está dividida em eras, que são: 
 
1950 a 1965 
A Primeira era do desenvolvimento de software 
• O desenvolvimento de software era considerado uma arte; 
• Haviam poucos métodos sistemáticos para o desenvolvimento; 
• O desenvolvimento de software não era gerenciado; 
• O hardware sofria contínuas mudanças e era o centro das atenções; 
 
 MODELO DE MATURIDADE DE SOFTWARE 26 
• O software era customizado, ou seja, adequado às necessidades do usuário 
final, e a sua distribuição era limitada; 
• O software era desenvolvido e utilizado pela mesma pessoa ou organização; 
• Não havia documentação, todas as informações necessárias sobre o software 
estavam na cabeça das pessoas que o desenvolveram (one’s head); 
• O processamento de dados era em lote (batch). 
 
1963 a 1974 
A segunda era do desenvolvimento de software 
• Surgimento da multiprogramação e dos sistemas multiusuários; 
• Desenvolvimento de técnicas interativas homem-máquina; 
• Utilização de sistemas de tempo real; 
• Surgimento da 1ª geração de sgbds; 
• Nascem as software houses e os produtos de software; 
• O software era produzido para ampla distribuição em um mercado 
multidisciplinar, em várias áreas de conhecimentos; 
• Surge o conceito de biblioteca de software; 
• Devido à falta de metodologias de desenvolvimento e de documentação, a 
manutenção era praticamente impossível. 
 
1973 a 1978 
A terceira era do desenvolvimento de software 
• Surgimento dos sistemas distribuídos e paralelos; 
• Desenvolvimento das redes locais e globais de computadores; 
• Necessidade de elevada demanda por acesso imediato a dados por parte dos 
usuários; 
• Criação dos computadores de uso pessoal (PC - personal computers) e 
estações de trabalho (workstations); 
• Uso generalizado de microprocessadores; 
• Começa a haver um grande consumo de computadores, o que 
consequentemente baixa o custo do hardware; 
 
 MODELO DE MATURIDADE DE SOFTWARE 27 
• Há um forte impacto de consumo, pois os computadores tornaram-se 
acessíveis a um grande público que antes não tinham acesso ao uso de 
computadores. 
 
1985 aos dias atuais 
A quarta era do desenvolvimento de software 
• Surgimento dos ambiente cliente-servidor; 
• Desenvolvimento do paradigma orientado a objetos, da linguagem de 
modelagem unificada (UML) e do processo unificado; 
• Surgimento dos sistemas multimídia e da realidade virtual; 
• Desenvolvimento dos sistemas especialistas e de software de inteligência 
artificial utilizados em sistema do mundo real; 
• Surgimento das técnicas de 4ª Geração (4GT); 
• Desenvolvimento da computação biológica e da computação vestível 
(wearable computers); 
• Surgimento da internet (information superhighway). 
 
Classificação do software 
Vamos entender agora quais são os diferentes tipos de software existentes e a 
sua classificação. O software está classificado nos seguintes tipos: 
 
Básico: é uma coleção de programas escritos para dar suporte a outros 
programas. Como por exemplo: compiladores, interpretadores, editores, 
componentes de sistemas operacionais, dentre outros. 
 
De Tempo Real: são programas que monitoram, analisam e controlam os 
eventos do mundo real quando eles ocorrem. Um sistema de tempo real precisa 
responder dentro de restrições de tempo especificadas. Há um limite máximo 
tolerável de resposta, de acordo com as especificações do software, como por 
exemplo: software de controle de usina nuclear, software de controle e 
navegação de satélites, dentre outros. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 28 
Comercial: é o software desenvolvido para o negócio de uma organização. É amaior área para a qual o software é desenvolvido. Divide, basicamente, em 
Sistemas Discretos, como: sistemas de estoque, de contabilidade, de 
pagamento, dentre outros. E em Sistemas de Informações, como: sistemas de 
processamento de transações, sistemas de informações gerenciais, sistemas de 
suporte à decisão, sistemas de comércio eletrônico, dentre outros. 
 
Científico e de Engenharia: são caracterizados por algoritmos que tratam 
dados numéricos. Como por exemplo: software para cálculo da dinâmica da 
órbita de um ônibus espacial, software para computação auxiliada por 
computador (computer aided design), software para simulação de sistemas, 
dentre outros. 
 
Embutido ou Embarcado: é um software que normalmente reside em 
memória não volátil (ROM) e é utilizado para o controle de produtos e de 
sistemas para os mercados consumidor e industrial. Como por exemplo: 
software para controle de micro-ondas, para computadores de bordo de 
automóveis, para sistemas de freio, dentre outros. 
 
Computador Pessoal: é o software utilizado nas atividades domésticas para 
soluções de problemas do dia a dia, como por exemplo: processadores de 
texto, planilhas eletrônicas, multimídia, jogos, dentre outros. 
 
Inteligência Artificial: é o software que faz uso de algoritmos não numéricos 
para resolver problemas complexos que não podem ser tratados de forma 
convencional. Como por exemplo: software de apoio ao diagnóstico de infarto 
agudo do miocárdio, software para concessão de cartão de créditos, dentre 
outros. 
 
Definição de engenharia de software 
Nesta parte da aula apresentaremos a área da Engenharia de Software, seus 
objetivos e características. Abordaremos também os fatores que afetam a 
 
 MODELO DE MATURIDADE DE SOFTWARE 29 
prática da Engenharia de Software e o seu uso como uma tecnologia em 
camadas. 
 
Como já foi discutido na aula anterior, no início da computação a preocupação 
era com o hardware e o software, nada mais era do que uma reflexão 
posterior. Entretanto, essa visão mudou e com ela gerentes e técnicos se fazem 
as seguintes perguntas: 
 
• Por que o software demora tanto tempo para ser concluído? 
• Por que os custos de produção têm sido tão elevados? 
• Por que não é possível detectar todos os erros antes que o software seja 
entregue ao cliente? 
• Por que é tão difícil medir o progresso durante o processo de 
desenvolvimento? 
 
A resposta para todas essas perguntas é: a não adoção de práticas de 
engenharia de software para o desenvolvimento de software, ou seja, 
devemos desenvolver software como uma engenharia, da mesma forma que 
utilizamos a engenharia civil para construir prédios ou utilizamos a engenharia 
aeronáutica para construir aviões. 
 
A Engenharia objetiva analisar, projetar, construir, verificar e gerenciar 
entidades técnicas e/ou sociais. Quando a entidade a ser construída com a 
engenharia é software, temos a Engenharia de Software. 
 
Então podemos definir Engenharia de Software como: o estabelecimento e uso 
de sólidos princípios de engenharia para que se possa obter economicamente 
um software que seja confiável e que funcione eficientemente em máquinas 
reais (PRESSMAN, 2006). 
 
Também podemos definir da seguinte forma: Engenharia de Software é a 
aplicação de uma abordagem sistemática, disciplinada e quantificável no 
 
 MODELO DE MATURIDADE DE SOFTWARE 30 
desenvolvimento, operação e manutenção de software (IEEE STANDARD 
610.12). 
 
Objetivo e características da engenharia de software 
A engenharia de Software tem como objetivo projetar e desenvolver software 
com maior qualidade em menos tempo e com o menor custo possível para 
resolver problemas de forma eficiente e eficaz. A qualidade envolve desenvolver 
softwares mais eficientes, mais precisos, fáceis de modificar, de usar ou de 
entender. Essas são características importantes que devem ser priorizadas em 
um software. 
 
A Engenharia de Software é uma disciplina de engenharia que está envolvida 
com todos os aspectos do desenvolvimento de produtos de software. Os 
produtos de software consistem de programas desenvolvidos, estruturas de 
dados e documentação associada. Essa engenharia não está voltada para a 
programação individual, mas para abordagens provendo mecanismos para que 
grupos possam lidar com complexidade e mudança na construção de um 
software. 
 
Fatores que afetam a prática da Engenharia de software 
A Engenharia de Software tem uma série de fatores que afetam a viabilidade de 
entrega de produtos de software. Os fatores são: 
 
• Necessidade de entregar produtos de software de acordo com as exigências 
do mercado. É o que é frequentemente referenciado como time to market; 
• Mudanças na economia que afetam a computação. Grandes alterações na 
economia que têm forte impacto na área de Tecnologia da Computação; 
• Maior disponibilidade de computadores de mesa potentes. 
Usuários têm computadores com ótimas configurações para atividades 
rotineiras; 
• Redes de telecomunicações extensíveis. 
Grande disponibilidade de infraestrutura de redes de computadores à todos; 
 
 MODELO DE MATURIDADE DE SOFTWARE 31 
• Disponibilidade e adoção de tecnologia orientada a objetos; 
• Necessidade de interfaces gráficas para os usuários; 
• Imprevisibilidade do modelo cascata para o desenvolvimento de software. 
 
Tecnologia em camadas 
A Engenharia de Software é uma tecnologia em Camadas. Para que um 
problema seja resolvido, a solução deve empregar um conjunto variado de 
métodos ou técnicas, ferramentas e processos utilizando um paradigma de 
desenvolvimento específico. É muito importante que no desenvolvimento de um 
software haja um compromisso organizacional com a qualidade, que leva ao 
desenvolvimento de abordagens cada vez mais amadurecidas para a 
Engenharia de Software. 
 
FERRAMENTAS 
• Automatizam o processo de desenvolvimento de software dando suporte aos 
métodos; 
• Elas são denominadas de ferramentas Case (Computer Aided Software 
Engineering – Engenharia de Software auxiliada por computador). Como por 
exemplo: editores, testadores, modeladores, gerenciadores; 
• Quando as ferramentas são integradas é estabelecido um sistema de suporte 
ao desenvolvimento de software chamado I-CASE (Integrated CASE). 
 
MÉTODOS 
• Os métodos de Engenharia de Software fornecem a técnica de como fazer 
para construir software; 
• Incluem um amplo conjunto de tarefas que abrange: análise de requisitos, 
projeto,construção de programas, teste e manutenção, dentre outros; 
• São constituídos por um conjunto de princípios básicos, que regem cada área 
da tecnologia e incluem atividades de modelagem a outras técnicas descritivas. 
 
PROCESSOS 
• Representa o fundamento, o principal elemento, da Engenharia de Software; 
 
 MODELO DE MATURIDADE DE SOFTWARE 32 
• O processo da Engenharia de Software é o “adesivo” que mantém unidas as 
camadas de tecnologia e permite o desenvolvimento racional e oportuno de 
software para o computador. 
 
Atividade proposta 
Faça uma comparação entre a Engenharia de Software e a Engenharia Civil, 
enfatizando a importância de cada uma destas engenharias para desenvolver 
um software e para construir um prédio. 
 
Chave de resposta: Ambas devem ser vistas como engenharias e necessárias 
para que todas as técnicas sejam utilizadas para construir um software de 
qualidade e para a construção de um prédio com segurança e qualidade. 
 
 
Material complementar 
 
Para saber mais sobre engenharia de software, leia os textos 
disponíveis em nossa biblioteca virtual. 
 
 
Referências 
PRESSMAN, Roger S. Engenhariade software – uma abordagem 
profissional. 7. ed. São Paulo: MCGRAW-HILL BRASIL, 2011. 
SOMMERVILLE, Ian. Engenharia de software. 9. ed. São Paulo: Pearson 
(livros universitários), 2011. 
PFLEEGER, Shari Lawrence. Engenharia de software – teoria e prática. 2. 
ed. São Paulo: Pearson (livros universitários), 2003. 
 
Exercícios de fixação 
Questão 1 
Fonte: Funiversa – 2009 – IPHAN 
 
 MODELO DE MATURIDADE DE SOFTWARE 33 
Assim como a Engenharia de Software, existe também na área de informática a 
Ciência da Computação. Assinale a alternativa que melhor apresenta a 
diferença entre Engenharia de Software e Ciência da Computação. 
a) A Ciência da Computação tem como objetivo o desenvolvimento de 
teorias e fundamentações. Já a Engenharia de Software se preocupa 
com as práticas de desenvolvimento de software. 
b) A Engenharia de Software trata da criação dos sistemas de computação 
(softwares) enquanto a Ciência da Computação está ligada ao 
desenvolvimento e criação de componentes de hardware. 
c) A Engenharia de Software trata dos sistemas com base em 
computadores, que inclui hardware e software, e a Ciência da 
Computação trata apenas dos aspectos de desenvolvimento de sistemas. 
d) A Ciência da Computação trata dos sistemas com base em 
computadores, que inclui hardware e software, e a Engenharia de 
Software trata apenas dos aspectos de desenvolvimento de sistemas. 
e) A Ciência da Computação destina-se ao estudo e solução para problemas 
genéricos das áreas de rede e banco de dados e a Engenharia de 
Software restringe - se ao desenvolvimento de sistemas. 
 
Questão 2 
Com base nos conceitos de Engenharia de Software e da Ciência da 
Computação, julgue a questão a seguir: A ciência da computação estuda os 
aspectos do desenvolvimento e da evolução de software; a engenharia de 
software estuda o uso de ferramentas e de codificação. 
a) Verdadeiro 
b) Falso 
 
Questão 3 
Dentre as alternativas a seguir, assinale a que representa os elementos que 
compõem um software: 
a) Dados, sistema e instruções. 
b) Instruções, estruturas de dados e sistema. 
 
 MODELO DE MATURIDADE DE SOFTWARE 34 
c) Documentos, dados e instruções. 
d) Estruturas de dados, documentos e instruções. 
e) Sistemas, documentos e instruções. 
 
Questão 4 
Dentre as alternativas abaixo, assinale a única que não representa um 
problema encontrado na primeira era de desenvolvimento de software: 
a) O desenvolvimento de software era considerado uma arte. 
b) O desenvolvimento de software não era gerenciado. 
c) Haviam poucos métodos sistemáticos para o desenvolvimento. 
d) Não havia documentação. 
e) Necessidade de elevada demanda por acesso imediato a dados. 
 
Questão 5 
É o software que faz uso de algoritmos não numéricos para resolver problemas 
complexos que não podem ser tratados de forma convencional. Estamos nos 
referindo ao software: 
a) Básico. 
b) De inteligência artificial. 
c) Embutido ou embarcado. 
d) De tempo real. 
e) Comercial. 
 
Questão 6 
Fonte: Cespe 2013 TRT 10ª Região – Analista Judiciário – Tecnologia da 
Informação 
Com relação a conceitos gerais de engenharia de software, julgue o item a 
seguir: A engenharia de software engloba processos, métodos e ferramentas. 
Um de seus focos é a produção de software de alta qualidade a custos 
adequados. 
a) Verdadeiro 
b) Falso 
 
 MODELO DE MATURIDADE DE SOFTWARE 35 
Questão 7 
Fonte: Cespe 2010 TRE-BA – Analista de Sistemas – Desenvolvimento de 
Sistemas 
Com relação à engenharia de software, julgue o item a seguir: Entre os 
desafios enfrentados pela engenharia de software estão lidar com sistemas 
legados, atender à crescente diversidade e atender às exigências quanto a 
prazos de entrega reduzidos. 
a) Verdadeiro 
b) Falso 
 
Questão 8 
Fonte: FGV 2010 Badesc – Analista de Sistemas – Desenvolvimento de Sistemas 
De acordo com Pressman, a engenharia de software é baseada em camadas, 
com foco na qualidade. Essas camadas são: 
a) Métodos, processo e teste. 
b) Ferramentas, métodos e processo. 
c) Métodos, construção, teste e implantação. 
d) Planejamento, modelagem, construção, validação e implantação. 
e) Comunicação, planejamento, modelagem, construção e implantação. 
 
Questão 9 
Fonte: FCC – 2010 – TRE-RS – Analista Judiciário – Analista de Sistemas 
Suporte 
Sobre a engenharia de software, considere: 
I. Atualmente todos os problemas na construção de software de alta qualidade 
no prazo e dentro do orçamento foram solucionados. 
II. Ao longo dos últimos 50 anos, o software evoluiu de um produto de 
indústria para um ferramental especializado em solução de problemas e análise 
de informações específicas. 
III. Todo projeto de software é iniciado por alguma necessidade do negócio. 
IV. O intuito da engenharia de software é fornecer uma estrutura para a 
construção de software com alta qualidade. 
 
 MODELO DE MATURIDADE DE SOFTWARE 36 
Está correto o que consta em: 
a) III e IV, somente. 
b) II e III, somente. 
c) I, II e IV, somente. 
d) II, III e IV, somente. 
e) I, II, III e IV. 
 
Questão 10 
Fonte: FCC 2012 – TCE-AM – Analista de Controle Externo – Tecnologia da 
Informação 
Considere o excerto a seguir: 
A engenharia de software pode ser considerada uma tecnologia, com métodos 
e ferramentas próprios, estruturada em camadas, do ponto de vista sistêmico. 
A abordagem sistêmica da engenharia de software deve se apoiar num 
compromisso organizacional com a qualidade que leve à cultura de um 
processo contínuo de aperfeiçoamento, e é essa cultura que, em última análise, 
leva ao desenvolvimento de abordagens cada vez mais efetivas. A camada de 
base em que a engenharia de software se apoia é I e o “adesivo” que mantém 
unidas as camadas, estruturadas segundo a visão sistêmica, é o II. 
As lacunas I e II devem ser preenchidas, correta e respectivamente, por: 
a) A qualidade de processo – método. 
b) O uso de ferramentas - controle de qualidade. 
c) O controle de qualidade – método. 
d) O controle de requisitos – projeto. 
e) O foco na qualidade – processo. 
 
Aula 2 
Exercícios de fixação 
Questão 1 - A 
 
 MODELO DE MATURIDADE DE SOFTWARE 37 
Justificativa: A Ciência da Computação deve desenvolver os fundamentos e as 
teorias para que a Engenharia de Software possa utilizá-los no desenvolvimento 
de software. 
 
Questão 2 - B 
Justificativa: Segundo os conceitos apresentados a Ciência da Comutação 
desenvolve os fundamentos e as teorias para que sejam utilizados pela 
Engenharia de Software. 
 
Questão 3 - D 
Justificativa: De acordo com o conceito de software ele é composto de: 
instruções, estruturas de dados e documentos. 
 
Questão 4 - E 
Justificativa: Os problemas encontrados na primeira era de desenvolvimento de 
software são decorrentes da falta de métodos e técnicas de desenvolvimento, 
bem como da falta de documentação. Dessa forma, somente a última 
alternativa não representa um problema desta era. 
 
Questão 5 - B 
Justificativa: De acordo com a definição apresentada no início da aula, ela 
refere-se ao software de inteligência artificial. 
 
Questão 6 - A 
Justificativa: A Engenharia de Software utiliza a tecnologia em camadas com o 
foco na qualidade. 
 
Questão 7 - A 
Justificativa: A Engenharia de Software lida com muitos sistemas legados e 
deve atender a grande necessidade do mercado quanto aos prazos de entrega. 
 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 38 
Questão 8 - B 
Justificativa: De acordo com o abordado nas aulas, a Engenharia de Software é 
composta por ferramentas, métodos e processo.Questão 9 - A 
Justificativa: Os problemas de custo e prazo ainda persistem, e o software 
ainda está em processo de evolução para se tornar uma solução para os 
problemas existentes. E os itens III e IV estão corretos. 
 
Questão 10 - E 
Justificativa: O foco da Engenharia de Software é sempre na qualidade e o 
processo é o adesivo que mantém unidas as camadas das ferramentas e dos 
métodos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 39 
Introdução 
Esta aula tem como tema central apresentar aos alunos os principais modelos 
de ciclo de vida utilizados no mercado, seus conceitos, características e 
aplicações. 
Os modelos de ciclo de vida de software surgiram pela necessidade de termos 
um conjunto de etapas a serem seguidas para que um este produto pudesse 
ser desenvolvido. 
 
Com um modelo bem definido e estabelecido, é mais fácil para que todos na 
organização possam seguir as mesmas etapas e saber em que fase se encontra 
o desenvolvimento do software. 
 
Objetivo: 
1. Apresentar o conceito de ciclo de vida de software e alguns modelos, como: 
cascata, v, incremental, evolutivo, iterativo e incremental; 
2. Discutir os modelos Rad, prototipação, espiral e Rup. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 40 
Conteúdo 
Ciclo de vida de software 
Vamos começar a nossa aula com uma pergunta simples: 
 
por que precisamos utilizar um modelo de ciclo de vida para desenvolver 
software? 
 
Porque ele define a estrutura e a filosofia utilizadas obrigatoriamente em um 
processo de desenvolvimento de software. Um modelo de ciclo de vida define 
também as diferentes fases na existência deste produto, além de determinar 
também os princípios e diretrizes que guiarão a realização destas fases. 
Precisamos entender também que a adoção de um ciclo de vida não é 
suficiente para guiar e controlar um projeto de software na prática. 
 
 
Atenção 
 As seguintes características devem ser levadas em consideração 
durante a vida de um produto de software: 
• Organização das atividades do processo; 
• Recursos humanos, hardware e software; 
• Procedimentos de operação; 
• Políticas de desenvolvimento e restrições; 
• Tipos de software. 
Ou seja, precisamos conhecer bem a equipe de desenvolvimento 
e entender quais são as suas habilidades e quais as ferramentas 
disponíveis na organização, dentre outras características. 
 
Com essas informações, podemos definir o melhor ciclo de vida a ser utilizado 
no desenvolvimento de um software, pois não existe um melhor ciclo de vida a 
ser utilizado. Precisamos conhecer bem as características do projeto a ser 
desenvolvido para escolher ciclo de vida mais adequado para esse projeto. 
 
 MODELO DE MATURIDADE DE SOFTWARE 41 
Um ciclo de vida possui algumas características básicas que são comuns a todos 
os modelos, tais como: 
 
• Descrever as principais fases do desenvolvimento; 
• Definir as principais atividades a serem realizadas durante cada uma das 
fases; 
• Especificar os produtos de cada uma das fases, além dos insumos necessários 
para o início delas; 
• Fornecer um framework sobre o qual as atividades necessárias podem ser 
mapeadas. 
 
Principais modelos de ciclo de vida de software 
Existem vários modelos de ciclo de vida disponíveis no mercado; entretanto, 
vamos discutir os principais modelos utilizados nas organizações, que são: 
cascata, V, incremental, evolutivo, iterativo e incremental. 
 
Modelo cascata 
Modelo mais antigo e o mais amplamente usado na engenharia de software, 
modelado em função do ciclo da engenharia convencional. Também conhecido 
como modelo clássico ou sequencial linear. 
 
Ele requer uma abordagem sistemática e sequencial ao desenvolvimento de 
software, sendo adequado em situações nas quais os requisitos são bem 
entendidos, e o gerente do projeto confia na capacidade da equipe de 
desenvolver utilizando o processo. 
 
A ideia da cascata nasceu das etapas que possuem este formato, sendo 
executadas sequencialmente e podendo retornar a uma etapa anterior. 
Entretanto, o retorno a uma etapa anterior deve ser muito bem analisado 
quanto à sua viabilidade financeira e técnica. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 42 
 
Atenção 
 Esse modelo apresenta as seguintes vantagens: 
• A fase única de requisitos leva à especificação antes do projeto 
e ao projeto antes da codificação; 
• O uso de revisões ao fim de cada fase permite o envolvimento 
do usuário; 
• O modelo permite que se imponha um controle de 
configuração; 
• Cada passo serve como uma base aprovada e documentada 
para o passo seguinte. 
E possui as seguintes desvantagens: 
• O fluxo sequencial que o modelo propõe geralmente não é 
seguido em projetos reais; 
• Requisitos devem ser estabelecidos de maneira completa, 
correta e clara no início de um projeto; 
• Difícil avaliar o progresso verdadeiro do projeto durante as 
primeiras fases; 
• Uma versão executável do software só fica disponível numa 
etapa avançada do desenvolvimento; 
• Ao final do projeto, é necessário um grande esforço de 
integração e testes. 
 
Modelo V 
Assim como o modelo cascata, o modelo V é sequencial; isto significa que cada 
fase precisa ser completada antes que a próxima se inicie. Os testes são muito 
mais enfatizados nesse modelo do que no modelo cascata. Os procedimentos 
de teste são desenvolvidos desde cedo no ciclo de vida, antes da 
implementação. 
 
Esse modelo apresenta as seguintes vantagens: 
 
 MODELO DE MATURIDADE DE SOFTWARE 43 
• Menor custo e menos tempo são necessários para a entrega da primeira 
versão; 
• Riscos associados ao desenvolvimento de incrementos são menores devido ao 
seu tamanho reduzido; 
• Número de mudanças nos requisitos pode diminuir devido ao curto tempo de 
desenvolvimento da primeira versão. 
E possui as seguintes desvantagens: 
• Se os requisitos não são tão estáveis ou completos quanto se esperava, 
alguns incrementos podem ser retirados de uso e retrabalhados; 
• O gerenciamento de custo, cronograma e configuração são mais complexos. 
 
Modelo incremental 
Neste modelo, as necessidades do usuário são segmentadas em uma série 
incremental de produtos. O processo se repete até que um produto completo 
seja produzido, e a segmentação das necessidades é realizada antes do 
desenvolvimento da primeira versão. A ideia desse modelo condiz com o 
propósito de aumentar pouco a pouco o software. 
 
O modelo incremental deve ser adotado quando os requisitos são conhecidos 
no início do desenvolvimento e há a necessidade de entrega de um produto 
funcional em pouco tempo. Deve notar que, a cada incremento, é produzida 
uma versão operacional do software. 
 
 
 
 
 
 
 
 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 44 
 
Atenção 
 Esse modelo apresenta as seguintes vantagens: 
• Menor custo e menos tempo são necessários para a entrega da 
primeira versão; 
• Riscos associados ao desenvolvimento de incrementos são 
menores devido ao seu tamanho reduzido; 
• Número de mudanças nos requisitos pode diminuir devido ao 
curto tempo de desenvolvimento da primeira versão. 
E possui as seguintes desvantagens: 
• Se os requisitos não são tão estáveis ou completos quanto se 
esperava, alguns incrementos podem ser retirados de uso e 
retrabalhados; 
• O gerenciamento de custo, cronograma e configuração são 
mais complexos. 
 
Modelo evolutivo 
Neste modelo, as versões parciais são desenvolvidas para atender aosrequisitos conhecidos inicialmente. A primeira versão é usada para refinar os 
requisitos para uma segunda versão e, a partir do conhecimento sobre os 
requisitos obtido com o uso, continua-se o desenvolvimento, evoluindo o 
produto. 
 
MODELO EVOLUTIVO 
 
Esse modelo apresenta as seguintes vantagens: 
 
• É adequado quando os requisitos não podem ser completamente 
especificados no início do desenvolvimento; 
• O uso do sistema pode aumentar o conhecimento sobre o produto e, 
consequentemente, melhorar os requisitos. 
E possui as seguintes desvantagens: 
 
 MODELO DE MATURIDADE DE SOFTWARE 45 
• Necessária uma forte gerência de custo, cronograma e configuração; 
• Usuários podem não entender a natureza da abordagem e se decepcionarem 
quando os resultados não são satisfatórios. 
 
Modelo iterativo e incremental 
O fundamento deste modelo é dividir o desenvolvimento do software em 
pequenos ciclos, considerando um pequeno conjunto de necessidades do 
cliente final para que estes ciclos sejam executados. 
 
Os ciclos dizem respeito a pequenos modelos cascatas que são executados para 
contemplar as necessidades do usuário. Dessa forma, precisamos dividir as 
necessidades dos clientes finais em partes e definir um grau de importância 
para cada uma delas. 
 
Modelos de ciclo de vida mais utilizados 
Nesta parte do curso, discutiremos mais alguns modelos de ciclo de vida que 
são muito utilizados no mercado, que são: RAD (Rapid Application 
Development), prototipação, espiral e RUP (Rational Unified Process). 
 
Modelos de ciclo de vida mais utilizados 
O modelo RAD (Rapid Application Development) é sequencial linear que 
enfatiza o desenvolvimento rápido de um software. Essa “alta velocidade” é 
conseguida através de uma abordagem de construção baseada em várias 
equipes que trabalham paralelamente enquanto o produto é dividido em 
módulos. Geralmente, um projeto de software que utiliza RAD tem duração de 
60 a 90 dias. 
 
Ele pode ser utilizado quando os requisitos são bem definidos e estão 
estabilizados, o escopo do sistema é restrito, e a aplicação pode ser 
modularizada. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 46 
Necessita de recursos humanos capacitados e comprometidos, suficientes para 
todas as equipes. A equipe deve utilizar componentes no desenvolvimento do 
software. 
 
 
Atenção 
 Esse modelo apresenta as seguintes vantagens: 
• O ciclo de desenvolvimento é extremamente curto; 
• Maior distribuição de tarefas entre as equipes. 
E possui as seguintes desvantagens: 
• Requer recursos humanos suficientes para criar um número 
adequado de equipes em projetos grandes e escaláveis; 
• Requer um comprometimento entre desenvolvedores e 
clientes; 
• Não é apropriado quando os riscos são grandes; 
• Não é apropriado quando o sistema precisa interagir com 
outros sistemas. 
 
Prototipação 
Um protótipo é uma versão preliminar do produto final, o software. É uma 
técnica que deve ser utilizada para explorar (elicitar) as necessidades do cliente 
final, principalmente quando eles são vagos ou indefinidos. Os usuários podem 
fazer experiências com o protótipo, conhecendo mais sobre o software que será 
disponibilizado futuramente. 
 
É uma versão inicial de um software que pode ser utilizado para determinar a 
viabilidade técnica, de custo e de cronograma de um projeto. 
 
Deve haver uma forte interação com o usuário para que as suas necessidades 
sejam rapidamente projetadas e implementadas na construção e validação do 
protótipo, de acordo com etapas descritas na figura seguinte. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 47 
Ele possui as seguintes vantagens: 
 
• Um protótipo deve ser submetido a uma avaliação, geralmente feita pelo 
cliente; 
• O fato de o cliente poder interagir com um protótipo ajuda a cristalizar suas 
necessidades funcionais e de desempenho; 
• Os desenvolvedores podem implementar os requisitos baseado no feedback 
do usuário. 
E apresenta os seguintes riscos na sua utilização: 
• Clientes imaginam que a maior parte do trabalho já foi feita; 
• Protótipo pode crescer de maneira não planejada, tornando-se um incremento 
funcional; 
• Protótipo pode ter um desempenho melhor do que um incremento funcional, 
pois não implementa toda a funcionalidade, causando frustração aos clientes 
quando o sistema completo é entregue. 
 
Modelo espiral 
Esse modelo possui as melhores características do ciclo de vida clássico e da 
prototipação, acrescentando um elemento muito importante: a análise de risco. 
 
Além disso, assume que o desenvolvimento acontece em ciclos e possui as 
seguintes fases: planejamento, análise de riscos, engenharia e avaliação. Um 
software passa repetidamente por essas fases em iterações (chamadas espirais 
nesse modelo). A cada passagem na espiral, é realizada a análise de risco para 
avaliar a continuidade ou não do desenvolvimento do software. 
 
Rational Unified Process (RUP) 
O RUP (Rational Unified Process) é um processo proprietário de engenharia de 
software desenvolvido pela Rational Software, atualmente subsidiária da IBM, e 
possui um framework de processo que pode ser adaptado e estendido. 
 
 
 MODELO DE MATURIDADE DE SOFTWARE 48 
Ele usa o paradigma orientado a objetos, juntamente com a notação UML 
(Unified Modeling Language) para a documentação do software. 
 
Esse modelo está organizado em disciplinas, nas quais são distribuídas tarefas e 
responsabilidades para que sejam gerados produtos de software de cada uma 
destas tarefas, conhecidas como artefatos de software. 
 
O ciclo de vida é dividido em fases sequenciais, as quais, por sua vez, são 
divididas em iterações, que são planejadas em número, duração e objetivos, 
como pode ser observado na figura. 
 
As etapas do modelo são descritas abaixo: 
 
Concepção: 
Entender os requisitos gerais e determinar o escopo do esforço de 
desenvolvimento. 
 
Elaboração: 
Planejar as atividades e recursos necessários e especificar as características e 
projeto da arquitetura. 
 
Construção: 
Construir o produto e evoluir a visão, arquitetura e planos até que o material 
esteja pronto para entrega. 
 
Transição: 
Garantir que o sistema tenha o nível correto de qualidade para atingir os 
objetivos, além de realizar correções, treinamento de usuários, ajustes e adição 
de elementos que estavam faltando. Posteriormente, o produto final é 
produzido e entregue. 
 
Esse modelo possui as seguintes vantagens: 
 
 MODELO DE MATURIDADE DE SOFTWARE 49 
• Permite e encoraja o feedback do usuário,elicitando os requisitos reais do 
sistema; 
• Inconsistências entre requisitos, projeto e implementação podem ser 
detectados rapidamente; 
• Divisão da carga de trabalho por todo o ciclo de vida; 
• Compartilhamento de lições aprendidas, melhorando continuamente o 
processo; 
• Evidências concretas do andamento do projeto podem ser oferecidas durante 
todo o ciclo de vida. 
 
Atividade proposta 
Antes de finalizarmos esta aula, vamos fazer uma atividade! 
Discuta como o modelo cascata e a prototipação podem ser utilizados no 
modelo em espiral. 
 
Chave de resposta: Podemos utilizar a prototipação na análise de riscos, e o 
modelo cascata na engenharia. 
 
 
Material complementar 
 
Para saber mais sobre os modelos de ciclo de vida de software, 
leia os textos disponíveis em nossa biblioteca virtual. 
 
 
Referências 
PRESSMAN, Roger S. Engenharia de Software: Uma Abordagem Profissional. 
7ª Edição. São Paulo: McGraw-Hill Brasil, 2011. 
SOMMERVILLE, Ian. Engenharia de Software. 9ª Edição. São Paulo: