PlayOnLinux ( Seus Games estão migrando também)

Entendendo o Wine e o PlayOnLinux

O Wine, como o próprio nome diz (Wine é um acrônimo recursivo para Wine Is Not Emulator, ou Wine não é emulador), não é um emulador de Windows para Linux, o conceito de emulação requer que você sejam feitas transcrições de instruções de um determinado ambiente para outro, no qual se seja rodar certa aplicação, como ocorre nos emuladores de Vídeo Games, aonde se usa um emulador para interpretar e transcrever os códigos dos jogos escritos para arquiteturas PowerPC, MIPS, e outras, em computadores com processadores x86.

Como estamos lidando com o mesmo ambiente x86, seja no Linux, seja no Windows, não é necessária nenhuma emulação. O que o Wine faz é basicamente recriar uma estrutura de diretórios do Windows, interpretar os executáveis e apontar para eles onde se encontram as bibliotecas (dlls) necessárias para rodar determinadas funções, tudo isso através de um conjunto de APIs que criam está “camada de compatibilidade”. Desta forma nenhum comando é emulado, e as aplicações não sofrem com perdas de desempenho, comuns nos emuladores (onde muitas vezes temos que usar um hardware muito superior ao original para conseguir emular de forma decente um jogo ou aplicativo).

O PlayOnLinux complementa o Wine, de forma que ele age com scripts já prontos para instalação de determinado programa a partir do Wine, deixando o usuário longe da complexidade e configuração do Wine. Os scripts são nada mais que procedimentos que devem ser seguidos e requisitos que devem ser pré cumpridos para a correta instalação e funcionamento do software, o PlayOnLinux interpreta estes scripts e resolve tudo de forma amigável para o usuário. Estes scripts são desenvolvidos e testados pela comunidade que mantém o programa, e são atualizados regularmente, aumentando gradativamente a lista de programas compatíveis.

Apesar de o nome sugerir o PlayOnLinux não é compatível somente com jogos, diversos softwares de produtividade também podem ser instalados a partir do PlayOnLinux.

Instalando o PlayOnLinux

Apesar de algumas distribuições já trazerem o PlayOnLinux nos seus repositórios, é recomendado visitar o site oficial do projeto PlayOnLinux e fazer o download da ultima versão disponível (algumas distribuições, como o Ubuntu, não tem a ultima versão do programa nos seus repositórios). Lá há informações para a instalação do PlayOnLinux nas distribuições mais conhecidas.

Instalando os programas

Após ter o PlayOnLinux instalado, o próximo passo é a instalação dos programas desejados. A interface do PlayOnLinux é bastante simples e intuitiva, basta clicar no botão Instalar, que uma janela com a lista dos programas compatíveis é aberta, basta então escolher o programa e clicar em Aplicar. O PlayOnLinux se encarregará de baixar e instalar a versão correta do Wine e todas as dependências necessárias para o programa escolhido, além do próprio programa, se este for gratuito, restando ao usuário apenas os “Next, Next, Next, Finish” do Windows. Se o programa não for gratuito, ou for distribuído na forma de CDs/DVDs, o PlayOnLinux requisitará que você coloque o CD/DVD na unidade, ou indique aonde se encontra o executável instalador do programa, para prosseguir a instalação.

Janela principal do PlayOnLinux

Os programas são separados em oito categorias (Acessórios, Educação, Jogos, Gráficos,…) e há ainda mais quatro categorias extras: Maior Taxa, Mais baixados, Correções e Testando. A tradução para Português não deixou muito clara qual seria a lógica para Maior Taxa, mas é bem possível que sejam os programas que receberam os melhores votos pela comunidade. Nas categorias Mais baixados você encontra os programas mais instalados pelos usuários, em Correções você encontra principalmente as atualizações e patches mais recentes para os jogos. Em testando encontram-se programas pelos quais os scripts de instalação ainda estão na fase de testes, seu funcionamento não é garantido.

Após a instalação completa o programa passa a aparecer na janela principal do PlayOnLinux, indicando que este está instalado.

Rodando os programas

Rodas os programas é tão ou mais simples que instalá-los, muitos já criam atalhos na área de trabalho do usuário (como acontece no Windows), para os que não criam atalhos, basta abrir o PlayOnLinux, selecionar o programa na janela principal e dar dois cliques com o mouse, ou então clicar no botão Executar. Tão simples que nem precisaria de uma explicação.

Testes

Instalei alguns jogos e programas com o PlayOnLinux rodando no Ubuntu Linux 10.10 para testar seu funcionamento. Foi possível instalar e rodar quase todos os programas testados. O único que não funcionou corretamente foi o iTunes, que começava a carregar repetidamente o processo “AppleMobileDevice” entupindo a memória RAM em poucos minutos, e por vezes parava de funcionar inesperadamente.

O Microsoft Office 2007, que está no topo da lista dos mais baixados funcionou perfeitamente, boa parte deste artigo inclusive foi escrita a partir dele. O Google SketchUp também funcionou corretamente, apresentando apenas alguns erros na renderização dos cursores do mouse, que por vezes ficava contornado por um quadrado branco.

Microsoft Office Word 2007 no Linux

Todos os jogos que foram testados funcionaram corretamente, entre eles: Age of Empires III, e a sua expansão The WarChiefs; Far Cry 2; FIFA 11; Full Tilt Poker e o Prince of Persia – The Forgotten Sands. Mas como o site do projeto já avisa, nem todos os efeitos gráficos estão disponíveis em todos os jogos, às vezes foi necessário desabilitar alguns efeitos que apresentavam erros na renderização. Entretanto, a jogabilidade é perfeita.

Age Of Empires III - The WarChiefs, rodando em janela, no Linux

Considerações finais:

A lista de programas listados com compatibilidade é razoavelmente grande, temos softwares como o Microsoft Office, e até jogos bem atuais, como o Far Cry 2 e FIFA 11, porém existem programas que só estão disponíveis em versões mais antigas, como o AutoCAD que só está disponível das versões de 2000 até 2008. É compreensível que as versões mais novas dos programas sejam mais difíceis de serem trazidas para o Linux, visto que a complexidade dos programas aumenta, necessitando de muito mais esforços para seu funcionamento correto fora do sistema para o qual foi desenvolvido.
Como foi possível notar, nem tudo são flores no PlayOnLinux. Nos testes realizados apenas o iTunes não rodou satisfatoriamente, mas isso abre brecha para que mais algum outro programa listado como compatível possa não rodar de forma aceitável. Este mesmo iTunes só está disponível na versão 7, sendo que a ultima versão disponível pela Apple é o iTunes 10.

Problema com o iTunes, serviço que abre diversas vezes.

Mesmo o FIFA 11, que rodou perfeitamente, precisou de uma modificação para funcionar, o PlayOnLinux informa que ele não funciona com o executável original, sendo necessário procurar na internet por uma versão “crackeada” do executável, destas que não exigem que o CD/DVD que esteja presente na unidade para rodar o jogo. Isso não deve desagradar a todos, visto que muitos preferem os executáveis “crackeados” para preservar o CD/DVD original e não precisar colocar o CD/DVD da unidade toda vez que deseja rodar o jogo.
O PlayOnLinux traz uma facilidade muito grande ao Linux, pois evita de o usuário ter que correr atrás de scripts e configurações para instalar um programa ou jogo do Windows no Linux através do Wine. Seu desenvolvimento é aberto e constante, trazendo sempre atualizações na lista de softwares compatíveis. A tendência é que com o passar do tempo melhorias venham e o software se torne cada vez melhor, removendo algumas das deficiências encontradas hoje.
Uma lista completa dos softwares e jogos suportados pelo PlayOnLinux está disponibilizada no site oficial do projeto, e pode ser vista aqui.

SCF - Official Edition PASCAL MOD!

Esse código esta compilado para Dev-Pascal, se usar Pascalzim dai tem q mudar algumas coisas...

CORRIGIDO O BUG DAS NOTAS QUE PODIA DAR NOTA NEGATIVA AO FILME E TAMBÉM MAIOR DO QUE 10.

VERSÃO BETA 3 AGORA ....

Quem estiver testando e achar algum BUG acesse a página de Bugs e me avise.

23/03/2011 - Implementado "loader" para algumas funçoẽs...



Download Here
-------------------

///Código Criado Por B03iR4 
//boeira.exe@live.com
//geekDevTeam.blogspot.com
//--------------------------------------

program cadastro_com_texto;
uses crt;
type
     cadastro = record
         nome_orig, nome_br, genero:string[200];
         nota:integer;
         preco:real;
end;
arquivo_texto = file of cadastro;
var dados_filme : cadastro;
    opcao: char;
    banco_dados: arquivo_texto;
    user, pass, certeza:String[200];
    i:integer;
    loader: string[200];
    contador :integer;






procedure gera_arquivo_banco;
begin

 textbackground(white);
        textcolor(black);
     clrscr;
     writeln('-----------------------------------------------------------------------------');
       writeln(' B 0 3 i R 4  -  S o f t w a r e s | Sistema de Cadastro de Filmes v1.2 BETA');
       writeln('-----------------------------------------------------------------------------');
     writeln('-----------------------------------------------');
     writeln('                  ATENCAO!!!');
     writeln('-----------------------------------------------');
     writeln;
     writeln('Criando um Novo Banco de Dados Voce Exclui o atual.');
     writeln;
     writeln('-----------------------------------------------');
     writeln('Voce esta certo disso? [S/N]  ');
     read(certeza);
     if (certeza = 'sim') or (certeza = 'Sim') or (certeza = 'S') or (certeza = 's') or (certeza = 'SIM')then
     begin
                         loader := '||||||||||||||||||||||||||||||||||||';
                         write('Gerando : ');
                         for contador := 1 to length(loader) do
                              begin
                                 write(loader[contador]);
                                 delay(100);
            
             end;
            end;
       delay(3000);
     readln;
     writeln;
     assign(banco_dados, 'C:\dados_filme.txt');
     rewrite(banco_dados);
     delay (3000);
     writeln('Novo Banco de Dados Gerado com Sucesso!');
     writeln;
     writeln('Pressione uma tecla para voltar ao Menu principal!');
     readln;
     close(banco_dados);
      end;


procedure novo_filme;
begin
 textbackground(white);
        textcolor(black);
        clrscr;
             writeln('-----------------------------------------------------------------------------');
       writeln(' B 0 3 i R 4  -  S o f t w a r e s | Sistema de Cadastro de Filmes v1.3 BETA');
       writeln('-----------------------------------------------------------------------------');
        write('Digite o Nome do Filme Original.: ');
        readln(dados_filme.nome_orig);
        write('Digite o Nome do Filme No Brasil.: ');
        readln(dados_filme.nome_br);
        write('Digite o Genero do Filme.: ');
        readln(dados_filme.genero);
        write('Digite a nota do Filme (1 a 10).: ');
        readln(dados_filme.nota);
        while ((dados_filme.nota < 1) or (dados_filme.nota > 10)) do
              begin
                    writeln('- Nota Inválida -');
write(' Escreva Uma Nota Válida (1 a 10) .: ');
readln(dados_filme.nota);
 end;

        writeln('------------------------------------------------------------------------');
        //gravando os dados no arquivo
        assign(banco_dados, 'C:\dados_filme.txt');
        reset(banco_dados);
        write(banco_dados,dados_filme);
        writeln('Dados Gravados no Banco de Dados com Sucesso!');
        writeln('Pressione qualquer Tecla para Voltar ao Menu Principal');
        readln;
        close(banco_dados);
end;

procedure mostrar_dados;
begin
        textbackground(white);
        textcolor(black);                                 clrscr;
      assign(banco_dados, 'C:\dados_filme.txt');
      reset(banco_dados);
      read(banco_dados, dados_filme);
             writeln('-----------------------------------------------------------------------------');
       writeln(' B 0 3 i R 4  -  S o f t w a r e s | Sistema de Cadastro de Filmes v1.3 BETA');
       writeln('-----------------------------------------------------------------------------');
      writeln('Bando de Dados informa que: ');
      writeln('Nome do Filme   .: ..... ',dados_filme.nome_orig);
      writeln('Nome no Brasil  .: ..... ',dados_filme.nome_br);
      writeln('Genero do Filme .: ..... ',dados_filme.genero);
      writeln('Nota do Usuario .: ..... ',dados_filme.nota);
      writeln('Pressione qualquer Tecla para Voltar ao Menu Principal');
      readln;
      close(banco_dados);
end;
 procedure menu;
begin
 textbackground(white);
        textcolor(black);
    repeat
    begin
      clrscr;
       writeln('-----------------------------------------------------------------------------');
       writeln(' B 0 3 i R 4  -  S o f t w a r e s | Sistema de Cadastro de Filmes v1.3 BETA');
       writeln('-----------------------------------------------------------------------------');
        gotoxy(10,03);writeln('Seja Bem Vindo ',user,' :');
        writeln;
        gotoxy(10,05);delay (100);writeln('1 - Gerar Novo Banco de Dados(Apagar)');
        gotoxy(10,06);delay (100);writeln('2 - Cadastrar um novo Filme');
        gotoxy(10,07);delay (100);writeln('3 - Mostrar Filme Cadastrado');
        gotoxy(10,08);delay (100);writeln('4 - Sair');
        gotoxy(10,08);delay (100);writeln('4 - Sair');
  gotoxy(10,11);            write('Escolha uma Opcao.: ');
        readln(opcao);
           if opcao = '1' then   gera_arquivo_banco
           else if opcao = '2' then  novo_filme
           else if opcao = '3' then  mostrar_dados

    end;
    until opcao = '4';
       end;
           procedure login_menu;
           begin
           textbackground(white);
           textcolor(black);
       clrscr;
       writeln('-----------------------------------------------------------------------------');
       writeln(' B 0 3 i R 4  -  S o f t w a r e s | Sistema de Cadastro de Filmes v1.3 BETA');
       writeln('-----------------------------------------------------------------------------');

       writeln('O Sistema esta sendo Inicializado Aguarde...');
        writeln('------------------------------------------');
        delay (2800);writeln(' - Conectando ao Banco de Dados;');
        delay (900);writeln(' - Conferindo Credenciais;');
        delay (1300);writeln(' - Ligando Sistemas de Inicializacao;');
        delay (4000);writeln(' - Inicializando HD;');
        delay (3000);writeln(' - Abrindo Menu de Selecao...');
        writeln('------------------------------------------');
        writeln('Sistema Carregado Com Sucesso!');
        delay(2000);
        menu;

           end;





BEGIN
       repeat
       clrscr;
        textbackground(white);
        textcolor(black);
       writeln('-----------------------------------------------------------------------------');
       writeln(' B 0 3 i R 4  -  S o f t w a r e s | Sistema de Cadastro de Filmes v1.3 BETA');
       writeln('-----------------------------------------------------------------------------');
       writeln(' Para Cadastrar Mais usuarios Contate o Desenvolvedor - boeira.exe@live.com');
       writeln('-----------------------------------------------------------------------------');
       writeln;
       WRITELN;
       WRITELN;
       gotoxy(10,06);write('_____________________');
       gotoxy(10,09);write('---------------------');
       gotoxy(10,19);write('---------------------------------------------------------');
       gotoxy(10,20);write('  BOEIRA-SOFT CORP® - All Rights Reserved | Prouct Free');
       gotoxy(10,21);write('---------------------------------------------------------');
       gotoxy(10,07);write('|Login:');
       gotoxy(10,08);write('|Senha: ');
       GOTOXY(18,07);readln(user);
       GOTOXY(18,08);readln(pass);


       writeln;
       if (user ='admin')     and(pass ='123')
       or (user ='Marcelo')   and(pass ='boeira2k10')
       or (user ='localhost') and(pass ='123')
       or (user ='usuario')    and(pass ='senhadousuario')
       or (user ='666TheNumberofTheBeast') and (pass ='666thenumberofthebeast')
       then
  
       login_menu

        else
        loader := '|||||||||||||||||||||||||||||||||||';
         write('Conferindo : ');
       for contador := 1 to length(loader) do
           begin
             write(loader[contador]);
             delay(250);
           end;
      
      
        writeln('Senha e/ou Login Incorreto(s) | Tente Denovo...') ;

        delay(2000);

       until opcao = '4';

   clrscr;
   writeln('-----------------------------------------------------------------------------');
       writeln(' B 0 3 i R 4  -  S o f t w a r e s | Sistema de Cadastro de Filmes v1.3 BETA');
       writeln('-----------------------------------------------------------------------------');
       writeln('O Sistema esta sendo Finalizado Aguarde...');
    writeln('------------------------------------------');
    delay (1700);writeln(' - Gravando Mudancas;');
    delay (1200);writeln(' - Desconectando do Servidor;');
    delay (800); writeln(' - Desfazendo Alteracoes de Hardware;');
    delay (1400);writeln(' - Reinicializando HDs;');
    delay (3000);writeln(' - Desempregando Programadores...');
    writeln('------------------------------------------');

    delay (1800);Writeln('Sistema Finalizado com Sucesso!');
    readln();



end.

SCF - Bugs Oficiais v1.3Beta2

----------------------------------------------------------------------------------
BUGS DECLARADOS DA VERSÃO 1.3 BETA 2

1) NÃO GRAVA MAIS DE 1 FILME (EM ANDAMENTO)
2) NÃO LÊ MAIS DE 1 FILME          (EM ANDAMENTO)

3) NÃO EXISTE POSSIBILIDADE DE CRIAR OUTROS USUÁRIOS PELO PROGRAMA ( SÓ PELA SOURCE ) - Práticamente Impossível em PASCAL(acho eu)

4) DA ERRO E SAI DO PROGRAMA SE VOCÊ DIGITA ALGO ERRADO NA HORA DE PREENCHER AS CARACTERÍSTICAS DE FILMES...

--------------------------------
BUGS CORRIGIDOS DA VERSÃO BETA 1

1) NOTAS DO FILME PODIAM SER NEGATIVAS E/OU MAIORES QUE 10


Eu achei esses...
bom se vocês acharem mais, por favor procurem, testem tudo que der imaginem...
depois me avisem pelos comentários ou por e-mail... boeira.exe@live.com

SCF - Sistema de Cadastro De Filmes v1.3Beta2

Programinha Bem Simples que estou criando.. Ainda em Versão Beta 3  ...
posteriormente colocarei o source dele ai pra galera que gosta...


Basicamente ele tem 4 Opções no Menu;

1 - Gerar Banco de Dados
2 - Criar Cadastro de Filme
3 - Ler Cadastro de Filme
4 - Sair

 e antes ainda tela de login.

 User:admin
Senha:123


Obs : Se user Win7 ou Vista tem q executar como admin para criar banco de dados!

2.2) Resolvendo alguns Exercícios Parte1

Vamos resolver aguns exercício achados na internet, para aprender melhor, na prática mesmoO...


1. Faça um algorítimo que imprima na tela a soma de números inteiros 35 e 47:

algoritimo "Problema_Exemplo"

var 

n1,n2:inteiro

inicio 

n1 := 35

n2 := 47  //atribuindo os valores para as variáveis  

 escreva(n1,n2) /mandando escrever as variáveis

fimalgoritimo 

Análise:

Usou-se ":="  lido Recebe, por exemplo n1:=35 fica N1 recebe 35, é atribuido um valor a variavel inteira N1.

Depois de atribuidos os valores são mostrados na tela como o pedido.

O Mesmo Poderia ter sido feito sem variaveis mas como queria deixar essa parte mais clara logo ja coloquei assim, poderia ser assim também.

algoritimo "Problema_Exemplo"

var 

inicio 

 escreva("35 e 47") /mandando escrever as variáveis

fimalgoritimo 

E se esse mesmo algorítimo pedisse para que você escrevesse um valor e depois ele fosse mostrado? Aí sim era de uso obrigatório variaveis:

algoritimo "Problema_Exemplo"

var 

n1,n2:inteiro

inicio 

leia(n1,n2) //lendo as variaveis em vez de definir você mesmo.                                 

escreva(n1,n2) /mandando escrever as variáveis

fimalgoritimo 

________________________________________________________

________________________________________________________

2. Faça um Algoritimo que execute e imprima a soma de 2 números:

Obs: Vamos usar como base o exercício anterior para ler as variaveis n1 e n2.

algoritimo "Problema_Exemplo"

var 

n1,n2,soma:inteiro

inicio 

leia(n1,n2) //                                                                                                                  

soma := n1+n2   //cálculo da soma de 2 variaveis digitadas.                                                                                  

escreva("A Soma é: ",soma)

fimalgoritimo 

Agora faça soma,multiplicação,divisão, e subtração de 2 números quaisquer digitados pelo usuário:

algoritimo "Problema_Exemplo"

var 

n1,n2,soma,subtracao,multiplicacao:inteiro

divisao : real
inicio 

leia(n1,n2)                                                                                                         
soma := n1+n2   //cálculo da soma de 2 variaveis digitadas.                                 

subtracao := n1-n2   //cálculo da subtração de 2 variaveis digitadas.   

multiplicacao := n1*n2   //cálculo da multiplicação de 2 variaveis digitadas.  

divisao := n1/n2   //cálculo da divisão de 2 variaveis digitadas.                                                                                                                                                                                                                                                                

escreval("A Soma é: ",soma)

escreval("A Subtração é: ",subtracao)

escreval("A Multiplicação é: ",multiplicacao)

escreval("A Divisão é: ",divisao)  

fimalgoritimo 

 Análise: Ao final desse código repare na parte de declaração de variáveis, destaquei que divisão está como REAL, por quê?


Resposta simples e matemática: Qualquer número dividido por qualquer número pode e geralmente alertórios gerarão um número decimal, ou seja REAL.

Se você digitasse 4 / 2 iria dar 2 , mas e se fosse 6 / 4 ?  o Número seria 1,5 que é Real, teste colocar divisao como inteiro e o programa VisuALG ja vai te dar um erro, depois tente colocar algum número decimal, vai trancar e sair do programa, pois ainda não está 1/1000 de ser um programa completo e sim apenas um protótipo para desenvolvimento de raciocício lógico de programação.

1.6) Operadores Matemáticos para Programação

Exemplos:

x := 7
y := 5
x Recebe 7
y Recebe 5

Comparações:

X=7         Sim
X>7         Não
X>=7      Sim (ele cabe dentro do = e não do maior mas como é >=)
X<>5      Sim
X<>Y      Sim
X<Y         Não
X>Y         Sim

 Considere a=3, b=7, total=200.0, média=8.1 e ano=2000

• a > b -- resultado falso
• total = 100.0 -- resultado falso
• média >= 7.0 -- resultado verdadeiro
• ano <> 2001 -- resultado verdadeiro

Exemplos:

Para as Contas Matemáticas :

As Contas devem ser passadas para uma forma compreensível para o processador, uma forma mais linear...

Botão sem ruído (Erros)

Este exemplo demonstra o uso de um interruptor como uma chave: cada vez que é pressionado, o LED (ou o que for) é ligado (se estiver desligado) e vice-versa. Além disso, também funciona como filtro para o ruído mecânico característico dos interruptores, sem o qual, ao pressionar o interruptor, detectaríamos uma seqüência de múltiplos toques. O código a seguir faz uso da função millis() para acompanhar o momento em que o interruptor é pressionado.

Circuito

O interruptor no pino 7 e o LED no pino 13.

Código

int inPin = 7;      // o número do pino de entrada
int outPin = 13;  // número do pino de saída

int state = HIGH;  // estado atual do pino de saída
int reading;       // estado atual do pino de entrada
int previous = LOW;  // estado anterior do pino de entrada

// as seguintes variáveis são do tipo ''long'' porque o tempo,
// medido em milissegundos,
// transformar-se-á logo em um valor grande demais para um ''int''
long time = 0;      // último momento em que o pino de saída foi atualizado
long debounce = 200 // tempo do filtro, aumente se ocorrer irregularidades

void setup()
{
  pinMode(inPin, INPUT);
  pinMode(outPin, OUTPUT);
}

void loop()
{
  reading = digitalRead(inPin);

  // se acabamos de pressionar o interruptor (isto é, se a entrada
  // foi de LOW para HIGH), e esperamos o bastante desde o
  // último toque de forma a ignorar o ruído...  
  if (reading == HIGH && previous == LOW && millis() - time > debounce)

 {
    // ... inverta a saída
    if (state == HIGH)
      state = LOW;
    else
      state = HIGH;

  // ... e lembre-se do momento do último toque
    time = millis();    
  }

  digitalWrite(outPin, state);

  previous = reading;
}

Controle um círculo de LEDs com um joystick

Circuito completo

Detalhe do cabeamento dos LEDs

Detalhe do cabeamento ao Arduino

Como funciona?

O joystick fornece coordenadas (x,y) ao Arduino de acordo com a sua posição. Como pode se ver, o espaço no qual o joystick se move é um círculo. Esse círculo será o que chamaremos de agora em diante de 'Torta' (veja a parte inferior direita da primeira imagem).
A única coisa que precisamos entender é que a Torta está dividida em 8 fatias. A cada fatia há um LED correspondente. (Veja a figura abaixo). Dessa forma, quando o joystick fornece-nos uma coordenada, ela necessariamente pertencerá a uma dessas fatias. O programa então acende o LED correspondente à fatia.

Código

 /* Controle_CírculodeLED_com_joystick
  * ------------
  * Este esboço controla um círculo com 8 LEDs
  * via joystick
  *
  * Primeiro lê-se os dois pinos analógicos conectados
  * ao joystick feito com dois potenciômetros
  *
  * Essa entrada é interpretada como coordenadas (x,y)
  *
  * Em seguida, calcula-se qual das 8 zonas possíveis 
  * faz parte das coordenadas (x,y)
  * 
  * Finalmente acende-se o LED que está na zona detectada
  *
  * @authors: Cristina Hoffmann and Gustavo Jose Valera
  * @hardware: Cristina Hofmann and Gustavo Jose Valera
  * @context: Arduino Workshop at medialamadrid
  */

  // Declaração de variáveis

  int ledPins [] = { 2,3,4,5,6,7,8,9 };

 // Matriz com 8 LEDs organizados em círculo
  int ledVerde = 13;
  int espera = 40;     // Tempo necessário para ligar o LED
  int joyPin1 = 0;   // variável deslizante conectada ao pino analógico 0
  int joyPin2 = 1;   // variável deslizante conectada ao pino analógico 1
  int coordX = 0;  // variável para ler o valor no pino analógico 0
  int coordY = 0;    // variável para ler o valor no pino analógico 1
  int centerX = 500;  // valor para a posição central do joystick
  int centerY = 500;
  int actualZone = 0;
  int previousZone = 0;

  // delegação dos pinos
  void setup()
  {
    int i;
    beginSerial(9600);
    pinMode (ledVerde, OUTPUT);
    for (i=0; i< 8; i++)
    {
      pinMode(ledPins[i], OUTPUT);
    } 
  }

  // função que calcula a inclinação da linha que passa pelos pontos
  // x1, y1 e x2, y2
  int calculateSlope(int x1, int y1, int x2, int y2)
  {
    return ((y1-y2) / (x1-x2));
  }

  // função que calcula em qual das 8 zonas possíveis
  // estão as coordenadas x, y dado o centro cx, cy
  int calculateZone (int x, int y, int cx, int cy)
  {
    int alpha = calculateSlope(x,y, cx,cy); 

// inclinação do segmento entre o ponto e o centro

    if (x > cx)
    {
      if (y > cy) // 1o quadrante
      {
        if (alpha > 1) // Inclinação > 1, portanto parte mais alta do 1o quadrante
          return 0;
        else
          return 1;    // Caso contrário, parte mais baixa do 1o quadrante
      }
      else // 2o quadrante
      {
        if (alpha > -1)
          return 2;
        else
          return 3;
      }
    }

    else
    {
      if (y < cy) // 3o quadrante
      {
        if (alpha > 1)
          return 4;
        else
          return 5;
      }
      else // 4o quadrante
      {
        if (alpha > -1)
          return 6;
        else
          return 7;
      }
    }
  } 

   void loop() {
    digitalWrite(ledVerde, HIGH); 

// flag para sabermos que se entrou em loop(), é opcional

    // leia o valor dos potenciômetros
    coordX = analogRead(joyPin1);   
    coordY = analogRead(joyPin2);   

    // calcule em qual x
    actualZone = calculateZone(coordX, coordY, centerX, centerY); 

    digitalWrite (ledPins[actualZone], HIGH);     

    if (actualZone != previousZone)
      digitalWrite (ledPins[previousZone], LOW);

   // imprima no terminal o valor cartesiano da coordenada
   // e a zona ao qual faz parte
   //não é necessário caso o Arduino rode em modo autônomo
    serialWrite('C');
    serialWrite(32); // imprima espaço
    printInteger(coordX);
    serialWrite(32); // imprima espaço
    printInteger(coordY);
    serialWrite(10);
    serialWrite(13);

    serialWrite('Z');
    serialWrite(32); // imprima espaço
    printInteger(actualZone);
    serialWrite(10);
    serialWrite(13);

  // Não apague a linha abaixo, ela é necessária!
    previousZone = actualZone;
   // delay (500);

 }

2.1) Seu Primeiro Programa

 Essa é a tela do VisuALG comentado nos últimos posts como opção para desenvolvimento.

Onde encontramos uma ótima base para programação inicial...


Bom, para início vamos definir o que fazer, que problema resolver...

DICA: Crie uma pasta em um local de sua preferência com nome EXERC_EXEMPLO e vá posteriormente salvando cada exercício que fez a fins de estudo, organização e ajuda se precisar relembrar algo.

O QUE ESTIVER ASSIM É SEMPRE UM CÓDIGO

//comentários não compilados pelo computador

A mensagem acima só para exemplificar como separo código de texto normal!

Problema_Exemplo1: Mostrando uma Mensagem na tela :

algoritimo "Problema_Exemplo"//aqui define-se o nome do programa

var 

//aqui definimos o nome e tipo de cada variavél

exemplo : Caracter

inicio 

//aqui vai as intruções e comandos

escreva('Olá Mundo')

fimalgoritimo

Explicação dos Comandos Usados

escreva: Escreve uma mensagem na tela
escreval: Escreve uma mensagem e pula uma linha
Uso:

escreva('escreva aqui sua mensagem')

Tudo que estiver entre as ' ' não vai ser executado e sim apenas Mostrado.
Se você não colocar por exemplo as aspas e tivesse uma variavel para mostrar iria usar assim

escreva(variavel) ou

escreva('Mensagem que voce deseja escrever',variavel)

Perceba que a parte entre aspas é uma mensagem não compilada e sim mostrada e a variavel é o valor que deseja mostrar.


Vamos para o próximo?

Problema_Exemplo2 - Lêr um Nome e mostrar!

algoritimo "Problema_Exemplo"//aqui define-se o nome do programa

var 

//aqui definimos o nome e tipo de cada variavél

nome: Caracter

inicio 

//aqui vai as intruções e comandos

leia(nome)

escreva('O nome digitado Foi ',nome)

fimalgoritimo

Explicação dos Comandos Novos Usados:


leia: Lê algo digitado no teclado, espera o enter ser pressionado confirmando o fim da digitação e armazena como variavel pré definida.

No exemplo pede-se leia(nome) ele le a variável NOME declarada como caracter, então mesmo que você digite números como seu nome ele vai aceitar mas os números serão apenas demonstrativos pois não podem ser usados para contas pois a variável foi declarada como Caracter.


Resultados Obtidos:

O que obteve do código foi provavelmente  +- isso:

Visualg 2.5 Beta ...


Marcelo 

O Nome digitado foi Marcelo _ 

                                                                                   

htge

http://geekDevTeam.blogspot.com

Bom Basicamente você ja criou um programa, agora é esperar o próximo post e tentar variações em casa, brinque... tente fazer ler números,faça ele ler mais coisas criando mais variais e depois vá testando qualquer dúvida poste seu código nos comentários...

2. Praticando em Portugol Com VISUALG

Vamos partir para prática, exercitar seu lobo frontal!
Apartir daqui não tem mais volta, você vai entrar no mundo real da programação e concerteza se apaixonar, assim como eu, amante dessa prática.

Para não implicar seu aprendizado em nenhuma linguagem específica pois isso pode atrapalhar e você acabar não se adequando com específicas linguagens fazemos isso com VisuALG, um compilador em portugol a base de PASCAL.

Um programa que interpreta e executa algoritmos como um "programa" normal de computador. Baseado em uma linguagem parecida com o "Portugol" ensinado em cursos em todo o Brasil, possui recursos como simulação da "tela" do computador, visualização de variáveis, impressão dos fontes e outras características que auxiliam o aprendizado das técnicas de programação.

Pode Ser baixado Aqui: DOWNLOAD Direto do servidor do baixaki.com.br

1.5) Variáveis

São os nomes que utilizamos para referenciar as posições de memória. A memória de um computador pode ser entendida como um conjunto ordenado e numerado de palavras. Na maioria dos PCs que usamos diariamente a memória pode ser considerada como um conjunto ordenado e numerado de bytes (8 bits). As linguagens de programação de alto nível atribuem nomes as posições de memória que armazenam os dados a serem processados. Deste modo os programadores tem mais facilidade para construir seus algoritmos. Na linguagem a-- um nome de variável é contruído da seguinte maneira: uma letra seguida por um conjunto de letras ou algarismos. Por exemplo, os nomes seguintes são nomes de variáveis válidos:

• i
• valor
• nome
• nota1

Como nomes inválidos podemos dar os seguintes exemplos:

• 2nota (nome começado por algarismo)
• nome de aluno (nome com espaços em branco no meio)

Durante a apresentação da linguagem iremos fazer referências a listas de variáveis. Uma lista de variáveis é um conjunto de nomes de variáveis separados por vírgulas, por exemplo: Ex. nota1, nota2, media

Na linguagem a-- uma variável não precisa ser definida antes de ser usada em um algoritmo. A variável irá assumir, dinamicamente, o tipo do dado que estiver sendo atribuído a esta variável. Por exemplo se armazenarmos o valor 5 em uma variável ela passará a ser do tipo inteiro. Caso resolvamos trocar o valor para 3.14 a variável passará a ser real.


Por que usar estrutura Inteiro, Real...?

Imagine Você criando um programa que lê quantos anos a pessoa tem e ela coloca 14,6 anos, acabou seu programa, com essa limitação de variaveis possibilita que se bloqueie esse tipo de erro.

1.4) Tipos de Dados

Os algoritmos irão manipular dados, que normalmente são fornecidos pelos usuários, e entregar resultados para estes usuários. Uma pergunta importante neste momento é: que tipo de dados poderemos manipular? As linguagens de programação normalmente estabelecem regras precisas para definir que tipos de dados elas irão manipular. A pseudo-linguagem a-- também estabelece, ainda que informalmente, algumas regras que limitam o conjunto de dados existentes na natureza e que poderão ser manipulados pelos algoritmos.
Existem três tipos básicos de dados que a linguagem irá manipular:

• Dados numéricos
• Dados alfa-numéricos
• Dados Logicos

---

Dados Numéricos:

Os dados numéricos que os algoritmos podem manipular são de dois tipos:

• Dados inteiros
• Dados reais

O conjunto dos dados inteiros pode ser definido como Z={...,-3,-2,0,1,2,...}. O conjunto dos números reais inclui o conjunto dos números inteiros, dos números fracionários e dos números irracionais. O conjunto dos números fracionários pode ser formalmente definido como Q={p/q | p,q pertencem a Z}. O conjunto dos números irracionais engloba aqueles que não podem ser representados por uma fração, por exemplo o número PI=3.141515... Os números irracionais são armazenados até um certo número de casas decimais que o computador consegue representar a partir daí as casas decimais são descartadas.
Neste ponto é importante lembrar que dois fatos importantes. Primeiro computadores trabalham com uma base diferente de 10. Computadores trabalham em base 2 e no processo de conversão entre a base 10 e a base 2 podem ocorrer problemas de perda de dígitos significativos. Por exemplo, o número real 0.6 ao ser convertido para a base dois gera uma dízima periódica. Outro fato importante é que a memória do computador é limitada e portanto o número de dígitos binários que podem ser armazenados é função deste tamanho. Deste modo o processo de conversão e desconversão entre bases pode causar perda de informação.
Os dados inteiros tem a seguinte forma: NúmeroInteiro = [+,-]algarismo{algarismo}
O sinal de + e - entre colchetes significa que um número inteiro pode ou não ter sínal, isto é o sinal é opcional. Em seguida temos um algarismo que é obrigatório. Isto é dados inteiros tem de ter pelo menos um algarismo. A seguir temos a palavra algarismo entre chaves, o que significa que um número inteiro deve ter pelo menos um algarismo e pode ser seguido por uma seqüência de algarismos.
São portanto exemplos de números inteiros:

• +3
• 3
• -324

Os dados reais tem a seguinte forma: [+,-]algarismo{algarismo}"."algarismo{algarismo}. Ou seja um número real pode ou não ter sinal, em seguida um conjunto de pelo menos um algarismo, um ponto decimal e depois um conjunto de pelo menos um algarismo. É importante notar que o separador entre a parte inteira e a fracionário é o ponto e não a vírgula.
São exemplos de números reais:

• 0.5
• +0.5
• -3.1415

---

Dados Alfa-numéricos

Dados alfa-numéricos servem para tratamento de textos e normalmente são compostos por uma seqüência de caracteres contendo letras, algarismos e caracteres de pontuação. Nos algoritmos são normalmente representados por uma seqüência de caracteres entre aspas, por exemplo:

• "Linguagem de programação"
• "Qual é o seu nome?"
• "12345"

---

Dados Lógicos

Este tipo de dados é intensamente aplicado durante o processo de tomada de decisões que o computador frequentemente é obrigado a fazer. Em muitos textos este tipo de dados também é chamado de dados booleanos, devido a George Boole, matemático que deu ao nome à álgebra (álgebra booleana) que manipula este tipo de dados. Os dados deste tipo somente podem assumir dois valores: verdadeiro e falso. Computadores tomam decisões, durante o processamento de um algoritmo, baseados nestes dois valores. Por exemplo, considere a decisão abaixo:

Se raiz >= 0 imprima "Existe raiz" caso contrário imprima "Não existe raiz real."

Nesta instrução aparece a expressão raiz >= 0, que procura descobrir se o valor de raiz é maior que 0. Esta expressão somente pode ter como resultado os valores: verdadeiro ou falso. Nos nossos algoritmos estes valores serão representados por verdadeiro e falso. Mais adiante ficará claro como este tipo de dados será empregado nos algoritmos.

1.3.3) Pseudo Linguagem

Pseudo Linguagem

Este modo de representar algoritmos procura empregar uma linguagem que esteja o mais próximo possível de uma linguagem de programação de computadores de alto nível mas evitando de definir regras de construção gramatical muito rígidas. A idéia é usar as vantagens do emprego da linguagem natural, mas restringindo o escopo da linguagem. Normalmente estas linguagens são versões ultra reduzidas de linguagens de alto nível do tipo Pascal ou C. No próximo capítulo veremos um exemplo de uma destas pseudo-linguagens.

A Pseudo Linguagem a--

Para escrever estes exemplos de algoritmos usaremos uma pseudo linguagem de programação, que chamaremos de a--. Nesta linguagem definimos um número mínimo de comandos, o suficiente para descrever os algoritmos exemplos. Os dados não tem tipo definido, como em C e PASCAL. A linguagem como o C, que é utilizado no resto do programa é baseada em funções. Todos os algoritmos são descritos por funções, sendo que a função básica, e que deve existir sempre, pois ela é sempre a primeira a ser executada é a função principal.
Um exemplo simples da forma geral de um algoritmo em a-- é o seguinte:

principal ()
início
    imprimir "Olá Mundo."
fim

O algoritmo começa com a função principal que é a função obrigatória em todos os algoritmos. Os parênteses após o nome principal são normalmente usados para delimitar a lista de argumentos, também chamados parâmetros que a função irá receber para executar a sua tarefa. Neste caso a função não está recebendo nenhum parâmetro. Esta algoritmo executa um único comando que imprime o texto "Alo mundo" em um dispositivo qualquer de saída de dados.

1.3.2) Fluxogramas

Fluxogramas

Esta forma de representação de algoritmos emprega várias formas geométricas para descrever cada uma das possíveis açoes durante a execução do algoritmos. Existem algumas formas geométricas que são empregadas normalmente e que estão mostradas na Figura abaixo. Cada uma destas formas se aplica a uma determinada ação como está indicado. Existem outras formas que podem ser aplicadas, no entanto nesta apostila estas formas serão suficientes para os exemplos que serão mostrados.

Como primeiro exemplo de um algoritmo descrito por meio de fluxogramas vamos considerar o exemplo do algoritmo para decidir o que fazer em um dia de domingo. A Figura a seguir mostra o fluxograma equivalente à descrição feita por meio da linguagem natural.

Outro exemplo de um algoritmo descrito por meio de fluxogramas é o problema de calcular a solução da equação de primeiro grau

ax+b=0

que vale

x=-(b/a)

se a for diferente de zero. A Figura abaixo mostra um possível algoritmo para resolver este problema.

 

 

 

 

 

 

Fluxogramas Engraçados Para descontrair...

 

Clique para Aumentar

 

1.3.1) Linguagem Natural

Linguagem Natural

Como ilustração de algoritmo em linguagem natural vamos considerar a receita abaixo. Por economia de texto e facilidade a receita não mostra as quantidades dos ingredientes (as entradas). Alguns mais maldosos dizem que o cozinheiro não quis divulgar o seu segredo.

• Filé de peixe com molho branco.
  • {preparo dos peixes}
    • Lave os filés e tempere com o suco dos limões, sal, pimenta e salsinha picada. Deixe por 1/2 hora neste tempero. Enxugue e passe cada filé na farinha de trigo. Depois passe pelos ovos batidos e frite na manteiga até ficarem dourados dos dois lados.
  • {preparo do molho branco}
    • Coloque numa panela a manteiga, a farinha e o leite e misture bem. Em fogo médio, cozinhe até engrossar. Adicione o sal, a pimenta e o queijo. Continue com a panela no fogo, cozinhando até que o queijo derreta, mexendo constantemente.
  • {juntando os dois}
    • Adicione queijo parmesão ralado e queijo gruyère. Misture e ponha sobre os filés.
• Fim da receita do filé de peixe com molho branco.

Observe que a receita foi subdividida em partes: preparo dos peixes, preparo do molho branco e finalmente juntar as duas partes. Esta é uma técnica comum na resolução de problemas: dividir para conquistar. Vamos considerar agora uma outra receita que tenha molho branco como parte, para ilustrar uma outra técnica comum da criação e descrição de algoritmos. A próxima receita é esta:

• Alface com molho branco.
  • {preparo do molho branco}
    • Coloque numa panela a manteiga, a farinha e o leite e misture bem. Em fogo médio, cozinhe até engrossar. Adicione o sal, a pimenta e o queijo. Continue com a panela no fogo, cozinhando até que o queijo derreta, mexendo constantemente.
  • {preparo da alface}
    • Derreta a manteiga. Junte a alface cortada. Salpique o sal e deixe cozinhar por uns 5 a 10 minutos ou até a alface ficar tenra, ou o líquido da panela secar.
  • {juntando os dois}
    • Junte ao molho branco e ao suco de limão. Coloque numa travessa e enfeite em volta com pão torrado cortado em triângulos.
• Fim da receita do alface com molho branco

Imagine que os pratos abaixo fazem parte de um livro de receitas. Observe atentamente as receitas. Perceba que os dois pratos usam molho branco e que, as duas receitas, ensinam ao leitor como preparar molho branco. Imagine que este livro de receitas tem 20 outros pratos ao molho branco. É fácil perceber que este livro terá numerosas páginas uma vez que, provavelmente, outras receitas básicas (molho de tomate, molho de mostarda, etc.) estarão repetidas em vários pontos do livro.
Observe agora uma nova maneira de descrever estas duas receitas:

• Molho branco
  • Coloque numa panela a manteiga, a farinha e o leite e misture bem. Em fogo médio, cozinhe até engrossar. Adicione o sal, a pimenta e o queijo. Continue com a panela no fogo, cozinhando até que o queijo derreta, mexendo constantemente.
• Fim da receita do molho branco

• Filé de peixe com molho branco
  • {preparo dos peixes}
    • Lave os filés e tempere com o suco dos limões, sal, pimenta e salsinha picada. Deixe por 1/2 hora neste tempero. Enxugue e passe cada filé na farinha de trigo. Depois passe pelos ovos batidos e frite na manteiga até ficarem dourados dos dois lados.
  • {preparo do molho branco}
    • Prepare a receita básica de molho branco.
  • {juntando os dois}
    • Adicione queijo parmesão ralado e queijo gruyère. Misture e ponha sobre os filés.
• Fim da receita do Filé de peixe com molho branco.

• Alface com molho branco
  • {preparo do molho branco}
    • Prepare o molho branco segundo a receita básica.
  • {preparo da alface}
    • Derreta a manteiga. Junte a alface cortada. Salpique o sal e deixe cozinhar por uns 5 a 10 minutos ou até a alface ficar tenra, ou o líquido da panela secar.
  • {juntando os dois}
    • Junte ao molho branco e ao suco de limão. Coloque numa travessa e enfeite em volta com pão torrado cortado em triângulos.
• Fim da receita do Alface com molho branco.

Observe a economia de linhas de texto que foi possível devido a separação da receita de molho branco das demais. Se o mesmo procedimento for seguido para as demais receitas básicas, é de se esperar que o livro fique mais "fininho" do que antes.
Você pode argumentar que, no método anterior, era mais rápido seguir uma receita. Agora, ao preparar o peixe ao molho branco, por exemplo, você tem de interromper a leitura, marcar a página onde você estava, abrir na página da receita de molho branco, aprender a prepará-lo e, então, retornar à receita do peixe. Você tem razão, mas, além da economia de papel, existem outras vantagens em separar a receita do molho branco. Imagine, por exemplo, que amanhã você descubra que o molho branco fica uma delícia se levar uma pitada de alho. Basta modificar a receita de molho branco, que aparece em um único lugar no livro, e todas as receitas "ao molho branco" estarão automaticamente modificadas. No método anterior, seria preciso modificar todas as receitas que usam molho branco, com o risco considerável de esquecermos de modificar alguma delas.
Observe ainda a variação abaixo da receita do peixe:

• Filé de peixe com molho branco
  • {preparo dos peixes}
    • Lave os filés e tempere com o suco dos limões, sal, pimenta e salsinha picada. Deixe por 1/2 hora neste tempero. Enxugue e passe cada filé na farinha de trigo. Depois passe pelos ovos batidos e frite na manteiga até ficarem dourados dos dois lados.
  • {preparo do molho branco}
    • Compre molho branco no supermercado
  • {juntando os dois}
    • Adicione queijo parmesão ralado e queijo gruyère. Misture e ponha sobre os filés.
• Fim da receita do filé de peixe com molho branco.

Você prestou atenção? Ao invés de ensinar a preparar molho branco, a receita instrui você a comprá-lo pronto, no supermercado. Ou, em outras palavras, é possível usar no preparo do seu prato, ingredientes já prontos, preparados por outra pessoa, que você talvez nem conheça. Além disso, se você não é um cozinheiro experiente, o molho à venda no supermercado já foi suficientemente testado e é, provavelmente, gostoso. Embora, nem todos vão concordar com tal infâmia! Você já tem problemas suficientes tentando preparar um bom peixe. Talvez seja melhor usar o molho do supermercado e não ter de se preocupar com essa parte do problema. O uso de algoritmos criados por outros é muito comum na informática e pode reduzir consideravelmente o tempo de criação de um sistema.
Toda a discussão acima tem uma forte analogia com o estudo de algoritmos e técnicas de programação. Isto ficará mais claro para você mais tarde, quando estudarmos procedimentos e funções.
Para ilustrar mais um conceito importante de algoritmos vamos analisar mais um exemplo, considerando o problema de calcular a área de uma mesa retangular. Este cálculo pode ser efetuado se seguirmos os seguintes passos.

• Cálculo da área de uma mesa.
  • Medir a largura da mesa e anotar o resultado.
  • Medir o comprimento da mesa e anotar o resultado.
  • Multiplicar o comprimento pela largura e anotar o resultado.
  • O valor da área da mesa é o resultado anotado no passo anterior.
• Fim do cálculo da área da mesa.

Vamos supor agora que dispomos de uma mesa e de uma toalha cobrindo esta mesa e gostaríamos de saber as áreas da toalha e da mesa. O algoritmo pode ser escrito da seguinte maneira.

• Cálculo das áreas de uma mesa e de uma toalha.
  • Cálculo da área de uma mesa.
    • Medir a largura da mesa e anotar o resultado.
    • Medir o comprimento da mesa e anotar o resultado.
    • Multiplicar o comprimento pela largura e anotar o resultado.
    • O valor da área da mesa é o resultado anotado no passo anterior.
  • Fim do cálculo da área da mesa.
  • Cálculo da área da toalha.
    • Medir a largura da toalha e anotar o resultado.
    • Medir o comprimento da mesa e anotar o resultado.
    • Multiplicar o comprimento pela largura e anotar o resultado.
    • O valor da área da toalha é o resultado anotado passo anterior.
  • Fim do cálculo da área da toalha.
• Fim do cálculo das áreas da mesa e da toalha.

Observe que os algoritmos para cálculo da área da mesa e da toalha são parecidos, trazendo a idéia que existe um algoritmo mais geral que é o de cálculo da área de um objeto retangular. Este algoritmo mais geral pode ser então aplicado tanto à mesa como à toalha.
Este algoritmo mais geral poderia ser descrito da seguinte maneira:

• Cálculo da área de um objeto retangular ou quadrado.
  • Medir a largura do objeto e anotar o resultado.
  • Medir o comprimento do objeto e anotar o resultado
  • Multiplicar o comprimento pela largura e anotar o resultado.
  • O valor da área e o resultado anotado no passo anterior.
• Fim do cálculo da área de um objeto retangular ou quadrado.

O algoritmo para cálculo da área da mesa e da toalha poderia ser reescrito de forma mais compacta com as seguintes instruções:

• Calcular a área da mesa usando o algoritmo acima.
• Calcular a área da toalha usando o mesmo algoritmo.

Observe que neste caso um mesmo algoritmo pode ser aplicado a diferentes objetos, reduzindo o número de algoritmos a serem definidos.
A maioria dos algoritmos contém decisões, por exemplo, para atravessar uma rua preciso verificar se o sinal de pedestres está verde e verificar se nenhum carro está avançando o sinal, somente após decidir se estes fatos se confirmaram poderei atravessar a rua.
Para considerar um algoritmo que inclua decisões vamos estudar um algoritmo que nos ajude a decidir o que fazer em um domingo. Um possível algoritmo poderia ser o seguinte:

• Algoritmo de domingo.
  • Acordar.
  • Tomar o café.
  • Se estiver sol vou à praia senão leio o jornal.
  • Almoçar.
  • Ir ao cinema.
  • Fazer uma refeição.
  • Ir dormir.
• Final do domingo.

A possibilidade de tomada de decisões é a característica mais importante de qualquer linguagem de programação. Ela permite que ao computador simular aproximadamente uma característica humana que é a escolha de opções. Sem esta característica o computador seria pouco mais do que uma veloz máquina de calcular.
Vamos agora considerar um exemplo um pouco mais matemático e estudar o algoritmo para calcular as raízes de uma equação do segundo grau da forma

ax²+bx+c=0

As raízes podem ser calculadas pelas fórmulas

x₁=[-b+(b²-4ac)^(1/2)]/(2a)

x₂=[-b-(b²-4ac)^(1/2)]/(2a)

Aparentemente o algoritmo se reduziria ao cálculo da fórmula, no entanto ao detalharmos as ações devemos prever tudo que pode acontecer durante o cálculo desta fórmula. Por exemplo o que fazer se o valor do coeficiente a for igual a zero? Um possível algoritmo é o seguinte:

• Algoritmo para cálculo de uma equação do segundo grau.
  • Obter os coeficientes a, b e c
  • Se o coeficiente a for igual a zero informar que esta não é uma equação do segundo grau e terminar o algoritmo.
  • Caso contrário continue e faça
    • Calcular delta=b²-4ac
    • Se o valor de delta for negativo informar que a equação não tem raizes reais e terminar o algoritmo.
    • Caso contrário continue e faça
      • Calcular a raiz quadrada de delta e guardar o resultado como raiz
      • Calcular x₁=(-b + raiz)/(2a)
      • Calcular x₂=(-b - raiz)/(2a)
      • Fornecer como resultado x₁ e x₂
      • Terminar o algoritmo.
• Fim do algoritmo para cálculo de uma equação do segundo grau.

Neste algoritmo em diversos pontos tivemos de tomar decisões e indicar o que fazer em cada uma das possibilidades, mesmo que seja mostrar que não podemos continuar o algoritmo. Toda vez que decisões tiverem de ser tomadas devemos incluir todas as possibilidades para o evento que estamos considerando.
Este é um dos possíveis algoritmos por diversas razões. Por exemplo, poderíamos incluir no algoritmo o cálculo das raízes imaginárias ou no caso do coeficiente a ser igual a zero calcular como se fosse uma equação do primeiro grau.

1.3) Representação Gráfica

Existem várias formas de representação gráfica e visual de algorítimos. As Mais Usadas São:

Linguagem Natural:

Os algoritmos são expressos diretamente em linguagem natural, como nos exemplos anteriores.

Fluxograma Convencional:

Esta é um representação gráfica que emprega formas geométricas padronizadas para indicar as diversas ações e  decisões que devem ser executadas para resolver o problema.

Pseudo-linguagem:

Emprega uma linguagem intermediária entre a linguagem natural e uma linguagem de programação para descrever os algoritmos.É mais usada em aprendizado do que em prática geral, começa usando linguagem nativa da pessoa e depois passa para o inglês e uma estrutura de linguagem mesmo(Em Portugol ou Português Estruturado).

Não existe consenso entre os especialistas sobre qual seria a melhor maneira de representar um algoritmo. Atualmente a maneira mais comum de representar-se algoritmos é através de uma pseudo-linguagem ou pseudo-código. Esta forma de representação tem a vantagem de fazer com que o algoritmo seja escrito de uma forma que está próxima de uma linguagem de programação de computadores. Algoritmo de encontrar a menor temperatura dentro de registros de temperaturas mostrada na seção anterior usou linguagem natural para representar o algoritmo.

1.2) Para Que Serve um Algorítimo?

O Algorítimo é a Idéia, o Rascunho do Programa.
Pode-se Interpretar que:

Algorítmo + Linguagem de Programação = PROGRAMA

O mesmo Algoritimo serve para todas linguagens de programação.


Serve principalmente para sairmos do problema e chagarmos ao PROGRAMA.

 

Qualidades de um Bom Algoritmo:

1) Definição Perfeita: Deve descrever exatamente quais são instruções que devem ser executadas e em que sequência.Deve ser colocado o maior número possivel de informações e definiçoẽs.

2) Ausência de Ambiguidade: Não se deve deixar dúvida alguma sobre o que deve ser feito. A Ambiguidade acerca do que deve ser feito também pode levar a uma interpretação errada.

3) Eficácia: Consegue Resolver o Problema de toda forma possivel que ele se apresenta? Tudo que for alterado ainda assim irá resolver o mesmo?

4) Eficiência: Resolver Sempre com mínimo de recursos possíveis antes da perda de qualidade. Para computação não adianta de nada saber o algoritmo que calcula o milionésimo número de Pi se você o fez para um computador que ainda não existe. Isso é só um exemplo, o que implica é a quantidade de Processamento necessitará seu Algoritmo e sempre que o criar crie da menor maneira possível e pense em mais umas 2 formas de resolve-lo para comparação.



Um exemplo rápido de simplificação:


Você tem que resolver em algum algoritimo uma conta assim;



N1 +  ( 12 * 10 ) / N2 + (N7 * 32) / (45+45)

Só um exemplo, percebe=se que N1,N2 e N7 seram respectivamente incluidos pelo usuário no programa então são váriaveis, você não tem como prever o que resultara de uma variavém com outra ou com qualquer número a menos que seja um campo limitado de números...
Simplificando pode-se obter: 

N1 + 120 / N2 + (N7 * 32) / 90

Perceba que foi resolvido 12*10 para o processador, ele não precisa mais calcular isso então você simplificou para ele e ele necessitara de menos recursos.

1.1) Resumidamente

Basicamente um Algorítimo é uma sequência de passos simples para resolução de um problema. É uma receita que qualquer um entenda, ...

Exemplo Simples:

Algoritimo para lavar Cabeça:

1:INÍCIO

2:MOLHE O CABELO

3:COLOQUE SHAMPOO

4:ESFREGUE

5:ENXAGUE

6:FIM

                Análise :

                                   Processo Simples do dia-à-dia
                                   Início e Fim Claramente Definidos
                                   Passo-à-passo bem definido.
     

Mas há imperfeições:
                    Não Especifica quanto de Shampoo, não especifica como molhar, como lavar, quanto tempo...

Vamos Melhorar isso:

1:INÍCIO

2:MOLHE O CABELO

3:REPITA 2 VEZES:

   3.1:COLOQUE QUANTIDADE DE 1 TAMPINHA DE  SHAMPOO

   3.2:ESFREGUE POR 1 MINUTO

   3.3:ENXAGUE

6:FIM

O que é Programação?

O que é Programação de Computadores?

Programação é o processo de escrita, teste e manutenção de um programa de computador. O programa é escrito em uma linguagem de programação, embora seja possível, com alguma dificuldade, escrevê-lo directamente em linguagem de máquina. Diferentes partes de um programa podem ser escritas em diferentes linguagens

Programação é o processo de escrita, teste e manutenção de um programa de computador. O programa é escrito em uma linguagem de programação, embora seja possível, com alguma dificuldade, escrevê-lo directamente em linguagem de máquina. Diferentes partes de um programa podem ser escritas em diferentes linguagens.

Diferentes linguagens de programação  funcionam de diferentes modos. Por esse motivo, os programadores podem criar programas  muito diferentes para diferentes linguagens; muito embora, teoricamente, a maioria das linguagens possa ser usada para criar qualquer programa. Para mais informações sobre estes métodos, veja Linguagem de programação.

Software é um nome colectivo para programas de computadores e dados.

Há várias décadas se debate se a programação é mais semelhante a uma arte (Donald Knuth), a uma ciência, à matemática (Edsger Dijkstra), à engenharia (David Parnas), ou se é um campo completamente novo.

Programas ou algoritmos?

Um algoritmo é uma sequência de passos para realizar um tarefa ou resolver um problema. Em nosso dia a dia utilizamos algoritmos para realizar nossas atividades, definindo a sequência de atividades que devemos fazer para atingir um objetivo.

Um algoritmo é, num certo sentido, um programa abstrato — dizendo de outra forma, um programa é um algoritmo concretizado. No entanto, os programas são, à excepção dos menores, visualizados mais facilmente como uma colecção de algoritmos menores combinados de um modo único — da mesma forma que uma casa é construída a partir de componentes.

Dessa forma, um algoritmo é uma descrição de como um computador pode ser levado a executar uma operação simples e específica, como, por exemplo, uma ordenação. Um programa, por outro lado, é uma entidade que na verdade implementa uma ou mais operações de forma que seja útil para as pessoas.

Veja mais no post sobre algorítimos...

Engenharia de software

A desenvolvimento de um programa de computador consiste de cinco passos principais:

   1. Reconhecer a necessidade de um programa para resolver um problema.
   2. Planificar o programa e seleccionar as ferramentas necessárias para resolver o problema.
   3. Escrever o programa na linguagem de programação escolhida.
   4. Compilação: tradução do código fonte legível pelo homem em código executável pela máquina, o que é feito através de compiladores e outras ferramentas.
   5. Testar o programa para ter a certeza de que funciona; se não, regressar ao passo 3.

Estes cinco passos são colectivamente conhecidos como engenharia de software. A programação põe ênfase nos passos 2, 3 e 4. A codificação põe ênfase no passo 3. O termo coder, por vezes usado como sinônimo para programador, pode tornar-se aviltante porque ignora as capacidades necessárias para lidar com os outros quatro passos.

História

Hero de Alexandria no século primeiro inventou teatros automatizados que usavam programação análoga para controlar os fantoches, portas, luzes e efeitos de som.

A mais antiga programadora de computadores que se conhece é Ada Lovelace, filha de Anabella e de Lord Byron (o poeta). Anabella transmitiu a Ada o seu amor à matemática, a qual, depois de conhecer Charles Babbage, traduziu e expandiu uma descrição da sua máquina analítica. Muito embora Babbage nunca tenha completado a construção de nenhuma das suas máquinas, o trabalho que ele e Ada desenvolveram sobre elas, garantiu a Ada o título de primeira programadora de computadores do mundo (veja as notas de Ada Byron sobre a máquina analítica. A linguagem de programação Ada recebeu o seu nome.

Um dos primeiros programadores que se tem notícia de ter completado todos os passos para a computação sem auxílio, incluindo a compilação e o teste, é Wallace J. Eckert. O trabalho deste homem antecede a ascensão das linguagens de computador, porque ele usou a linguagem da matemática para solucionar problemas astronômicos. No entanto, todos os ingredientes estavam lá: ele trabalhou um laboratório de computação para a Universidade de Columbia com equipamentos fornecidos pela IBM, completes com uma divisão de serviço de atendimento ao cliente, e consultores de engenharia para propósitos especiais, na cidade de Nova York, na década de 1930, usando cartões perfurados para armazenar os resultados intermediários de seus cálculos, e então formatando os cartões perfurados para controlar a impressão das respostas, igual ao trabalho para os censos décadas antes. Tinha técnicas de debug tais como códigos de cores, bases cruzadas, verificação e duplicação. Uma diferença entre Eckert e os programadores dos dias de hoje é que o exemplo do seu trabalho influenciou o projeto Manhattan. Seu trabalho foi reconhecido por astrônomos do Observatório da Universidade de Yale, Observatório da Universidade de Princeton, Observatório da Marinha dos EUA, Observatório da Faculdade Harvard, Observatório dos estudantes da Universidade da Califórnia, Observatório Ladd da Universidade de Brown e Observatório Sproul da Faculdade de Swarthmore.

Alan Turing é frequentemente encarado como o pai da ciência de computadores e, por afinidade, da programação. Ele foi responsável por ajudar na elaboração e programação de um computador destinado a quebrar o código alemão ENIGMA durante a Segunda Guerra Mundial — ver Máquina Enigma.

Lista de linguagens

Existem várias linguagens de programação. As mais populares são: Java, C, C++, Visual Basic, PHP, Perl, Python, C#, JavaScript, Ruby, Delphi , D e ActionScript.