Pelo veto ao projeto de cibercrimes - Em defesa da liberdade e do progresso do conhecimento na Internet Brasileira

http://www.petitiononline.com/veto2008/

Se esta lei for aprovada, podemos fazer uso do Tor para navegar tranquilamente.

Tor é um conjunto de ferramentas para um amplo grupo de organizações e particulares que desejam aumentar a sua segurança na Internet. Usar Tor pode ajudar a tornar anónima a navegação e publicação na Web, instant messaging, IRC, SSH, e outras aplicações que usem o protocolo TCP. Tor também disponibiliza uma plataforma para os programadores de software, criarem novas aplicações com funções de anonimato, segurança e privacidade já incorporadas.

Tor pretende defender contra a análise de tráfego, uma forma de vigilância que ameaça o anonimato pessoal e a privacidade, a confidencialidade dos negócios e relacionamentos, e a segurança de estados. As comunicações são enviadas através de uma rede distribuída de servidores chamados onion routers, protegendo-nos de sites Web que constroem perfis com os nossos interesses, pequenos espiões que lêem os nossos dados ou registam que sites visitámos.

A segurança do Tor aumenta à medida que a sua base de utilizadores aumenta e mais pessoas se oferecem para alojar servidores. Por favor considere oferecer o seu tempo ou oferecer a sua largura de banda. Convém lembrar que estamos a lidar com código em desenvolvimento — Não deve usar o Tor se precisa realmente de fortes garantias de anonimato.

Fonte: http://www.torproject.org/index.html.pt

Agora vamos usar as funções específicas para manipular listas.

-module(tut).
-export([generate/1]).

%%
%% Funcao generate(X)
%% Quando X for 0, retorna [0]
%% Quando X > 0, retorna [X,X-1,...,0]
%% Caso contrario retorna [0,1,2,...,abs(X)]
%%
generate(0) -> [0];
generate(L) when integer(L), L > 0 -> 
        lists:seq(0,L); % cria uma lista de 0 até L
generate(L) when integer(L) -> 
        % vamos reverter a lista?
        lists:reverse(generate(-L)).

Muito mais simples, certo? Veja o teste:

$ erl
Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]

Eshell V5.5.5  (abort with ^G)
1> c(tut). 
{ok,tut}
2> tut:generate(5) ++ tut:generate(-5).
[0,1,2,3,4,5,5,4,3,2,1,0]
3> 

O operador ++ une 2 listas :)

Erlang é realmente dificil?

-module(tut).
-export([generate/1]).

%%
%% Funcao generate(X)
%% Quando X for 0, retorna [0]
%% Quando X > 0, retorna [X,X-1,...,0]
%% Caso contrario retorna [0,1,2,...,abs(X)]
%%
generate(0) -> [0];
generate(L) when integer(L) -> gera_lista(L).

gera_lista(L) when L > 0 -> gera_lista_direita(L);
gera_lista(L) -> gera_lista_inversa(-L).

gera_lista_direita(L) -> gera_lista_direita(L,[]).

gera_lista_direita(-1,Z) -> Z;
gera_lista_direita( L,Z) -> 
        %io:format("chamando: gera_lista_direita(~p,Z)~n",[L]),
        gera_lista_direita(L - 1,[L | Z]).

gera_lista_inversa(L) -> gera_lista_inversa(L,[]).

gera_lista_inversa(-1,Z) -> Z;
gera_lista_inversa( L,Z) -> gera_lista_inversa(L,0,Z).

gera_lista_inversa(-1,_,Z) -> gera_lista_inversa(-1,Z);
gera_lista_inversa( L,A,Z) -> 
        %io:format("chamando: h(~p,~p,Z)~n",[L,A]), 
        h(L - 1, A + 1,[A | Z]).

Ok, dessa forma é dificil. Erlang é uma linguagem funcional, ou seja, suas funções seguem um raciocínio matemático e não imperativo. Vc sente o problema quando quer resolver algo iterativo ou utilizar variaveis de qualquer forma.

Fiz uma pequena função chamada generate, do modulo tut (de tutorial, uma vez que estou seguindo um). Ela é muito simples, se vc informar 0, ela gera uma lista simples contendo 0. Se vc passar um numero positivo ela gera uma lista de 0 até o número, inclusive. Se o numero for negativo, ele assume que vc quer fazer fazer a lista de forma inversa.

Veja só:

$ erlc tut.erl   # compilando o modulo
$ erl
Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]

Eshell V5.5.5  (abort with ^G)
1> c(tut).           # carregando o modulo
{ok,tut}
2> tut:generate(0).  # invocando modulo:funcao(parametros).
[0]
3> tut:generate(10).
[0,1,2,3,4,5,6,7,8,9,10]
4> tut:generate(-10).
[10,9,8,7,6,5,4,3,2,1,0]
5> 

A função generate chama a função gera_lista se o parametro passado for um número inteiro.
A função gera_lista chama a função para gerar a lista direita ou inversa, de acordo com o valor do parâmetro.

Veja só a simplicidade:

gera_lista_direita(L) -> gera_lista_direita(L,[]).

gera_lista_direita(-1,Z) -> Z;
gera_lista_direita( L,Z) -> 
        %io:format("chamando: gera_lista_direita(~p,Z)~n",[L]),
        gera_lista_direita(L - 1,[L | Z]).

quando eu chamo gera_lista_direita(10) eu estou, na verdade, chamado a função gera_lista_direita(10,[]), onde eu fico usando uma lista como acumulador.

A operação [L | X] pode ser lida como [ elemento | lista ] , ou seja, eu adiciono um elemento em uma lista. gera_lista_direita(10,[]) vai chamar, então, gera_lista_direita(9,[10]), e depois gera_lista_direita(8,[9, 10]), e assim recursivamente até gera_lista_direita(-1,Z), quando eu retorno a lista. Fica claro se removerem os comentários (%) da frente dos io:format, que é a forma de fazer PPADD (Passei Por Aqui Driven Development) em Erlang.

Erlang precisa de MUITA pratica, principalmente de quem nunca programou em uma linguagem funcional e fica tentado a fazer coisas ‘não ortodoxas’ ;-)

Ah sim, o google é seu amigo:

http://www.dei.isep.ipp.pt/~paf/orgcdocs/Intro_Erlang.pdf