O homem aprende por dois motivos: por gosto ou por necessidade.

Depois de passar um semestre brincando com Pascal na era pré-google ( quando não encontravamos uma pagina através do yahoo ou cadê, tentavamos urls aleatórias como www.pascal.org - que era a pagina da família pascal ), tive uma disciplina cujo professor só sabia Fortran e C.

Através do MOO descobri o curso on-line da UFMG, e pude dar os primeiros passos em C. Entretanto o foco dessa disciplina não era fazer agenda ou video-locadora - eram programas científicos. Linux, gnuplot, maple… foi um mundo muito divertido.

É claro que algumas coisas eu simplesmente não compreendia: os tais dos ponteiros, por exemplo. Era só ver um * que não fosse multiplicação que eu já tinha dor de cabeça. E assim se passaram alguns anos onde eu apenas reproduzia os comandos que tinha aprendido.

Anos depois, conversando com o CaSantos caímos em uma micro-aula de programação. Eis que ele profere sabias palavras: Ao estudar uma linguagem de programação, a primeira coisa que se precisa estudar são os conceitos e, por último, a sua sintaxe.

Toda a vez que eu entrava em uma lista de discussão ou forum e via as perguntas dos novatos eu lembrava dessa frase. Coisas como dizer que os arquivos .h do C são bibliotecas, colocar system(“pause”) pro programa não “fechar do nada” e por ai vai. O tipo da coisa que, quem conhece o conceito, não perguntaria.

Por que razão não se ensina os conceitos de uma linguagem logo no começo? Eu só posso pensar que é para os alunos aprenderem de forma intuitiva no começo e resgatar isso mais tarde (talvez em uma cadeira de compiladores, sei lá), mas será que isso acontece?

Geralmente o trabalho de fim de semestre dessas cadeiras é um CRUD em C com listagem (ou relatório) de alguma coisa ordenada de uma ou mais formas. Cadastrar alunos ou contas bancárias, salvando em arquivo.

Pois bem, se é uma disciplina introdutória, por que raios alguem iria pedir um CRUD?? Meu deus, os alunos mal sabem como compilar o programa, tampouco debuga-lo - No maximo enchem de printf(“passei por aqui”) - e pedem um programa com ‘menu interativo’! Ai o camarada perde metade do tempo fazendo ‘menuzinho’ com asteriscos ou outro caracter e não consegue implementar a lógica. Quando implementa é aquela maçaroca. O que isso ensina?

Eu daria uma sugestão: quer ensinar C ou Java ou Snobol 4, ensine. Mas não peça um programa CRUD cheio de frescura - peça uma biblioteca. De um arquivo header ou uma interface java e diga: implementem essas funções/metodos ai. Eu vou testar o meu programa com essa biblioteca e espero que tudo funcione.

videolocadora.h

int cadastra_video(char *nome, int preco, int categoria);
int cadastra_cliente(char *nome, char *cpf, char *endereco);
int aluga_video(...);

Enfim, não consigo pensar num exemplo melhor. A ideia é introduzir um desenvolvimento em camadas, deixando o aluno pensar em como ele vai gravar, ler e ordenar os dados sem frescuras de tela, ensinando a fazer testes e também a debugar a aplicação.

Quer ensinar a fazer telinha? Ensina em outra disciplina, nesse caso ensinando técnicas de design apropriadas. Começando pela linha de comando do unix: como pode um aluno se formar sem nunca ter criado o seu próprio grep? Criar interfaces com o usuário não é algo facil, requer muito estudo, principalmente de usabilidade.

Alias fazer “telinhas” geralmente supõe colocar um programa em um estado. Quem aprende o conceito de maquina de estados no momento que esta fazendo esse cadastro? Posso apostar que esse pessoal não sabe o que é stateless e statefull e o professor nem pensa q isso seja importante (aqui eu lembro da agenda de telefones que eu fiz em pascal).

Fica aqui a minha sugestão. Espero que faça sentido :)

Um dos meus primeiros desafios na área de programação foi fazer um conversor de números decimais para romanos. Eu estava aprendendo Turbo Pascal e usava um potente 286 com 1MB de memória - sem HD.

Fiz a maior sequencia de ifs da minha vida. Hoje estava relembrando e resolvi fazer uma versão SED.

/[0-9]*[5-9]...$/q
s/1...$/M&/;s/2...$/MM&/;s/3...$/MMM&/;s/4...$/MMMM&/
s/6..$/DC&/;s/7..$/DCC&/;s/8..$/DCCC&/;s/9..$/CM&/
s/1..$/C&/;s/2..$/CC&/;s/3..$/CCC&/;s/4..$/CD&/;s/5..$/D&/
s/6.$/LX&/;s/7.$/LXX&/;s/8.$/LXXX&/;s/9.$/XC&/
s/1.$/X&/;s/2.$/XX&/;s/3.$/XXX&/;s/4.$/XL&/;s/5.$/L&/
s/1$/I/;s/2$/II/;s/3$/III/;s/4$/IV/;s/5$/V/
s/6$/VI/;s/7$/VII/;s/8$/VIII/;s/9$/IX/
s/[0-9]//g

Tendo um número por linha ja basta.

$ echo '3999' | sed -f other.sed
MMMCMXCIX

O sed é realmente fantástico! Pena que acima de 5 mil tem que colocar uma barra em cima dos números.

Exatamente: Não vem com essa que vc é istudante, vai tomar tapa na cara se não aprender Java. Saiba que, de cada 100, só 5 terminam o curso. Nem na Sun se treina programador assim.

/*
* O Bope foi criado para atuar quando a policia perde o controle
* E no rio de janeiro isso acontece com bastante frequencia
*/
class Bope{
        
 private String nome; 
 private int vitimas;
  
 public Bope(String nome){
  this.nome = nome;
  this.vitimas =0;
 }
  
 public void matou(int tantas_vitimas_agora){    
  this.vitimas = this.vitimas + tantas_vitimas_agora;
 }
 
 public int quantas_vitimas(){
  return this.vitimas;
 }
}

public class Programa{
 public static void main(String [] xxx){
  // Apresento o capitão nascimento
  Bope capitao = new Bope("Capitao Nascimento");
  
  // quando o capitão sobe a favela, é pra matar, não pra morrer
  capitao.matou(1000);
  
  // agora ele subiu o morro de novo, com ele não tem erro.
  capitao.matou(2000);
  
  // e a farda dele não é azul, é PRETA
  System.out.println("O Bope matou: " + capitao.quantas_vitimas());
 }
}

Entendeu? Não?

ENTÃO PEDE PRA SAIR, GUERREIRO!
TU É CORRUPTO, TEU LUGAR É COM .NET, É COM VB! JOCKEY DE IDE! PEDE PRA SAIR AGORA!

Os objetos em Ruby possuem um método chamado ‘respond_to?’ para verificar se o objeto possui (ou melhor, se ele responde a) um determinado método. Em uma linguagem dinâmica como o ruby, onde podemos incluir um método numa classe em runtime, é um recurso muito necessário, ainda mais se pensarmos em termos de Duck Typing.

Em caso de dúvida, basta fazer um if, afinal chamar um método que não existe causa um NoMethodError, certo?

Depende. Observe:

class A
        def xxx()
                puts "xxx"
        end
        def method_missing(m, *args)
                puts "nao tenho esse metodo: #{m}"
        end
end

a = A.new
a.xxx
# aqui normalmente daria erro e o script seria abortado 
# sem o rescue adequado
a.yyy 

Resultado:

~> ruby A.rb
xxx
nao tenho esse metodo: yyy

Eu sobreescrevi o método ‘method_missing’, que como o próprio nome indica, intercepta uma chamada a um método inexistente. Divertido, não?