Haskell: Operações Recursivas em Listas

Fala galera, tudo tranquilo?

Hoje o assunto é bem bacana, venho fazendo uma listinha de exercícios marotos em Scala, e estou aprendendendo muito. Hoje o assunto é recursividade, de novo esse assunto? Sim isso está mudando minha vida ou mesmo a forma como penso. (Exagerando rs)

Então, vamos fazer em Haskell?

A ideia é simples, quero deixar bem claro e simples as operações em listas imutáveis usando recursividade, já expliquei algo sobre listas imutáveis aqui.

Bom, vamos começar com um problema, que tal fazermos um map* em uma lista.

* = Para quem não sabe, mapear uma lista é transformar cada valor da lista atual, em um valor que passará através de uma determinada função.

Crie um novo arquivo, double.hs, como não falo há pouco de tempo de Haskell, nos meus primeiros posts, você consegue ver como instalar o interpretador Hugs.

Vamos ao double.hs:

double [] = []
double (head:tail) = head * 2 : double tail

Bom, isso aí já torna a compreensão pouco simples, mas vou explicar, entenda:  double [] = [] é a nossa guarda, ou seja, um ponto onde devemos parar a execução da função. Já falei muito a respeito em posts mais antigos.
Já na segunda linha, vemos algo novo, mas acredito ser bem expressivo, double (head:tail), ali estamos separando a cabeça da lista, de seu corpo, faremos uma operação na cabeça (head *2) e concatenaremos com o corpo, mas passando o corpo como argumento da função double, repetiremos esse processo novamente, isso é incrível e simples.

Para exercitar, primeiro vamos deixar nosso double mais genérico, pois podemos querer fazer outros tipos de map em lista, crie um arquivo mapear.hs:

mapear f [] = []
mapear f (x:xs) = (f x) : mapear f xs

Pronto, agora nossa função está apta a receber outras funções a serem aplicadas a lista, você pode testar no Hugs.

Vá ao seu terminal, caminhe até o diretório do arquivo e digite: hugs mapear.hs

Para construir listas em Haskell, você pode usar de duas formas:

[1,1,2,3,5,8]
1 : 1 : 2 : 3 : 5 : 8 : []

Agora é só passar os parâmetros para sua função: mapear (*2) (1 : 2 : 3 : [])

Use os parênteses para "separar" os argumentos. Tudo certo! (Ou deveria estar).

Vamos evoluir mais um pouco, outra das operações básicas que podem ser efetuadas com lista é o Filter, onde você filtra os elementos da lista e só extraí o que "passar pelo filtro". Basicamente vamos passar uma validação para cada elemento da lista, e como fazer? Crie um arquivo filtro.hs e vamos codar nele:

filtro :: (a -> Bool) -> [a] -> [a] 
filtro f [] = []
filtro f (x:xs) | f x = x : filtro f xs
                | otherwise = filtro f xs

Trabalhamos com quase a mesma forma de aplicar a função do mapear, porém fizemos uma verificação, onde:

•  | é a nossa verificação;
• caso f x retorne false:
• devolvemos só  filtro f xs;
•  caso f x retorne true:
• concatenamos a cabeça x ao filtro f xs;

Ou seja, como vamos navegando na lista, cada hora a cabeça é o elemento posterior, isso é muito simples. Já falei de estruturas de verificação.

O desafio de hoje é meio trabalhoso, caso a preguiça domine vai ter que esperar eu fazer aqui também pra disponibilizar no Github. Você deve implementar um Flatten, ou seja, caso receba uma lista de listas, deve devolver uma lista contendo todos os elementos das listas internas.

É isso aí gente, qualquer dúvida comente abaixo ou email-me: abner.terribili@lambda3.com.br.

C# : Polimorfismo nas suas diversas formas (Parte 1)

Fala aí galera.
Hoje o assunto é bem objetivo, vamos falar a respeito de Polimorfismo.

O que é Polimorfismo?
A primeira vista, parece algo como "Várias Formas", na verdade não é tudo isso. Encontrei uma definição bem interessante dada pelo Ivan Ricarte, da Unicamp, onde: "Polimorfismo é o princípio pelo qual duas ou mais classes derivadas de uma mesma superclasse podem invocar métodos que têm a mesma identificação (assinatura) mas comportamentos distintos, especializados para cada classe derivada, usando para tanto uma referência a um objeto do tipo da superclasse. A decisão sobre qual o método que deve ser selecionado, de acordo com o tipo da classe derivada, é tomada em tempo de execução, através do mecanismo de ligação tardia."

Bom e aí, será que ficou claro? Talvez com um exemplo mais simples, dê para entender.

Vou escrever em C#, é bem simples de replicar em Java.
Imagine que você tenha a necessidade de fazer com que Diferentes Classes possuam comportamentos semelhantes:

Em um dos meus exercícios aqui na Lambda3, tive que construir um "processador de URL's", algo que avalia o conteúdo de uma URL e de acordo faz determinada ação.

Nosso processador, não precisa encapsular diversos métodos, pois assim estaríamos dando muita responsabilidade para apenas uma classe, então basicamente o que nosso processador fará é Armazenar uma

Armazenará uma URL e a processará.

ProcessadorUrl:

class ProcessadorUrl
{
    private readonly String endereco;

    public ProcessadorUrl(String url) { this.endereco = url;}

    public String ProcessaUrl() { return endereco; }
}

Feito isso, da pra entender um pouco o que precisamos fazer. Basicamente, agora faremos as classes avaliadoras:
Farei apenas duas, para compreensão simples.

Primeira classe avaliadora:

class AvaliadorGoogle
{
    private readonly String endereco;
    
    public AvaliadorGoogle(String endereco) { this.endereco = endereco; }
    
    public bool Avalia() { return endereco.Contains("google"); }
        
    public string Executa() {
            return endereco.Replace("google", "bing"); }
}

Segunda classe avaliadora:

class AvaliadorAsdrubal
{
    private readonly String endereco;
    
    public AvaliadorAsdrubal(String endereco) { 

       this.endereco = endereco; }

    
    public bool Avalia() { 

       return endereco.Contains("asdrubal"); }
        
    public string Executa(){ 

       return endereco.Replace("asdrubal", "outro"); }
}

Agora nosso processador de URL pode fazer as comparações e retornar o necessário:

class ProcessadorUrl
{
    private readonly String endereco;
        
    public ProcessadorUrl(String url) { this.endereco = url; }
        
    public String ProcessaUrl()
    {
        if(new AvaliadorGoogle(endereco).Avalia())
               return new AvaliadorGoogle(endereco).Executa(); 
        if(new AvaliadorAsdrubal(endereco).Avalia())
               return new AvaliadorAsdrubal(endereco).Executa();
        return "";
    }
}

Então podemos notar que ambas classes, AvaliadorGoogle e AvaliadorAsdrubal, possuem comportamentos semelhantes, por que não fazer uso do Polimorfismo?

Crie uma nova Interface e de o nome de Avaliacao:

interface Avaliacao {
    bool Avalia();
    String Executa();
}

Agora os nossos Avaliadores implementarão essa interface:

class AvaliadorAsdrubal : Avaliacao
{
    private readonly String endereco;

    public AvaliadorAsdrubal(String endereco) { 

       this.endereco = endereco; }

    public bool Avalia() { 

       return endereco.Contains("asdrubal"); }
    
    public string Executa() { 

       return endereco.Replace("asdrubal", "outro"); }
}

Faça o mesmo para o avaliador Google e beleza! Vamos a classe que processa, podemos fazer bom uso do Polimorfismo:

public class ProcessadorUrl
  {
        private readonly String endereco;
        

        public ProcessadorUrl(String url)
        {
            this.endereco = url;
        }
        

        public String ProcessaUrl()
        {
           List<Avaliacao> lista = new List<Avaliacao>();
           lista.Add(new AvaliadorGoogle(endereco));
           lista.Add(new AvaliadorAsdrubal(endereco));
         
           for (var i = 0; i < lista.Count; i++){
               if(lista[i].Avalia()
                  lista[i].Executa();
           }
           return "";
        }
  }

Conseguiram compreender um bom uso do polimorfismo?

Criamos uma Lista de Objetos que implementam a interface Avaliação. Essa, como diz o Jonas, é a parte gostosa da "Herança" :).

Exemplos no meu Github:
https://github.com/aterribili/Mapeando
https://github.com/aterribili/AvaliacaoEnderecosWeb

Qualquer dúvida email-me: abner.terribili@lambda3.com.br ou comente abaixo.

Valeu galera!

Java, C# : Imutabilidade

Fala galera, tudo tranquilo?

Você já teve interesse de conhecer como são as implementações de Listas ? (List do C#, Java)

Basicamente, as interfaces(List) definem os tipos de operações que podem ser realizadas nas Lista. Vou escrever algo bem bacana, faremos uma implementação de Lista Imutável.

Imutabilidade
Basicamente, é uma característica de um objeto permanecer o mesmo sempre. Quer saber mais sobre Imutabilidade: Bruno Nardini http://www.brunonardini.com.br/artigos/favoreca-a-imutabilidade-e-a-simplicidade

A classe String, tanto do Java quanto C# , encapsula alguns métodos de manipulação de String, como o toUpperCase() (C# = ToUpper()), que têm o objetivo de converter sua string para maiúsculo. Porém por baixo dos panos, o que acontece é você receberá uma nova instância, com o conteúdo de sua string antiga convertida para maiúsculo. (Você pode verificar isso nos links acima)

Já definido o que é Imutabilidade, vamos ao conceito básico de Listas Ligadas (Linked List). (http://www.caelum.com.br/apostila-java-estrutura-dados/listas-ligadas/#5-1-solucao-classica-de-lista-ligada)

Uma Lista Ligada é uma lista onde o elemento atual "aponta"(tem o endereço) para/do o seu próximo irmão, analisem a fotografia abaixo:

Um conceito simples, agora vamos a prática, assim podemos misturar os dois conceitos! (Imutabilidade e Linked List). No exemplo vai rolar um pouco Generics, se já sabe legal, caso não: http://en.wikipedia.org/wiki/Generic_programming#Generics_in_Java .

Primeiro, vamos criar uma interface para nossas listas, para isso, crie um projeto novo no Eclipse, dê um nome e vamos lá:

New -> Interface

public interface List {
    T cabeca();
    List cauda();
    List adicionaNoComeco(T elemento);
    T pegaPosicao(int position);
    List removePrimeiraPosicao();
}

Bom e o que é cabeça e cauda?
Cabeça é o elemento superior de nossa lista, ou seja a head da Lista.
Cauda é todo o restante da lista, é composta por sua cabeça e outra cauda, e assim respectivamente.

Nosso método adicionaNoComeco(T elemento) recebe um parâmetro e retorna uma nova Lista com o respectivo elemento adicionado. Bem parecido com o método removePrimeiraPosicao() que remove o primeiro elemento e retorna a cauda da lista.

Bom vamos as implementações, vamos criar uma nova classe, que podemos chamar de No, ou seja, serão os respectivos nós de nossa Lista:

public class No implements List {
    private final T cabeca;
    private final List cauda;

    public No(T cabeca, List cauda) {
        this.cabeca = cabeca;
        this.cauda = cauda;
    }
    @Override
    public T cabeca() {
        return cabeca;
    }
    @Override
    public List cauda() {
        return cauda;
    }
    @Override
    public List adicionaNoComeco(T elemento) {
        return new No(elemento, this);
    }
    @Override
    public T pegaPosicao(int position) {
        if (position == 0)
            return cabeca();

        return cauda.pegaPosicao(position - 1);
     }
    @Override
    public List removePrimeiraPosicao() {
    return cauda();
    }
}

Entenda:
Ao criar um No, nós receberemos a cabeça (elemento) e sua respectiva cauda (List). Fora o método pegaPosicao, o restante é bem trivial, por isso não entrarei em maiores detalhes.

pegaPosicao(T elemento)
Esse método faz uso recursivo de si próprio, ou seja, ele percorre a cauda, caso o posicao não seja 0, e recursivamente ele vai caminhando de cabeça em cabeça, das caudas, para encontrar o elemento desejado. Bem simples e objetivo.

Certo, feito isso, fica simples entender algumas coisas, a primeira de todas, como será o fim de nossa lista?
Temos que saber onde a Lista tem seu final e como o fazemos?

Faremos outra implementação de List, que agora chamaremos de Nil, será o fim de nossa lista.

public class Nil implements List {
    @Override
    public T cabeca() {
        throw new RuntimeException("Lista Vazia");
    }
    @Override
    public List cauda() {
        throw new RuntimeException("Lista Vazia");
    }
    @Override
    public List adicionaNoComeco(T elemento) {
        return new No(elemento, this);
    }
    @Override
    public T pegaPosicao(int position) {
        throw new RuntimeException("A lista não possui elementos");
    }
    @Override
    public List removePrimeiraPosicao() {
        throw new RuntimeException(
        "Impossível remover elementos de uma lista vazia");
    }
}

O Nil, que como dito acima, tem o objetivo de ser o fim da lista, a única coisa que podemos escrever interessante ao seu respeito é que a reescrita do método adicionaNoComeco vai retornar uma nova instância de No, ou seja, iniciaremos uma lista.

Feito isso, temos um Container, o List, que armazena valores e possui funções para alterar os dados internos, isso nos ajuda muito com a Imutabilidade, nos sentimos mais seguros e sabemos que nosso objeto não será um mutante, que pode perder/alterar seus valores em tempo de execução.

Bom galera, o conceito de hoje foi bem bacana e construtivo, é o que tenho mais feito no meu treinamento com o Jonas, aqui na Lambda3. Espero que tenha ficado claro.

Para os C# manjadores, no meu Github tem um exemplo parecido escrito em C#. Para os Javas, deixarei outro repositório no GitHub já com os testes implementados.

Qualquer dúvida ou sugestão email-me: abner.terribili@lambda3.com.br ou comente abaixo!

Valeu galera!

Java: Testes de Unidade

E aí galera, tudo tranquilo?

Passei um tempo fora daqui, porque estou em processo de treinamento com o Jonas Abreu, na Lambda3. Minha semana, ausente do blog, começou muito diferente. Meu primeiro estágio na área foi em uma empresa convencional, então estava acostumado com aquele lance de calça jeans, tênis e Gerentes com caras de bravos.
Então conheci a Lambda3, através de um amigo, e fiquei super interessado na filosofia e nos valores, que são bem próximos aos meus. Os apaixonados por desenvolvimento, que não curtem gerentes e nem trabalhar vestido como se fosse a um casamento. No primeiro dia, foi um choque, realmente não é normal ver um dos Fundadores (Giovanni Bassi) de Chinelo! Mas venho concluindo que isso só nos deixa mais confortáveis para maiores desafios!

Continuarei me dedicando a vocês e já conversei com o Jonas, vou escrever toda segunda-feira a minha experiência da semana.

Para começar de um jeito novo, minha primeira lição foi TDD!
Imagine o quão confortável é refatorar todo seu código e ter certeza de que se rolar alguma merda, você vai saber antes da Produção. :)

E o assunto será exatamente esse: TDD! (Test Driven Development)

O que é TDD?
Desenvolvimento Orientado a Testes. Você simplesmente escreve seus testes antes de codar seu software. Existe algo mais profundo aqui: http://pt.wikipedia.org/wiki/Test_Driven_Development

O que é um Teste?
Imagine a seguinte situação: Você precisa verificar se dois números foram somados corretamente (Exemplo extremamente didático). Assim você escreve seu teste e vai codar de forma que aquele teste seja satisfeito. Vamos fazer um exemplo prático (Java):

Crie um novo projeto TestandoTDD no Eclipse;

No diretório raiz de TestandoTDD crie um source folder test;

Feito isso, crie dentro do folder test um novo arquivo JUnit Test Case, caso role de você não encontrar o JUnit no seu Eclipse: http://www.vogella.com/tutorials/JUnit/article.html

Por convenção, não sei de quem, nós damos o nome do teste assim: SuaClasseTest
Ou seja, SomaTest.

Bom, agora o lindo e maravilhoso código:

// Não se esqueça dos imports
public class SomaTest{
  @Test
  public void DeveSomarDoisNumeros(){
    // Setup
    Soma soma = new Soma(1, 2);

    // Execução e Verifição
    Assert.assertEquals(4, soma.ExecutaSoma());
  }
}

Bom, mas e aí o que tudo isso significa?
O nome do método de teste tem que ser bem objetivo, muito mesmo. Assim caso der erro, fica "simples" de identificar o ocorrido.

Assim que você escrever a annotation @Test, você declara que aquele é um metodo para testar um caso. (Mais Detalhes: http://junit.sourceforge.net/javadoc/org/junit/Test.html)

O teste é convencional é composto de 3 etapas: Setup, Execução e Verificação.

No Setup, nós definimos o que será testado, no nosso caso o Objeto Soma(que ainda não existe).

Nossa execução acontece no método soma.ExecutaSoma(), que deve retornar o resultado da soma.

E o mais legal aí é a Verificação, que no momento acontece com a Classe Assert (http://junit.sourceforge.net/javadoc/org/junit/Assert.html). Essa classe é composta de diversos métodos que avaliam diversas situações, nós usaremos o assertEquals(int Esperado, int Resultado) que compara dois números.

Caso nosso retorno seja o resultado esperado (3), veremos a aba do JUnit (geralmente a esquerda) com uma barra verde. Caso contrário a cor vermelha predomina.

Bom, nosso teste está escrito, como provavelmente você sabe, ele não funcionará, pois não temos a classe Soma e nem mesmo o seu respectivo método.

Vamos na pasta /src e e criarmos a classe Soma.java. Nosso objetivo atual é satisfazer o teste, ou seja, implementar a classe soma, de forma que nosso teste dê certo.

File -> New -> Class

Soma.java:

//imports
public class Soma {
  private int x;
  private int y;

  public Soma(int x, int y){
    this.x = x;
    this.y = y;
  }

  public int ExecutaSoma(){
    return x + y;
  }
}

E pronto, temos uma situação que satisfaz nosso teste!

Teste seu SomaTest clicando com o direito em cima do arquivo e Run as -> JUnit Test.

Isso foi um simples Teste de Unidade, onde testamos a função ExecutaSoma() da classe Soma.

Na Aba JUnit, logo abaixo você verá algo como Failure Trace, onde caso ocorra algum erro no teste, serão impressos os resultados. Como você deve ter visto, nosso teste retornou um erro, procure no Failure Trace qual foi o erro. E esse é o exercício de hoje, e a dica é você pode encontrar algo no expected:<valor> but was:<valor>. Ou seja valor experado e valor atual.

Caso você tenha ficado com preguiça de digitar todo esse código, que não é muito. Ele está lá no meu Github, é só baixar, importar no Eclipse e testar!

Qualquer dúvida, observação ou mesmo dica email-me: abner.terribili@lambda3.com.br ou comente abaixo!

Node.js : Apresentando Node.js

Boa noite pessoal.

Hoje estou meio inspirado e acho que esse post vai ficar grande! 

O assunto é bem legal, muitos já ouviram falar e talvez poucos se atrevem a testar, mas hoje é o dia.

O que é Node.js?

É um interpretador JavaScript, escrito em C++, do lado do servidor e sim é Open Source. 

JavaScript no servidor? Algo inimaginável há um tempo atrás. O Node veio com uma proposta interessante. Ele possibilita que criemos aplicativos altamente escaláveis e que mantém milhares de conexões simultâneas. Ou seja, ao contrário do Java e algumas outras linguagens, que reservam um determinado espaço de memória(aprox. 2bm) e processamento para manter as conexões simultâneas, o Node.js cria novas instancias da aplicação, para lidar com a demanda, assim o servidor não tem que monitorar e nem requisitar mais recursos. 

Se houver grande interesse de conhecimento, pode ler algo no developerWorks da IBM:

http://www.ibm.com/developerworks/br/library/os-nodejs/#toggle

E a trilha Node.js do Giovanni Bassi:

http://blog.lambda3.com.br/2013/08/node-node-node/

Tenha certeza que se você ler os links acima, não estará perdendo tempo :).

Vamos a parte prática?

A instalação do Node.js é bem simples, entrar no site e baixar:

http://www.nodejs.org/#download

Para os amantes do Terminal, nos nomes existem links com tutoriais mais profundos:

Mac, com o HomeBrew: 

brew install node

Linux:

(Tem que instalar Python também)

sudo apt-get update

sudo apt-get install -y python-software-properties python g++ make

sudo add-apt-repository ppa:chris-lea/node.js

sudo apt-get update

sudo apt-get install nodejs

Windows:

http://dailyjs.com/2012/05/03/windows-and-node-1/

Feito isso, só testar com o famoso version:

node --version

v0.10.25

E tudo certo. 

Vamos fazer o clássico Hello World?

Faremos toda tarefa usando JavaScript e um pouquinho, quase nada, de HTML.

Em seu diretório favorito, crie um arquivo chamado helloworld.js e em seu interior digite e entenda:

// Carrega a biblioteca HTTP do Node.js

var http = require('http');

// Cria um serviço web para tratar a requisição de resposta da mensagem Hello World.

var server = http.createServer(function (request, response) {

  // Define os parâmetros de cabeçalho de resposta.

  response.writeHead(200, {'Content-Type': 'text/html'});

  // Escreve uma mensagem de resposta do servidor.

  response.write('<html><body><h1>Hello World!</h1></body></html>');

  // Envia uma resposta para o cliente

  response.end();

});

// Define a porta e IP que será executado a aplicação.

server.listen(3000);

// Imprime mensagem no terminal do servidor.

console.log('Servidor Node.js em execucao');

Para testar é fácil, vá até seu terminal, caminhe até o diretório do arquivo helloworld.js e digite:

node helloworld.js

Servidor Node.js em execucao

Agora é só abrir seu navegador favorito e inserir a url:

localhost:3000

Vai ver o resultado escrito em HTML!

Quem estiver com pique, continue. Vamos tentar algo um pouco mais legal.

Imagine que você precisa requisitar ao seu servidor a soma de dois números. Se você não viu, faça esse exercício em Haskell também.

Mas vamos lá, JavaScript e tal...

Em seu diretório favorito, crie um novo arquivo chamado soma.js e em seu interior digite:

var http = require("http");

var url = require("url");

http.createServer(function(request, response) {

  response.writeHead(200, {"Content-Type": "text/plain"});

  // Pegando os parâmetros passados via URL

  var params = url.parse(request.url, true).query;

  var x = params.numberX;

  var y = params.numberY;

  var inputX = new Number(x);

  var inputY = new Number(y);

  soma = new Number(inputX + inputY);

  response.write(soma.toString());

  response.end();

}).listen(3000);

console.log("Somando dois números");

E como executar?

node soma.js

Mas ao abrir seu navegador, não estará vendo resultado algum(NaN)... Por que?

Porque não passamos nenhum parâmetro via url.
Tente de novo assim:

localhost:3000/?numberX=3&numberY=4

Entenda...

?	Indica passagem de parâmetros
numberX	Primeiro parâmetro
&	Indica passagem de mais de um parâmetro
numberY	Segundo parâmetro

Verá algo muito mais legal:

7

O servidor Node.js, se emcumbiu de fazer a soma e printar na tela o resultado. "Fácil" não? 

Para fixar, vou deixar um exercício básico:

Faça uma aplicação Node.js que gera um número aleatório, no intervalo de 0 - o número passado via parâmetro.

Dica: (Math.random() * seu_numero).toFixed(0);

Assim você gera um número pseudo-randômico em JS.

A resposta está no meu GitHub. Qualquer dúvida, email-me: abner.terribili@gmail.com ou comente abaixo.

Valeu galera!