ElasticSearch: Analyzer e seus amigos Tokenizer e Filter

Será que seria aceitável se o Google não ‘adivinha-se’, quando você está procurando por FLAMENGO, e você coloca em sua busca MENGO?
Se ele não te peguntar o que você quis dizer no erro de sua ortografia, seria chato, né?
😦
Se o motor de busca não “prever” o que estamos procurando, estaremos circunscritos a nos apaixonar por outro motor de busca que possa fazer essa tal “mágica”!
Um BING, quem sabe… 😛

Esse artigo focará na sutileza dos Analyzers, para tentar mostrar que ele são mais do que um valor exato de MENGO. Em suma, queremos ter uma melhor compreensão da pesquisa.

Com essa pequena introdução, poderei dar um enfoque melhor nos processos de análise do ElasticSearch.

Ao inserir dados em um índice no ElasticSearch, eles são armazenados em uma estrutura chamada de índice invertido, isso quer dizer que os dados são transformados e passam por um processo. Esse processo de transformação dos dados é chamados de análise.(ou Analysis).  

Curiosidade: Esse processo de analise tem dois pilares básicos:  tokenizing e normalizing.

O primeiro passo desse processo de analise é quebrar o texto em termos usando o Tokenizer após passar pelo filtro de caracteres, em seguida, esses termos são normalizados para serem facilmente pesquisáveis.

diagrama-textGeralmente um Analyzer é composto pode um tokenizing e um ou vários filters.

Curiosidade: O ElasticSearch faz o controle em tempos de execução da consulta, você está livre para usar um novo Analyzer a qualquer hora. 🙂

Voltando…

O ElasticSearch já vem com vários Analyzer instalados.

São eles:
Standard Analyzer
Utiliza o Standard Tokenizer para fatiar o texto, juntamente com o Standard Token Filter, Lowercase Token Filter e o Stop Token Filter. Normaliza símbolos, letras minusculas.

Simple Analyzer
Utiliza o Letter Tokenizer para fatiar texto, juntamente com o Lowercase Tokenizer.

Whitespace Analyzer
Utiliza o Whitespace Tokenizer para fatiar o texto com espaços.

Stop Analyzer
Utiliza o Letter Tokenizer para fatiar o texto, juntamente com o Lowercase Tokenizer e o Stop Token Filter. Remove palavras a partir de fluxos de token.

Pattern Anaylzer
Utiliza expressão regular para fatiar o texto.

Language Analyzer
Utiliza um conjuntos de Analyzers para analisar o texto para um determinado idioma.
São vários idiomas. =)

Os Analyzers seguem três ‘dogmas’ principais que utilizam filtros de caracteres, tokenizers e filtros de termos, são eles:

  1. Filtragem de caracteres
  2. Tokenização
  3. Filtragem de termos.

Pelo que já foi explicado acima, já podemos ter um entendimento de como funciona um Analyzer, certo?

Não?  😦

Ok, então segue mais uma explicação.

O Processo de analise se utiliza de um Tokenizer para quebrar um texto em tokens (ou termos). Antes dessa operação, o texto é transmitido através de algum filtro de caracteres.

Em seguida, os filtros de efetuam seu trabalho.

Esses filtros de caracteres são sempre utilizados antes do Tokenizer em um processo de analise.

O ElasticSearch foi construído com filtros personalizados e nos deixa construir nossos próprios filtros.

Já que falamos em Filtros, vamos ver alguns?

(Continua…)

Anúncios

Boas práticas ao desenvolver em javascript

Hoje em dia javascript esta na moda, certo?

ERRADO!

O que esta na moda é o uso dos frameworks da vida.

Com isso, tenho notado que até mesmo alguns ‘plugins’ ou  até mesmo frameworks estão esquecendo de algo básico…

BOAS PRÁTICAS!

Essa foi minha motivação para fazer esse artigo, que foi  apresentado para a equipe de desenvolvimento de minha antiga empresa.

Então, vamos lá…

A primeira pergunta que faço em minha apresentação é

Onde começam as boas práticas?

Onde começam as boas práticas?

E sua resposta é óbvia…

Em você!

em você!

Nesse momento, muitas pessoas se fazem as seguintes perguntas:

  1. Como assim?
  2. Comigo? Blz, mas como gênio?

E a resposta para as perguntas supracitas é mais simples ainda…

Pensando antes de começar a fazer!!

Pensando antes de fazer!!!!

É algo simples e óbvio, mas acredite, com advento da tecnologia “CTRL+C , CTRL+V” e a febre dos plugins!
Muitos esquecem de ver se quele código ou plugin está fazendo o que você quer da forma correta, pois um axiôma que costumo usar é que “esta funcionando, não significa que esta certo.

Quando os plugins ou códigos não fazem o que precisamos, caimos no cenário de ter que codificar algo do zero, e acabamos caindo no uso abusivo dos frameworks…

Outro axiôma muito relevante que meu amigo Thiago Anselme sempre diz é “não existe bala de prata” ou seja, não existe uma solução,plugin,framework que resolverá todos os problemas de sua vida! 🙂

Criar algo do zero ou não. Usando boas práticas de programação e se possivel sem ficar dependente de framework…

  1. Para muitos… Isso da medo.
  2. Para muitos… Parece ser mais difícil… (até concordo…)
  3. Para muitos… Isso é impossível!

    ……………………………..
  4. Para poucos, blz tamo ae!  😉

Com isso vamos iniciar uma sequencia de códigos com o título “seria bom evitar”

Seria bom evitar!

Evitar o uso de eval ou Function

Function e a função a eval são operações pesadas que usados em excesso pode complicar a vida do interpretador.
Suas chamadas sãp convertidas em código fonte para código executável.

Lento:
function addPropriedade(objeto,propriedade,codigo){

objeto[propriedade] = new Function(codigo);

};
addPropriedade({},”nome”,”this.Variavel=2012″);

Rápido:
function addPropriedade(objeto,propriedade,funcao){

objeto[propriedade] = funcao;

};
addPropriedade({},”nome”,function(){ this.Variavel = 2012; });

Evitar passar,uma função na forma de strings, para setTimeout () e setInterval ()

Se você passar uma string em setTimeout() ou setInterval() a string será avaliada da mesma forma que o eval() que é lento.
Envolva seu código em uma função anônima. Assim o interpretado poderá  executar sua instrução de forma mais rápida durante a “compilação”.

Lento:

window.setInterval(“minhaFuncao()”,100);
window.setTimeout(“minhaFuncao()”,100);

Rápido:

window.setInterval(minhaFuncao,100);
window.setTimeout(minhaFuncao,100);

Sempre que puder, faça cache de valores variáveis

Lento:
O comprimento do arr array é recalculado a cada vez que o loop repete.

for(var i = 0; i < arr.length; i++){

//fazer algo…

}

Rápido:
Melhor maneira é para armazenar em cache o comprimento do array:

for(var i = 0,_length = arr.length; i < _length; i++){

//fazer algo…

}

Sempre que puder, faça cache de objetos DOM

Lento:

documento.getElementById(“elemento”).style.backgroundColor = “red”;
documento.getElementById(“elemento”).innerHTML = “….”;

Rápido:

var elemento = documento.getElementById(“elemento”);
elemento.style.backgroundColor = “red”;
elemento.innerHTML = “..”;

Evite pegar um formulário por getElementById

Em meus 6 anos de desenvolvimento de sistemas web, foi o que mais vi acontecer, algo muito recorrente.

As formas de de pegar o valor de um campo:

var form = document.forms[0];

#1
form[“buscar”].value

#2
form.buscar.value

#3
form.elements[“buscar”].value

Tantas formas e ainda vejo pessoas pegando o valor de um campo assim
$(“#buscar”).val() ou document.getElementById(“buscar”).value;

Remova referências que não serão mais usadas

..Lixo no lixo, blz? O browser agradece!

Não muito legal:
//inicio…
var elemento = document.getElementById(“elemento”);
//…
elemento.innerHTML = “valor… valor… “;
elemento.style.backgroundColor=”green”;
//…
//…
//…
//Fim…

Mais legal:
//inicio…
var elemento = document.getElementById(“elemento”);
var valor = “valor… valor…     “;
//…
elemento.innerHTML = valor;
elemento.style.backgroundColor=”green”;
//…
//…
//…
elemento = null;
delete valor;
//Fim…

Bom, fico por aqui..;

Existem vários outros exemplos de boas práticas, mas coloquei nesse artigo os que considero os mais gritantes…

O que é REST ( Representational State Transfer ) ?

A grosso modo REST  é a evolução do SOAP, tá blz, já estou criando polêmica 🙂 , mas em minha simplória opinião é básicamente  “mais do mesmo”, SÓ que pensando em fazer algo realmente flexível.

Seu termo foi usado pela primeira vez na tese de doutorado do Dr. Roy Fielding em meiados de 2000, ele foi um dos criadores do nosso querido e tanto usado protocolo HTTP .

Pai do  protocolo HTTP ( esse é o pai da criança! ) =)

Pai do protocolo HTTP ( esse é o pai da criança! ) =)

Então…

Já esta claro que a web esta se tornando a cada dia mais voltada para serviços.  E tanto REST quando o bom e velho SOAP são ótimas  opções para integrações de sistemas através de redes privadas e públicas, sendo que o REST é mais focado em WEB 2.0, onde ser agil é de suma importância, e o SOAP para o segmento empresarial, onde é necessário um maior formalismo.

Acredito que em alguns anos o REST assumirá todos os segmentos de comunição HTTP, mas por enquanto…  =)

As aplicações que seguem os príncípios REST, são frequentemente chamados de RESTFull, que é muitas vezes confundido com uma especificação, já que suas chamadas são através dos verbos HTTP. Neste caso cada verbo tem uma responsábilidade.

Útilizações dos verbos HTTP:

  • GET : Representa uma acesso de buscar de algum recurso, leituras online ou em cache;
  • POST : Representado para efetuar ações de criação, sem o uso de cache;
  • PUT :  Representado como atualizações de um  recurso existente;
  • DELETE :  Como já está explicito, é representado para  deletar um recurso;

Comunicação não padronizada!

As trocas de informações entre clientes e serviços são definidos no cabeçalho (Content-Type) das requisições e respostas HTTP com isso formatos como JSON,RSS/ATom/XML ou formatos como JANE(Javascript Array Notation Expretion) e etc,  com isso a famosa interoperabilidade se faz presente em quaisquer tipo de tecnologia.

Quem já esta usando REST?

Segundo a wikipédia, empresas como Amazon,eBay e Yahoo já estão usando esta definição em suas aplicações.

Conclusão e  etc.

Esse tópico foi básicamente para explicar de forma rápida e prática o que é REST. 
O REST defende que não precisamos usar nenhuma ‘abstração’ para expor serviços web efetivos, precisamos apenas de um cliente, um serviço e informar como faze-lo (XML,JSON e etc), tudo em cima do protocolo HTTP,  ou seja…  Usar o que já temos para um propósito já existente  =)

Links que usei sobre REST

Next Stop

Passo a passo para criar um serviço REST com WCF

Design patterns – Factory (Fábrica)

Antes de começarmos, segue algumas pergunta/respostas:

  1. O que é padrão de projeto?
    R: http://pt.wikipedia.org/wiki/Padr%C3%A3o_de_projeto_de_software
  2. O que é Factory pattern (fábrica)?
    1. Explicação sobre o padrão Factory:R: http://en.wikipedia.org/wiki/Factory_method_pattern
      R: http://en.wikipedia.org/wiki/State_pattern
    2. Qual sua categoria?R: Criacional
    3. Sua estrutura padrão:Estrutura Básica

Bom, explicações dadas, agora vamos começar a brincar com nossopadrão. O exemplo usado foi de uma fábrica celular.

Com base na estrutura básica do padrão fábrica, criei as seguintes classes:

//Produto
    abstract class Celular
    {
protected string numero;
public Celular(string numero) { this.numero = numero; }
public abstract void Ligar(string numero);
   }

//Produto concreto.

class IPhone : Celular
{
public Hashtable Agenda = new Hashtable();
public IPhone(string numero) : base(numero) { }
public override void Ligar(string numero)
{
Console.WriteLine(“({0} ligando para {1}.”,this.numero,numero);
Agenda[numero] = ( Agenda[numero] == null)? 0 : Convert.ToInt32( Agenda[numero])+1;
}
}
class Nokia : Celular
{
public Nokia(string numero) : base(numero) { }
   public override void Ligar(string numero)
{
Console.WriteLine(“({0} ligando >>> {1}…”, this.numero, numero);
}
}

//Criador

abstract class Factory
{
private Celular celular;
public abstract void Criar( string numero);
public Celular Celular
{
get {   return celular;  }
set  { celular = value;  }
}
}

//Fábrica

class IPhoneFactory : Factory
{
public override void Criar(string numero)
{
this.Celular = new IPhone(numero);
}
}
class NokiaFactory : Factory
{
public override void Criar( string numero)
{
this.Celular = new Nokia(numero);
}
}

O Diagrama dessa implementação ficará assim:


Sua chamada ficará assim:

Criando um jogo da forca em 80 linhas com javascript puro [ nada de framework! ;-) ]

Esse artigo é básicamente para mostrar como é fácil desenvolver coisas legais em javascript, em apenas algumas linhas de código, sem depender de frameworks, basta colocar a caixóla para funcionar.

Então vamos ao código, simples e fácil! 😉

Diagrama de nossa ‘classe’:

function Forca(params){

var root = this,elemento = params.Elemento || document.body;
this.Palavras = params.Palavras || []; // vetor de palavras
this.Palavra = “”;  // palavra corrente
this.Erros = 0; // número de errros
this.Boneco = “”; // desenho do boneco

this.Teclado = function(){ // metodo responsável por montar o teclado.
var teclado = document.getElementById(“forca_teclado”);
if(!teclado){
teclado = document.createElement(“div”);
teclado.setAttribute(“id”,”forca_teclado”);
teclado.setAttribute(“class”,”teclado”);
for(var i = 65; i < 91; i++){
var tecla = document.createElement(“div”);
tecla.setAttribute(“class”,”tecla”);
tecla.innerHTML = String.fromCharCode(i);
tecla.setAttribute(“title”,String.fromCharCode(i));
if(tecla.addEventListener )
tecla.addEventListener(‘click’,function(){ root.Validar(this); },false);
else
tecla.attachEvent(‘onclick’,function(e){ root.Validar(event.srcElement);  });
teclado.appendChild(tecla);
}
elemento.appendChild(teclado);
}
}
this.Sorteio = function(){ //Método responsável pelo sorteio de uma nova palavra.
var novoIndice = Math.ceil(Math.random()*params.Palavras.length-1)
root.Palavra = params.Palavras[novoIndice];
var painel = document.getElementById(“forca_painel”);
if(!painel){
painel = document.createElement(“div”);
painel.setAttribute(“id”,”forca_painel”);
painel.setAttribute(“class”,”painel”);
elemento.appendChild(painel)
}
painel.innerHTML = “”;
for(var i = 0; i < root.Palavra.length;i++){
var letra = document.createElement(“div”);
letra.setAttribute(“id”,root.Palavra.substr(i,1));
letra.setAttribute(“class”,”letra”);
letra.innerHTML = “”;//root.Palavra.substr(i,1);
painel.appendChild(letra);
}
}
this.Validar = function(letra){   // Método responsável por validar e desenhar o boneco.
var desenho = document.getElementById(“forca_desenho”);
if(!desenho){
desenho = document.createElement(“div”);
desenho.setAttribute(“id”,”forca_desenho”);
elemento.appendChild(desenho);
}
var boneco;
if(root.Palavra.indexOf(letra.title) == -1){
this.Erros++;
switch(this.Erros){
case 1: root.Boneco += “\n   o”; break;
case 2: root.Boneco += “\n  \/”; break;
case 3: root.Boneco += “|”; break;
case 4: root.Boneco += “\\”; break;
case 5: root.Boneco += “\n  /”; break;
case 6: root.Boneco += ” \\\n <button onclick=’window.location.reload(true);’ style=’padding:0px;width:85px;border:1px solid black;’>GAME OVER</button>”; break;
}
desenho.innerHTML = ” <pre> “+root.Boneco+” </pre> “;
}
else
{
var indices = [];
for(var i = 0; i < root.Palavra.length;i++)
if(root.Palavra.substr(i,1) == letra.title) indices.push(i);
painel = document.getElementById(“forca_painel”).getElementsByTagName(“div”);
for(var i = 0; i < indices.length; i++)
painel[indices[i]].innerHTML =  letra.title;
}
}
this.Comecar = function(){ // Método responsável por iniciar tudo, criado só para deixar a chamada mais organizada!  😉
root.Teclado();
root.Sorteio();
}
}

A chamada do jogo ficará assim:

var parametros = { Elemento:/*algum elemento (div,e etc…)*/, Palavras:[/* um vetor de palavras, exemplo: “BRASIL”,”PADRE” */] }

var forca = new Forca(parametros);
forca.Comecar();

literalmente simples assim…

Para ver o jogo funcionando, acesse : http://migre.me/5ld1V

Design patterns – State (Estado)

Antes de começarmos, segue algumas pergunta/respostas:

  1. O que é padrão de projeto? 
    R: http://pt.wikipedia.org/wiki/Padr%C3%A3o_de_projeto_de_software
  2. O que é   State pattern (estado)?

    1. Explicação sobre o padrão State:

      R: http://pt.wikipedia.org/wiki/State
      R: http://en.wikipedia.org/wiki/State_pattern

    2. Qual sua categoria?

      R: Comportamental

    3. Sua estrutura padrão:

      Estrutura Básica

  3. O que é um semáforo?

    R: http://bit.ly/mVxUVT

Bom, explicações dadas, agora vamos começar a brincar com nossopadrão. O exemplo usado foi de um semafóro de trânsito.

Com base na estrutura básica do padrão de estado, criei as seguintes classes:

public enum Sinal { VERMELHO, AMARELO, VERDE };

//Estado
public abstract class Status
{
public abstract Sinal Sinal { get; }
  public abstract ConsoleColor Cor { get; }
public abstract void ProximoStatus(Semaforo semaforo);
}

//Estados concretos.

public class Verde : Status
{
     public override ConsoleColor Cor { get { return ConsoleColor.Green; } }
public override Sinal Sinal { get { return Sinal.VERDE; } }
public override void ProximoStatus(Semaforo semaforo)
{
semaforo.Status = new Amarelo();
}
}

public class Verde : Status
{
public override ConsoleColor Cor { get { return ConsoleColor.Green; } }
       public override Sinal Sinal { get { return Sinal.VERDE; } }
public override void ProximoStatus(Semaforo semaforo)
{
semaforo.Status = new Amarelo();
}
}

public class Vermelho : Status
{
public override ConsoleColor Cor { get { return ConsoleColor.Red; } }
public override Sinal Sinal { get { return Sinal.VERMELHO; } }
public override void ProximoStatus(Semaforo semaforo)
{
semaforo.Status = new Verde();
}
}

//Contexto

 public class Semaforo
{
private Status status;
private ConsoleColor Vermelho = ConsoleColor.DarkRed;
private ConsoleColor Amarelo = ConsoleColor.DarkYellow;
private ConsoleColor Verde = ConsoleColor.DarkGreen;
public Semaforo(Status status)
{
this.status = status;
this.Desenhar();
}
public Status Status
{
get { return status; }
set
{
status = value;
Vermelho = ConsoleColor.DarkRed;
Amarelo = ConsoleColor.DarkYellow;
Verde = ConsoleColor.DarkGreen;
switch (status.Sinal)
{
case Sinal.VERDE:
Verde = ConsoleColor.Green;
break;
case Sinal.AMARELO:
Amarelo = ConsoleColor.Yellow;
break;

case Sinal.VERMELHO:
Vermelho = ConsoleColor.Red;
break;
}
this.AlterarSemaforo();
}
}
public void AlterarSinal()
{
status.ProximoStatus(this);
}
   private void AlterarSemaforo()
{
//código que aleterá as cores do semáforo.

}
private void Desenhar()
{
//código que desenhará o semáforo no console.
}

}

O Diagrama dessa implementação ficará assim:

Sua chamada ficará assim:

E o resultado final no console será :

Fonte : http://www.xmasters.com.br/francke/StatePattern.zip

public enum Sinal { VERMELHO, AMARELO, VERDE };

enviar SMS em suas applicações (C#,Java,Php e etc..)

          Você conhece o IPIPI?

O ipipi.com possui alguns serviços bem bacanas, entre eles o que se destaca é o de envio de mensagens SMS para praticamente para qualquer pessoa do mundo.

Para saber mais sobre, acesse o site http://www.ipipi.com/Home.do

Como enviar SMS através de sua aplicação:

1) Se cadastrar no IPIPI…
1.1 Cadastro – http://www.ipipi.com/RegEditNonLogon.do

2) Enviando SMS…
Para enviar sms é bem simples, basta saber os sequintes dados:
2.1 – SMTP :  ipipi.com  (porta 25), lembrando que você deverá se autenticar com seu LOGIN e SENHA.
2.2 – No From de seu envio você deverá colocar seu LOGIN@ipipi.com.
2.3 -No To deverá ser informado o [código do país] + [código do estado] + celular > 5521XXXXXXXX@sms.ipipi.com.

3.0) Enviar, simples assim!