Perl Moderno Usando MooseX::Declare Parte 1

INTRODUÇÃO

Bom pessoal, pretendo com esta série de artigos mostrar como criar uma aplicação usando tecnicas modernas de desenvolvimento em Perl fazendo uso do modulo MooseX::Declare.

Para isso resolvi que iria tramalhar com uma aplicação desktop e não com algo web. Usaremos para esta empreitada um modulo que nos permite criar telas de forma bem rápida e simples, o Tk (Toolkit).

Como não pretendo me prender a aspectos basicos da linguagem e tão pouco ao uso do módulo, imagino que o aspirante tenha conhecimentos em Perl (basicos~intermediarios) e que tenha uma boa base em desenvolvimento e estruturas de aplicações orientadas a objetos.

COMEÇANDO DO COMEÇO

Obviamente espero que voce tenha o MooseX::Declare instalado em sua maquina. Caso não o tenha, siga os simples passos a seguir:

$ sudo perl -MCPAN -e "install MooseX::Declare"

Importante lembrar que este modulo depende do Moose e sendo assim este será instalado para que o MooseX::Declare possa ser usado.

Agora vamos instalar o Tk:

$ sudo perl -MCPAN -e "install Tk"

Simples? Apos tudo instalado podemos começar.

ESTRUTURA

Abaixo vamos falar um pouco sobre a estrutura da aplicação. Pode não ser a melhor estrutura para fazermos uso mas é bem didática e isso garantirá um compreendimento por um maior numero de leitores.

+ – /calc
– calc.pl
+ – /App
+ /Form
– Base.pm
– Main.pm

SOBRE A ESTRUTURA

A aplicacao sera inicializada pela classe calc.pl que executará o nosso formulario principal (Main.pm), que por sua vez herdará habilidades comuns para as classes de formulários implementadas na classe Base.pm

CHAMANDO O FORMULÁRIO PRINCIPAL

Vamos criar nosso arquivo chamado calc.pl que fará a chamada do nosso formulário principal.

        
        #!/usr/bin/perl

        use strict;
        use warnings;

        use App::Form::Main;

        my $app =  App::Form::Main->new;
        $app->start;

=> Explicando:

Neste arquivo nos criamos uma instancia da classe que representa nosso formulário (tela) principal e invocamos o metodo C que faz com que a tela seja apresentada ao usuário.

A BASE DE TODOS OS FORMS

Neste momento vamos criar uma classe que servirá de base para todos os outros FORMs. Esta classe terá metodos comuns que serão usados pelas telas do sistema.

        
        use MooseX::Declare;

        # start Tk base class
        class App::Form::Base {
            use Tk;
            
            # Tk class attribute
            has "window" => ( 
                is => 'rw', 
                lazy => 1, 
                default => sub { 
                    return MainWindow->new;
                }
            );
           
            # method that config window widgets
            method init {
                die "Not implemented";
            }

            # method that start main window
            method start {
                $self->init;
                return MainLoop;
            }
        }

=> Explicando:
Nesta classe nos temos uma implementação generica que disponibiliza um atributo que retorna uma instancia de uma janela.

O metodo C será utilizado para configurar os widgets (botoes, caixas de texto, menus, etc), e o C “executará” a criacao da janela propriamente dita.

CONSTRUINDO NOSSA TELA

Neste momento construiremos a nossa tela propriamente dita.

        use MooseX::Declare;

        # start Tk main window class
        class App::Form::Main extends App::Form::Base {
            
            # class attributes
            has 'content'   => ( is => 'rw' );
            has 'display'   => ( is => 'rw' );
            has 'buttons01' => ( is => 'rw' );
            has 'buttons02' => ( is => 'rw' );
            has 'buttons03' => ( is => 'rw' );
            has 'buttons04' => ( is => 'rw' );
            has 'buttons05' => ( is => 'rw' );
            has 'buttons06' => ( is => 'rw' );
            has 'buttons07' => ( is => 'rw' );
            has 'buttons08' => ( is => 'rw' );
            has 'buttons09' => ( is => 'rw' );
            has 'buttons00' => ( is => 'rw' );
            has 'dot'       => ( is => 'rw' );
            has 'percent'   => ( is => 'rw' );
            
            has 'plus'      => ( is => 'rw' );
            has 'minus'     => ( is => 'rw' );
            has 'multiply'  => ( is => 'rw' );
            has 'divide'    => ( is => 'rw' );
            
            has 'c'         => ( is => 'rw' );
            has 'ce'        => ( is => 'rw' );
            has 'back'      => ( is => 'rw' );
            has 'equals'    => ( is => 'rw' );
            
            # method that start main window
            override init {
                my $menu = $self->window->Menu();

                # config main window
                $self->window->title('Modern Perl - Calculator');
                $self->window->configure(
                    -menu=>$menu
                );
                
                # setting up menu
                my $help = $menu->Menubutton(-text=>'Ajuda');
                $help->command(-label=>'Sobre');


                # calculator content
                $self->content($self->window->Frame(
                    )->pack( -fill=>'both', -expand=>1, -ipadx=>135, -ipady=>145 )
                );

                # display screen
                $self->display($self->content->Entry(
                        -text=>'',
                        -background=>'white',
                    )->place(
                        -y=>10,
                        -x=>10,
                        -height=>50,
                        -width=>250,
                    )
                );
                
                # clear button
                $self->c($self->content->Button( -text=>'C', -command=> sub{ $self->clear_all } 
                        )->place( -x=>216, -y=>75, -width=>42, -height=>42) 
                );
                
                # ce button
                $self->ce($self->content->Button( -text=>'CE', -command=> sub{  } 
                        )->place( -x=>216, -y=>127, -width=>42, -height=>42) 
                );
                
                # back button
                $self->back($self->content->Button( -text=>' sub{  } 
                        )->place( -x=>216, -y=>179, -width=>42, -height=>42) 
                );
                
                # equals button
                $self->equals($self->content->Button( -text=>'=', -command=> sub{  } 
                        )->place( -x=>216, -y=>229, -width=>42, -height=>42) 
                );
                
                # plus button
                $self->plus($self->content->Button( -text=>'+', -command=> sub{  } 
                        )->place( -x=>164, -y=>229, -width=>42, -height=>42) 
                );

                # plus button
                $self->plus($self->content->Button( -text=>'+', -command=> sub{  } 
                        )->place( -x=>164, -y=>229, -width=>42, -height=>42) 
                );

                # minus button
                $self->minus($self->content->Button( -text=>'-', -command=> sub{  } 
                        )->place( -x=>164, -y=>177, -width=>42, -height=>42) 
                );

                # multiply button
                $self->multiply($self->content->Button( -text=>'x', -command=> sub{  } 
                        )->place( -x=>164, -y=>125, -width=>42, -height=>42) 
                );

                # divide button
                $self->divide($self->content->Button( -text=>'/', -command=> sub{  } 
                        )->place( -x=>164, -y=>75, -width=>42, -height=>42) 
                );

                # percent button
                $self->percent($self->content->Button( -text=>'%', -command=> sub{  } 
                        )->place( -x=>112, -y=>229, -width=>42, -height=>42) 
                );

                
                $self->dot($self->content->Button( -text=>'.', -command=> sub{ $self->set_value( '.' ); } 
                        )->place( -x=>62, -y=>229, -width=>42, -height=>42) 
                );
                
                $self->buttons00($self->content->Button( -text=>'0', -command=> sub{ $self->set_value( 0 ); } 
                        )->place( -x=>10, -y=>229, -width=>42, -height=>42) 
                );
                
                $self->buttons01($self->content->Button( -text=>'1', -command=> sub{ $self->set_value( 1 ); } 
                        )->place( -x=>10, -y=>177, -width=>42, -height=>42) 
                );
                
                $self->buttons02($self->content->Button( -text=>'2', -command=> sub{ $self->set_value( 2 ); } 
                        )->place( -x=>62, -y=>177, -width=>42, -height=>42) 
                );
               
                $self->buttons03($self->content->Button( -text=>'3', -command=> sub{ $self->set_value( 3 ); } 
                        )->place( -x=>112, -y=>177, -width=>42, -height=>42) 
                );
                
                $self->buttons04($self->content->Button( -text=>'4', -command=> sub{ $self->set_value( 4 ); } 
                        )->place( -x=>10, -y=>125, -width=>42, -height=>42) 
                );
                
                $self->buttons05($self->content->Button( -text=>'5', -command=> sub{ $self->set_value( 5 ); } 
                        )->place( -x=>62, -y=>125, -width=>42, -height=>42) 
                );
                
                $self->buttons06($self->content->Button( -text=>'6', -command=> sub{ $self->set_value( 6 ); } 
                        )->place( -x=>112, -y=>125, -width=>42, -height=>42) 
                );
                
                $self->buttons07($self->content->Button( -text=>'7', -command=> sub{ $self->set_value( 7 ); } 
                        )->place( -x=>10, -y=>75, -width=>42, -height=>42) 
                );
                
                $self->buttons08($self->content->Button( -text=>'8', -command=> sub{ $self->set_value( 8 ); } 
                        )->place( -x=>62, -y=>75, -width=>42, -height=>42) 
                );
                
                $self->buttons09($self->content->Button( -text=>'9', -command=> sub{ $self->set_value( 9 ); } 
                        )->place( -x=>112, -y=>75, -width=>42, -height=>42) 
                );
                
            }

            # Action that set method to Entry display
            method set_value ( $value ){
                $self->display->insert('end', $value);

                # DEBUG: remove it
                print "$value - ". $self->display->get() ."\n";
            }
            
            # Action that clear last number
            method clear_last {
                # TODO: get all display value, split by operators and remove last number
            }

            # Action that clear all display value
            method clear_all {
                $self->display->delete('0', 'end');
            }
            
        }

=> Explicando:
Esta classe cria a nossa tela, que e a de uma calculadora simples onde implementaremos a nossa solução.

O desenvolvimento da tela não existe segredo, nos só declaramo as propriedades da classe (uma para cada widget), contruimos e configuramos os widgets conforme a nossa necessidade.

CONCLUSÃO

Com este exemplo simples, podemos ver o quanto foi simples e rápido escrever uma app usando o MooseX::Declare. No próximo artigo, pretendo abordar a implementação das rotinas de calculo deste exemplo.

Pensamentos Retrógrados Que Acabam Com Uma Empresa

Pensamentos Retrógrados Que Acabam Com Uma Empresa

1 – “A TI da nossa empresa não é importante!”

Realmente, se você pensa dessa forma a sua empresa vai ter sérios
problemas num futuro próximo, quando você precisar fazer integrações
entre sistema ou de um sistema parrudo para ajudar na tomada de
decisões, automação de processo, etc…

2 – “Não vamos gastar dinheiro com este sistema! Nós mesmos podemos construir…”

Isso… assim vocês contratam Gerente de Projetos, Analistas, Arquitetos, Testadores e tudo mais que precise este pacote… Mas o melhor de tudo é você gastar tempo e dinheiro fazendo uma feramenta qua já existe e esta sendo largamente testada para dar mais segurança, estabilidade, etc…

Mas claro que você vai garantir tudo isso na sua aplicação, não é!?
Que tal comprar ou customizar uma? Vai ser mais rápido e vai gastar
menos dinheiro!

3 – “Ahh eu clico aqui, copio ali colo e corto aqui e pronto, meu Excel faz a mesma coisa que esse sistema…”

Claro que faz… e você vai versionar a planilha cheia de macros e VBAs e depois de alguns meses vai ter vários monstrinhos na sua empresa.
Isso tudo sem contar a garantia de compatibilidade entre versões dos editores e tudo mais. Mas claro que você ja pensou nisso tudo!

4 – “Para que fazer uma aplicação para isso? Faz direto no banco!”

Hahahahaha essa é a pior!!!
O banco vai garantir o versionamento e claro que podemos usar paradigmas de programação dos mais atuais, testes automatizados, UML e documentação.
Faça um favor a você mesmo e diga pausadamente a palavra “BANCO DE DADOS”… Se não conseguir, tente novamente com um dicionário ao lado, você vai intender o verdadeiro uso desta solução.

5 – “Acesse o servidor XXY.ZZZ.W.YZZ e desenvolva aquela melhoria para liberarmos antes do almoço…”

Faça isso mesmo e vai ganhar um doce! =B
… e uma versão desatualizada de um sistema da próxima vez que publicar sua aplicação com aquela alteração que não estava no sistema de controle de versão! A propósito você usa ou sabe o que é um sistema de controle de versão?! Caso não, deveria pensar seriamente em usa-lo…. de forma CORRETA!

Bom acima temos um desabafo baseado em algumas da muitas situações lamentáveis a que já fui submetido e que eu realmente aconselho que as pessoas pensem muito bem antes de fazer!

Outras simplesmente são muito tristes e não teria forças para colocar aqui!

Trabalhar de forma correta, usando as soluções certas para resolver os problemas que estas se propõem é uma forma muito útil de garantir, economia de dinheiro, tempo e papel, pois você precisará ir menos no médico e consequentemente ele usará menos o bloco para lhe receitar remédios de pressão, enxaqueca e “anti-stress”!

Estes são meus centavos!

WebInject Improvements

A algum tempo tenho estudado trabalhar na criação de uns hacks no sistema WebInject para utilizar na empresa Bivee afim de simplificar a execução dos testes em aplicações web pelo time de testes.

Entre algumas melhorias que serão desenvolvidas estão melhorias na interface, trabalho forte na documentação do projeto, modulo web e outros. Abaixo segue a lista estimada para a a primeira versão do projeto após o hackathon:

- Melhorias na interface gráfica do projeto
- Melhorias nos manuais e documentações
- Aplicação de Modern Perl Coding style
- Uso de banco de dados e logs
- Módulo web para publicação e consulta
- Versionamento dos casos de teste
- Modo teste de regressão
- Módulo de relatórios

Bom, esperamos que esta seja algumas das melhorias conseguidas logo após o primeiro hackathon para que possamos reportar os hack na ferramenta aos criadores originais fazendo assim crescer o uso a ferramenta e a força da comunidade também.

Verificação de erros simples em Perl

Sei que este tema ja foi largamente discutido na comunidade e que temos várias formas de fazer isso com módulo e tudo mais… mas a intenção deste post realmente não é dar uma bala de prata para a resolução do problema.

Vamos a explicação:

PROBLEMA: Temos um código que é propicio a “exceções” e gostaríamos de fazer uma tratativa para verificar quando estes códigos “morrem”.

package FileOp;

sub new {
    return bless {}, shift || ref shift;
}

sub open_file {
    my $self = shift;

    open my $file, shift or die $!;
    ...
    close $file;
}


package main;

my $file = FileOp->new;
my $foo = $file->open_file( './file.txt' ); # die "arquivo não existe"

PROPOSTA: Uso do eval {}

use Carp;

my $file = FileOp->new;
eval {
    my $foo = $file->open_file( './file.txt' ); # die "arquivo não existe"
    ...
};
if ( $@ ) {
    say "O sistema foi encerrado porque: ". $!;
}

Isso é uma solução simples e primária para o problema, porem no CPAN existem inúmeros módulos que tratam fluxo de erros, exceptions, etc..
Abaixo eu sito alguns:

Carp – http://search.cpan.org/~jesse/perl-5.14.1/lib/Carp.pm
Try::Tiny – http://search.cpan.org/~doy/Try-Tiny-0.09/lib/Try/Tiny.pm
TryCatch – http://search.cpan.org/~ash/TryCatch-1.003000/lib/TryCatch.pm
Throwable – http://search.cpan.org/~rjbs/Throwable-0.102080/lib/Throwable.pm
… e muitos outros! ; )

Fica a dica, tratem os fluxos de erros do seu sistema, pois isso é tão [importante quanto|faz parte] o desenvolvimento das funcionalidades do seu sistema.

A melhor hospedagem grátis de sites que conheço

Bom, não sou de postar essas coisas mas tem muita gente que esta começando e gostaria de ter o gostinho de colocar um web site no ar, mas ainda sim tem receio de pagar uns $ 5 mangos para isso rs.

Eu em meados de 2005 procurei um serviço de hospedagem grátis para me ajudar a publicar uns trabalhos de uns clientes para validação e para colocar uns projetos em teste online e conheci o Awardspece.com.

Uso o serviço até hoje e gosto da qualidade do serviço (mesmo que gratis), o pessoal mostra um comprometimento bacana no forum para tentar ajudar os usuários.

Com 250MB da espaço, uso de ftp, suporte a linguagens como Perl e PHP, banco de dados MySQL e não obriga uso de Ads, torna-se uma excelente opção para fazer pequenos trabalhos e para quem esta começando a desenvolver sistemas para web e gostaria de estars

Não estou ganhando nada para indicar mas achei que valeria a dica pra que possa interessa…

Awardspace: www.awardspace.com

Hello World Orientado a Objetos

Vi um post em um blog uma vez e achei muito interessante… se tratava de Hello Worlds em linguagens orientadas a objetos que o autor do post conhecia e decidi fazer uma brincadeira dessas por aqui também…

Primeiro em Perl:

1 package HelloWorld;
2
3 use Moose;
4
5 has mensagem => ( is => ‘rw‘, isa => ‘Str‘ );
6
7 sub show {
8 my $selft = shift;
9 print $selft->mensagem($_[0]);
10 }
11
12 my $hello = HelloWorld->new;
13 $hello->show(“Hello World“);

Agora em Java:

1 public class HelloWorld {
2
3 private String mensagem;
4
5 public HelloWorld(String mensagem) {
6 this.mensagem = mensagem;
7 }
8
9 public void show() {
10 System.out.println(this.mensagem);
11 }
12
13 public static void main(String[] args) {
14 HelloWorld hello = new HelloWorld(“Ola Mundo!!!“);
15 hello.show();
16 }
17 }

Em C# também:

1 using System;
2
3 namespace HelloWorld
4 {
5 public class HelloWorld
6 {
7
8 private string _mensagem;
9
10 public HelloWorld(string mensagem)
11 {
12 _mensagem = mensagem;
13 }
14
15 public void Show()
16 {
17 Console.WriteLine(_mensagem);
18 }
19
20 public static void Main(string[] args)
21 {
22 HelloWorld hello = new HelloWorld("Ola Mundo!!!");
23 hello.Show();
24 }
25 }
26 }

Continuarei a postar sobre as outras linguagens assim que tiver um tempinho a mais…

Forte abraço a todos,

Hello world!

package Hello;

sub new {
my $class = shift;
my $self = {};
$self->{value} = shift;
return bless($self, $class);
}

sub show {
my $self = shift;
print $self->{value};
}

my $hello = new Hello(“Hello Perl!!!”);
$hello->show();

 

Yes… yes.. yes….

Just yet another developer blog!!!

E como não poderia faltar neste blog um pequeno, amado, famigerado e necessário Hello World.

Bom… como todo bom blog nerd de um desenvolvedor sem nenhum tempo livre e muitaaaaaaaa imaginação vou postar coisas como computadores antigos, tips, codigos e projetos nos quais estou participando.

Se você teve curiosidade de acessar este site e de ler este texto pesso desculpas por fazer você perder seu tempo e agradeço de coração a sua visita.

Daniel Vinciguerra

Perl, Java and C# Developer

Damn Small Linux Brasil Project