Archive for the ‘tutoriais’ Category

Introdução a Linguagem Scala – Parte 1

novembro 7th, 2009
e acordo com o livro Programming in Scala, escrito pelos criadores da linguagem – , o nome Scala vem da combinação das palavras em inglês Scalable Lang (Linguagem escalável), e foi chamada assim pois foi desenhada para crescer com a demanda de seus usuários (nós programadores). É possível usá-la em um grande espectro de atividades: desde de pequenos scripts a aplicações web ou GUI com alto tráfico e acesso (ou carga de processamento). Ela é simples para começar, principalmente para o pessoal que já usa o Java pois roda dentro da JVM e tem integração bem próxima das APis e bibliotecas Java.
Uma primeira coisa que podemos dizer que a linguagem é uma mistura com sabor funcional e orientado a objeto e isso será notado a medida que for avançando em seu aprendizado. O interessante é que ao fundir essas duas característica, tendo como objetivo pegar o melhor de cada, Scala acabou se tornando uma boa escolha frente as todas as da moda hoje e atingindo a meta geral de ser altamente capaz de escalar: a parte funcional torna fácil a missão de construir coisas rapidamente com código de alta legibilidade; a parte OO permite a manipulação fácil de dados e sua adaptabilidade.
A Catedral e a Bazar
Eric Raymond fez a metáfora da Catedral e Bazar para construção de sistemas. A catedral, segundo ele, é um tipo de construção próxima “a perfeição” que leva muito tempo para ser construída. Uma vez que tenha sido construída, pouco coisa resta para fazer ou modificar (pelo menos eu não vejo grandes obras, além das de restauro, dentro de igrejas antigas e catedrais). Já os bazares, pelo contrário, são feitos muito rápido, simples e adaptáveis mudando todos os dias para atender e superar as expectativas dos clientes. Scala é algo mais próximo do Bazar.
Primeiro programa
object HelloWorld{
def main (args : Array[String]) : Unit ={
println (“Hello World, ou em português, Olá Mundo”)
}
}
Nesse programa já podemos ver algumas das características interessantes da linguagem. Embora ela se proponha ser da família das dinâmicas, ela é estaticamente tipada: os tipos das variáveis devem ser definidos em tempo de compilação (não existe o famoso duck type como o Python). Com isso mesmo que não defina o tipo, o compilador vai definir um por inferência.  Outra característica interessante é forma que declaramos a classe e seus métodos.
Em Scala, tudo é dado, inclusive as funções ( para quem já trabalhou com Haskell ou Lisp isso é mais simples de entender). Assim as funções tem os seus “valores” (o código) passado como numa variável : algo = valor . Isso é algo que o pessoal está muito acostumado com nossas linguagens imperativas vai demorar um pouco para se convencer disso.
Outra coisa é que o tipo é definido depois e não antes como fazíamos. Confesso que é algo que a gente se acostuma com o tempo para ler um código e entendê-lo logo de cara.
No exemplo acima não deu para ver mais uma característica interessante que é a questão de tornar concisa a escrita de sistemas. Veja os dois trechos de código abaixo
Classe em Java
class Pessoa {
private String nome;
private String sobrenome;
public Pessoa (String nome,String sobrenome){
this.nome = nome;
this.sobrenome = sobrenome;
}
}
Mesma classe escrita em Scala
class Pessoa (nome : String, sobrenome: String)
Bem por hoje paramos por aqui, no próximo artigo da séria continuamos daqui  para falarmos mais
De acordo com o livro Programming in Scala, escrito pelos criadores da linguagem – , o nome Scala vem da combinação das palavras em inglês Scalable Lang (Linguagem escalável), e foi chamada assim pois foi desenhada para crescer com a demanda de seus usuários (nós programadores). É possível usá-la em um grande espectro de atividades: desde de pequenos scripts a aplicações web ou GUI com alto tráfico e acesso (ou carga de processamento). Ela é simples para começar, principalmente para o pessoal que já usa o Java pois roda dentro da JVM e tem integração bem próxima das APis e bibliotecas Java.
Uma primeira coisa que podemos dizer que a linguagem é uma mistura com sabor funcional e orientado a objeto e isso será notado a medida que for avançando em seu aprendizado. O interessante é que ao fundir essas duas característica, tendo como objetivo pegar o melhor de cada, Scala acabou se tornando uma boa escolha frente as todas as da moda hoje e atingindo a meta geral de ser altamente capaz de escalar: a parte funcional torna fácil a missão de construir coisas rapidamente com código de alta legibilidade; a parte OO permite a manipulação fácil de dados e sua adaptabilidade.
A Catedral e a Bazar
Eric Raymond fez a metáfora da Catedral e Bazar para construção de sistemas. A catedral, segundo ele, é um tipo de construção próxima “a perfeição” que leva muito tempo para ser construída. Uma vez que tenha sido construída, pouco coisa resta para fazer ou modificar (pelo menos eu não vejo grandes obras, além das de restauro, dentro de igrejas antigas e catedrais). Já os bazares, pelo contrário, são feitos muito rápido, simples e adaptáveis mudando todos os dias para atender e superar as expectativas dos clientes. Scala é algo mais próximo do Bazar.
Primeiro programa
object HelloWorld{
def main (args : Array[String]) : Unit ={
println (“Hello World, ou em português, Olá Mundo”)
}
}
Nesse programa já podemos ver algumas das características interessantes da linguagem. Embora ela se proponha ser da família das dinâmicas, ela é estaticamente tipada: os tipos das variáveis devem ser definidos em tempo de compilação (não existe o famoso duck type como o Python). Com isso mesmo que não defina o tipo, o compilador vai definir um por inferência.  Outra característica interessante é forma que declaramos a classe e seus métodos.
Em Scala, tudo é dado, inclusive as funções ( para quem já trabalhou com Haskell ou Lisp isso é mais simples de entender). Assim as funções tem os seus “valores” (o código) passado como numa variável : algo = valor . Isso é algo que o pessoal está muito acostumado com nossas linguagens imperativas vai demorar um pouco para se convencer disso.
Outra coisa é que o tipo é definido depois e não antes como fazíamos. Confesso que é algo que a gente se acostuma com o tempo para ler um código e entendê-lo logo de cara.
No exemplo acima não deu para ver mais uma característica interessante que é a questão de tornar concisa a escrita de sistemas. Veja os dois trechos de código abaixo
1
2
3
4
5
6
7
8
9
class Pessoa {
    private String nome;
    private String sobrenome;
   
    public Pessoa (String nome,String sobrenome){
        this.nome = nome;
        this.sobrenome = sobrenome;
    }
}
Mesma classe escrita em Scala
1
 class Pessoa (nome : String, sobrenome: String)
Bem por hoje paramos por aqui, no próximo artigo da séria continuamos daqui  para falarmos mais
 

Posted in Scala, atualidades, tutoriais

2 Comments

 

Palestra de padrões de projeto no Riojug

outubro 22nd, 2009

Pessoal, a palestra foi sensacional… não pela conteúdo ou pelo autor (eu) mas pela pessoal que foi lá assistir. Em plena quinta-feira, meio de semana, o pessoal adiou a volta para casa, outros trocaram a saída, para irem assistir minha palestra no encontro mensal do riojug. O quorum foi de aproximadamente 40 pessoas (valor bastante expressivo).

Foi uma excelente conversa, com bastante interessante, discussões , etc.  Obrigado a todos que foram. Aproveito faço um pedido : Comentem com sugestões de melhorias e assim me ajudem na próxima vez ser melhor.

Design Patterns
View more presentations from aoqfonseca.
 

Posted in Informática, tutoriais

Tags: , ,

3 Comments

 

Instalando e Configurando o MAC PORTS

setembro 4th, 2009

Bom, para o pessoal que tem  Mac e já trabalhou com uma distribuição linux, principalmente com o Ubuntu, deve estar acostumado com a forma simples que é instalar coisas nesses sistemas. Praticamente é abrir um terminal e digitar o comando :

1
 sudo apt-get install nome_do_pacote_a_instalar_aqui

Embora considere o Mac OS um sistema operacional excelente, acredito que o fato de não existe algo nativo como o apt-get é uma das fraquezas dele. Mas, não é por isso que vamos desanimar. Existe um produto similar chamado MAC PORTs, que faz exatamente igual ao apt-get e sua instalação é simples.
Vamos ao passo a passo:

  1. Acesse o site do mac ports (www.macports.org) e baixe o pacote de instalação (.dmg)
  2. Ao fazer isso o sistema irá começar a instalar. Vá lendo as instruções e fazendo Next, Next até terminar
  3. Pronto ele está instalado
  4. Para testar abra um terminal e digite o comando : sudo port -d selfupdate

Possivelmente não irá funcionar, pois, você precisa tornar o caminho onde está a instalação visível para o terminal que você usa. Para fazer isso é bem simples:

  1. Acesse o terminal
  2. Edite os arquivos .bashrc e .bash_profile e acrescente a linha :source ~/.profile
  3. Edite o arquivo .profile e coloque as seguintes linhas nele : export PATH=/opt/local/bin:/opt/local/sbin:$PATH

Como os passos acima repita o teste e provavelmente irá funcionar.

Agradecimentos ao Henrique Bastos que ajudou muito com a configuração

     

    Posted in Informática, tutoriais

    Tags: , , , ,

    4 Comments

     

    Usando atributos customizável em C#

    setembro 1st, 2009

    Muitos programadores sabem o quanto criar configurações ou arquivos de configurações para flexibilizar as aplicações ou uso de apis é um trabalho árduo. Na maioria dos casos opta-se por arquivos de XML  cuja a sintaxe nem sempre é fácil de entender e muito desacoplada da classe que irá usá-la dificultando muito a compreensão do funcionamento do sistema.

    Muitas pessoas (desenvolvedores) sempre procuram criar sistemas ou api que sejam capazes de atender a uma grande quantidade de cenários sem que hajam modificações diretas em seus fontes.  Para tanto, parametrizam em forma de configuração externas valores que o sistema deve usar que serão particulares para cada caso, exemplo:  nome do banco de dados, diretório onde ficam os arquivos de template, quantidade de dias que devem manter um dado no memória, mapeamento objeto relacional de um objeto, etc.

    Na maioria dos casos essa parametrização ou configuração é possibilitada pela criação de arquivos XML, onde quem irá usar o sistema ou a biblioteca deverá preencher com os valores desejados. Isso faz com que o sistema torne-se flexivel e evita customizações em código para casos particulares.  Detendo-se mais no caso de bibliotecas, por exemplo, api de persitencia (mapeamento objeto relacional), esta forma de fazer é bastante útil, embora adicione uma grande carga ao desenvolver pois além de escrever suas classes e etc, também tem que escrever e gerenciar os arquivos de configuração daquela Dll ( ou jar se for caso de java, por exemplo).

    Um outro aspecto que considero no uso de XML para configurações é que ele fica desacoplado demasiadamento do código. Para o caso de um sistema, issso é bom, pois o usuário não interessa, somente importa definir os parametros e é tudo. Para o caso de uma biblioteca a coisa muda um tanto de figura, pois se quer deixar sua aplicação com um entendimento claro e no caso aqui, a classe e sua parametrização ficam em arquivos separados.

    Foi pensando nisso que as linguagens atuais começaram a tentar em suas novas versões criarem recurso de forma a facilitar este tipo de trabalho.  Neste contexto que temos as anotações, para o JAVA, e os atributos, para o .NET.

    Anotações e atributos fazem o elo entra a implementação e a parametrização. Tornando o código claro, legível e compreensível.

    As anotações ou atributos são metadados que adicionamos as nossa classe que nos permitem de através delas passarmos informações de parametrização e configuração.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    class Client
    {
    private string nome;
    [MyCustomTag(sbrubles=true)]
    public void SayHello()
    {
    System.out.println("Hello" + nome);
    }
    }

    No exemplo acima, minha classe tem um método que coloco um atributo que tem uma propriedade Sbrubles que pode receber um valor booleano. Depois, por Reflection, posso pegar os dados deste atributo e usar para fazer alguma coisa. Esse tipo de abordagem neste tipo de caso, é bem melhor por fica claro os parametros e sua associação. Além disso o trabalho reduz pois agora basta a própria classe para a implementação e para a configuração.

    Em Csharp, para criar seu atributo, bastar criar uma classe que extenda a classe System.Attribute. Além disso, por meio de atributos na classe, é preciso definir se este atributo será ligado a metodo, classe, propriedade, etc, se pode se repetir, etc.  Exemplo:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    [AttributeUsage(AttributeTargets.Class |
        AttributeTargets.Constructor |
        AttributeTargets.Field |
        AttributeTargets.Method |
        AttributeTargets.Property,
        AllowMultiple = true)]
    class MyCustomAtribute : System.Attribute
    {
           private bool sbrubles;
           public bool Sbrubles
           {
                get { return sbrubles;}
                set { sbrubles = value;}
           }
    }

    E para ter acesso ao dados, você pode ter o seguinte codigo:

    1
    2
    3
    4
    ...
    object[] attributes;
    attributes =
       inf.GetCustomAttributes(typeof(BugFixAttribute),false);
     

    Posted in .NET, Informática, tutoriais

    Tags: , , , ,

    1 Comment

     

    Gerando de forma automatica suas classes

    maio 3rd, 2009

    Mais um daqueles artigos para me ajudar a não esquecer como fazer depois. Preciso gerar diversas classes para minha aplicação Csharp. A questão é que a estrutura delas são quase constante e o trabalho intelectual de fato é de apenas criar alguns métodos e definir os relacionamentos. Os relacionamentos já foram definidos quando estudamos e fizemos a analise, restando o código chato de fazer a classe de persistência, classe de controle, classe de modelo, etc. De forma mais detalhada o trabalho consiste, a partir da definição da entidade (propriedades, tabela a relacionar, etc), devo gerar duas classes no mínimo : a classe que serviria como VO (Value Object) e outra como DAO (Data Access Object – classe que será responsável por acessar os dados na base de dados).
    Para fazer optei por usar algo como um template: escrevo um template da classe com palavras chaves que serão substituídas pelos dados que desejo. Algo semelhante a:

    1
    Ola Mundo para $nome $sobrenome

    Depois este arquivo seria processado por um programa que iria realizar o cruzamento dele com os dados a serem populados.:

    1
    2
    3
    4
    5
    6
    ///Pseudo codigo
    mapDados = ['nome':'Andre','sobrenome':'Fonseca']
    t = Template (file="nome_Arquivo")
    t.bind(mapDados);
    t.render()
    print t

    Bem tendo isso em mente, olhei para as linguagens que conheço (preferencialmente as scripts – dinamicas, suggar sintax, etc) para ver qual delas me forneceriam algo semelhante ao pseudo código escrito acima. Em ruby não consegui achar porém não busquei com afinco. Encontrei duas excelentes opções: uma em Python e outra em Groovy (amo o groovy).
    Do Groovy foi o mais fácil de achar pois o “engine” simples de texto é algo “nato” (não é necessário a instalação de nenhuma api externa). Que já programou em Java e usou a bilbioteca Velocity vai ver que é algo extremamente simples e parecido.
    Do Python contei com a ajuda do Alexandre Bairos. Ele me indicou o jinja e o Cheetah. Achei o Jinja muito complicado e “over” para que desejava fazer. Optei pelo Cheetah.
    Em Groovy o código ficaria mais ou menos assim:
    —- Template

    1
    Ola Mundo "$nome $sobrenome"

    –Groovy Class

    1
    2
    3
    4
    5
    6
    def binding = ["nome":"Andre", "sobrenome":"Fonseca"]
    def fileTemplate = new File('test.template')
    engine = new GStringTemplateEngine()
    template = engine.createTemplate(fileTemplate).make(binding)
    ...
    println template.toString()

    Em Python:
    –Template (olamundo.tmpl)

    1
    ola mundo $name $surname

    Aqui que as coisas se diferem: em python graças ao Cheetah voce pode compilar este template e criar uma classe Python. Na linha de comando digite: cheetah -compile olamundo.tmpl
    Isso gerará um arquivo com o mesmo nome e extensão .py (um python file). E depois é só usar:

    1
    2
    3
    4
    5
    from olamundo import olamundo
    teste = olamundo();
    teste.name = "andre"
    teste.surname = "fonseca"
    print teste
     

    Posted in Informática, Java, python, tutoriais

    0 Comments

     

    Uso do modificador static dentro do Java

    abril 18th, 2009

    Uma coisa que poucas pessoas sabem é que, em Java, podemos usar o modificador estático (static) para classes e que tal fato pode ser bastante util na hora de escrever algumas coisas. Antes de mais, me desculpem os mais avançados em programação, é preciso gastar algumas linhas para explicar o que significa estatico.
    Dentro de orientação objeto dependendo da forma que voce declare algo dentro de uma classe, esta “coisa” terá o seu ciclo de vida ligado a classe, ou ao metodo, ou a um bloco, ou ao objeto. Em alguns livros você achará tal explicação como algo instancia do objeto, instancia do metodo, e por ai vai…. Que tal um exemplo para entendermo melhor
    Instancia do Objeto
    - é algo que vai existir enquanto existir o objeto. Não necessariamente nasce com o objeto mas “morre” com ele e seu valor está atrelado ao objeto.

    1
    2
    3
    4
    5
    6
    public class Aluno {
       private String nome;
        Aluno (String val){
          this.nome = val;
       }
    }

    No Exemplo acima a variavel nome pertence ao objeto. Sendo assim se fizemos:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    ...
    Aluno[] sala12 = new Aluno []{
    new Aluno("aluno1"),
    new Aluno("aluno2"),
    new Aluno("aluno3"),
    };
    foreach(Aluno aluno in sala12){
     System.out.println(aluno.getNome());
    }

    Embora façam parte da mesma classe cada um tem seu “nome”, logo a variavel nome pertence ao objeto.
    Fazendo uma pequena modificação no codigo da classe Aluno e colocando a variavel nome com o modificador static e executarmos novamente o codigo acima, a saida será o mesmo nome do ultimo setado. Isso porque a variavel deixou ser do contexto do objeto e passou para o dominio da classe; por mais instancias do objeto aluno criadas no processo da JVM, o valor do nome será unico para todas elas

    1
    2
    3
    4
    5
    6
    public class Aluno {
       private static String nome;
        Aluno (String val){
          this.nome = val;
       }
    }

    Seguindo esse mesmo raciocinio podemos explicar o escopo de metodo e bloco…. Mas deixo isso para o pessoal estudar senão vai ficar muito extenso o post.

  1. Logo ser estatico ou a função do modificador estatico (static) é de informar ao compilador e executor que aquela variavel, emtodo, ou quaisquer outras coisas são da classe

    2. Uma segundo coisa a explicar antes de falarmos de classes estáticas, tipos de classes. Dentro de java voce pode ter os seguintes tipos: top-level e inner classes.

  2. Top level classes

    3. São as classes comuns: cada classe tem seu arquivo proprio e está inserida dentro de um pacote. SEria como escrever o arquivo Aluno.java e dentro dele especificar a classe Aluno. Esta classe aluno será uma top level. Este tipo de classe não pode ser estatica

  3. Inner classes

    4. São classes que pertencem a outras classes. São como propriedade de uma classe e declaradas dentro da especificação de uma classe. Elas podem ser anonimas ou locais. Vejam os dois exemplos abaixo:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    okButton.addActionListener( new ActionListener(){
       public void actionPerformed(ActionEvent e){
          dispose();
       }
    });
    ______________________________________________________
    class ListListener implements ItemListener {
          List list;
          public ListListener(List l) {
             list = l;
          }
          public void itemStateChanged(ItemEvent e) {
             String s = l.getItemSelected();
             doSomething(s);
          }
       }
       List list1 = new List();
       list list2 = new List();
       list1.addItemListener(new ListListener(list1));
       list2.addItemListener(new ListListener(list2));
    }

    As classes locais podem ser estaticas. Isso, de acordo como definimos em cima, significa dizer que voce tem uma classe que está definida dentro da outra classe e pertence a ela e não ao objeto que será instanciado dela.
    Exemplo(tirado do artigo da Java world:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    public class Filter {
       Vector criteria = new Vector();
       public addCriterion(Criterion c) {
          criteria.addElement(c);
       }
       public boolean isTrue(Record rec) {
          for(Enumeration e=criteria.elements();
          e.hasMoreElements();) {
             if(! ((Criterion)e.nextElement()).isTrue(rec))
                 return false;
          }
          return true;
       }
       public static class Criterion {
          String colName, colValue;
          public Criterion(Stirng name, String val) {
             colName = name; colValue = val;
          }
          public boolean isTrue(Record rec) {
             String data = rec.getData(colName);
             if(data.equals(colValue)) return true;
             return false;
          }
       }
    }

    E para usar:

    1
    2
    3
    4
    5
    Filter f = new Filter();
    f.addCriterion(new Filter.Criterion("SYMBOL", "SUNW"));
    f.addCriterion(new Filter.Criterion("SIDE", "BUY"));
    .....
    if(f.isTrue(someRec)) //do some thing .....
     

    Posted in Informática, Java, tutoriais

    0 Comments