24 de fevereiro de 2010

Atividade 1 - Matrizes

Utilizando linguagem C, resolva os problemas abaixo. Entregue as respostas separadamente até o dia 19/02 as 23:55h

1- Calcular a determinante de uma matriz 4x4 através do método de Sarrus.


#include <stdio.h>
#include <math.h>
#include <conio.h>

int calcSarrus(int matriz[4][4], int coluna);

void main(void)
{

int matriz[4][4];
float dt;
int linha, coluna;

clrscr();

for(linha = 0; linha < 4; linha++){
for(coluna = 0; coluna < 4; coluna++){
printf("\nEntre com o valor de [%d][%d]: ", linha, coluna);
scanf("%d", &matriz[linha][coluna]);
}
}

printf("\nMatriz:\n");
for(linha = 0; linha < 4; linha++){
for(coluna = 0; coluna < 4; coluna++){
printf("\t[%d]", matriz[linha][coluna]);
}
printf("\n");
}

dt = 0;
for(coluna = 0; coluna < 4; coluna++){
dt += matriz[0][coluna] * pow(-1,(0+coluna)) * calcSarrus(matriz, coluna);
}

printf("\nValor da Determinante: %.0f", dt);

getch();

}

int calcSarrus(int matriz[4][4], int coluna){
int i, j, x, y, dt;
int m_temp[3][5];

x = 0;
y = 0;

for(i = 1; i < 4; i++){
for(j = 0; j < 4; j++){
if(j != coluna){
m_temp[x][y] = matriz[i][j];
if(y < 2)
m_temp[x][y+3] = matriz[i][j];
y++;
}
}
y = 0;
x++;
}

dt = (m_temp[0][0] * m_temp[1][1] * m_temp[2][2]) + (m_temp[0][1] * m_temp[1][2] * m_temp[2][0]) + (m_temp[1][1] * m_temp[1][0] * m_temp[2][1]) - (m_temp[0][0] * m_temp[1][2] * m_temp[2][1]) - (m_temp[0][1] * m_temp[1][0] * m_temp[2][2]) - (m_temp[0][2] * m_temp[1][1] * m_temp[2][0]);

return dt;

}


2- Resolver um sistema de duas equações a duas incógnitas através do método de Cramer.


#include <stdio.h>>
#include <conio.h>

void main(void)
{
int a1=0, a2=0, b1=0, b2=0, c1=0, c2=0;
float x,y,d,dx,dy;

clrscr();

printf("\na1: ");
scanf("%d", &a1);
printf("\nb1: ");
scanf("%d", &b1);
printf("\nc1: ");
scanf("%d", &c1);
printf("\na2: ");
scanf("%d", &a2);
printf("\nb2: ");
scanf("%d", &b2);
printf("\nc2: ");
scanf("%d", &c2);

d = (a1 * b2) - (a2 * b1);
dx = (c1 * b2) - (c2 * b1);
dy = (a1 * c2) - (a2 * c1);

if (d != 0.0){
x=(dx / d);
y=(dy / d);
}

printf("\nX: %.2f", x);
printf("\nY: %.2f", y);

getch();

}

22 de fevereiro de 2010

Ataques ao Google podem ter partido de instituições chinesas de ensino

E ai mais um capítulo do combate (Guerra) entre Google x Crackers Chineses ( ou quem sabe, o governo chiêns) O.o

Ataques ao Google podem ter partido de instituições chinesas de ensino

Por IDG News Service

Publicada em 19 de fevereiro de 2010 às 10h57
Investigação aponta que uma universidade e uma escola de vocação estão envolvidas nos ataques, que teriam começado em abril de 2009.
Especialistas em segurança investigaram os ataques feitos ao Google e outras empresas dos Estados Unidos e concluíram que computadores de instituições educacionais chinesas podem estar envolvidos, de acordo com relatos da mídia dos EUA.

Os ataques podem ter começado em abril, disseram fontes anônimas envolvidas na negociação ao jornal New York Times. O Google revelou em janeiro que seus sistemas foram atacados, mas disse que o começo dos eventos foi em dezembro.

As instituições supostamente envolvidas são a Universidade Shanghai Jiaotong e a Escola Vocacional Lanxiang, segundo o New York Times.

Crackers, porém, frequentemente disfarçam a identidade mandando comandos por diversos computadores até alcançarem o alvo. Assim, mesmo que investigações mais aprofundadas sustentem os resultados citados, elas podem não apontar para o envolvimento de chineses no ataque, já que a trilha pode ir além disso. Investigadores ainda trabalham com uma série de teorias, de acordo com o New York Times.

O Google anunciou em janeiro que crackers tentaram entrar em contas do Gmail de ativistas de direitos humanos na China. Durante a investigação, a empresa descobriu que companhias dos Estados Unidos de internet, finanças, tecnologia, mídia e químicas também foram atacadas.

19 de fevereiro de 2010

Inscrição em Disciplinas

Horário de Atendimento: Segundas, Quartas e Sextas (18h-19h) Campus Urbanova


INSCRIÇÃO EM DISCIPLINAS: TODOS OS ALUNOS DEVEM PREENCHER O FORMULÁRIO DE INSCRIÇÃO EM DISCIPLINA E ENTREGAR NO TUDO AQUI ATÉ 26 DE FEVEREIRO. SEGUE DOIS MODELOS:

- FORMULÁRIO PARA PREENCHIMENTO MANUAL

- FORMULÁRIO PARA PREENCHIMENTO DIGITAL

OBS: NO FORMULÁRIO DEVE CONSTAR TODAS AS DISCIPLINAS QUE DESEJA CURSAR NESTE SEMESTRE COM TODAS AS INFORMAÇÕES CORRETAS (CÓDIGO, NOME, TURMA E TURNO).

Supermanual: como aumentar o seu QI

Hoje em dia as pessoas não se destacam mais pelo seu QI, porém, essa matéria talvez seja boa para nós, futuros cientistas da computação ou programadores! OMG!!

Nunca pensei que seria um cientista...
muito menos um garoto de programa..  ¬¬
vida sarcástica!

"
Você lê livros de teorias freudianas, calcula a raiz quadrada das ovelhinhas quando vai dormir, estuda conceitos filosóficos. Mas chega uma hora que ficar mais esperto é muito difícil. a solução: juntamos estudos que provam ser possível aumentar sua capacidade cognitiva.  
por Texto Nina Weingrill"...

http://super.abril.com.br/historia/como-aumentar-seu-qi-446948.shtml



17 de fevereiro de 2010

Projeto III - Problemas A e B

Problema A
Copa do Mundo


Nome do arquivo fonte:
copa.c, copa.cpp ou copa.java

Uma Copa do Mundo de futebol de botões está sendo realizada com times de todo o mundo.

A classificação é baseada no número de pontos ganhos pelos times, e a distribuição de pontos é feita da forma usual. Ou seja, quando um time ganha um jogo, ele recebe 3 pontos; se o jogo termina empatado, ambos os times recebem 1 ponto; e o perdedor não recebe nenhum ponto.

Dada a classificação atual dos times e o número de times participantes na Copa do Mundo, sua tarefa é de determinar quantos jogos terminaram empatados até o momento.

Entrada

A entrada contém vários casos de teste. A primeira linha de um caso de teste contém dois inteiros

O final da entrada é indicado por uma linha que contém apenas o número zero.

T e N, indicando respectivamente o número de times participantes (2<=T<=200) e o núumero de partidas jogadas (0 <=N<=104). Cada uma das T linhas seguintes contém o nome de um time (uma cadeia de máximo 10 letras e dígitos), seguido de um espaço em branco, seguido do número de pontos que o time obteve até o momento.Os dados devem ser lidos da entrada padrão

Saída

Para cada um dos casos de teste seu programa deve imprimir uma única linha contendo um número inteiro, representando a quantidade de jogos que terminaram empatados até o momento.

O resultado de seu programa deve ser escrito na saída padrão.

Exemplo de entrada:

3 3

Brasil 3

Australia 3

Croacia 3

3 3

Brasil 5

Japao 1

Australia 1

0 0

Exemplo de saída:

0

2

Possível solução:
Fatos:
Quantidade Total de pontos é igual a 2 vezes o número de empates + 3 vezes o número de vitórias, (QTP = 2EMP+3TV).
O número total de partidas é igual ao número de empates + o número de vitórias,
(TP = EMP+TV).
Tudo isso é obvio se você pensar pensar pensar!!!

Equações:
QTP = 2EMP+3TV
TP = EMP+TV

QTP = Quantidade total de pontos;
EMP = Empates;
TV = Total de vitórias;
TP = Total de partidas.

Conclusão útil:
QTP = 3TP-EMP
ou
EMP = 3TP - QTP

Usando no exemplo dado:
1°
3 3
3
3
3

QTP = 9 ( 3+ 3 + 3)
TP = 3
EMP = 3 * 3 - 9 = 0

2°
3 3
5
1
1

QTP = 7 (5 + 1 + 1)
TP = 3
EMP = 3 * 3 - 7 = 2
Problema B

Suco de Acerola

Nome do arquivo fonte:

suco.c, suco.cpp ou suco.java

Natural das Antilhas, a acerola

Um grupo de amigos está visitando o Sítio do Picapau Amarelo, renomado produtor de acerola. Com a permissão de Dona Benta, dona do sítio, colheram uma boa quantidade de frutas, e pretendem agora fazer suco de acerola, que será dividido igualmente entre os amigos durante o lanche da tarde.

Conhecendo o número de amigos, a quantidade de frutas colhidas, e sabendo que cada unidade da fruta é suficiente para produzir 50 ml de suco, escreva um programa para determinar qual o volume, em litros, que cada amigo poderá tomar.

Malpighia glabra Linn, também conhecida como cereja das Antilhas) já era apreciada pelos nativos das Américas há muitos séculos. Mas o grande interesse por essa fruta surgiu na década de 1940, quando cientistas porto-riquenhos descobriram que a acerola contém grande quantidade de ácido ascórbico (vitamina C). A acerola apresenta, em uma mesma quantidade de polpa, até 100 vezes mais vitamina C do que a laranja e o limão, 20 vezes mais do que a goiaba e 10 vezes mais do que o caju e a amora.

Entrada

A entrada contém vários casos de teste. Cada caso de teste é composto por uma única linha, contendo dois números inteiros

O final da entrada é indicado por uma linha que contém apenas dois zeros, separados por um espaço em branco.

N e F, indicando respectivamente o número de amigos (1<=N <= 103) e a quantidade de de frutas colhidas (1<= F <= 103). Os dados devem ser lidos da entrada padrão Saída

Para cada caso de teste da entrada seu programa deve imprimir uma única linha, contendo um número real, escrito com precisão de duas casas decimais, representando o volume de suco, em litros, a que cada amigo tem direito.

O resultado de seu programa deve ser escrito na saída padrão

Exemplo de entrada:

1 1

5 431

101 330

0 0

Exemplo de saída:

0.05

4.31

0.16

Possível solução:
Este é o mais simples, suponhamos que as entradas sejam A e B, a saída será:
B * 0.05 / A

Usando no exemplo dado:
1°
1 1
1 * 0.05 / 1 = 0.05

2°
5 431
431 * 0.05 / 5 = 4.31


Agora é só fazer o leitor das informações dadas!

lol

Download do Turbo C

Para fazer o download do Turbo C, clique Aqui.
Ainda vou descobrir o porque de chamar essa coisa de Turbo...

14 de fevereiro de 2010

Questão de Lógica!!!

Existem duas portas, uma que leva ao céu, e outra que leva ao inferno. Cada porta é protegida por um guardião. Um deles só diz a verdade, e o outro só diz mentira. Você não sabe qual porta leva ao céu ou ao inferno, nem sabe quem fala verdade ou mentira (não necessariamente o que fala mentira guarda a porta do inferno, tome cuidado na resposta). Partindo disso, diga como proceder para passar pela porta que leva ao céu sendo que, você pode fazer uma única pergunta a somente um dos guardiões. Você só tem uma chance de perguntar a uma pessoa, se errar, será jogado automaticamente no inferno.

Detalhes Adicionais

Dois guardiões, um só fala mentira (tudo o que ele diz é mentira) e o outro só fala a verdade (tudo o que ele diz é verdade). O problema é: não se sabe se o guardião que só fala a verdade realmente guarda a porta que leva ao céu, e se o guardião que fala a verdade guarda a porta que leva ao inferno? Esse é o maior problema. Se eu tivesse dito que o guardião que só fala verdade guarda a porta do céu e o guardião que só fala mentira guarda a porta do inferno, o problema estaria resolvido. Mas não é o caso, eu não sei quem mente e quem fala a verdade e naum sei qual a porta do céu ou do inferno, entenderam? Tem gente achando que o guardião que só fala verdade guarda a porta do céu, isso pode não ser verdade. Pensem bem.

13 de fevereiro de 2010

Informativo!!!

Segue nome do representante discente do curso de ciência da computação na congregação da FCSAC eleito no dia 11/02/2010.

Diogo Akira Wakabayashi.

*Eu mesmo kkk

12 de fevereiro de 2010

Anatel também será acionada pelo Idec para garantir serviço de banda larga

Anatel também será acionada pelo Idec para garantir serviço de banda larga



Órgão de defesa do consumidor dará prosseguimento à ação contra operadoras e agência para exigir mudanças em contratos de serviços.


O Instituto Brasileiro de Defesa do Consumidor (Idec) decidiu dar continuidade a uma ação civil pública que obriga as operadoras de telefonia a oferece a velocidade contratada pelo consumidor, incluindo a Agência Nacional de Telecomunicações (Anatel) no processo.

A mudança ocorre após uma decisão judicial proferida na quarta-feira (9/2) pelo juiz João Batista Gonçalves, da 6ª Vara Federal da Seção Judiciária de São Paulo, afirmando que a agência não poderia ser responsabilizada por exigir das operadoras de telefonia o cumprimento da velocidade dos serviços de banda larga. Em seu parecer, o juiz afirma que as operadoras e o consumidor possuem uma “relação jurídica privada”.

A ação civil, que envolve as operadoras Telefônica, Net São Paulo, Brasil Telecom e Oi (Telemar Norte Leste), agora também se estende à Anatel. “Nesse atual cenário, o Idec dará continuidade à ação, para se fazer cumprir o direito do consumidor”, afirma o órgão de defesa em um comunicado emitido nesta quarta-feira (10/2).

Velocidade ‘real’ e pagamento por serviço
O objetivo do Idec é exigir alterações nas cláusulas contratuais das operadoras, que as eximem de sua responsabilidade em cumprir a oferta da velocidade de acesso a banda larga. Atualmente, em média, os contratos de nível de serviço garantem apenas 10% da velocidade contratada pelo internauta.

A ação do Idec também prevê que a Anatel determine que as operadoras esclareçam ao consumidor a efetiva velocidade da banda larga entregue, incluindo a informação na fatura mensal do serviço, ou sempre que o consumidor pedir.

O pedido da ação pública da banda larga foi motivado por uma pesquisa realizada pelo Idec entre maio de 2008 e novembro de 2009, que apontou as irregularidades do setor.

O órgão também pede que o usuário de banda larga pague somente pelo serviço utilizado e que possa rescindir o contrato, sem pagar multas, caso o serviço entregue não esteja de acordo com o contratado.

Fonte:  http://idgnow.uol.com.br/telecom/2010/02/11/idec-inclui-anatel-em-acao-para-garantir-velocidade-de-banda-larga/


Obs: Finalmente, alguém tem que lutar pelo nosso direito, porque a internet no Brasil é uma verdadeira merda.

Aviso!!!

Dia 18/02 quinta-feira após carnaval nossa aula será a distância.

Acessem o AVA e vejam as atividades e as respectivas datas de entrega.

voltamos a nos encontrar no dia 25 de fevereiro

*1 dia sem ir pra facul xD

10 de fevereiro de 2010

Lab. de Programação (EAD) - Introdução e Aula 1

Introdução

Dados Gerais:
Linguagem C
100% prática
Modalidade a distância
Equivalente a 3 aulas por semana

Ementa:
Estudo dos tipos mais comuns de algoritmos computacionais, com aplicação pratica a problemas chaves;
Aprendizado das principais técnicas e estratégias na resolução de problemas computacionais;
Resolução de problemas reais com as técnicas e algoritmos aprendidos;
Aplicações em Programação Orientada a Procedimentos

Metodologia:
Ambiente de Apoio (http://ava.univap.br)
Avaliações (presenciais)
13 de abril e 22 de junho
Exame Final (presencial)
29 de junho
Freqüência (não contabilizadas na EAD)

9 de fevereiro de 2010

Pense Matemática!!!

*alguém arrisca abrir???

No Cálculo, a derivada representa a taxa de variação de uma função.

5 de fevereiro de 2010

Um Momento para Refletir

Uma frase para todos refletirem um pouco.


“Adoraria mudar o mundo, mas não me deram o código-fonte...”
                                                                                                         Autor Desconhecido

4 de fevereiro de 2010

Marcando Presença na Campus Party

Fernandão esta famoso, aparecendo no JN, Sábado dia 30/01/2010, confira no minuto 1:19:

3 de fevereiro de 2010

Começou bem?

Prezados Alunos, que irão cursar a disciplina PROJETO MULTIDISCIPLINAR III
(QUINTA-FEIRA).

Infelizmente, nesta quinta-feira não poderei dar aula em virtude de um
compromisso que eu assumi anteriormente...

Novo Contribuinte!!

Olá Pessoal!!
Meu nome é Felipe Antonio Cardoso (Negão xD), e a partir de hoje serei um dos administradores do blog da faculdade de Ciência da Computação.
Participarei ativamente das atividades do Blog e sempre que possível postarei novidades uteis.

OBS: Prometo que falarei o mínimo de besteiras possíveis no Blog, aqui eu tenho tempo de pensar antes de falar xD

2 de fevereiro de 2010

Return to Begin...

Pessoal, já já blog de cara nova e com mais administradores, aguardem! há!

Calendário 2010
Horários 2010

24 de dezembro de 2009

Feliz Natal!

:)

14 de dezembro de 2009

Boliche!

Quando: Amanhã (15 de dezembro);
Horário: 18:30 ~ 19:00 hs
Local:Dragon Bowling Shopping Colinas.

Boraa!!!

1 de dezembro de 2009

Código Fonte - Projeto II

Se alguém quiser baixar o código fonte do projeto, esta aí!

Parabéns pra você, nessa data querida... ^^

Tirando todos os dias 11000 do ano, hoje é oficialmente o niver do Negão! xD
Parabéns para o premiado da nossa turma.

30 de novembro de 2009

Semana de Provas!

Estudem! oO

24 de novembro de 2009

Projeto II - Fase 4

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

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.

12 de novembro de 2009

Banco de Dados I - 10

Normalização

Exercício X:



Primeiro



Segundo



ps. Não sei se está correto, não entendi quase nada do era para fazer... ^^

Banco de Dados I - 09

Banco de Dados III

Exercício IX:

Utilizando os dois exercícios feitos na Aula 8, passar do modelo conceitual para o modelo lógico relacional, conforme o exemplo da aula da Vídeo Locadora.

Resolução em breve. :P

3 de novembro de 2009

Função "CAPS" do YouTube ™ by Negão.

Clique na imagem para ampliá-la

23 de outubro de 2009

Banco de Dados I - 08

Banco de Dados I
Banco de Dados II

Exercício VIII:

1) Uma Empresa possui funcionários. Um funcionário trabalha em uma Empresa.



2) Os Atletas participam de competições. Em uma competição participam vários atletas.



3) Deseja-se fazer um banco de dados para uma rede de hotelaria. Um hotel possui quartos. Cada quarto pertence a apenas um hotel.



4) Um soldado, que possui as características nome, Registro Militar (RM), data de nascimento, possui armas. Uma arma, que possui as características de série, registro e calibre, é de um soldado. Uma arma é limpa por vários soldados. Um soldado limpa várias armas.



5) Um médico trata de pacientes. Do médico deseja-se saber CRM, nome e suas especializações. Um paciente, no qual há a necessidade de sabermos seu nome, endereço e idade, é tratado por vários médicos. Um paciente realiza vários tipos de exames. Um tipo de exame, destes há a necessidade de guardar seu número, data e descrição, é feito por vários paciente.



6) Construir um DER de uma Companhia de Seguros - Slide



7) Crie um Diagrama de ER com as seguintes informações:

Um cliente faz pedidos de produtos. Os produtos são fornecidos por produtores que se encontram em várias cidades do país.
Cada cliente nasceu e mora em uma Cidade. A empresa produtora tem funcionários que trabalham no período diurno e noturno.
Os clientes podem utilizar para pagamento cartões de crédito e cartão de débito como também boleto bancário.


Banco de Dados I - 07

Banco de Dados - Introdução

Exercício VII:

1.O que é um SGBD?

Sistema Gerenciador de Banco de Dados é um conjunto de dados que se associam a um conjunto de programas para acesso a esses dados, ou seja, o SGBD proporciona um ambiente tanto conveniente quanto eficiente para a recuperação e armazenamento das informações do banco de dados, além de prover compartilhamento e segurança das mesmas.

2.Cite 3 vantagens de um SGBD?

Consistência de dados e independência de dados;
Facilitam a proteção contra a perda de dados, através de recursos de backup;
Promovem a adoção de padrões para toda a empresa.

3.Quais as principais funções e responsabilidades de um DBA?

O DBA (Database Administrator) é responsável pelo acesso à base de dados, coordenar e monitorar o uso da base de dados, por problemas, tais como, quebra de segurança ou baixo desempenho, ou seja, é o administrador maior da base de dados.

4.Defina: Processamento de Consultas, Administração de Armazenamento de dados e Implementação física do sistema.

- Processamento de Consultas é composto por: Compilador DML - traduz os comandos de baixo nível (DML); Pré-compilador para comandos DML - pré-compilam os comandos DML;

Componentes para o tratamento de consultas - executam as instruções geradas por esse compilador DML.

- Administração de Armazenamento de dados é composto por: Gerenciamento de autorizações e integridade - gerencia as autorizações dos usuários e a integridade dos dados;

Gerenciamento de transações - gerencia as transações garantindo que o banco de dados permaneça em estado constante a despeito de falhas;

Administração de arquivos - administra os arquivos gerenciando a alocação de espaço no armazenamento em disco Administração de buffer, responsável pela intermediação de dados do disco para a memória principal e pela decisão de quais dados colocar em memória cache;

- Implementação física do sistema é composto por: Arquivo de dados - que armazena o próprio banco de dados;

Dicionário de dados - que armazena os meta-dados relativos à estrutura do banco de dados;

Índices - que proporcionam acesso rápido aos itens de dados que são associados a valores determinados;

Estatística de Dados - que armazenam informações estatísticas relativas aos dados contidos no banco de dados. Essas informações são usadas pelo processador de consultas para seleção de meios eficientes para execução de uma consulta.

22 de outubro de 2009

<span> ? </span> - 3


Será?

<span> ? </span> - 2


Optei?

19 de outubro de 2009

No Aula.

Hoje dia 19/10, não terá aula.
o.O'
Não sabemos o por que, mas, é um bom começo de semana, não acham? ^^

17 de outubro de 2009

III INIC Júnior / XIII INIC / IX EPG - FOTOS

Dalton

























Felipe Cardoso




















Felipe Cardoso


Trabalho Pre miado


O orgulho da nossa turma. ^^

15 de outubro de 2009

III INIC Júnior / XIII INIC / IX EPG






Dias 15 e 16 de outubro de 2009

14 de outubro de 2009

1° Maratona de Programação - UNIVAP

A maratona será hoje, 14/10/2009, quem ainda não se inscreveu, ainda da tempo:

http://www1.univap.br/alberto/maratona

7 de outubro de 2009

Notas!

Quando será que vão sair as notas??
Alguém tem a prova de sábado?
=p

30 de setembro de 2009

<span> ? </span> - 1


Sr.(a) [email]? o.O

29 de setembro de 2009

Semana de Provas!

TENSO!

24 de setembro de 2009

Engenharia de Software I - 03

Capítulo 4: Fase Requisitos de Software RS

Fase Requisitos de Software RS (SW I) - Download
Documento liberável DRS - Download

Banco de Dados I - 06

UML - Parte II

Exercício VI:

1 - Com suas palavras definam os 9 diagramas usados nas fases da UML:

Diagrama de use case: Descreve um cenário que mostra as funcionalidades do sistema do ponto de vista do usuário e tem o objetivo de auxiliar a comunicação entre os analistas e o cliente. O cliente deve ver no diagrama de Use Cases as principais funcionalidades de seu sistema.

Diagrama de classes: Tem como objetivo descrever os vários tipos de classes ou objetos no sistema e o relacionamento entre eles. Um diagrama de classes contém entidades e relacionamentos.

Diagrama de objeto: É uma variação do diagrama de classes e utiliza quase à mesma notação. O diagrama de objetos é como se fosse o perfil do sistema em certo momento de sua execução.

Diagrama de estado: Um diagrama de estado mostra os possíveis estados de um objeto e as transações responsáveis pelas suas mudanças de estado.
Diagrama de seqüência: Consiste em um diagrama que tem o objetivo de mostrar como as mensagens entre os objetos são trocadas no decorrer do tempo para a realização de uma operação.

Diagrama de colaboração: A grande diferença entre um diagrama de colaboração e um de seqüência consiste no fato de que o tempo não é mais representado por linhas verticais, mas sim através de uma numeração.

Diagrama de atividade: O objetivo do diagrama de atividades é mostrar o fluxo de atividades em um único processo. O diagrama mostra como uma atividade depende uma da outra.

Diagrama de componente: Os diagramas de componentes representam, de forma estática, aspectos físicos do sistema sendo modelado. Os diagramas mostram um conjunto de componentes e seus relacionamentos.

Diagrama de execução: Exibe a arquitetura física do hardware e do software no sistema. Pode mostrar os atuais computadores e periféricos, juntamente com as conexões que eles estabelecem entre si e pode mostrar também os tipos de conexões entre esses computadores e periféricos.

2 - Faça um Diagrama de Use-case e um Diagrama de Classes de um sistema a sua escolha.
( Não sei se estão certos!) :P

Diagrama de Use-case - Biblioteca



Diagrama de Classes - Biblioteca




Obs. Ninguém vai conseguir entregar na data certa: Data de entrega: quarta, 24 setembro 2008, 22:55... =/