************************************
********** ICC2 - Resumo **********
************************************

Data     : 11/12/2001
Versão   : 04/07/2007
Professor: Edson Satoshi Gomi
Autor    : Leandro Salvador ( leandrosalvador.com.br )

* Montador
- traduz cada instrução do código-fonte para uma única instrução de máquina
- a linguagem Assembly é muito próxima da linguagem de máquina, na proporção de 1 instrução Assembly corresponder a 1 instrução binária, por isso o montador, qua transforma de Assembly para binário, traduz de 1 (Assembly) para 1 (binário)

* Compilador
- produz diversas instruções em linguagem de máquina para obter o equivalente a uma única instrução do código fonte

* Paradigma Imperativo (Procedimental)
- analisa um problema buscando um método para resolvê-lo

* Paradigma Declarativo
- descobrir e implementar um algoritmo geral para solucionar problemas
- descrição do problema a ser solucionado

* Paradigma Funcional
- resolve um problema levando em consideração a entrada, a saída desejada e a transformação necessária para produzir tal saída à partir da entrada fornecida
- funções complexas são construídas através do aninhamento de funções mais simples, de forma modular
- descreve a solução do problema baseando-se na solução dos problemas menores

* Paradigma Oriantado a Objetos
- divide um programa em módulos conhecidos como objetos, que são implementados como uma unidade independente e bem definida
- descreve os elementos do ambiente do problema

* Gerações de Linguagens
- as linguagens das gerações mais recentes permitem que o programa seja expresso mais nos termos do ambiente do problema e menos nos termos da ininteligibilidade do computador, como faziam as linguagens das primeiras gerações

* Requisitos de Sistema
- necessidades de um sistema postas nos termos do ambiente aplicativo

* Especificações de Sistema
- necessidades de um sistema em termos técnicos, identificando de que maneira tais necessidades serão satisfeitas

* Etapas da fase de desenvolvimento do ciclo de vida do software
- Análise
    - determina o que o sistema proposto deve realizar
- Projeto
    - como o sistema realiza suas mentas
- Implementação
    - construção do sistema
- Teste
    - obter a certeza de que o sistema faz o que dele se espera
- Modelo da Cachoeira
    - as fases de análise, projeto, implementação e teste devem ser executadas de maneira seqüêncial
- Modelo da Prototipação
    - permite um método mais flexível, de tentativa-e-erro
- Documentação
    - pode-se preparar tanto na fase de desenvolvimento como na de modificação
    - pode-se documentar nos manuais que acompanham o software interno do programa-fonte na forma de comentários e códigos bem redigidos, por meio de mensagens interativas que o próprio programa escreve no terminal, por meio de dicionários de dados, e na forma de documentos de projeto, tais como diagramas estruturais (NS e/ou Fluxogramas), diagramas de fluxo de dados e diagramas completos das relações

* Diagrama NS

- diagrama NS tem 3 estruturas básicas:

 _____________________
| x <- 1;             | --> ATRIBUIÇÃO
|---------------------|
| enquanto x < 5 faça | --> ITERAÇÃO
|   ------------------|
|  | imprima x;       |
|   ------------------|
|  | x <- x + 1;      |
 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

- exemplo de programa em Java baseado no Diagrama NS acima (utilizando while):

...
int x = 1;
while(x < 5)
    {
    ...print(x);
    x = x + 1;
    }
...

- exemplo de programa em Java baseado no Diagrama NS acima (utilizando for):

...
int x;
for(x = 1; x < 5; x++)
    {
    ...print(x);
    }
...

- outro exemplo de Diagrama NS:

 ______________________________________
| n <- 6;                              |    --> ATRIBUIÇÃO
|--------------------------------------|
| maior <- a[1];                       |    --> ATRIBUIÇÃO
|--------------------------------------|
| k <- 1;                              |    --> ATRIBUIÇÃO
|--------------------------------------|
| enquanto k <= n faça                 |    --> ITERAÇÃO
|   |----------------------------------|
|   | sim    \ a[k] > maior? /    não  |    --> CONDICIONAL
|   |----------------------------------|
|   | maior <- a[k];     |       nada; |    --> se a[k] > maior, atribui, senão não
|   |----------------------------------|
|   | k <- k + 1;                      |    --> após o condicional (if), incrementa k
|--------------------------------------|
| imprima maior;                       |    --> após a iteração (while), imprime maior
 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

- teste de mesa do Diagrama NS acima:

n   6                       --> tamanho
k   1   2   3   4   5   6   --> posição
a   14  21  7   16  48  30  --> valor

----------//----------