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.

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!

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.

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.

Para saber mais noticias sobre este módulo veja o doc em http://search.cpan.org/~flora/MooseX-Declare-0.34/lib/MooseX/Declare.pm

Sem mais delongas, vamos ao exemplo e as notas sobre o mesmo:

No exemplo acima, podemos perceber que a sintaxe na declaração da classe foi completamente “alterada”.

Na declaração da classe tivemos mudanças radicais…
package People; => class People { … }

Se olharmos bem a declaração dos atributos da classe neste exemplo vamos perceber que não mudaram muito do modo como os declarávamos usando o Moose, mas este por outro lado revolucionou e simplificou e muito a forma tradicional de se criar classes, roles e declarar atributos.

use MooseX::Declare;

class People {

    # class attribute
    has 'name' => ( isa => 'Str', is => 'rw' );

    # method declaration
    method meet_you() {
        say "Prazer em conhecer você, ". 
            $self->name if defined $self->name;
    }
}

Nos métodos também podemos ver uma mudança sutil, não vemos a linha abaixo da declaração do método as inscrições “my $self = shift;” que mesmo no Moose tradicionalmente usávamos para receber a referencia para a objeto instanciado. Esta inscrição agora implícita, simplifica ainda mais a forma com que vemos nossos métodos.

Como vimos no exemplo acima, em Perl nós temos mais de uma maneira de se fazer algo e isso vem ficando cada vez mais evidente. O modulo MooseX::Declare nos traz algumas features muito interessantes e que simplificam ainda mais a forma como lemos e escrevemos nosso código.

Então deem uma olhada no doc que contem melhores exemplos e explicações, faça seus testes e brinque um pouco com o módulo que é bem interessante.

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

Pensando nisso e enquanto conversava com ele abri o meu VIM e começei a brincar com os códigos e o módulo Tk… e o resultado pode ser visto na screenshot abaixo!

Perl File Manager (using Tk module)

Claro que não existe nem um callback mais complexo implementado (o horário de almoço tinha acabado e estava no Windows…) mas em fim, foi uma experiencia interessante para fins didáticos.

Perl Tk Development IDE

O layout do IDE foi inspirado no Glade para que ficasse mais simples a adaptação e uso por desenvolvedores acostumados com o mesmo.

O sistema ainda esta em fase de desenvolvimento mas promete ser uma excelente alternativa já que as IDEs para desenvolvimento gráfico em Perl/Tk são tão pouco intuitivas e o desenvolvimento das telas lento e maçante.

Forte abraço a todos.

O projeto Damn Small Linux Brasil visa desenvolver as ferramentas para este sistema de forma que as mesma façam uso mínimo da memória seguindo assim a filosofia da distribuição porem sem perder a beleza e provendo facilidades na administração e configuração do sistema ao usuário.

Imagem de ferramentas desenvolvidas
(DSL Panel e MyDSL Browser)

O projeto esta em fase de desenvolvimento e levantamento dos requisitos e arquitetura e a implementação será feita em C++ utilizando o Tool Kit gráfico FLTK que alem de ser muito bem acabado e pequeno é muito poderoso e fornece uma infinidade de widgets uteis ao propósito do projeto.

“Aos desenvolvedores que estiverem e/ou puderem ajudar no projeto serão sempre muito bem vindos.”

Alguns links referentes ao projeto:

Qualquer duvida sobre o projeto deixo-me a disposição para responder.

Daniel Vinciguerra

Forte abraço a todos,

Primeiro em Perl:

Agora em Java:

Em C# também:

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

Forte abraço a todos,