Projeto II - Fase 4

Se alguém quiser baixar o projeto, esta aí!

Download

Banco de Dados I - 12

Interbase - Parte III
Interbase - Parte VI

Exercício XX:

1) Selecionar todos os registros de todas as tabelas;

select * from Usuarios
select * from Dependentes
select * from Funcionario
select * from Area
select * from Cargo
select * from Cidade
select * from Estado_Civil

2) Selecionar os campos nome, nome do pai, nome da mãe para os usuários do sexo feminino;

select Nome, Nome_do_Pai, Nome_da_Mae from Usuarios where Sexo = "F"

3) Selecionar os campos nome, endereço, ddd e telefone para os usuários do sexo masculino que moram no Jardim Damasco;

select Nome, Endereco, DDD, Telefone from Usuarios where Sexo = "M" and Bairro = "Jardim Damasco"

4) Selecionar todos os registros das tabelas de funcionários com seus dependentes;

select * from Funcionario t1, Dependentes t2 where t1.CodUsuario = t2.CodUsuario

5) Selecionar todos os funcionários que trabalham na Área de Engenharia e no Financeiro;

select * from Funcionarios t1, Area t2 where t1.CodArea = t2.CodArea and (t2.Nome = "Engenharia" or t2.Nome = "Financeiro")

6) Selecionar todos os funcionários que são secretárias, engenheiros e gerentes;

select * from Funcionario t1, Cargo t2 where t1.CodCargo = t2.CodCargo and (t2.Nome = "Secretária" or t2.Nome = "Engenheiro" or t2.Nome = "Gerente")

7) Selecionar os dependentes das secretárias;

select t1.CodDependente, t1.Nome, t1.Data_Nascimento, t1.Parentesco, t1.Sexo from Dependentes t1, Funcionario Func, Cargo t3 WHERE t2.CodDependente = t1.CodDependente and t2.CodCargo = t3.CodCargo and t3.Nome = "Secretaria"

8) Selecionar os funcionários com salário maior ou igual a R$ 1000,00;

select * from Funcionario where Salario >= 1000

9) Selecionar os usuários Casados da cidade de São José dos Campos;

select * from Usuarios t1, Cidade t2, Estado_Civil t3 where t1.CodCidade = t2.CodCidade and Cid.Cidade = "São José dos Campos" and t1.CodCivil = t3.CodCivil and t3.Descricao = "Casado"

10) Selecionar os dependentes dos funcionários cujos usuários são do sexo feminino;

select * from Dependentes t1, Funcionario t2, Usuarios t3 where t1.CodDependente = t2.CodDependente and t2.CodUsuario = t3.CodUsuario and t3.Sexo = "F"

11) Incluir mais 4 funcionários, sendo dois com salário maior que R$ 1000,00 e dois com salário menor que R$ 1000,00;

insert into Funcionarios values (1,1,1,1,1001,"19/11/2009","",1)
insert into Funcionarios values (2,2,2,2,1002,"19/11/2009","",1)
insert into Funcionarios values (3,3,3,3,999,"19/11/2009","",1)
insert into Funcionarios values (4,4,5,998,"19/11/2009","",1)

12) Selecionar os dependentes dos funcionários que ganham mais de R$ 1000,00 e cujos usuarios são do sexo masculino;

select * from Dependentes t1, Funcionario t2, Usuarios t3 where t1.CodDependente = t2.CodDependente and t2.CodUsuario = t3.CodUsuario and t3.Sexo = "M" and t3.Salario > 1000

Banco de Dados I - 11

Introdução ao Interbase
Interbase - Parte II

Exercício XX:

Escrever os comandos para criação das tabelas e executá-las no Interbase

Área:

CREATE TABLE AREA
(
"CODAREA" INTEGER NOT NULL,
"NOME" VARCHAR(50),
PRIMARY KEY ("CODAREA")
);

Cargo:

CREATE TABLE CARGO
(
"CODCARGO" INTEGER NOT NULL,
"NOME" VARCHAR(50),
PRIMARY KEY ("CODCARGO")
);

Cidade:

CREATE TABLE CIDADE
(
"CODCIDADE" INTEGER NOT NULL,
"CIDADE" VARCHAR(50),
"UF" VARCHAR(2),
PRIMARY KEY ("CODCIDADE")
);

Dependentes:

CREATE TABLE DEPENDENTES
(
"CODDEPENDENTE" INTEGER NOT NULL,
"NOME" VARCHAR(50),
"DATANAS" DATE,
"PARENTESCO" VARCHAR(50),
"SEXO" CHAR(1) NOT NULL,
PRIMARY KEY ("CODDEPENDENTE")
);

Estado Civil:

CREATE TABLE ESTADO_CIVIL
(
"CODCIVIL" INTEGER NOT NULL,
"DESCRICAO" VARCHAR(255),
PRIMARY KEY ("CODCIVIL")
);

Funcionário:

CREATE TABLE FUNCIONARIO
(
"CODFUNCIONARIO" INTEGER NOT NULL,
"CODUSUARIO" INTEGER,
"CODAREA" INTEGER,
"CODCARGO" INTEGER,
"SALARIO" FLOAT,
"DATAADM" DATE,
"DATADEM" DATE,
"CODDEPENDENTE" INTEGER,
PRIMARY KEY("CODFUNCIONARIO")
);

Usuários:

CREATE TABLE USUARIOS
(
"CODUSUARIO" INTEGER NOT NULL,
"NOME" VARCHAR(50),
"DATANAS" DATE,
"NOMEPAI" VARCHAR(50),
"NOMEMAE" VARCHAR(50),
"CODCIVIL" INTEGER,
"ENDERECO" VARCHAR(70),
"BAIRRO" VARCHAR(70),
"CODCIDADE" INTEGER,
"CEP" VARCHAR(9),
"DDD" INTEGER,
"TELEFONE" INTEGER,
"SEXO" CHAR(1) NOT NULL,
"CPF" VARCHAR(14),
"RG" VARCHAR(12),
PRIMARY KEY ("CODUSUARIO")
);

Ordenação Utilizando Filas de Prioridade

Implemente os algoritmos Insertion-Sort e Selection-Sort utilizando um TAD Fila de Prioridade que também deve ser desenvolvido.

Classes:

Fila:

import java.util.ArrayList;

abstract class Fila{

private ArrayList<Item> Array = new ArrayList<Item>();

public Fila(){
}

abstract public void InsereItem(int Chave, Object Elemento);

abstract public Item RemoveMin();

abstract public int MinKey();

abstract public Object MinElement();

public int Size(){
return Array.size();
}

public boolean IsEmpty(){
return Array.isEmpty();
}

}

Item:

public class Item {

private int Chave;
private Object Elemento;

public Item(int Chave, Object Elemento){
this.Chave = Chave;
this.Elemento = Elemento;
}

public void setChave(int Chave){
this.Chave = Chave;
}

public void setElemento(int Elemento){
this.Elemento = Elemento;
}

public int getChave(){
return Chave;
}

public Object getElemento(){
return Elemento;
}

}

Sort:

import java.util.ArrayList;

public class Sort {

private Fila fila;
private ArrayList<Item> Array;

public Sort(ArrayList<Item> Array, Fila fila){
this.Array = Array;
this.fila = fila;
}

public ArrayList<Item> SortList(){
ArrayList<Item> ArrayOrdenado = new ArrayList<Item>();

for(int i = 0; i < Array.size(); i++)
fila.InsereItem(Array.get(i).getChave(), Array.get(i).getElemento());

int Tamanho = fila.Size();

for(int i = 0; i < Tamanho; i++)
ArrayOrdenado.add(fila.RemoveMin());

return ArrayOrdenado;
}

}

Selection-Sort:

import java.util.ArrayList;

public class SelectionSort extends Fila{

private ArrayList<Item> Array = new ArrayList<Item>();

public SelectionSort(){
}

public void InsereItem(int Chave, Object Elemento){
Array.add(new Item(Chave, Elemento));
}

public Item RemoveMin(){
Item menor = Array.get(0);
for(int i = 0; i < Array.size(); i++){
if(Array.get(i).getChave() < menor.getChave())
menor = Array.get(i);
}
Array.remove(menor);
return menor;
}

public int MinKey(){
Item menor = Array.get(0);
for(int i = 0; i < Array.size(); i++){
if(Array.get(i).getChave() < menor.getChave())
menor = Array.get(i);
}
return menor.getChave();
}

public Object MinElement(){
Item menor = Array.get(0);
for(int i = 0; i < Array.size(); i++){
if(Array.get(i).getChave() < menor.getChave())
menor = Array.get(i);
}
return menor.getElemento();
}

public int Size(){
return Array.size();
}

public boolean IsEmpty(){
return Array.isEmpty();
}

}

Insertion-Sort:

import java.util.ArrayList;

public class InsertionSort extends Fila{

private ArrayList<Item> Array = new ArrayList<Item>();

public InsertionSort(){
}

public void InsereItem(int Chave, Object Elemento){
Array.add(new Item(Chave, Elemento));

int posicao = 1;
if(Array.size() >= 1){
while(posicao < Array.size()){
for(int i = posicao; i > 0; i--){
if(Array.get(i).getChave() < Array.get(i - 1).getChave())
SwapElements(Array.get(i), Array.get(i - 1));
}
posicao++;
}
}
}

public Item RemoveMin(){
Item temp = Array.get(0);
Array.remove(temp);
return temp;
}

public int MinKey(){
return Array.get(0).getChave();
}

public Object MinElement(){
return Array.get(0).getElemento();
}

private void SwapElements(Item Elemento1, Item Elemento2){
int index1 = Array.indexOf(Elemento1);
int index2 = Array.indexOf(Elemento2);

Array.set(index1, Elemento2);
Array.set(index2, Elemento1);
}

public int Size(){
return Array.size();
}

public boolean IsEmpty(){
return Array.isEmpty();
}

}

Main:

import java.util.ArrayList;


public class Main {

public static void main(String Args[]){

SelectionSort Sel = new SelectionSort();
InsertionSort Ins = new InsertionSort();

ArrayList<Item> ArraySel = new ArrayList<Item>();

ArraySel.add(new Item(5, "Elemento 5"));
ArraySel.add(new Item(4, "Elemento 4"));
ArraySel.add(new Item(2, "Elemento 2"));
ArraySel.add(new Item(3, "Elemento 3"));
ArraySel.add(new Item(1, "Elemento 1"));

Sort SelSort = new Sort(ArraySel, Sel);

ArrayList<Item> ArrayIns = new ArrayList<Item>();

ArrayIns.add(new Item(10, "Elemento 10"));
ArrayIns.add(new Item(9, "Elemento 9"));
ArrayIns.add(new Item(8, "Elemento 8"));
ArrayIns.add(new Item(7, "Elemento 7"));
ArrayIns.add(new Item(6, "Elemento 6"));

Sort InsSort = new Sort(ArrayIns, Ins);

ArrayList<Item> ArrayRetornoSel = SelSort.SortList();

for(int i = 0; i < ArrayRetornoSel.size(); i++)
System.out.printf("%d ", ArrayRetornoSel.get(i).getChave());

System.out.printf("\n");

ArrayList<Item> ArrayRetornoIns = InsSort.SortList();

for(int i = 0; i < ArrayRetornoIns.size(); i++)
System.out.printf("%d ", ArrayRetornoIns.get(i).getChave());

}

}

TAD Árvore Binária

Objetivo: Escreva um programa que leia uma seqüência de números e monte uma Árvore Binária.

O programa deve ter as seguintes opções:

• Ler números digitados pelo usuário e montar a Árvore Binária ordenada;
• Remover um determinado elemento da árvore;
  Obs: Para simplificar permita remover somente "folhas".
• Verificar se a árvore está vazia;
• Percorrer a árvore pelos modos: preorder, inorder e posorder;
• Exibir a árvore na tela, de modo que a estrutura binária da árvore possa ser visualizada, ou seja, de maneira que possamos conferir a estrutura da árvore;
• Retornar a altura da árvore.

Classes:

Árvore:

import java.util.ArrayList;

public class Arvore {

// Atributo
private Elemento Raiz;

// Construtor recebe um Elemento Raiz para criar a árvore
public Arvore(Elemento Raiz){
this.Raiz = Raiz;
}

// Método SET
public void setRaiz(Elemento Raiz){
this.Raiz = Raiz;
}

// Método GET
public Elemento getRaiz(){
return this.Raiz;
}

// Método para inserir um novo elemento na árvore
public void InserirElemento(int Valor){

// O caminhamento na arvore vai começar a partir da raiz
Elemento ElementoAux = Raiz;

// Cria um novo elemento com o valor a ser inserido
Elemento NovoElemento = new Elemento(Valor);

// Inicia o caminhamento na árvore
while(ElementoAux != null){

// Verifica se o valor a ser inserido é maior que o valor do elemento atual
if(Valor > ElementoAux.getValor()){
// Verifica se elemento direito é diferente de nulo
if(ElementoAux.getElementoDireito() != null) // Se sim, pega o elemento direito para continuar a busca
ElementoAux = ElementoAux.getElementoDireito();
else{ // Se não, insere o elemento como o elemento direito
ElementoAux.setElementoDireito(NovoElemento);
ElementoAux = null;
}
// Valor a ser inserido menor que o valor do elemento atual
} else {
// Verifica se elemento esquero é diferente de nulo
if(ElementoAux.getElementoEsquerdo() != null) // Se sim, pega o elemento esquerdo para continuar a busca
ElementoAux = ElementoAux.getElementoEsquerdo();
else{ // Se não, insere o elemento como o elemento esquerdo
ElementoAux.setElementoEsquerdo(NovoElemento);
ElementoAux = null;
}
}
}
}

// Método para fazer o caminhamento "PreOrder"
public void PreOrder(Elemento Elemento){
if(Elemento != null){
System.out.printf("%d ", Elemento.getValor());
if(Elemento.Interno()){
PreOrder(Elemento.getElementoEsquerdo());
PreOrder(Elemento.getElementoDireito());
}
}
}

// Método para fazer o caminhamento "PostOrder"
public void PostOrder(Elemento Elemento){
if(Elemento != null){
if(Elemento.Interno()){
PostOrder(Elemento.getElementoEsquerdo());
PostOrder(Elemento.getElementoDireito());
}
System.out.printf("%d ", Elemento.getValor());
}
}

// Método para fazer o caminhamento "InOrder"
public void InOrder(Elemento Elemento){
if(Elemento != null){
if(Elemento.Interno()){
InOrder(Elemento.getElementoEsquerdo());
}
System.out.printf("%d ", Elemento.getValor());
if(Elemento.Interno()){
InOrder(Elemento.getElementoDireito());
}
}
}

// Método para remover um elemento
// Recebe como parâmetro um elemento e o valor a ser removido
public boolean Remover(Elemento Elemento, int Valor){
// Verifica se elemento é diferente de nulo
if(Elemento != null){
// Verifica se o valor do elemento é igual ao valor a ser removido
if(Elemento.getValor() == Valor){
// Verifica se o elemento é um elemento externo
if(!Elemento.Interno()) // Se sim, retorna verdadeiro, pois pode ser removido
return true;
else // Se não, retorna falso, pois não pode ser removido
return false;

// Se valor do elemento atual for diferente do valor a ser removido...
} else {

// Verifica se o elemento atual é um elemento interno
if(Elemento.Interno()){

boolean flag; // Flag para verificar se foi removido o elemento

flag = Remover(Elemento.getElementoEsquerdo(), Valor); // Chama a função remover recursivamente enviando o elemento esquerdo

// Verifica se foi removido o elemento
if(flag){
Elemento.setElementoEsquerdo(null); // Remove a ligação com o elemento
return false;
} else {

flag = Remover(Elemento.getElementoDireito(), Valor); // Chama a função remover recursivamente enviando o elemento direito

// Verifica se foi removido o elemento
if(flag){
Elemento.setElementoDireito(null); // Remove a ligação com o elemento
return false;
} else
return false;
}
}
}
}
return false;
}

// Método chamado para calcular Altura da árvore
public int Altura(){
return CalculaAltura(this.Raiz, 0);
}

// Método para calcular a Altura da árvore
// Recebe como parâmetro um elemento e a altura atual da contagem
private int CalculaAltura(Elemento Elemento, int Altura){
// Verifica se elemento é diferente de nulo
if(Elemento != null){

// Verifica se elemento atual é um elemento interno
if(Elemento.Interno()){
int AlturaAux1, AlturaAux2;
// Chama o método para Calcular altura recursivamente, enviando o elemento esquerdo e a altura atual + 1
AlturaAux1 = CalculaAltura(Elemento.getElementoEsquerdo(), Altura + 1);

// Chama o método para Calcular altura recursivamente, enviando o elemento direito e a altura atual + 1
AlturaAux2 = CalculaAltura(Elemento.getElementoDireito(), Altura + 1);

// Verifica qual dos lados teve a maior altura e retorna
if(AlturaAux1 > AlturaAux2)
return AlturaAux1;
else
return AlturaAux2;

// Se elemento atual é um elemento externo, apenas retorna a altura recebida
} else {
return Altura;
}
}
return 0;
}

// Método Auxiliar do método para imprimir
// Método Cria um Array onde cada posição do array representa um nível da arvore.
private ArrayList<object> BuscaPai(){

// Cria um array de niveis
ArrayList<object> ArrayNiveis = new ArrayList<object>();

// Cria um array auxiliar para fazer o laço
ArrayList<object> ArrayAux = new ArrayList<object>();
ArrayAux.add(this.Raiz); // Inicia o array com o elemento Raiz

ArrayNiveis.add(ArrayAux); // Adiciona no array de niveis o array contendo o elemento raiz

// Percorre o array auxiliar
while(ArrayAux.size() >= 1){

// Cria um array para receber o array do método BuscaFilhos
ArrayList<object> Array = new ArrayList<object>();

// Recebe o array do método BuscaFilhos
Array = BuscaFilhos(ArrayAux);

// Adiciona o array recebido no array de níveis
ArrayNiveis.add(Array);

// Verifica se o conteudo do array recebido tem algum elemento válido, não nulo
boolean Flag = false;
for(int i = 0; i < Array.size(); i++){
if(Array.get(i) != null){
Flag = true; // Existe elemento válido
break;
}
}

// Se existe elemento válido, seta o array auxiliar com o array recebido pelo método BuscaFilhos
if(Flag)
ArrayAux = Array;
else{ // Se não existe elemento válido, remove esse último array do array de níveis
ArrayNiveis.remove(ArrayNiveis.indexOf(Array));
break;
}
}

// Retorna o array de níveis para a impressão
return ArrayNiveis;
}

// Método Auxiliar do Método BuscaPai
// Método cria um array de filhos de acordo com o array passado
private ArrayList<object> BuscaFilhos(ArrayList<object> Array){

// Cria um novo array de filhos
ArrayList<object> ArrayNovo = new ArrayList<object>();

// Percorre o array passado, adicionando no novo array o filho da esquerda e da direita
for(int i = 0; i < Array.size(); i++){
// Recupera o elemento do array
Elemento ElementoAux = (Elemento)Array.get(i);

// Verifica se elemento é diferente de nulo
if(ElementoAux != null){ // Se sim, adiciona o elemento esquerdo e direito no novo array
ArrayNovo.add(ElementoAux.getElementoEsquerdo());
ArrayNovo.add(ElementoAux.getElementoDireito());
} else { // Se não, adiciona dois valores nulos no novo array, indicando que não tem filhos
ArrayNovo.add(null);
ArrayNovo.add(null);
}
}

// Retorna o novo array de filhos para a função BuscaPai
return ArrayNovo;
}

// Método para imprimir a árvore
public void Imprimir(){

// Chama a função BuscaPai que retornará o array de níveis da arvore
ArrayList<object> Array = BuscaPai();

// Verifica o tamanho do array da ultima posição do array de níveis
ArrayList<object> ArraySize = (ArrayList<object>) Array.get(Array.size() - 1);

// Cria uma variavel de tamanho
int Tamanho = ArraySize.size();

// Percorre o array de níveis
for(int i = 0; i < Array.size(); i++){

// Recupera o array da posição atual do array de niveis
ArrayList<object> Array2 = (ArrayList<object>) Array.get(i);

// Divide o tamanho pela metade, que é o número de espaços que serão utilizados para o nivel atual
Tamanho = Tamanho/2;

if(i == Array.size() - 1)
System.out.printf(" ");

for(int j = 0; j < Array2.size(); j++){

int Espacos; // Variavel que conterá quantos "\t" serão necessários para desenhar o nível atual

if(j == 0) // Se for o primeiro índice do FOR, recebe o próprio tamanho
Espacos = Tamanho;
else // Se não, recebe o tamanho * 2
Espacos = Tamanho * 2;

// Percorre o número de espaços tabulando a impressão
for(int k = 1; k <= Espacos; k++)
System.out.printf("\t");

// Verifica se é o último nível que está sendo impresso na tela
if((i == Array.size() - 1) && (j != 0))
System.out.printf("\t "); // Se sim, insere alguns espaços depois da tabulação

// Recupera o elemento para recuperar o valor
Elemento NovoElemento = (Elemento)Array2.get(j);

// Se elemento diferente de nulo...
if(NovoElemento != null)
System.out.printf("%d", NovoElemento.getValor()); // Imprime o valor do elemento
else
System.out.printf("-"); // Imprime um traço
}
System.out.printf("\n"); // Pula de linha a cada nível
}

}

}

Elemento:

public class Elemento {

// Atributos
private int Valor;
private Elemento ElementoDireito;
private Elemento ElementoEsquerdo;

// Contrutor recebe um valor como parâmetro
public Elemento(int Valor){
this.Valor = Valor;
this.ElementoDireito = null;
this.ElementoEsquerdo = null;
}

// Métodos SET
public void setValor(int Valor){
this.Valor = Valor;
}

public void setElementoEsquerdo(Elemento ElementoEsquerdo){
this.ElementoEsquerdo = ElementoEsquerdo;
}

public void setElementoDireito(Elemento ElementoDireito){
this.ElementoDireito = ElementoDireito;
}

// Métodos GET
public int getValor(){
return this.Valor;
}

public Elemento getElementoEsquerdo(){
return this.ElementoEsquerdo;
}

public Elemento getElementoDireito(){
return this.ElementoDireito;
}

// Método para verificar se nodo é interno
public boolean Interno(){
if((ElementoEsquerdo != null) || (ElementoDireito != null))
return true;
return false;
}

}

Main:

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

public static void main(String Args[]){

int Opcao;

Scanner input = new Scanner(System.in);

// Cria um novo elemento que será o elemento Raiz
Elemento elemento = new Elemento(25);

// Cria a nova árvore, enviando o elemento Raiz
Arvore arvore = new Arvore(elemento);

// Insere os elementos na árvore
arvore.InserirElemento(15);
arvore.InserirElemento(20);
arvore.InserirElemento(10);
arvore.InserirElemento(13);
arvore.InserirElemento(30);
arvore.InserirElemento(28);
arvore.InserirElemento(35);
arvore.InserirElemento(14);

Opcao = 1;

while((Opcao >= 0) && (Opcao <= 7)){
Menu();
Opcao = input.nextInt();

if((Opcao >= 0) && (Opcao <= 7)){
int Valor;
switch(Opcao){
case 1 : ;
System.out.printf("\nDigite o valor do elemento a ser inserido: ");
Valor = input.nextInt();
arvore.InserirElemento(Valor);
break;
case 2 : System.out.printf("\nDigite o valor do elemento a ser removido: ");
Valor = input.nextInt();
arvore.Remover(arvore.getRaiz(), Valor);
break;
case 3 : System.out.printf("\nAltura da árvore: %d", arvore.Altura());
break;
case 4 : System.out.printf("\nPreOrder: ");
arvore.PreOrder(arvore.getRaiz());
break;
case 5 : System.out.printf("\nPostOrder: ");
arvore.PostOrder(arvore.getRaiz());
break;
case 6 : System.out.printf("\nInOrder: ");
arvore.InOrder(arvore.getRaiz());
break;
case 7 : arvore.Imprimir();
break;
}

}

}

}

private static void Menu(){
System.out.printf("\n");
System.out.printf("\n");
System.out.printf("0 - Sair\n");
System.out.printf("1 - Inserir Elemento\n");
System.out.printf("2 - Remover Elemento\n");
System.out.printf("3 - Verificar Altura\n");
System.out.printf("4 - Caminhamento PreOrder\n");
System.out.printf("5 - Caminhamento PostOrder\n");
System.out.printf("6 - Caminhamento InOrder\n");
System.out.printf("7 - Imprimir Árvore\n");
System.out.printf("Digite Sua Opção: ");
}

}

CMMI

Introdução

Hoje em dia, com a intensa demanda de softwares nas mais variadas áreas do mercado, muitos softwares têm sido desenvolvidos para atender essa demanda. Mas, muitos deles não são produzidos segundo uma norma, uma vez que seus desenvolvedores estão focados somente em satisfazer as necessidades inicias de seus clientes, negligenciando assim alguns aspectos de manutenção e durabilidade do software. Gerando então preocupações consideráveis quanto à qualidade desses produtos.

Para resolver este problema, foram criados os Modelos de Qualidade de Software cujo objetivo principal é garantir a qualidade do produto através da definição e normatização de processos de desenvolvimento. Os modelos mais conhecidos atualmente são: ISO, CMM, CMMI.

O CMMI (Capability Maturity Model Integration), desenvolvido pelo SEI (Sofware

Engineering Institute), é uma evolução do CMM (Capability Model Integration) que tenta suprir problemas de integração deste.

Para atender aos diversos setores da indústria de software, o SEI divulgou diversos documentos derivados do CMM. Mas, essa diversidade gerou problemas de integração e custo de treinamento, já que cada modelo possui características específicas. Com intuito de unificar os modelos baseados no CMM, o SEI desenvolveu o CMMI.

Será apresentado neste trabalho o Modelo de Qualidade CMMI, sua definição, bem como suas características e seus objetivos. Serão esplanadas também as representações do CMMI: continua e em estágios, algumas empresas brasileiras que possuem qualificações CMMI, e por fim, serão feitas as considerações finais sobre o assunto.

Definição

O CMMI é um modelo de referência que contém práticas: Genéricas ou Específicas necessárias à maturidade em disciplinas específicas. Desenvolvido pelo SEI (Software Engineering Institute) da Universidade Carnegie Mellon, o CMMI é uma evolução do CMM e procura estabelecer um modelo único para o processo de melhoria corporativo, integrando diferentes modelos e disciplinas.

Características

Como seus antecessores, o CMMI não define como o processo deve ser implementado, mas prescreve suas características estruturais e semânticas em termos de objetivos e de grau de qualidade com que o trabalho deve ser realizado.

O CMMI constitui tanto um modelo de capacidade como um modelo de maturidade. O modelo dentro de uma empresa pode ser alcançado em etapas consecutivas, representando a idéia de maturidade ou também de maneira contínua, onde é mensurada a capacidade em práticas individuais.

Quando uma organização atinge um nível de maturidade, considera-se que seus processos alcançaram uma determinada capacidade, ou seja, têm mecanismos que garantem a repetição sucessiva de bons resultados futuros relacionados principalmente à qualidade, custos e prazos.

É de grande importância conhecer os processos definidos da organização para que possam se reconhecer os pontos fortes e pontos em que possa haver melhorias e assim seguir alguns passos genéricos para a implementação de CMMI:

• Iniciar o compromisso organizacional para se estabelecer um ambiente propício ao ciclo de melhoria;


• Diagnosticar os pontos fortes e as oportunidades de melhoria utilizando um método de avaliação;


• Estabelecer um plano de ação;


• Implementar o plano de ação e controlar seu progresso, tomando atitudes corretivas necessárias de maneira oportuna. Uma forma de controlar o estado de institucionalização do processo é mediante processos de auto-avaliação ou uma nova avaliação;


• Propagar a institucionalização na organização revisando problemas ou lições aprendidas no caminho, preparando-se para o próximo ciclo.

Objetivos do CMMI

Redução do custo da implementação de melhoria de processo multidisciplinar baseada em modelo por meio de:

• Eliminação de inconsistências, redução de duplicidades


• Melhoria da clareza e entendimento


• Utilização de terminologia comum e estilo consistente


• Estabelecimento de regras de construção uniformes


• Manutenção de componentes comum


• Consistência com a futura norma ISSO/ IEC 15504


• Sensibilidade às implicações dos esforços legados

Para que esses objetivos sejam alcançados é necessário que a empresa tenha um foco, um objetivo a ser alcançado, onde a partir daí um avaliador capacitado faz todas as entrevistas e avaliações possíveis para com isso dar um retorno a empresa lhe indicando o seu nível de maturidade e pontos a serem melhorados para que a empresa possa se desenvolver.

Representações do CMMI

O CMMI contém duas representações: contínua e por estágios. Elas permitem à organização utilizar diferentes caminhos para a melhoria de acordo com seu interesse.

A contínua permite que uma organização selecione uma área (ou um grupo de áreas) de processo e melhore os processos relacionados. Ela usa níveis de capacidade para caracterizar melhorias relativas a uma área de processo individual.

A estagiada usa conjuntos pré-definidos de áreas de processo (KPA's) para definir um caminho para uma organização, caracterizado por níveis de maturidade. Cada nível contém um conjunto de áreas de processo que caracterizam diferentes comportamentos organizacionais, correspondendo à capacidade da empresa de realizar projetos grandes e complexos.

Representação Continua

Na representação contínua, o enfoque ou componentes principais são as áreas de processo. Existem metas e práticas de dois tipos: específicas a uma determinada área de processo e genéricas aplicáveis indistintamente a todas as áreas de processo. A partir da avaliação e do atendimento dessas práticas e metas é possível classificar o nível de capacidade de cada área de processo, em níveis de zero a cinco:

Nível 0 - Incompleto: Quando um processo é parcialmente realizado ou não realizado. Um ou mais objetivos específicos do processo não estão satisfeitos.

Nível 1 - Realizado: Quando um processo realizado satisfaz todos os objetivos específicos da área de processo e produz algum trabalho.

Nível 2 - Gerenciado: Quando um processo de capacidade nível dois é um processo realizado (nível um) que também é planejado e executado de acordo com políticas pré-definidas. Emprega pessoas hábeis com os recursos adequados para produzir saídas adequadas, envolve os stakeholders (“qualquer pessoa ou entidade que afeta ou é afetada pelas atividades de uma empresa”) principais e é monitorado, controlado, revisto e avaliado quanto à aderência à sua descrição. A gerência do processo é relacionada com a realização de objetivos específicos estabelecidos para o processo, como custo, cronograma e qualidade.

Nível 3 - Definido: Quando um processo definido é um processo gerenciado e ajustado para o conjunto padrão de processos da organização de acordo com suas políticas de conduta. Esse conjunto é estabelecido e melhorado com o tempo e descreve os elementos fundamentais de processos que são esperados nos processos definidos.

Nível 4 - Gerenciado quantitativamente: um processo neste nível é definido e controlado com a ajuda de técnicas quantitativas e estatísticas. A qualidade e o desempenho do processo são compreendidos em termos estatísticos e são geridos durante sua vida. Objetivos quantitativos para qualidade e desempenho de processos são estabelecidos e usados como critério na gerência do processo.

Nível 5 - Otimizado: um processo otimizado é gerenciado quantitativamente, alterado e adaptado para atender aos objetivos de negócio atuais e projetados.

Vantagens da representação contínua

• Maior flexibilidade para focar em áreas de processo específicas de acordo com as metas e objetivos de negócio;


• Estrutura familiar para os que migram da comunidade de engenharia de sistemas.

Representação por estágios

A representação em estágios oferece uma abordagem estruturada e sistemática para a melhoria de um estágio por vez. Atingir um estágio significa que uma estrutura de processo adequada foi estabelecida como base para o próximo estágio.

As áreas de processo são organizadas por níveis de maturidade (1 a 5), que definem o caminho de melhoria que uma organização deve seguir do nível inicial ao nível otimizado. Dentro de cada nível, existem áreas de processo que contêm metas, características comuns e práticas.

Na representação em níveis, as práticas são caracterizadas pelos atributos: compromisso para execução (práticas que garantem que o processo seja estabelecido e apoiado); habilidade para execução (práticas que criam condições para que o processo seja estabelecido completamente) e atividade para execução (práticas que implementam diretamente o processo); controle e verificação de implementação. A transição entre os níveis resulta em melhorias incrementais e duradouras.

Os estágios de maturidade são:

Nível 1 - Inicial: Neste nível em geral, as organizações desse nível têm processos imprevisíveis que são pobremente controlados e reativos. Nesse nível de maturidade os processos são normalmente “ad hoc” (“para um fim específico”) e caóticos. A Organização geralmente não fornece um ambiente estável. Neste nível não há KPA's.

Nível 2 – Gerenciado: No nível de maturidade dois os projetos da organização têm a garantia de que os requisitos são gerenciados, planejados, executados, medidos e controlados. Quando essas práticas são adequadas, os projetos são executados e controlados de acordo com o planejado. O foco, neste nível, é o gerenciamento básico de projetos e tem as seguintes KPA's desse nível são: gerenciamento de requisitos; planejamento do projeto; controle e monitoração do projeto; gerenciamento de suprimentos; avaliação e análise; garantia da qualidade do processo; configuração do gerenciamento.

Nível 3 – Definido: No nível de maturidade três, em que todos os objetivos específicos e genéricos atribuídos para os níveis de maturidade dois e três foram alcançados, os processos são mais bem caracterizados e entendidos e são descritos em padrões, procedimentos, ferramentas e métodos. O foco neste nível é a padronização do processo, tendo como KPA's: requisitos de desenvolvimento; soluções técnicas; integração de produtos; verificação; validação; foco no processo organizacional; definição do processo organizacional; treinamento organizacional; gerenciamento de projeto integrado; gerenciamento de riscos; integração da equipe de trabalho; gerenciamento integrado de suprimentos; análise de decisões; ambiente organizacional para integração.

Nível 4 - Quantitativamente Gerenciado: No nível de maturidade quatro, em que os objetivos específicos atribuídos para os níveis de maturidade 2, 3 e 4 e os objetivos genéricos atribuídos para os níveis de maturidade 2 e 3 foram alcançados, os processos são medidos e controlados. O foco neste nível é o gerenciamento quantitativo e possui as seguintes KPA's: performance organizacional do processo; gerenciamento quantitativo de projetos.

Nível 5 – Otimizado: No nível de maturidade cinco, o mais alto nível de maturidade CMMI, uma organização atingiu todos os objetivos específicos atribuídos para os níveis de maturidade 2, 3, 4 e 5, e os objetivos genéricos atribuídos para os níveis de maturidade 2 e 3. Os processos são continuamente aperfeiçoados, e baseados em um entendimento quantitativo em que a variação de um processo existe devido às interações, normais e presumidas, entre os componentes desse processo. Esse nível de maturidade tem como objetivo a melhoria contínua do processo. As KPA's desse nível são: inovação organizacional e análise de causas e resoluções.

Vantagens da representação por estágios

• Fornece um mapa para implementação:


• Grupos de áreas de processos


• Seqüência da implementação


• Estrutura familiar para os que migram do SW-CMM.

Considerações Finais

A utilização de metodologias em desenvolvimento de software como o CMMI é de grande importância no desenvolvimento das organizações para torná-las mais competitivas no mercado de trabalho obtendo melhorias nos seus processos assim fazendo com que alcancem a qualidade necessária de seus produtos e melhores resultados em seus negócios com cumprimento de prazos.

Para garantir essa qualidade e que seus processos estejam sendo executados de maneira correta é necessária uma avaliação contínua dos processos da organização, verificando assim se a organização está em desenvolvimento ou até mesmo em outro nível, mas para isso é exigido um número de avaliações por um período de tempo.

Referências Bibliográficas

[1] Ministério da Ciência e Tecnologia Secretaria de Política de Informática Qualificação CMM e CMMI no Brasil:
www.mct.gov.br/upd_blob/0009/9238.pdf
Acessado em 26/10/09.
[2] Comércio Eletrônico: Uma Análise da Aplicabilidade de Modelos de Qualidade de Software:
www.lbd.dcc.ufmg.br:8080/colecoes/sbqs/2002/009.pdf
Acessado em 26/10/09.
[3] Uma visão geral do CMMI:
www.dromostg.com.br/CMMI.PDF
Acessado em 26/10/09.
[4] Análise de uma Organização de Software utilizando o Modelo CMMI/SEI v1.0:
www2.dem.inpe.br/ijar/Qualidade%20de%20Software/PDFs/CMMI-Artigo.pdf
Acessado em 26/10/09.
[5] Gerência de Risco em Processos de Qualidade de Software: uma Análise Comparativa:
www.sbc.org.br/bibliotecadigital/download.php?paper=235
Acessado em 26/10/09.
[6] Departamento de Produção POLI O novo modelo CMMI
www.spinsp.org.br/apresentacao/new_cmmi.pdf
Acessado em 26/10/09.
[7] ISO/IEC 15504:
www.cin.ufpe.br/~processos/TAES3/slides-2006.2/ISO15504_V02.ppt
Acessado em 26/10/09.
[8] CMM - Dificuldades de implantação do modelo; sua aplicação no setor financeiro:
www.mbis.pucsp.br/monografias/Monografia_-_Mauro_Dias.pdf
Acessado em 26/10/09.
[9] ISD Brasil:
www.isdbrasil.com.br/default.asp
Acessado em 26/10/09.
[10] Wikipedia Capability Maturity Model Integration:
en.wikipedia.org/wiki/CMMI
Acessado em 26/10/09.
[11] Expandindo o Agile para se adequar ao CMMI Nível 3:
msdn.microsoft.com/pt-br/library/cc517970.aspx
Acessado em 26/10/09.