Açúcar Sintático com Extension Methods no C#

Fala galera, tudo tranquilo?
Essa semana me empolguei nos Extensions Methods de C# e resolvi escrever a respeito!

Extension Methods

Os Extension Methods surgiram com o intuíto de te auxiliar na hora do desenvolvimento. Ele resolvem um problema dos grandes, permitem que você adicione métodos a tipos de dados já existentes. Evitando assim, que você tenha que criar um novo tipo.
Existe uma biblioteca muito famosa no C# que se chama LINQ no qual implementa diversos extension methods para trabalharmos com IENumerable.

Bom, mas como de costume, existem fontes mais detalhadas a respeito Extension Methods, se puder, invista uns 15 minutos lendo.

Vamos a prática? É bem simples! Criei um projetinho Class Library no Visual Studio, e adicionei algumas dependências que já estou acostumado a usar: FluentAssertions e NUnit.
Primeira classe:

public static class Ext
{
    public static int Soma(this int x, int y)
    {
        return x + y;
    }
       
    public static string RecortarEColar(this string s, string old, string neww)
    {
        return s.Replace(old, neww);
    }
}

E como usamos esses métodos?

public class extTest
{
    [Test]
    public void DeveSomar()
    {
        234.Soma(266).Should().Be(500);
    }
    [Test]
    public void DeveTrocar()
    {
        "Extension Methods são fodas".RecortarEColar("fodas", "úteis").Should.Be("Extension Methods são úteis");
    }
}

Simples de usar e entender. Mas por que os métodos são estáticos? Eles são apenas um Açucar Sintático, servem para deixar o código mais legível! Assim como o Should().Be()... Na Real o que o compilador faz é tornar o código acima parecido com isso:

      
    Ext.Soma(234, 266);
    Ext.RecortarEColar("Extension Methods são fodas", "úteis");

E aí qual ficou mais legível, nosso código acima, ou o clássico chama a classe estática e seu método e passamos os parâmetros?

Por hoje é isso aí galera. Abraços

Mais Polimorfismo (Haskell)

Fala galera, tudo tranquilo?

Bom, hoje vou levantar um dos assuntos que mais falo a respeito no Blog: Polimorfismo. Mas vamos estudar um pouco disso no Haskell. Certo?

Haskell incorpora alguns tipos polimórficos, as expressões de tipos polimórficos, na essência, descrevem famílias de tipos. Por exemplo, uma lista de caracteres ['h', 'a', 's', 'k', 'e', 'l', 'l'] , uma lista de inteiros [1,1,2,3,5,8] e podemos chegar até na lista de lista de caracteres [['a'], ['b'], ['c']], ou seja, todas essas listas compartilham da mesma família de tipos. Mas, no Haskell, temos uma pequena restrição, uma lista que foi determinada para ser usada com Inteiros, não pode receber um caracter. (Ex.: [1, 'b'])

Ao definirmos uma função que utiliza tipos polimórficos, definimos uma função genérica. Como exemplo abaixo:

   length [] = 0
   length (a:x) = 1 + length x 

Com essa função podemos ver claramente que independente do tipo de dado que for utilizado, conseguiremos usa-lo como parametro para a função que calcula o tamanho da lista. E você sabe dizer qual o retorno da função acima?

 Prelude> :t length
          length :: [a] -> Int

O a é uma variável do tipo polimórfica. A função length é uma função genérica.

O sistema de tipos Haskell possui duas propriedades: - Toda expressão bem tipada é garantida por ter um único tipo genérico. - O tipo genérico ou mais geral pode ser inferido automaticamente.

Lembrando que, no Haskell temos uma linda type inference(Inferência de tipos), mesmo que você possa definir o tipo de uma função, o Haskell o faz:

    soma :: Int -> Int -> Int
    soma x y = x + y

No entanto a função acima pode ser escrita somente pela segunda linha, usando assim o type inference do Haskell.

Por hoje é só, escrevi esse post porque acordei cedo e estava sem sono rs. No próximo, vou falar do Polimorfismo ad hoc.

Abraços!

Já testou seu código Javascript? Jasmine!

Fala aí galera, tudo tranquilo?

Você certamente já brincou ou trabalhou com Javascript, mas já testou o que você fez? E saiba, não estou falando de testes manuais. hehe

Em algum momento dos meus atuais exercícios com o Jonas aqui na Lambda, ele me apresentou o Jasmine que é um framework de teste para Javascript, que rola seguindo uma técnica de desenvolvimento Ágil, chamada BDD(Behavior Driven Development), mas como não é o foco, não entrarei em maiores detalhes.

Jasmine

Vamos diretamente a prática, baixe o arquivo do Jasmine no Github deles.
Abra esse arquivo, que é um diretório, abra a pasta spec e crie um novo arquivo "testando-soma.js". Feito isso, vamos abrir o arquivo e criar uma função de soma em Javascript:

 function soma(x, y){
    return x + y;
}

Agora vamos escrever um teste para essa função básica:

 
describe("Dado a soma de 2 e 1:", function(){
    it("O retorno deve ser 3.", function(){
        var resultado = soma(2, 1);
        expect(resultado).toBe(3);
    })
}

Entendendo Basicamente na primeira linha describe, nós descrevemos nossa função, na segunda linha it definimos o que deveria ser o resuldado. Já ali na quarta linha expect nós inspecionamos a variável resultado e com o toBe(), veja como Ser. Ou seja, o resultado esperado deve ser 3.
Agora teste você mesmo, abra o arquivo SpecRunner.html, com o seu navegador, e verá o resultado do seu teste. Mas antes, já que você não vai ver nenhum resultado do seu teste, e o motivo é simples, com o seu editor padrão, abra o arquivo SpecRunner.html e inclua a linha:

 <script type="text/javascript" src="spec/testando-soma.js"></script>

Feito isso, nosso arquivo javascript, escrito acima, será carregado e poderá passar pelos testes.
Bom, agora vamos escrever um teste mais legal certo?
Vamos reverter uma string, então bora escrever o teste primeiro:

 describe("Dado a string 'Asdrubal' a reversão:", function(){
    it("O retorno deve ser laburdsA.", function(){
        expect(reverse("Asdrubal").toBe("laburdsA");
    }); 

});

Agora vamos escrever a função:

 function reverse(texto){
    return texto.split("").reverse().join(""); 
}

No código acima, fizemos um split para pegar cada letra e transformar num array de char, depois usamos o reverse para reverter esse array e, por fim, o join para montar novamente uma string, coisa básica. Mas já é um teste mais legal :). Não deixe de conferir a documentação e a Introdução, mas é claro, não se prenda ao Jasmine, apenas a idéia de testar seu código já é sensacional, ou não!

Dica para os JS testers: Mocha.

Valeu Galera!

Vi IMproved, mais conhecido como Vim!

Fala galera, tudo bom?

Há um tempo atrás prometi que iria falar a respeito do editor de texto Vim, e hoje o assunto é esse.
Para começar, que tal instalar o Vim no seu pc/mac?

Quem tem Linux ou MacOS como Sistema Operacional, muito provavelmente já vem instalado, só ir até terminal e digitar:
vim --version

Caso você não possua instalado é só baixar no link ao lado: vim.org.

O Vim (Vi IMproved) é uma versão melhorada do antigo VI, é um excelente e produtivo editor de texto modal, hoje conheceremos os 2 modos básicos:
Insert: O modo de inserção, onde podemos editar texto normalmente.
Command: No modo de comando temos algumas maneiras eficientes de navegação e edição de texto.

Agora vamos a prática, crie um novo arquivo e abra-o em seu terminal ou editor Vim para aprendermos.

A primeira coisa são os modos, assim que você abre o arquivo, está no modo command, como citado acima, pode navegar pelo documento e manipular textos.

Para começarmos a inserir texto digite i, entrará no modo de inserção, vamos fazer um hello-world.html:

  
    <html>
    <head>
      <title>Hello World</title>
    </head>
    <body>
      <h1>Hello World :)</h1>
    </body>
    </html>

Feito isso, vamos treinar algumas comandos no modo command, basicamente para navegação simples:

• h: para navegar a esquerda.
• j: para navegar para baixo.
• k: para navegar para cima.
• l: para navegar a direita.

Pratique esses movimentos, caminhe pelo nosso hello-world.html.
Próxima lista de comandos básicos:

• G: para ir até a última linha do arquivo.
• gg: para ir até a primeira linha do arquivo.
• w: para navegar de palavra em palavra para frente.
• b: para navegar de palavra em palavra para trás.

Pratique esses movimentos, navegue pelo nosso hello-world.html.
E aí, sentindo dificuldades? É só acostumar, depois fica tudo mais simples. Vamos para comandos de copiar, colar e deletar:

• yy: você copia uma linha.
• p: você cola uma linha.
• dd: você recorta a linha.

Bom, agora vamos misturar as coisas, os comandos também aceitam uma quantidade específica de vezes que eles devem ser executados, como funciona?
( <repetição> <comando> )

• 2h : para navegar 2 vezes para a esquerda.
• 4k : para navegar 2 linhas acima.
• gg yG : copiar todo o arquivo.
• 3w : para navegar 3 palavras a direita.
• 2b : para navegar 2 palavras a esquerda.
• 10dd : para recortar 10 linhas a partir da atual.
• 8p : para colar 8 linhas a partir da atual.

Bom, essa é a hora da sua imaginação fluir e ir tentando coisas novas e não se prenda aos poucos ensinamentos que passei hoje, busque muito mais.

E a boa de hoje?
Venho acompanhando o Drew Neil do VimCast e estou aprendendo milhares de coisas novas a cada vimcast. Esse site da UniRio também me ajudou muito no início e não deixe de acompanhar meu blog, prometo escrever mais a respeito do Vim.

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

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.

Java, C#: Substituindo o Switch com Polimorfismo

Fala galera, tudo tranquilo? Passado o Carnaval, espero que tenham se divertido, eu estou há uma semana sem escrever e hoje, vou escrever algo não muito novo. O exemplo acontece em Java, mas é simples de replicar em C#, acredite.

Recebi um desafio na faculdade, de escrever uma estrutura de tomada de decisão, aquela famosa "coisa bizarra" chamada Switch.

Imagine o seguinte, nós temos 4 regiões, sendo elas: Sul, Norte, Leste e Oeste. E para cada valor setado, desejo retornar uma região diferente, por exemplo:

Região	Valor
Sul	2
Norte	3
Leste	5
Oeste	7

Com essa tabela ficou mais claro, se eu passar como parâmetro o valor 2, quero receber a região Sul. Bom, escrevendo o teste, poderemos refatorar depois, certo?

Crie um projeto no Eclipse/Visual Studio, e dê o nome de SubstituindoSwitch, feito isso, crie um source folder de test e crie um pequeno teste de unidade, em seu interior:

public class SustituindoSwitchTest {

    @Test
    public void DeveBuscarRegiaoSul() {
        Assert.assertEquals("Sul", new SubstituindoSwitch().buscaRegiao(2));
    }

    @Test
    public void DeveBuscarRegiaoNorte() {
        Assert.assertEquals("Norte", new SubstituindoSwitch().buscaRegiao(3));
    }

    @Test
    public void DeveBuscarRegiaoLeste() {
        Assert.assertEquals("Leste", new SubstituindoSwitch().buscaRegiao(5));
    }

    @Test
    public void DeveBuscarRegiaoOeste() {
        Assert.assertEquals("Oeste", new SubstituindoSwitch().buscaRegiao(7));
    }

}

Agora vamos resolver da forma mais simples. E o Switch cai como uma luva certo? Olha ele aí:

public class SubstituindoSwitch {

    public String buscaRegiao(int valor) {

        switch (valor) {
        case 2:
            return "Sul";
        case 3:
            return "Norte";
        case 5:
            return "Leste";
        case 7:
            return "Oeste";
        default:
            return "Região não encontrada.";
        }
    }
}

Bom, resolvemos o problema certo? Sim! Mas se temos toda aquela história de orientação a objetos e polimorfismo, por que usamos essa estrutura forrada de responsabilidades e totalmente procedural?

Podemos começar a pensar apenas em dividir as responsabilidades, ali no switch ficou claro que nossa classe SubstituindoSwitch tem uma grande responsabilidade de avaliar e claro devolver o retorno esperado e isso não é nada vantajoso. Vamos tentar encontrar semelhanças na responsabilidade. Para todas as situações um determinado valor é avaliado e caso seja ele o correto, recebemos uma String. E aí identificamos uma responsabilidade, vamos construir uma interface para esses responsabilidade:

public interface Regiao {
    public boolean avalia(int valor);

    public String procedencia();
}

Pronto, já definimos a responsabilidade, agora precisamos delegar os respectivos comportamentos, sabemos que o quando o valor for 7, desejamos receber a string Oeste, ok?

public class Oeste implements Regiao {
    @Override
    public boolean avalia(int valor) {
        return valor == 7;
    }

    @Override
    public String procedencia() {
        return "Oeste";
    }
}

E podemos fazer isso para todas as outras três regiões esperadas(Sul, Norte e Leste), cada uma dessas regiões com a mesma responsabilidade mas diferentes comportamentos. Certo? Implemente as outras classes para podermos dar continuidade. Caso a preguiça domine, vá até meu Github.
Agora voltaremos a nossa classe SubstituindoSwitch, e faremos algumas pequenas modificações, a primeira de todas é apagar o devorador de responsabilidades switch:

public class SubstituindoSwitch {
    private List<Regiao> regioes;

    public SubstituindoSwitch() {
        regioes = new ArrayList<>();

        regioes.add(new Sul());
        regioes.add(new Norte());
        regioes.add(new Leste());
        regioes.add(new Oeste());

    }

    public String buscaRegiao(int valor) {

        for (Regiao regiao : regioes) {
            if (regiao.avalia(valor))
                return regiao.procedencia();
        }

        return "Região não encontrada.";
    }
}

Vou tentar ao máximo deixar claro o que está acontecendo no código acima, a primeira coisa que fizemos foi definir uma lista de regiões, ou seja, uma lista que armazenará todas as opções de regiões possíveis. Nosso método buscaRegiao continuou recebendo o parâmetro valor, mas ele não mais detém a responsabilidade de conter os valores das regiões, ele apenas delega a responsabilidade de acordo com uma avaliação também executada por cada responsável pelo valor, poxa, perdi até o fôlego. Detalhando:

if (regiao.avalia(valor)) return regiao.procedencia();

Esse if passa o valor para a região, a região detém o comportamento esperado e ela retorna o resultado desejado. Bom, só rodar os testes, e se maravilhar com o resultado. Bom, o próximo desafio é substituir o if, aí já envolve um pouco mais de estudo. :P

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

Se surgir dúvidas, tem o exemplo lá no meu Github:
Para os Java: https://github.com/aterribili/SubstituindoSwitch
Para os C#: https://github.com/aterribili/SubstituindoSwitch-CSharp


Abraços!

Java: Polimorfismo e suas diversas formas (Parte 2)

Fala galera, beleza?

Hoje vou dar continuidade ao assunto Polimorfismo e suas diversas formas, para que não leu Polimorfismo Parte 1.

E faremos algumas mutretas usando os poderes do Polimorfismo.

Imagine a situação onde você precisa categorizar 3 objetos diferentes que partilhem dos mesmos atributos, em um dos meus exercícios com o Jonas, na Lambda3, nós fizemos, com fins educacionais, um mini avaliador de endereços web, que retorna os corretos endereços.

Basicamente, vamos criar um novo projeto Java no Eclipse. Vamos manter o costume e escrever um teste básico:

@Test
public void deveRetornarDominioBuscape(){
   ProcessadorUrl processador = new ProcessadorUrl("buscape");

   Assert.assertEquals("http://www.buscape.com.br", processador.dominio());
}

@Test
public void deveRetornarParametroBuscape(){
   ProcessadorUrl processador = new ProcessadorUrl("buscape");

   Assert.assertEquals("p", processador.parametro());
}

@Test
public void deveRetornarCookie(){
   ProcessadorUrl processador = new ProcessadorUrl("buscape");

   Assert.assertEquals("bp", processador.cookie());
}

Definido nosso teste, podemos criar uma classe para satisfazer o teste:

public class ProcessadorUrl {
   private String dominio;

   public Dominio(String dominio){
      this.dominio = dominio;
   }

   public String dominio(){
      if(dominio=="buscape")
         return "http://www.buscape.com.br";
      if(dominio=="bondfaro")
         return "http://www.bondfaro.com.br";
      return "";
   }

   public String parametro(){
      if(dominio=="buscape")
         return "p";
      if(dominio=="bondfaro")
         return "b";
      return "";
   }  

   public String cookie(){
      if(dominio=="buscape")
         return "bp";
      if(dominio=="bondfaro")
         return "bf";
      return "";
   }
}

Pronto, conseguimos satisfazer nosso teste, mas espera aí, se o tema é Polimorfismo, por que estamos fazendo nessa forma procedimental?

Consegue ver que nossa classe ProcessadorUrl possui muitas responsabilidades? Ela é obrigada a avaliar o dominio, parametro e o cookie? Acho que para nossos "sites" temos características semelhantes, para todos os sites devemos ter metodos que busquem o domínio, parâmetro e cookie, certo? Então vamos para a Orientação a Objetos.

E como fazer bom uso do polimorfismo nesse caso? Antes de prosseguir, rode seus testes. Crie mais alguns para o bondfaro. Divida as responsabilidades, nossa classe ProcessadorUrl, deve apenas reconhecer o parâmetro String de dominio, e retornar o objeto correto. Creio ser uma boa forma de início.

ProcessadorUrl = deveria apenas avaliar dominio
Buscape = ter os atributos dominio, parametro e cookie
Bondfaro = igual Buscape

Vamos refatorar nossas classes:

De início vamos montar nossa classe ProcessadorUrl:

public class ProcessadorUrl{
   private String dominio;

   public Dominio(String dominio){
      this.dominio = dominio;
   }

   Site avaliaDominio(){
      if(dominio=="buscape")
         return new Buscape();
      if(dominio=="bondfaro")
     return new Bondfaro();
      throw new RuntimeException("Não foram encontrados registros");
   }
}

Já evitamos aquele retorno horrível de String vazia, dividimos mais a responsabilidade da nossa Classe ProcessadorUrl, agora vamos aos nossos "Sites". Podemos notar comportamentos semelhantes, como dito acima, sabendo disso que tal criar uma interface que delega as responsabilidades que os objetos devam implementar.

Crie uma Interface Site, onde teremos os seguintes métodos:

public interface Site(){

String Dominio();
String Parametro();
String Cookie();
}

Para completar podemos criar a classe Buscape, que implementará a interface Site:

public class Buscape implements Site {

    @Override
    public String dominio() {
        return "http://www.buscape.com.br";
    }

    @Override
    public String parametro() {
        return "p";
    }

    @Override
    public String cookie() {
        return "bp";
    }

}

Feito isso, rode seus testes! E aí o que rolou? Um problemão (rs), devemos refatorar nosso teste, agora ele também trabalha com objetos.

@Test
    public void deveRetornarDominioBuscape(){
       ProcessadorUrl processador= new ProcessadorUrl("buscape");

       Assert.assertEquals("http://www.buscape.com.br", processador.avaliaDominio().dominio());
    }

    @Test
    public void deveRetornarParametroBuscape(){
       ProcessadorUrl processador= new ProcessadorUrl("buscape");

       Assert.assertEquals("p", processador.avaliaDominio().parametro());
    }

    @Test
    public void deveRetornarCookie(){
       ProcessadorUrl processador = new ProcessadorUrl("buscape");

       Assert.assertEquals("bp", processador.avaliaDominio().cookie());
    }

O retorno do objeto não é muito explícito, mas nosso processador, possui o método avaliaDominio() que retorna um objeto do tipo Site, isso mesmo, assim podemos buscar os devidos comportamentos das devidas implementações da interface Site.

Legal né? Você então, usando Polimorfismo com uso de interfaces, pode fazer com que seus objetos partilhem os mesmas responsabilidades e direfentes comportamentos, evitando assim Heranças.

Aqui terminamos mais um exemplo do bom uso do Polimorfismo. Se surgir alguma dúvida, corre lá no meu Github

E a dica de hoje é, na verdade pergunta, já sabe usar o controlador de versões Git? Caso não e esteja afim de aprender, o Jonas tem feito um bom trabalho com uma mistura de prática e jogos: Git Game

Bom, por hoje é só galera. Qualquer coisa email-meabner.terribili@lambda3.com.br ou comente abaixo.

C#: Um suporte a funções

Fala aí galera!

Seguindo os posts atuais sobre C#, em uma das minhas aulas com o Jonas, descobri uma das maravilhas de C# e seu "pequeno" suporte a programação funcional.

Hoje faremos algo bem prático. Vamos criar um exemplo genérico de um método que recebe três parametros, sendo eles: int, int, função.

Comecei hoje a leitura de um livro muito bacana: Código Limpo - Robert C. Martin. (Que já me proíbe a criação de uma função que recebe três parâmetros, mas vamos relevar isso rs) Parece muito bom, como o nome diz é um livro que através da pratica deliberada, nos "promete" o conhecimento para distinguir um bom código de um código ruim, digo isso como dica a todos vocês leitores, e que também é mais uma das minhas lições no desenvolvimento de software. (E o VIM galera, estão usando?)
Se ainda faltam alguns conceitos de paradigma funcional, dê uma lida nos meus posts anteriores, sempre estou com esse tema em pauta.

Vamos a prática.
Crie um projeto novo no seu Visual Studio e dê um nome bacana e objetivo.

Dei o nome de AprendendoFunc, na minha opinião, objetivo.

Segundo passo, vamos criar os Testes:

Cria uma nova Solution, dentro dela crie um projeto Class library e outro Projeto de Test Unit. Então a primeira coisa que vamos testar é uma possível soma entre dois números:

...
[TestMethod]
public void DeveSomarDoisNumeros()
{
    Func<int, int, int> funcaoSoma = (x, y) => x + y;

    Assert.AreEqual(120, new Calculadora().Calcula(60, 60, funcaoSoma));
}

Claro que nosso teste apresentará alguns erros, porém com ele já sabemos qual o nosso objetivo.

Nossa classe Calculadora, deve possuir um método que recebe 3 parâmetros. A função acima (funcaoSoma) é uma função que vem lá da matemática, entenda:

Func<parametro, parametro, tipoRetorno> nomeFuncao = (parametro, parametro) => funcao;

Ficou simples de entender, certo? Passamos dois números inteiros e recebemos o resultado da operação da função passada, isso é incrivel! Dizem as más linguas, ou boas, que o F# tem um pézinho aí!

Agora vamos implementar nossa classe Calculadora:
...

public class Calculadora()
{
    public int Calcula(int primeiroNumero, int segundoNumero, Func<int, int, int> funcao)
    {
        return funcao(primeiroNumero, segundoNumero);
    }   
}

Pronto, nossa Calculadora está pronta para receber os parâmetros corretos. Agora rode seus testes e assegure-se do resultado estar correto.

Feito isso, crie mais um método de teste que deve executar a multiplicação de dois números. É muito fácil né?

Bom, e se precisarmos fazer algum tipo de comparação? Um exemplo prático, ao tentar dividir o primeiroNumero pelo segundoNumero, poderemos encontrar um problema caso segundoNumero = 0, para evitar isso, podemos criar mais um método:

public class Calculadora(){
    ...
    public int VerificaECalcula(int primeiroNumero, int segundoNumero, Predicated<int> verificacao, Func<int, int, int> funcao)
    {
        if(verificacao(primeiroNumero, segundoNumero)
        return funcao(primeiroNumero, segundoNumero);
    return 0;
    }
}

Entenda: Predicated recebe apenas um parâmetro e retorna um booleano, é amplamente usado para verificações, acredite. Temos também o Action, que é void, mas não é útil no nosso exemplo.
Vamos ao teste?

...
[TestMethod]
public void DeveCalcularDivisaoComVerificacao()
{
    // Aqui podemos fazer as três etapas em uma só linha: Setup, Execução e Verificação
    Assert.AreEqual(0, new Calculadora().VerificaECalcula(100, 0, (y) => y > 0, (x, y) => x / y));
}

Pronto, assim podemos passar a função de verificação e ainda a função de execução, isso sim é incrível.

Bom galera, por hoje é só, qualquer dúvida email-me: abner.terribili@lambda3.com.br ou comente abaixo!

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!

C#: Um Pouco Mais Recursivo

E aí galera, tudo beleza?

Hoje o assunto é semelhante ao meu post a respeito de Recursividade (http://aterribili.blogspot.com.br/2014/01/haskell-recursividade.html), vou falar mais um pouco, só que ao invés de usarmos Haskell, vamos usar C#!

(Se por acaso você não possua uma forma de compilar C#, replique o exercício em Java, é bem parecido!)

Se você ainda não sabe o que é Recursividade, aconselho ler meu post anterior.

Vamos imaginar um problema simples e que você não possa usar um for para resolver?

Crie um método que Multiplica uma String, ou seja:

"a" * 3 = "aaa"
"ab" * 2 = "abab"

Consegue imaginar algo do tipo?

Com o uso da Resursividade, podemos resolver esse problema de forma simples e elegante.

Vamos ver o Teste de Unidade primeiro, assim fica mais simples de entender:

...
[TestMethod]
public void DeveMultiplicarString(){
  Assert.AreEqual("abab", new Multiplicador().MultiplicaString(2, "ab");
}

Daí ficou simples entender o que deve acontecer.

Vamos criar a classe Multiplicador:

public class Multiplicador() {
  public String MultiplicaString(int vezes, String string){
    if(vezes == 1) //Aqui definimos uma Guarda
      return string;

    return string + Multiplicador(--vezes, string); 
  }
}

Feito isso, entenda que a Guarda é um ponto onde a execução do método será parada.
A execução do método é efetuada de forma recursiva, toda vez que a variável vezes for maior que 1.
E existem n exemplos onde recursão é aplicável e criamos uma função muito mais legível aos olhos de outro programador.

Bom galera, por hoje é só! Estou preparando um post a respeito de Funcs no C#.

Qualquer coisa, email-me: abner.terribili@lambda3.com.br ou comente abaixo!

Cheers!

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!

Haskell: Lazy Evaluation e Listas

E aí galera!

Continuando na saga Haskell, hoje vou falar a respeito de uma de suas maiores características: Lazy Evaluation. (Avaliação Preguiçosa)

O que é Lazy Evaluation?
É uma estratégia utilizada para avaliação de funções. Ela consiste em não avaliar nenhuma subexpressão ou função até que seu retorno seja conhecido como necessário, ou seja, no momento em que o valor, da expressão ou função, for requisitado para continuidade da função, ele será calculado.

Quais são as vantagens?
- Melhor desempenho ao evitar cálculos desnecessários, evitando condições de erro na avaliação de expressões compostas.
- Habilitade de representar potencialmente estruturas de dados infinitas, exemplo:
Você precisa fazer a soma de a partir de n até o infinito:

-- A função lista, recebe um inteiro e retorna uma lista de inteiros dados a partir de n

lista :: Int -> [Int]
lista = n : lista (n + 1)

Ou seja, a função lista gera infinitos números para uma lista de inteiros a partir de um número passado como parâmetro. Vamos executar esse código:

Main> lista 5
lista 5 = 5 : lista (5 + 1)
        = 5 : 6 : lista (6 + 1)
        = 5 : 6 : 7 : lista (7 + 1)
        ...
        ....
        .....
        ......

A soma só é executada quando necessária :).

Para maior compreensão do exemplo que citei, vou deixar algumas noções sobre Listas em Haskell.

Listas
Uma lista é uma estrutura de dados que representa uma coleção de objetos homogêneos. Ou seja, objetos que são do mesmo Tipo de Dado.

Listas em Haskell
Uma lista em Haskell é composta por head (cabeça) e tail (corpo). A cabeça é o primeiro objeto da lista, por onde é feito o nó de acesso da lista. A partir dela(head) temos acesso aos objetos que estão no tail da lista.

Para criar uma lista em Haskell é bem simples:

-- Lista de números
fibonacci :: [Int]
fibonacci = [1, 1, 2, 3, 5, 8]
-- Lista de Char
nome :: [Char]
nome = ['A', 'B', 'C', 'D']
-- Lista de String
lista_char :: [[Char]]
lista_char = ["Haskell", ['H', 'A', 'S', 'K', 'E', 'L', 'L']]
-- A string "Haskell" é uma lista de Char

Legal né?

Para criar uma lista vazia:

[]

Pronto, alguns exercícios serão os melhores exemplos.
Vá ao seu terminal e entre no interpretador Hugs.

Digite:

Main> 1 : []

[1]

Main> 1 : 2 : 3 : []

[1,2,3]

Acho que deu pra perceber o que estamos fazendo né? Adicionando elementos a lista. Bem simples, com o caractere ':' nós adicionamos elementos a lista.

Podemos até mesmo fazer comparações de listas:

Main> [1,2,3] == (1 : 2 : 5 : [])

False

Main> [a,b] == [b, a]

ERROR - Undefined variable "b"

Por que vemos esse erro?
Simplesmente porque estamos a usar um tipo de dado Char, que DEVE vir entre ' '.

Main> ['a', 'b'] == ['b', 'a']

False

Pronto.
Não se esqueça também que os elementos de uma lista estão entre [ ] e separados por vírgula.

Galera, por hoje é só. Qualquer dúvida, comente abaixo ou email-me: abner.terribili@gmail.com.

Cheers!

Haskell: Tipos Compostos com Tuplas

E aí galera, tudo tranquilo?
Depois de um dia de praia e muito calor, decidi escrever rs.

De acordo com o meu último post a respeito de Haskell, falei sobre Tuplas. Será importante saber a respeito para dar continuidade.

Hoje tirei a noite pra falar a respeito dos Tipos Compostos e darei alguns exemplos usando Tuplas.

type
No Haskell quando usamos a função type criamos novos Tipos. Semelhante ao typedef do C.

É algo bem básico de entender. Imagine que você precisa definir um "novo" tipo, ou seja, quer definir um novo nome para um determinado tipo de dado:
type Numero = Float
raiz :: Numero -> Numero
raiz a = sqrt(a)

Na primeira linha, nós definimos o tipo e o nomeamos. Já na segunda linha definimos os parâmetros de entrada e saída da função raiz. No fim, tiramos a raiz. Nessa função, o type Numero equivale ao Float do Haskell.

Pô, e onde isso é útil?
Bom, durante meu processo de aprendizado em Haskell, pude ver que o type unido a Tupla fica muito mais interessante. Vamos ver?

Criemos a situação onde preciso de uma "objeto"(type) com seu "atributos". Como podemos definir um cachorro?
Nome
Raça
Idade
Peso

Acredito serem atributos válidos. Vamos usar o Haskell:
-- Define os nomes dos atributos do cachorro
-- String = [Char], ou seja um array de Char
type Nome = String
type Raca = String
type Idade = Int
type Peso = Float

-- Define Cachorro com seus respectivos atributos
type Cachorro = (Nome, Raca, Idade, Peso)

-- Criando um cachorro, um não dois
c_duda, c_pingo :: Cachorro
c_duda = ("Duda", "Teckel", 12, 2.5)
c_pingo = ("Pingo", "Poodle", 1, 4.1)

Com isso nós podemos trabalhar com "objetos" no Haskell.
Vamos ao exemplo prático. Crie um arquivo, types.hs, para começar digite em seu interior o conteúdo lido acima (Types até a criação do Cachorro), depois adicione o conteúdo abaixo:
-- Funções para retorno dos atributos
-- A função get_nome, recebe um Cachorro e devolve o seu nome
get_nome :: Cachorro -> Nome
get_raca :: Cachorro -> Raca
get_idade :: Cachorro -> Idade
get_peso :: Cachorro -> Peso

-- n = nome, r = raça, i = idade, p = peso
get_nome (n, r, i, p) = n
get_raca (n, r, i, p) = r
get_idade (n, r, i, p) = i
get_peso (n, r, i, p) = p

Bom, agora é só testar! Salve seu arquivo e vamos ao terminal e ao diretório do seu arquivo:
hugs types.hs

Main> c_duda
c_duda = ("Duda", "Teckel", 12, 2.5)

Main> get_nome c_duda
"Duda"

Main> get_idade c_pingo
1

E teste o que mais você quiser! Muito louco né?

E da pra fazer uma coisa mais legal ainda:
Main> get_nome ("Teka", "Basset", 3, 3.1)
"Teka"

Mas como assim? Nós criamos* um Cachorro e retornamos seu Nome.
*Entenda que no Haskell só trabalhamos com funções.
Não se esqueça do o Cachorro recebe uma tupla-4. Caso se esqueça desse pequeno detalhe, verá algo assim:

Bom galera, por hoje é só! O arquivo do exercício acima esta no meu GitHub. Só reforçando uma dica anterior , que tal aprender a usar um editor top?
Vim
Emacs

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

Valeu!

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!

Haskell: Apresentando Tuplas

E aí galera, hoje o assunto é bem interessante. Vou mostrar um pouco a respeito das Tuplas.

("Abner Terribili", 22, 72.4, "Verde")
Algo como Nome, Idade, Peso e Cor favorita. Imagine essa tupla como um objeto e seus respectivos atributos, do Java.

Esse exemplo acima é conhecido como Tupla. (Definição boa do Wikipédia, não deixe de ler)

Em Haskell podemos criar funções que manipulam um conjunto de dados. Esse conjunto, heterogênio de dados, tem como objetivo representar uma relação entre seus dados, de forma que a captura do mesmo seja atravês da posição, tal como um Array.

O número de objetos dentro da tupla, define o tamanho da tupla. Ou seja, caso avaliemos a tupla acima, teremos uma tupla-4, veja: 

("Abner Terribili", 22, 72.4, "Verde")

Caso nossa tupla possua somente:

("Abner Terribili", 22);

Teremos uma tupla-2. Podendo chegar até a tupla-n, dependendo somente da quantidade de elementos em seu interior.

Como no Haskell não somos "obrigados" a definir os tipos dos dados, o interpretador reconhece de forma automática, ele reconhecerá os respectivos elementos da seguinte maneira:

Abner Terribili	String
22	Int
72.4	Float
Verde	String

Lembrando que uma String é uma lista. (Sequência de caracteres)

A principal aplicação das tuplas é definir uma função que receba ou retorne mais de um valor e, geralmente, do tipo heterogênio. Apesar das suas vantagens, a tupla tem uma estrutura estática, ou seja, uma vez criada, não pode ser modificada. (Definição Livro: Haskell Uma abordagem prática)

Por padrão as tuplas-2, no Haskell, têm algumas duas pré-definidas, sendo elas:

fst; 
snd;

fst (first) = tem como função retornar o primeiro elemento da tupla-2.

snd (second) = tem como função retornar o segundo elemento da tupla-2.

Vamos testar? Vá até o seu terminal e entre no interpretador Hugs, digitando apenas:

$ hugs

Logo verá o Terminal Hugs, você pode testar vendo o retorno da função:

Main> fst (1, 2)

1

A função fst retornou o primeiro elemento da tupla-2 (1, 2). Agora teste o snd também. Gostou?

Imagine que você tem que calcular a multiplicação e soma de dois números (x, y).  Normalmente faríamos duas funções:

multiplicacao Int -> Int -> Int
multiplicacao x y = x * y

soma Int -> Int -> Int
soma x y = x + y

Pô, acho que uma tupla resolve e economiza na escrita, olha lá:

-- Na definição dos parâmetros, escrevemos que a função vai receber uma tupla-2 e devolverá outra tupla-2

multiplicacao_soma :: (Int, Int) -> (Int, Int)

multiplicacao_soma (x, y) = (x * y, x + y)

E aí, foi mais simples? Na minha opinião, sim!
Com apenas uma função resolvemos um problema "composto".

Teste o exercício acima, vai gostar do resultado, mas não se esqueça da passagem de uma tupla como parâmetro. Exemplos: (1, 2), (99, 27).

Se estiver com tempo, reescreva as funções "fst" e "snd". A resposta está no GitHub.

A dica para esse exercício é usar o "_" (Underscore), como variável anônima, imagine-o como um coringa, você não precisa definir o tipo da variável que não terá utilidade para você. Ou seja, o argumento "_" tem seu conteúdo desconsiderado pelo interpretador.

Esse post ficará por aqui, mas já estou preparando o próximo pra falar um pouco de "Tipos compostos com Tuplas".

E minha dica de hoje é um app, ou uma Android Activity, escrita em Haskell (!!!) , legal não? 

https://github.com/neurocyte/android-haskell-activity

Qualquer coisa, email-me: abner.terribili@gmail.com ou comente abaixo.

Cheers!

Ruby: Hello World!

E aí galera, hoje vou escrever sobre outra linguagem, que segundo alguns especialistas também tem algo funcional, não sei se é verdade, mas logo logo descubro e deixo aqui pra vocês :).

RUBY!

O Ruby foi lançado em 1995 por Yukihiro Matsumoto (também conhecido como Matz).
O objetivo de Matz ao fundamentar as bases do Ruby, foi pensar em algo expressivo, para assim ser simples de ler e ser compreendida. Com esses pensamentos, Matz criou uma linguagem orientada a objetos, com tipagem forte e dinâmica.

E fala sério, olha essa expressividade:

Vou deixar um material legal para vocês poderem ler a respeito :). A apostila aberta da Caelum vem ajudando muito no meu treinamento, se quiser dê uma olhadinha aqui. No site deles, Ruby, também existem alguns tutoriais bacanas.

Deixarei dois exemplos mais básicos, para você que ainda não configurou seu ambiente, vamos lá.

O site do Ruby, explica detalhadamente como configurar o seu ambiente. Então não vou estender muito essa parte, porque é "desnecessário".

Mas basicamente é isso:

Linux:

apt-get install ruby irb rdoc

Mac, com gerenciador Homebrew:

brew install ruby

Windows:
https://www.ruby-lang.org/pt/downloads/

Depois de instalado, podemos testar se ocorreu tudo certo assim, abra seu terminal e digite:

ruby --version

Verá algo como:

ruby 2.0.0p247 (2013-06-27 revision 41674) [universal.x86_64-darwin13]

E pronto! Podemos brincar.

Vamos ao Hello World descolado. Crie um arquivo em seu diretório favorito, com o nome de hello_world.rb. A extensão .rb significa Ruby, e é a extensão usada para o interpretador Ruby reconhecer como arquivo Ruby.

Abra seu arquivo com editor seu editor e digite em seu interior:

# Assim fazemos comentário de uma linha no Ruby

puts "Digite seu nome: "

nome = gets

puts "Hello #{nome.capitalize}!"

O que aconteceu aí em cima, é o seguinte:

puts = imprime conteúdo e pula uma linha.

nome = variável que recebe a string digitada pelo usuário, através de:

gets = um método que permite atribuir um valor do tipo string a uma variável.

#{sua_variavel} = Faz a interpolação da sua String com a variável inserida.

.capitalize = Deixa a primeira letra da sua cadeira de caracteres maiúscula.

Como você pode ver, não precisamos declarar o tipo da variável, e isso não quer dizer que Ruby é fracamente tipada, muito pelo contrário, seu interpretador reconhece e faz o trabalho por você. Mas lembre-se que ruby também é dinamicamente tipada, ou seja, pode ser trocado o valor da variável em tempo de execução. Mais para frente, dou alguns exemplos e melhores explicações.

Vamos exercitar na segunda função:
Podemos fazer esse hello_world ser mais moderno, como?

puts "Digite seu nome: "

nome = gets

def hello_world(nome)

 return "Hello , #{nome.capitalize)

end



puts hello_world(nome)

Agora só testar no seu terminal, digitando:

ruby hello_world.rb

E anime-se com o resultado! rs

Esse foi o primeiro post sobre Ruby e quero escrever muito mais. Qualquer dúvida comente abaixo, ou mande email: abner.terribili@gmail.com. Eu curto muito feedback. O exemplo está no GitHub.

Cheers!

Haskell: Recursividade

Fala aí galera, hoje peguei firme no estudo e estou escrevendo esse post com o Vim! :D

Vou falar mais um pouco de Haskell e o assunto hoje é Recursividade.

A recursividade é a definição de uma subrotina (função ou método) que pode invocar a si mesma (Definição Recursividade). A Matéria sobre Recursividade da Wikipédia está impecável, não deixe de ler.

Onde isso é útil?
Imagine, você precisa calcular a soma dos n primeiros números. Ou seja, precisa escrever uma função que receberá como parâmetro um número n, você terá que somar esse número n a todos os seus antecessores, para que não seja feito através da iteração, podemos usar a recursão.

E a idéia é simples, vamos as definições:
soma (n) = { 1                         : n = 1
                  { soma (n - 1) + 1 : n > 1

soma 10 = 1+2+3+4+5+6+7+8+9+10 = 55

Poxa, mas como minha função sabe onde deve parar?
Devemos definir um aterramento, ou seja, um ponto onde a função deva parar.(Uma Guarda!)

De acordo com a definição matemática de indução, registrada acima, para n = 1, temos como resultado o número 1, para n > 1, nós invocamos novamente a função soma.

Vamos codar, para isso crie um novo arquivo em seu diretório favorito, de o nome de soma_recursividade.hs e digite em seu interior:

soma Int -> Int
soma 1 = 1
soma n = soma (n-1) + n

Ou seja, caso nosso n = 1, a função soma 1, entra em ação e retorna 1. Caso n > 1, a função soma(n), entra em ação, fazendo uso de si mesma para executar a tarefa de soma, isso se chama recursividade.

Podemos compreender o que o Hugs faz, interpretando essa função como escadaria da recursividade, quer ver?

soma 5
= (soma 4) + 5
= ((soma 3) + 4) + 5
= (((soma 2) + 3) + 4 ) + 5
= ((((soma 1) + 2) + 3) + 4) + 5

Agora,o seu interpretador resolverá a função de acordo com as prioridades:

= ((((1) + 2) + 3) + 4) + 5
= (((3) + 3) + 4) + 5
= ((6) + 4) + 5
= (10) + 5
= 15

Teste você mesmo, caminhe até o local do arquivo e:
hugs soma_recursividade.hs

Main> soma 10
15

Pronto! Simples? Talvez meio complicado para compreender de início, mas quando entra na cabeça, parece até simples. rs

Vou até deixar um exercício, ou melhor, dois!

Exercício 3:
O que acha de aprender a usar o Vi ? ou o Vim (Vi improved)?
É simples, poderoso e um software livre!

Eu treinei com esse aí:
Tutorial Básico Vim

Logo, quando eu estiver mais confortável, escrevo um post a respeito do Vim.

Exercício 4:
Crie uma função, em Haskell, que receba um inteiro como parametro e calcule o seu fatorial.

Vamos as definições matemáticas:
O Fatorial, para quem não lembra, é o número corrente multiplicado pelo fatorial de seu antecessor.
fatorial (n) = { 1 : n = 0
                    { fatorial (n - 1) * n  : n > = 1

Bom, se rolar alguma dúvida, não se esqueçam de comentar abaixo ou email-me: abner.terribili@gmail.com. A resposta para o exercicio 4 está no meu GitHub, nome exercicio_4.hs.

Até mais galera!

Haskell: Operadores Relacionais e Estruturas Condicionais

Fala aí galera, acho que to gostando de falar/aprender sobre Haskell :)

No post passado falei a respeito Tipo de Dados e Introdução a Funções, se não o leu, favor ler, complementará o material de hoje.

Hoje, vou falar a respeito Operadores Relacionais e Estruturas Condicionais.
Para começar, vamos entender o que fazem os Operadores Relacionais. Eles têm a responsabilidade de realizar comparações, trabalhando com valores lógicos:
São eles:

Operador	Descrição
>	maior do que
>=	maior ou igual a
<	menor do que
<=	menor ou igual a
/=	diferente de

Vou deixar alguns exemplos, somente para fins didáticos. Vamos fazer a soma de dois números e verificar as operações básicas relacionais entre eles:

soma x y | x + y > 0 = 1
         | x + y >= 0 = 2
         | x + y < 0 = 3
         | x + y <= 0 = 4

         | x + y /= 0 = 5 



-- Se a soma de x y for maior do que 0, retorna 1.

-- Se a soma de x y for maior ou igual a 0, retorna 2.

-- Se a soma de x y for menor do que 0, retorna 3.

-- Se a soma de x y for menor ou igual a 0, retorna 4

-- Se a soma de x y for diferente de 0, retorna 5

Estruturas Condicionais nada mais são do que condições que controlam se um determinado trecho de código será executado ou não. Exemplo, vamos supor que sua equação só trabalhe com números positivos. Normalmente faríamos algo parecido com:

sua_funcao seu_numero se seu_numero > 0 = √seu_numero
        caso contrário = 0

Aqui no Haskell, não é muito diferente, na verdade, é idêntico!
O Haskell também possui tipos de dados Booleanos (True / False). Podemos trabalhar com eles, para melhorar nossas estruturas condicionais.

Vamos aos exemplos, crie um arquivo chamado raiz_quadrada.hs e insira o código abaixo:

-- Você não precisa definir os tipos dos parâmetros de entrada e saída toda vez, mas para fixar o conceito, pratique!
raiz_quadrada :: Float -> Float
raiz_quadrada x | x > 0 =  sqrt(x)

Vamos entender, aquele pipe '|' é o nosso 'se', mais conhecido como 'if'. Tem a função de verificar o parâmetro de entrada. O 'x', é o nosso parâmetro de entrada. Caso o número seja positivo, a função 'sqrt()' pré-definida na Biblioteca do Haskell, Prelude, vai fazer o 'favor' de calcular a raiz quadrada do 'x'.

Bom, vamos fazer um something more nessa função.

Caso o número seja negativo ou igual a 0, vamos retornar 0.

raiz_quadrada x | x > 0 = sqrt(x)
                | otherwise = 0

Bom, o que é 'otherwise'?
Nada mais é do que 'caso contrário', significa que se nenhuma das condições acima for satisfeita, execute a condição 'otherwise'.

E se minha função tiver que trabalhar com uma condição 'composta' ?
Seria limitar ainda mais sua entrada, nós podemos usar os operadores abaixo:

Operador	Descrição
&&	e / and, tem o objetivo de verificar se ambas condições são verdadeiras.
||	ou / or, tem o objetivo de verificar apenas uma das condições é verdadeira.
not	não / not, tem o objetivo de negar o booleano, converte true/false e vice versa.

Abra seu arquivo raiz_quadrada.hs novamente, vamos fazer mais algumas alterações:

raiz_quadrada :: Float -> Float
raiz_quadrada x | x > 0 || x == 0 = sqrt(x)
                | otherwise = 0

-- Poderíamos otimizar para x >= 0, só não fiz isso para seguirmos no exemplo.

Execute sua função no Terminal, digitando:

hugs raiz_quadrada.hs

Você verá a telinha de apresentação do Hugs, informe o número de entrada da sua função:

Main> raiz_quadrada 2
1.41414

Agora com um número negativo:

Main> raiz_quadrada (-1)
0

Lembre-se de inserir o '()', para que o sinal de '-' faça parte do número real.

Se tiver alguma dúvida sobre como executar o arquivo, ou mesmo instalar o Interpretador Hugs, olhe aqui! Nos próximos posts evitarei ficar falando disso :)

Acredito ter dado uma pequena, mas boa introdução a 'Operadores Relacionais e Estruturas Condicionais', espero que tenham gostado.

Deixarei 2 exercícios abaixo, que não são de minha autoria (Claudio C. de Sá e Márcio F. da Silva), apenas as resoluções são de minha autoria, se tiverem alguma dúvida ou sugestão, pode comentar ou mesmo me enviar um email: abner.terribili@gmail.com. As respostas estão no meu GitHub.

Exercício 1:
Fornecidos três valores, a, b e c, escreva uma função que retorne quantos dos três são iguais. 3 para os 3 iguais. 2 para dois iguais e 0 para nenhum igual.

Exercício 2:
Fornecidos três valores, a, b e c, elaborar uma função que retorne quantos desses três números são maiores que o valor médio entre eles. 3 para os 3 maiores. 2 para dois maiores e 0 para nenhum maior.

Boa sorte!

Já que nosso primeiro HelloWorld foi Matemático, que tal fazermos um HelloWorld de verdade?

Crie um arquivo chamado hello_world.hs e digite em seu interior:

hello_world :: IO()
hello_world = putStrLn "Hello World!"
-- Mais para frente entro em detalhes desse Tipo de Dado IO()

Agora vá em seu Terminal, caminhe até o local do arquivo e digite:

hugs hello_world.hs

Teremos essa bela saída, criada por B. W. Kernighan

Main> hello_world
Hello World!

Agora, se você curtiu esse 'Hello World!', que tal implementa-lo em 'todas' as linguagens?
Deve ser um exercício muito construtivo e interessante!

A dica de hoje é exatamente essa: Programa Olá Mundo

Bom, agora acabou mesmo, até a próxima galera!