aprendendo a programar com o RUR-PLE

Recentemente meu filho estava me pentelhando para aprender a programar. Eu achei cedo demais (8 anos de idade) e fui colocando algumas barreiras. Só que o danado se mostrou tão persistente que eu percebi que ele queria MESMO.

Pois bem, para encurtar a história... Pesquisei várias coisas sobre como ensinar programação para crianças pequenas e por fim decidi usar o RUR-PLE. Se você quiser pesquisar por conta própria, eis alguns termos para procurar no google (existe muito mais do que isso):

programacao logo seymour papert
scratch programming
robomind

também tem um bom artigo aqui: http://marshallbrain.com/kids-programming.htm

Talvez você perceba na web uma certa predileção pelo Scratch. Bem... não vou ficar dizendo porque não escolhi algumas abordagens. Vou me limitar a dizer porque escolhi o RUR-PLE:

utiliza sintaxe do python (python 2, é verdade, mas mesmo assim preferi), daí mais pra frente o moleque já vai poder usar python para inúmeras coisas;

já contem uma boa sequencia de lições prontas (só tive que traduzir e fazer algumas adaptações);

aprende-se a programar um robôzinho bem simples com comandos python, o resultado é visto em uma animação quando o programa é executado;

o robô só sabe dar um passo a frente, virar a esquerda, pegar e soltar objetos, todas outras funcionalidades precisam ser programadas;

a programação é feita digitando o código, e não com "arrastar e soltar" bloquinhos (há quem ache isso uma desvantagem, eu já acho vantagem).

Preciso dizer que o RUR-PLE não é um software maduro. Existem algumas desvantagens e empecilhos:

usa Python 2 (facilmente ignorável, quero ensinar programação, e não python 3);

problemas de dependências de certas versões do wxWindows (isso não é problema para quem vai usar no Windows);

o código não pode ter acentos, nem nos comentários (só aceita caracteres ascii);

entre outros...

Como já tenho uma certa intimidade com computadores, consegui contornar estas situações. Mas talvez alguns pais/professores tenham algumas dificuldades, e isto pode atrapalhar um pouco. Infelizmente... :(

Mas se mesmo assim você optar pelo RUR-PLE, pode conseguí-lo em http://code.google.com/p/rur-ple/

A receptividade do meu filho está sendo muito boa. Ele está gostando muito de programar o robozinho e já me alcançou nas traduções. Quando não tenho a próxima lição já traduzida, tenho que ficar inventando atividades extras para ele

OK. Chega de muita conversa. Se depois de suas pesquisas, você optar por usar o RUR-PLE para aprender a programar (ou para ensinar aos seus pequenos) aqui vão algumas lições que estou traduzindo e adaptando (encontrei na página da Profa. Carla Delgado, as lições do RUR-PLE já traduzidas para pt_BR, mas mesmo assim continuarei fazendo as minhas adaptações para crianças aqui):

00.ALGORITMOS - esta lição não é do RUR-PLE, é a tradução do primeiro capítulo do "Programación de Computadores con Scratch - Cuaderno de Trabajo para estudiantes"

01.introdução

02.conhecendo o reeborg

03.primeiro programa

04.lidando com erros

05.comentários

06.virando a esquerda

07.beepers

08.exercícios

09.evitando repetições

10.evitando repetições novamente

11.se o Reeborg pudesse decidir...

Não quero ficar chateando a criança fazendo ela criar os mundos para realizar os exercícios. Portanto aqui está o arquivo com os mundos prontos (coloque isso no diretório world_files):

world_files.zip - clique no link no canto superior direito, algo como "fazer download no formato original".

A medida que eu for traduzindo mais, vou colocando aqui. Qualquer feedback é muito bem vindo.

aprendendo java: métodos úteis para manipulação de arrays

Iniciando a série "lembretes úteis para quem está aprendendo Java". Esta dica foi obtida no livro "Core Java 2 - Volume I: Fundamentos".

Para copiar o conteúdo de um array para outro, pode-se usar o método arraycopy da classe System. a sintaxe é a seguinte:

System.arraycopy(from, fromIndex, to, toIndex, count);

As variáveis from e to devem ser Object. E como sabemos, todo array em java É UM Object (ou seja, herda os campos e métodos da classe Object).

Traduzindo para o bom português: copie os "count" elementos de "from", começando em "fromIndex" e vá armazenando em "to" a partir de "toIndex".

Exemplo de utilização do método arraycopy:

public class teste {
  public static void main(String args[]) {
    int[] smallPrimes = {2, 3, 5, 7, 11, 13};
    int[] luckyNumbers = {1001, 1002, 1003, 1004, 1005, 1006, 1007};

    System.arraycopy(smallPrimes, 2, luckyNumbers, 3, 4);

    for(int i = 0; i < luckyNumbers.length; i++)
      System.out.println(i +": "+ luckyNumbers[i]);

  } // final de main
} // final da classe teste

A saída deste programa será:

0: 1001
1: 1002
2: 1003
3: 5
4: 7
5: 11
6: 13


A simples ordenação de um array pode ser feita através do método sort da classe java.util.Arrays. Para ordenar basta fazer o seguinte (luckyNumbers é um array de inteiros):

Arrays.sort(luckyNumbers);

Reza a lenda que este método usa o QuickSort.


Outros métodos úteis para manipulação de arrays (todos da classe java.util.Arrays):

static int binarySearch(type[] a, type v)
usa o algoritmo de busca binária para buscar o valor v dentro do array a. Se econtrado, seu índice é retornado. Do contrário é retornado um valor negativo r; o valor -r - 1 é o ponto em que v deverá ser inserido para manter o array a ordenado.
Parâmetros:
a: um array ORDENADO do tipo int, long, short, char, byte, float ou double.
v: um valor do mesmo tipo que os elementos de a.

static void fill(type[] a, type v)
atribui o valor v a todos os elementos do array a.

maneira Deitel de checar data

Essa é mais uma dica da série "como é que eu não tinha pensado nisso antes?". Trata-se de uma maneira super-simples de checar a validade de uma data. Vi isso no livro "Java: Como Programar", sexta edição, do Deitel. Aí vai...

- ano: pode ser qualquer inteiro não negativo.
- mês: inteiro dentro do intervalo [1,12].
- dia: aí vai o algoritmo em C, levando em consideração que o mês e ano são válidos.

int checarDia(int dia, int mes, int ano) {
   /* aqui está a simplicidade do algoritmo:
   * cada elemento deste array é o maior dia do mês cujo número
   * é o índice do elemento, exceto o elemento 0
   */
   int diaPorMes[] = { 0, 31, 28, 31, 30, 31, 30
   31, 31, 30, 31, 30, 31, 30 };

   /* veja que coisa mágica! */
   if(dia > 0 && dia <= diaPorMes[mes])
     return dia;

   /* cuidando do danadinho do ano bissexto */
   if(mes == 2 && dia == 29 && (ano % 400 == 0 || (ano % 4 == 0 && ano % 100 != 0)))
     return dia;

   /* se não for uma data válida, retornamos o dia primeiro */
     return 1;
}

Me lembro de um dia fazer um exercício de programação que pedia para validar se a data que o usuário entrou era válida, fiz o código usando switch-case e alguns ifs...

Ver essa solução usando um simples array chega a dar raiva! Raiva por não ter pensado nisso de primeira.

usando o qsort() do stdlib.h

O protótipo é o seguinte:

#include <stdlib.h>

void qsort(void *base, size_t nmemb, size_t size, int (*compare)(cont void *, const void*));

Criei uma função compara() para comparar dois inteiros:

int compara(int const *a, int const *b) {
    return *a - *b;
}

e usei o seguinte comando para ordenar um array de inteiros lista[] com 10 elementos.

qsort(lista, 10, sizeof(int), &compara);

Pronto! Agora lista já está ordenada.

indentando no vim

Essa eu vi em http://plutao.wordpress.com/2007/02/08/identando-o-codigo-no-vim/ e na verdade é uma citação.

Você já se deparou com um código todo mal identado? Como resolver esse problema no vim?

Selecione o bloco de texto e aperte = (igual) e o vim identa para você

Essa mudou minha vida! ;-)

codigo para html

Dica retirada de http://www.ime.usp.br/~pf/algoritmos/apend/util.html.

Converter um código fonte em linguagem C, por exemplo, para html com syntax highlighting.

prompt$ enscript --highlight=c --color --language=html --output=arquivo.html arquivo.c

Projeto de Algoritmos

Achei esse conteúdo muito interessante para o estudo da disciplina Estrutura de Dados II: http://www.ime.usp.br/~pf/algoritmos/index.html.

O autor, Paulo Feofiloff, possui 2 características que eu aprecio muito: escreve todo código em C, e se preocupa com a elegância do código (indentação, comentários, etc.).

Monitorando tempo de execução de uma função

Esse macete eu achei especialmente útil na hora de estudar o desempenho dos diversos algoritmos de ordenação. Aprendi no "Advanced Programming in the UNIX Environment" (Stevens e Rago), no Seção 8.16.

Vamos direto à prática, para detalhes é necessário consultar o livro e/ou as man pages.

Primeiro temos que criar a seguinte função para imprimir o tempo:

#include <unistd.h>

static void imprimetempo(clock_t tempo) {
    static long clktck = 0;

    if(clktck == 0)
        if((clktck = sysconf(_SC_CLK_TCK)) < 0)
            perror("sysconf");

    printf("%7.2f s", tempo / (double) clktck);
}

E para que esta função seja útil temos que chamá-la de maneira análoga ao exemplo abaixo:

#include <sys/times.h>

int main() {
    clock_t ini, fim;
    .
    .
    .
    ini = times(NULL);
    funcao_que_quero_ver_quanto_tempo_leva(argumentos);
    fim = times(NULL);

    printf("Tempo que levou: ");
    imprimetempo(fim - ini);
    .
    .
    .
    return 0;
}

gerando números aleatórios

Essa eu aprendi no Programming in C - UNIX System Calls and Subroutines using C. Trata-se de uma gambiarra para gerar números aleatórios.

Abaixo uma função que gera n números aleatórios de zero a nove e guarda no vetor V passado a função como parâmetro:

#include <stdlib.h>
#include <time.h>

#define MAIOR 10


void geranumeros(int V[], int n) {
    srand((unsigned int) time(NULL));
    while(n > 0)
        V[--n] = rand() % MAIOR;
}

Achei isso especialmente útil na hora de testar os algoritmos de ordenação ensinados na disciplina de Estrutura de Dados II.

defeating non executable stack

A ser lido: http://community.corest.com/~juliano/non-exec-stack-problems.html

Insecure Programming by example

Ótimos exercícios para exploração de programas inseguros:

http://community.corest.com/~gera/InsecureProgramming/

stack smashing protection e outros

Documentos a serem lidos.

 

stack-smashing protection (wikipedia):

http://en.wikipedia.org/wiki/Stack-smashing_protection

 

defeating compiler-level buffer overflow protection: http://www.usenix.org/publications/login/2005-06/pdfs/alexander0506.pdf

 

four different tricks to bypass stackshield and stackguard protection: http://www.coresecurity.com/index.php5?module=ContentMod&action=item&id=1146

Editando programas em C com vim

O vim é o meu editor favorito. E para programar em C é o melhor que já usei. Aqui vai alguns macetes úteis que foram retirados do C editing with VIM HOWTO.

1. Movendo-se pelo texto

{ - volta um parágrafo
} - avança um parágrafo
][ - avança para o próximo } que estiver na primeira coluna
[] - volta para o mais próximo } que estiver na primeira coluna
% - alterna o (, {, ou [ que casa com seu respectivo ), }, ou ].



2. Saltando para posições aleatórias

+ ctags:
Resumo:
ctags *.c - cria o arquivo tags a ser usado pelo vim
CTRL+] - pula para a declaração do identificador (função ou var)
CTRL+T - pula para a posição que estava quando chamou CTRL+]

Descrição:
Primeiro deve-se usar o programa ctags nos arquivos .c para então
chamar o vim. Por exemplo:

[prompt]$ ctags *.c

Este comando criará um arquivo chamado tags no diretório corrente.
Agora quando chamar o vim basta teclar CTRL+] para ir para a declaração de
um identificador, e CTRL+T para voltar de onde chamou.


+ marcadores:
m' - marca uma posição
'' - vai para a posição marcada
m? - marca a posição ? que pode ser A-Z e a-z
'? - vai para a posição marcada com ?



3. Auto-completando palavras
CTRL+P - procura a palavra e mostra as opções (inclusive nos includes)
CTRL+N - idem acima só que no sentido contrário



4. Auto-formatação
:set textwidth=75 - texto com 75 colunas
:set cindent - indentação automática



5. Corrigindo rapidamente
:set makeprg=make\ %:r - configura :make para 'make arquivo_sem_extensao'
:make - executa o que está configurado em makeprg
:cn e :cN - vai para o erro (n vai, N volta)



6. Outros itens adicionados por mim
:map <F9> :w<CR>:make<CR> - <F9> salva e compila
:map <F10> :w<CR>:make<CR>:!./%:r - <F10> salva, compila e espera argumentos