Mentes do futuro…

Nada como o bom e velho C  =)

Implementando Singleton + Strategy

*****************************************************************************/

Classe main //classe teste

/*****************************************************************************/

package strategy;

public class Teste {

public static void main(String[] args) {

// criei apenas uma classe utilizando o singleton
// nessa classe estão todos os tipos
Tipos camadaDeTipos = Tipos.criarTipoUnico();

Dvd ouro = new Dvd(“Heroes”);
Dvd prata = new Dvd(“Lost”);
Dvd bronze = new Dvd(“Xuxa e os baixinhos”);

// setando os tipos as variáveis ouro prata e bronze
ouro.setCategoria(camadaDeTipos.getTipoOuro());
prata.setCategoria(camadaDeTipos.getTipoPrata());
bronze.setCategoria(camadaDeTipos.getTipoBronze());

// na camada de tipos, possui um default-value
// ouro = 3,00
// prata = 2,00
// bronze = 1,00

//primeiro – irei imprimir esse default-value
System.out.println(“——————– PRIMEIRO PASSO ——————–“);
System.out.println(ouro + “\n”);
System.out.println(prata + “\n”);
System.out.println(bronze);
System.out.println(“\n\n”);

//segundo – iremos modificar o preço dando o dobro do default-value
//          dos itens e imprimi-los
System.out.println(“——————– SEGUNDO PASSO ——————–“);
camadaDeTipos.getTipoOuro().setPreco(6.00);
camadaDeTipos.getTipoPrata().setPreco(4.00);
camadaDeTipos.getTipoBronze().setPreco(2.00);
System.out.println(ouro + “\n”);
System.out.println(prata + “\n”);
System.out.println(bronze);
System.out.println(“\n\n”);

//terceiro – iremos extravazar, modificaremos os objetos de caracteristica
//           ouro     vai ser    Bronze
//           bronze   vai ser    prata
//           prata    vai ser    ouro
System.out.println(“——————– TERCEIRO PASSO ——————–“);
ouro.setCategoria(camadaDeTipos.getTipoBronze());
bronze.setCategoria(camadaDeTipos.getTipoPrata());
prata.setCategoria(camadaDeTipos.getTipoOuro());
System.err.println(“Objeto Ouro”); System.out.println(ouro + “\n”);
System.err.println(“Objeto Prata”); System.out.println(prata + “\n”);
System.err.println(“Objeto Bronze”); System.out.println(bronze + “\n”);
System.out.println(“\n\n”);
}
}

/*****************************************************************************/

Classe Tipos // classe aonde é implementando o singleton, para conter apenas tipos unicos e com propósito de guardar em uma única classe todos os tipos existentes, em nosso exemplo são classificações de tipos em ouro = “mais cara”, prata = “intermediária” e bronze = “mais barata”.

/*****************************************************************************/

package strategy;

public class Tipos {

private Categoria tipoOuro;
private Categoria tipoPrata;
private Categoria tipoBronze;

private static Tipos tipo;

private Tipos() {
tipoOuro = new Categoria(3.0,”ouro”);
tipoPrata = new Categoria(2.0,”prata”);
tipoBronze = new Categoria(1.0,”bronze”);

}

public static Tipos criarTipoUnico()

{   if (tipo == null){     tipo = new Tipos();   }
return tipo;
}

public Categoria getTipoOuro() {   return tipoOuro;   }
public void setTipoOuro(Categoria tipoOuro) {   this.tipoOuro = tipoOuro;    }
public Categoria getTipoPrata() {  return tipoPrata; }
public void setTipoPrata(Categoria tipoPrata) { this.tipoPrata = tipoPrata;  }
public Categoria getTipoBronze() {   return tipoBronze;  }
public void setTipoBronze(Categoria tipoBronze) {  this.tipoBronze = tipoBronze;  }

}

/*****************************************************************************/

Classe DVD //  classe que possui os dvds

/*****************************************************************************/

package strategy;

public class Dvd {

private String titulo;
private Categoria categoria;

public Dvd(String titulo){
this.setTitulo(titulo);

}

public double getPreco(){  return this.getCategoria().getPreco(); //delegacao  }
public String getTitulo() {  return titulo; }
public void setTitulo(String titulo) {  this.titulo = titulo;  }
public Categoria getCategoria() {   return categoria;   }
public void setCategoria(Categoria setandoCategoria) {  this.categoria = setandoCategoria;  }
public String toString() {
return “Titulo : ” + titulo+ “\n” + getCategoria();
}

}

/*****************************************************************************/

Classe categoria // classe aonde está o modelo de tipos diferentes de categorias

/*****************************************************************************/

package strategy;

public class Categoria {
private double preco;
private String nome;

public Categoria(double preco,String nome) {
this.setPreco(preco);
this.setNome(nome);
}

public double getPreco() {  return preco;  }
public void setPreco(double preco) {  this.preco = preco;  }
public String getNome() {  return nome;  }
public void setNome(String nome) {  this.nome = nome;  }
public String toString(){
return “Categoria : ” + nome + “\n” +
“preco : ” + preco ;
}

}
// ps.. caso de algum erro enviar pergunta para jrafaell*bola*msn.com

//*bola* == @

// envio o arquivo tranquilamente, enquanto não arrumo um shared que não expire se você não usar por mais de 1 mês, kkkkkkkkkkkkkk.

Vantágens do linux

Descobri um programinha fácil de instalar e muito legal.

Uma idéia que me ajudou pra caramba…

nome dele é mp3Report, e o que ele faz de tão legal ?

Simplesmente ele pega a pasta aonde tem os msue mp3’s e gera como um (JAVADOC) um documento listando as mp3 e suas informações, muito legal para as pessoas que gostam de catalogar as suas musicas 😀

para instalar tem como fazer no leia-me, mas eu posso colar o migué (a colinha)

1) extrair o arquivo (via programa ou via linha de comando tar xfzv mp3report-1.0.2.tar.gz )

2) entrar na pasta extraida (cd mp3report-1.0.2)

3) executar o programa ( ./mp3report.pl pasta aonde estará as musicas)

exemplo de execução do programa :

./mp3report.pl /media/downloads/mp3

mas aonde eu consigo essa maravilha ???

link para download do programa

http://ufpr.dl.sourceforge.net/sourceforge/mp3report/mp3report-1.0.2.tar.gz

WHY LINUX IS BETTER !

Sua vida digital parece fragmentada ?

Se você já sabe o que é fragmentação, e tem o costume de desfragmentar o seu disco regularmente, aqui está a versão curta: o Linux não precisa de desfragmentação.

Agora imagine que o seu disco rígido é um armário enorme, com milhões de gavetas (obrigado a Roberto Di Cosmo por essa comparação). Cada gaveta pode guardar uma quantidade fixa de dados. Assim, os arquivos que são maiores do que essas gavetas podem suportar, precisam ser divididos. Alguns arquivos são tão grandes que eles precisam de milhares de gavetas. E claro, acessar esses arquivos é muito mais fácil quando as gavetas que ocupam estão próximas uma das outras no armário.

Agora imagine que você seja o dono desse armário, mas você não tem tempo de cuidar dele, e você quer contratar alguém para tomar conta dele para você. Duas pessoas vêm para o emprego, uma mulher e um homem.

• O homem tem a seguinte estratégia: apenas esvazia as gavetas quando um arquivo é removido, divide qualquer novo arquivo em partes menores, do tamanho de uma gaveta, e aleatoriamente guarda cada parte na primeira gaveta vazia disponível. Quando você menciona que isso torna difícil encontrar todas as partes de um determinado arquivo, a resposta é que uma dúzia de garotos devem ser contratados todo fim de semana para reorganizar as coisas.
• A mulher tem uma técnica diferente: tem anotado, num pedaço de papel, as gavetas vazias contíguas. Quando um novo arquivo chega, ela procura em sua lista por uma sequência suficientemente longa de gavetas vazias, e é onde o arquivo é colocado. Deste modo, contanto que haja atividade suficiente, o armário estará sempre arrumado.

Sem dúvida nenhuma, você deve contratar a mulher (vocês sabem disso, as mulheres são muito mais organizadas :)). Bem, o Windows usa o primeiro método; o Linux usa o segundo. Quanto mais você usa o Windows, mais lento fica o acesso a arquivos; quanto mais você usa o Linux, mais rápido ele fica. A escolha é toda sua!

Partituras em branco…

Para aquelas pessoas que precisam de partituras personalizadas, temos este site:

>> http://www.blanksheetmusic.net

Neste website podemos criar vários tipos de partituras(guitarra, violão,tablatura,piano,baixo).

O mais legal, se você está no nivel de mais de um instrumento nas composições, posui uma opção(format staves per set) aonde pode-se dizer quantos instrumentos estão tocando no momento.

Ferramenta porreta!!

uma nerd…

A noção popular de que as pessoas que usam óculos são nerds ou geeks não corresponde com os resultados de um novo estudo…

Um novo estudo australiano olhou para a associação entre a introversão (pessoas tímidas ou ensimesmadas) e a miopia, mal que afeta 20% dos estado-unidenses.

se ela fosse uma nerdzinha assim até eu me chamava de NERD…

Brasil Encacerado… ou não.

Por isso que todos amam o Brasil…

Uma vez eu encontrei uma cela dessas… mas não sabia que banco era uma prisão…

ahh agora entendi…

banco deve ser a prisão do meu dinheiro.

tudo se encaixa agora (yeah!)

Pow assim até eu queria ser preso…

Porque quem te dar flores não tem como fazer o mal.

E assim gera a certeza de ser livre denovo.

Preso assim só por aqui mesmo (yeah!).

Brasil adorado Brasil

Quando vi isto me caguei de rir… XP

Chuck Norris no mundo da informática.

1 – Chuck Norris é o controlador de domínio;
2 – Chuck Norris tem o IP 0.0.0.0 e a porta padrão é 0;
3 – Chuck Norris dá o comando ping 256.256.256.256 e consegue resposta;
4 – Chuck Norris consegue invadir QUALQUER banco com seu palmtop – desligado!;
5 – Chuck Norris usa o Windows XP no seu MAC;
6 – O erro 404 nunca apareceu para Chuck Norris;
7 – Chuck Norris é fluente em linguagem de máquina;
8 – O processador do computador do Chuck Norris não tem cooler;
9 – Chuck Norris lê e grava DVD no drive de disquete;
10 – Chuck Norris é o dono da internet;
11 – Chuck Norris consegue inserir imagens no Notepad;
12 – A impressora matricial do Chuck Norris imprime fotos… coloridas… a uma página por segundo(frente e verso);
13 – Todos os programas pedem desculpas para Chuck Norris antes de mostrar um erro;
14 – Chuck Norris usa o Notepad como banco de dados;
15 – Chuck Norris deu um roundhouse kick no modem de 14400 kbps e agora ele tem ADSL;
16 – Chuck Norris extrai arquivos compactados apenas com o olhar;
17 – Chuck Norris tem um processador AMD em uma placa-mãe Intel;
18 – Chuck Norris nunca recebeu um SPAM;

Auxílio a prova de ARVORES BINÁRIAS E RECURSIVIDADE

Postando um exemplo de arvores aonde criamos 2 arvores com o intúito de auxiliar a prova.

Primeiro temos uma forma de revisarmos como fazer o script de criar uma arvore específica.

Segundo caso é o de criar uma arvore defeituosa e em seguida deixar-la perfeita (seria pegar os espaços em branco, pedaços aonde não possuem folhas e adicionar aonde falta).

• main.c

#include <stdio.h>

#include <stdlib.h>

#include “arvore.h”

int main()

{

int maior=NULL;

int menor=NULL;

arvore auxDaArvore;

arvore novaArvore;

system(“cls”);

novaArvore = inicializa();

auxDaArvore = novaArvore ;

// criando a raiz da árvore

novaArvore = constroi(1);

// criando 2 folhas esquerda e direita

criafilhoesquerdo(novaArvore,2);

criafilhodireito(novaArvore,3);

//vamos andar um nível(esquerda) para baixo da árvore, para andarmos na árvore usamos o Auxiliar da Arvore(auxDaArvore)

// local aonde vai receber a posicao = função do lado a se locomover ( posicao atual );

auxDaArvore = filhoesq(novaArvore);

// agora que nos locomovemos para esqueda e um nivel a mais podemos criar os outros elementos (4,5)

criafilhoesquerdo(auxDaArvore,4);

criafilhodireito(auxDaArvore,5);

//agora que acabamos de locomovermos pelo lado esquerdo da árvore temos que voltar a raiz para podermos

//ir para o lado direito da árvore

auxDaArvore = novaArvore;

//temos que locomovermos uma posicao para continuar a adição de elementos pois já existe o elemento da

//direita da arvore(folha direita da raiz)

auxDaArvore=filhodir(novaArvore);

//agora estamos prontos para criar os filhos esquerdo e direito (7,6)

criafilhoesquerdo(auxDaArvore,7);

criafilhodireito(auxDaArvore,6);

//agora vamos imprimir em todos os tipos, informaremos como argumento a árvore (novaArvore)

printf(“Imprimindo em PREORDEM \n”);

preordem(novaArvore);

printf(“\n\nImprimindo em INORDEM\n”);

inordem(novaArvore);

printf(“\n\nImprimindo em POSORDEM\n”);

posordem(novaArvore);

printf(“\n\n\n\n”);

verificaSeMaiorOuMenor(novaArvore,&maior,&menor);

printf(“Item de maior valor : %d \n”,maior);

printf(“Item de menor valor : %d \n”,menor);

printf(“\n\n\n\n\n\n\n\n\n”);

printf(“Criando esta arvore \n”

“ 3 \n”

“ / \\ \n”

“ 5 6 \n”

“ / \\ / \\ \n”

“ 11 2 9 21 \n”

“ \\ \\ \n”

“ 40 22 \n”);

arvore arv;

arvore aux;

arv = inicializa();

arv = constroi(3);

aux = arv;

criafilhoesquerdo(aux,5);

criafilhodireito(aux,6);

aux = filhoesq(arv);

criafilhoesquerdo(aux,11);

criafilhodireito(aux,2);

aux = filhodir(aux);

criafilhodireito(aux,40);

aux = filhodir(arv);

criafilhoesquerdo(aux,9);

criafilhodireito(aux,21);

aux = filhodir(aux);

criafilhodireito(aux,22);

printf(“Imprimindo em PREORDEM \n”);

preordem(arv);

printf(“\n\nImprimindo em INORDEM\n”);

inordem(arv);

printf(“\n\nImprimindo em POSORDEM\n”);

posordem(arv);

printf(“\n\n\n\n”);

verificaSeMaiorOuMenor(arv,&maior,&menor);

printf(“Item de maior valor : %d \n”,maior);

printf(“Item de menor valor : %d \n”,menor);

printf( “\nDepois tornando ela perfeita\n”

“ 3 \n”

“ / \\ \n”

“ 5 6 \n”

“ / \\ / \\ \n”

“ 11 2 9 21 \n”

“ / \\ / \\ / \\ / \\ \n”

“ 12 13 39 40 10 12 23 22 \n”);

aux = filhoesq(arv);

aux = filhoesq(aux);

criafilhoesquerdo(aux,12);

criafilhodireito(aux,13);

aux = filhoesq(arv);

aux = filhodir(aux);

criafilhoesquerdo(aux,39);

aux = filhodir(arv);

aux = filhoesq(aux);

criafilhoesquerdo(aux,10);

criafilhodireito(aux,12);

aux=filhodir(arv);

aux =filhodir(aux);

criafilhoesquerdo(aux,23);

printf(“Imprimindo em PREORDEM \n”);

preordem(arv);

printf(“\n\nImprimindo em INORDEM\n”);

inordem(arv);

printf(“\n\nImprimindo em POSORDEM\n”);

posordem(arv);

printf(“\n\n\n\n”);

verificaSeMaiorOuMenor(arv,&maior,&menor);

printf(“Item de maior valor : %d \n”,maior);

printf(“Item de menor valor : %d \n”,menor);

return 0;

}

• arvore.c

#include “arvore.h”

noarv* inicializa(void) {

return NULL;

}

//Verificar se a árvore está vazia

int vazia(arvore arv) {

return (arv == NULL);

}

//Criação de um nó da árvore

/* cria um novo no do tipo arvore e retorna um ponteiro para a arvore criada */

noarv* constroi(int info){

noarv *novo;

if ((novo = aloca()) == NULL)

return NULL;

novo->dado = info;

novo->esq = NULL;

novo->dir = NULL;

return(novo);

}

//Criar filho esquerdo

/* Verifica se a arvore nao esta nula ou se se tem filho esquerdo.

Caso nao tenha filho esquerdo, sera construido um novo no a partir da

arvore passada como parametro */

int criafilhoesquerdo(arvore arv, int info){

noarv *novo;

if (arv == NULL)

return ERRO;

else if (arv->esq != NULL)

return ERRO;

else {

novo = constroi(info);

arv->esq = novo;

}

return OK;

}

//Alocar um nodo para a árvore

noarv* aloca(void) {

return ( (noarv*) malloc(sizeof(noarv)));

}

//Criar filho direito

/* Verifica se a arvore nao esta nula ou se se tem filho direito. Caso nao

tenha filho direito, sera construido um novo no a partir da arvore passada

como parametro */

int criafilhodireito(arvore arv, int info){

noarv *novo;

if (arv == NULL)

return ERRO;

else if (arv->dir != NULL)

return ERRO;

else {

novo = constroi(info);

arv->dir = novo;

}

return OK;

}

//Ir para o filho esquerdo

/* Caminha para o filho esquerdo da arvore passada como parametro, retornando

o endereco deste no’ */

noarv* filhoesq(arvore arv) {

if (vazia(arv))

return NULL;

else

return ( arv->esq );

}

//Ir para o filho direito de uma árvore

/* Caminha para o filho direito da arvore passada como parametro, retornando

o endereco deste no’ */

noarv* filhodir(arvore arv) {

if (vazia(arv))

return NULL;

else

return ( arv->dir );

}

//Pesquisar um nodo

int busca( arvore arv, int info ) {

if (vazia(arv))

return ERRO; // Nao encontrou o nodo

if ( info == arv->dado)

return OK;

else if (busca(arv->esq, info))

return OK;

else

return busca(arv->dir, info);

}

//Imprimir a árvore em pré-ordem

/* Esta procedure deve percorrer recursivamente a arvore, visitando todos

os nos e imprimindo sua informação, segundo o percurso em pré-ordem */

void preordem(arvore arv) {

if (!vazia(arv)) {

printf(“%d\t”, arv->dado);

preordem(arv->esq);

preordem(arv->dir);

}

}

//Imprimir a árvore em in-ordem

/* Esta procedure deve percorrer recursivamente a arvore, visitando todos

os nos e imprimindo sua informação, segundo o percurso em in-ordem */

void inordem(arvore arv) {

if (!vazia(arv)) {

inordem(arv->esq);

printf(“%d\t”, arv->dado);

inordem(arv->dir);

}

}

//Imprimir a árvore em pós-ordem

/* Esta procedure deve percorrer recursivamente a arvore, visitando todos

os nos e imprimindo sua informação, segundo o percurso em pós-ordem */

void posordem(arvore arv) {

if (!vazia(arv)) {

posordem(arv->esq);

posordem(arv->dir);

printf(“%d\t”, arv->dado);

}

}

int buscarMaior(arvore arv , int *maior){

if (vazia(arv)) return 0;

if (maior ==NULL)

maior = arv->dado;

if (*maior < arv->dado)

*maior = arv->dado;

buscarMaior(arv->esq,maior);

buscarMaior(arv->dir,maior);

return 1;

}

int verificaSeMaiorOuMenor(arvore novaArvore,int *maior,int *menor){

if(vazia(novaArvore))

return 0;

if (*maior == NULL && *menor==NULL){

*maior = *menor = novaArvore ->dado;

}

if(novaArvore->dado > *maior){

*maior= novaArvore->dado;

}else{

if(novaArvore->dado < *menor){

*menor= novaArvore->dado;

}

}

verificaSeMaiorOuMenor(novaArvore->esq, maior,menor);

verificaSeMaiorOuMenor(novaArvore->dir,maior,menor);

return 1;

}

• Arvore.h

#include<malloc.h>

#include<stdio.h>

#define ERRO 0

#define OK 1

typedef struct stnoarvore {

int dado;

struct stnoarvore *esq;

struct stnoarvore *dir;

}noarv;

typedef noarv* arvore;

noarv* inicializa(void);

int vazia(arvore);

noarv* constroi(int);

int criafilhoesquerdo(arvore,int);

noarv* aloca(void);

int criafilhodireito(arvore,int);

noarv* filhoesq(arvore);

noarv* filhodir(arvore);

int busca(arvore,int);

void preordem(arvore);

void inordem(arvore);

void posordem(arvore);

int verificaSeMaiorOuMenor(arvore,int *,int *);

int buscarMaior(arvore,int*);

Estudo de Fundamentos de Sistemas de informação

Trabalhos de FSI

E-health

• Termo utilizado quando falamos em comunicação entre saúde e a população, seu objetivo é expandir o conhecimento, melhorar os procedimentos utilizados com o auxilio da tecnologia da informação; Disponibilizando a pratica de recolhimento de dados com rapidez, segurança e sem duplicação e com isso a integridade.

E-Learning

• Processo de formar educação auxiliando a gestão de conhecimentos dos usuários diminuindo custo de locomoção de cursos antes ministrados localmente, passando a ministrar cursos via web, possui 2 formas de classificação:
  1. Forma síncrona, aulas ministradas em sala de aula com auxilio de recursos televisivos e chats para comunicação com o professor.
  2. Forma assíncrona, aulas empacotadas aonde são assistidas em qualquer lugar e a comunicação aluno-professor dar-se pela utilização de e-mails.

BI

• Chamado de “inteligência de negócios” trata de coletar(armazenar em um datawherehouse), organizar e analisar(data mining), compartilhar (passar para os indiviuos os dados traduzidos em infromações que eles entendam e analisem) e monitorar as informações da empresa, pois os conjuntos de regras ampliam os recursos disponíveis facilitando as tomadas de decisões.

EDI

• Intercâmbio eletrônico de dados é a tecnologia fundamental na transferência de dados através de transações automáticas entre máquinas gerando padrões de comunicação com ferramentas EDI. Possibilita a comunicação correta entre empresas, facilitando troca de informações entre fornecedores e empresas, gerando a diminuição dos estoques. Permite que a empresa possua a quantidade certa na hora certa. Com o recurso de visualização do seu estoque, ocorre que os fornecedores podem suprir essa quantidade em estoque que agora está em baixa,abastecendo um estoque mínimo e com isso diminuindo a perda de itens pela validade(mesmo itens não perecíveis são possui data de validade, pelo fato de itens fabricados ano passado não possui mesmo valor do ano atual, mas gastos em produção consegue ser iguais ou superiores a produtos produzidos atualmente).

E-GOVERNMENT

• São basicamente sites governamentais que abrangem os três poderes, legislativo, judiciário e executivo; Tem serventia de ser um canal de comunicação entre o governo e a população fornecendo serviços, aonde a população pode acompanhar-los ou requisitar-los pois alguns deles possuem funções que permitem comunicação e resolução de problemas é possível conseguir isto entrando nos portais ponto gov.

Ética

• Conjunto de normas e regras básicas para um profissional saber se portar em um determinado local(trabalho). É preciso e requisitado quando se entra em uma empresa, pois para manter os dados e aumento em sua integridade e segurança precisa de profissionais que saibam agir corretamente assim protegendo dados importantes, confidenciais e cruciais para o bom andamento de uma empresa.

Segurança

• Mecanismos que possibilitam que os dados cheguem com integridade aos receptores, para isto utilizam mecanismos de criptografia e funções hash para garantir que o dado chegue corretamente e que esse dado seja autêntico.

SCM

• 1ª definição

Seria a integração dos participantes do canal de distribuição com propósito de interligar as diversas unidades organizacionais e os membros do canal, desde o consumidor final até o fornecedor de matérias primas.

• 2ª definição

Seria um conjunto de processos que interligam a cadeia de suprimentos que unidos com o marketing, pesquisa e desenvolvimento, fabricação e logística geram uma redução de custos.

ECR (utilizado na atualidade)

• Objetiva integrar indústrias atacadistas e varejistas na busca pela eficiência em toda a cadeia de suprimentos, com o intuito de suprir a satisfação o consumidor. Trabalha no setor de produtos de consumo e varejo alimentar.

JIT (JUST IN TIME)

• Projeto que inicialmente começou na industria de automóveis japonesa cujo propósito era calcular e organizar a confecção de automóveis reduzindo os estoques e produzindo com rapidez para suprir a demanda.

QR (QUICK RESPONSE)

• É Considerada uma modificação melhorada do JIT aplicada no ramo de indústrias têxteis e de vestuário, cujo propósito é o mesmo de reduzir estoques e diminuir a perda de produtos por validade.

ECR – QR – JIT

• Na tentativa de melhorar a eficiência do JIT surge o QR, que foi introduzido no setor de alimento higiene e beleza.
• ECR é uma versão aperfeiçoada do QR que por sua vez é uma versão modificada do JIT.
• O ECR representa para cadeia de suprimentos de mercearia básica que o processo produtivo do JIT significou para a indústria automobilística japonesa e o QR para as indústrias têxteis.

JIT – QR

• Intensificação das relações de cooperação para maior eficiência.
• A Função de distribuição se torna estratégica nas organizações
• Foco nas necessidades dos consumidores, eliminando desperdícios e melhorando produtos e processos.

MARKETING INTEGRADO

• Varejistas e seus fornecedores, passam a unir esforços, recursos me programas que visam uma oportunidade de marketing emergente.

SELF-SERVICE

• Redução dos serviços tradicionalmente oferecidos
• Foco na eliminação de custos para conseguir operar com preços extremamente baixos.

Um canal de distribuição podem ser classificados em 2 grupos: membros primários e membros especializados.

Membros primários

• São aqueles que participam diretamente, assumindo o risco pela posse do produto, e incluem fabricantes, atacadistas, distribuidores e varejistas.

Membros secundários

• São aqueles que participam indiretamente, basicamente através da prestação de serviços aos membros primários, não assumindo o risco da posse do produto. Exemplo transportadoras,armazenagem e prestadores de serviços.
  

Processo de desverticalização

• Vem com a necessidade de não possui todas as funções da fábrica terceirizando-as repassando para prestadores de serviços especializados a maioria das operações produtivas