CODEPLACE

Uninstall de plugins no grails

2010-01-18T13:36:00.004-02:00

Dica rápida, e simples mas que é um pouco difícil de achar na documentação do Grails.
Para se instalar um plugin é muito fácil, você simplesmente roda o comando grails install-plugin *nome do plugin*.
Mas e para remover o plugin?
Não temos um comando grails uninstall-plugin.
Mas não há motivo para revolta, remover um plugin é bem simples.
Antes de instalar um plugin conheça o seu arquivo application.properties, nele são listados todos os plugins que você vier a instalar.
Quando um plugin é instalado lá ele é listado assim como os plugins que são dependências dele.
Para remover um plugin não mais utilizado no seu projeto simplesmente delete a linha com o mesmo nesse arquivo, ao rodar o build do seu projeto o console irá perguntar se você quer remover o plugin.
Pronto =)
Espero ter ajudado alguém com essa dica.

See you and Let's Code Better people.

Decorando objetos em Scala

2009-09-16T01:16:00.009-03:00

No desenvolvimento de software sempre existem características que são ortogonais ao sistema.

Para remover a duplicação de código que tais características causam podemos utilizar interceptors, aspectos, proxies, etc para com isso decorarmos o nosso objeto com a funcionalidade que queremos.

A solução fica legal, mas a quantidade de código que precisa ser gerada às vezes poderia desencorajar a implementação pois a duplicação de código seria trocada em alguns casos por muito código.

Entretanto se você resolver desenvolver seu sistema em Scala uma solução muito mais simples poderá ser implementada.

Com a utilização de traits, você pode adicionar novas características a objetos com muita facilidade e pouco código.

Por exemplo, suponhamos que você queira realizar um profile de alguns objetos no seu sistema.

O seguinte código resolveria tal problema:

  //classe que já possuo
  class T{
    def f = print("Ola enfermeira!")
  }
  //trait que adiciona comportamento a interface de T
  trait Profile extends T{
    abstract override def f = {
      val time = System.nanoTime()
      super.f
      println("Tempo total em nanos: " + (System.nanoTime() - time))
    }
  }

Ao rodar o seguinte código:

  val t = new T with Profile
  t.f

Obtemos o seguinte resultado: Ola enfermeira!Tempo total em nanos: 214972

O que acontece é que utilizando a palava with na declaração da variável eu estou dizendo ao compilador do scala que ele deve adicionar as caracteristicas na minha Trait Profile ao objeto.

Sim, isso é um tipo de herança

Logo quando eu chamo o método f, a implementação que é chamada é a da Trait e não do objeto T.

Nesse ponto um detalhe que precisamos notar é como o scala trata o super.

Quando chamamos o super dentro da implementação de f em T o método f chamado será o da implementação que está imediatamente a esquerda da definição da trait.

Ou seja, o seguinte código pode ser feito:

  trait Smile extends T{
    abstract override def f = {
      print("=)")
      super.f
    }
  }

  val t = new T with Profile with Smile
  t.f

Tendo como output: =)Ola enfermeira!Tempo total em nanos: 27238

A implementação que está mais a direita (no caso Smile) foi invocada.

Ao chamar super a implementação exatamente a esquerda foi chamada (Profile).

No próximo super a implementação de T foi chamada.

Com tal forma de encadeamento seus objetos podem ser decorados de inúmeras formas.

Tem alguma idéia melhor de como criar tais características?

Coloque nas revisões desse post =)

Eliminando ifs encadeados com scala.

2009-09-10T10:35:00.008-03:00

Estava lendo o seguinte post do meu amigo eliezer sobre eliminar if encadeados e pensei: Como seria um código para resolver esse problema em Scala.

Utilizando firstClass functions e placehoder syntax criei o seguinte código:

object StringUtils {                                                   
  def format( action: String => String, value: String ) = action(value)
  def removeBlanks = { (_:String).replaceAll( " ", "") }                       
  def onlyNumbers = { (_:String).replaceAll( "\\D", "" ) }             
}

Dá pra ver que o código fica bem mais enxuto e a responsabilidade fica toda dentro do objeto singleton StringUtils. O código cliente fica bem interessante também:

StringUtils.format( StringUtils.removeBlanks, "Ola enfermeira" )

O código retorna Olaenfermeira

Legal né =)

Se você tem alguma idéia melhor por favor compartilhe ela aí embaixo.

Scala e o jeito funcional de programar

2009-09-03T01:36:00.007-03:00

Ao programar por muitos anos com linguagens como C e Java nós nos acostumamos demais com o modo imperativo de programação. Fazendo isso esquecemos algumas vantagens que o paradigma funcional pode nos trazer.

Ultimamente estou estudando Scala, e apesar da linguagem permitir que você construa código imperativo, a mesma traz interessantes construções que nos incentivam a usar o paradigma funcional.

Um exemplo simples mas que mostra esse conceito seria um código para varrer os parâmetros de entrada de um programa e simplesmente imprimi-los na tela.

Um código imperativo em Scala seria assim:

var i=0
while(i < args.length){
  println(args(i))
  i += 1
}

Como podemos ver, nada muito complexo, simplesmente um laço que varre a lista imprimindo seus elementos.

Utilizando um pouco do paradigma funcional presente em Scala o mesmo código poderia ser feito da seguinte maneira:

args.foreach(arg => println(arg))

O seguinte código define um function literal. Esta função recebe como parâmetro um item da lista de argumentos e imprime o mesmo, o processo é repetido para cada argumento da lista.

Da mesma maneira que foi chamado um println, qualquer função poderia ter sido chamada sobre a iteração.

É importante notar que o código acima é facilmente implementado em Java, basta pensarmos de maneira mais funcional.

Entretanto, como o valor extraído da lista é o único parâmetro para a função que será executada, é possível fazer com que esse código seja ainda mais simples:

args.foreach(println)

E você achando que o laço no início do post que era simples ein =)

Múltiplas instâncias do JBoss na mesma máquina.

2009-08-27T21:19:00.007-03:00

Esta é uma dica simples porém muito útil.

Se você estiver desenvolvendo utilizando o JBossAS e precisar, por algum motivo, executar mais de uma instância na mesma máquina para testes, existe uma maneira muito fácil de fazer isso.

No diretório $JBOSS_HOME/server duplique o perfil que você quer subir duas vezes:

   cp -rf default node1
   cp -rf default node2

Em seguida ajuste o range de portas para que as duas instancias subam sem conflitos.

Mas como assim ajustar o range de portas? você está dizendo que vou ter que alterar uma por uma?

É aí que o JBoss mostra que é um application server bem configurado =).

No arquivo jboss-service.xml dentro do diretório conf de cada profile existe uma tag comentada que já configura todo o range de portas de um perfil automaticamente.

Neste arquivo busque pela seguinte tag:

   
     ports-01
     ${jboss.home.url}/docs/examples/binding-manager/sample-bindings.xml
     
       org.jboss.services.binding.XMLServicesStoreFactory

Descomente-a. Ao fazer isso o perfil em questão irá usar o range de ports-01. Já existem também pré configurados o ranges ports-02 e ports-03.

Com tal configuração todas as portas do perfil alterado serão somadas em 100

Por exemplo, para acessar o jmx console ao invéz de usarmos a url http://localhost:8080/jmx-console usaremos http://localhost:8180/jmx-console.

Tal regra serve para todas as portas como as de ejb ou jndi.

No range o ports-02 o valor somado é 200 e o ports-03 é 300.

Agora que você modificou uma das instâncias pra usar um novo range de portas basta subí-las:

   $JBOSS_HOME/bin/run.sh -c node1
   $JBOSS_HOME/bin/run.sh -c node2

Caso você ainda precise de mais perfis rodando ao mesmo tempo uma alternativa é o uso de ips virtuais na máquina.

Assim cada instancia dê um bind em um ip diferente (usando o parametro -b no run.sh).

Existe também a possibilidade de serem criados mais ranges de porta. Simplesmente os adicione no arquivo sample-bindings.xml listado no trecho xml acima.

Espero ter te ajudado com a dica. =)

Plugins no chrome para linux

2009-07-22T12:40:00.009-03:00

Uso o firefox diariamente para desenvolvimento muito em parte por conta de suas extensões que facilitam o meu trabalho.
Entretanto a sua lentidão me incomoda às vezes.
Recentemente vi no Chromium Blog que um release ainda unstable estava disponível para o linux (este já empacotado para o ubuntu, com atualizações, sem dor de cabeça).
Como gosto muito de testar novidades resolvi instalá-lo.
Você pode fazer o mesmo indo na página do download aqui.
Ao começar a usá-lo é notório que falta muita coisa a ser feita, mas fica evidente a velocidade e a estabilidade do navegador.
Depois de pouco tempo comecei a usá-lo como navegador do dia dia (não o de desenvolvimento) por conta de sua velocidade.
Entretanto o pacote não vem com plugins como o do flash ativados.
Olhando pela web vi esse post e resolvi testar.
O plugin do flash funciona perfeitamente.
Testei os plugins do mplayer e obtive total sucesso.
Basta criar um diretorio:

/opt/google/chrome/plugins
nele colocar os .so do flash e mplayer.
Após isso o chome deve ser iniciado da seguinte forma:

/opt/google/chrome/google-chrome --enable-plugins

O próximo passo é aprender sobre as ferramentas de desenvolvimento dele e fazer meus próprios plugins aí talvez eu esqueça o firefox

Alguém consegue rodar mais algum plugin? Se sim comente aí em baixo =)

Groovy e a magia do invokeMethod

2009-03-16T22:43:00.013-03:00

Estava eu discutindo com meu amigo André Ribeiro Gonçalves sobre o Groovy e sua simplicidade.

Durante a discussão começamos a trocar idéias sobre um recurso muito interessante da linguagem:
A possibilidade de interceptar a chamada de um método não existente de um objeto e fazer com que o mesmo faça algo de útil.
Como nós dois adoramos programação concorrente, o primeiro exemplo que nos veio a mente foi o de passar o processamento de um método de síncrono para assíncrono utilizando apenas convenção de código, escondendo assim a criação de um Runnable para encapsular o método e tornando isso algo mais transparente.
Ao final da discução o seguinte código foi criado, o mesmo é bem simples e é somente uma prova de conceito, mas é excelente pra mostrar a idéia.
E vocês, também acham isso fascinante?

   class A {

    def b( String name ){
        for( int i=0; i<15; i++ )
            println( name + i ) 
    }

    def invokeMethod( String name, args ){
        if( name.endsWith("Async") ){
            name = name.substring( 0, name.size()-5 );
            def m = A.metaClass.getMetaMethod(name, args)
            if( m == null ){
                println( "1. Nothing to do! No method definition found!" )
                return
            }
            def t = { 
                println( "Invoking $name in asyn way" )
                m.invoke(this,args)
            } as Runnable
            def t1 = new Thread(t)
            t1.start()
        }
        else {
           println( "2. Nothing to do! No method definition found!" )
        }
    }


}

def a = new A()

a.Async("t1")
a.c()
a.cAsync("t2")
a.b("name")
a.bAsync("t3")
a.bAsync("t4")
a.bAsync("t5")
a.bAsync("t6")
a.bAsync("t7")
a.bAsync("t8")
a.bAsync("t9")
a.bAsync("t10")
a.bAsync("t11")
a.bAsync("t12")
a.bAsync("t13")
a.bAsync("t14")
a.bAsync("t15")

Controle de Transação com Spring, JTA, JPA, Hibernate e Maven

2008-06-22T21:40:00.071-03:00

Com o crescimento das aplicações que vêm sendo desenvolvidas um dos maiores problemas na estruturação de um projeto reside no controle de transações. Quando vários datasources entram na história o problema só aumenta. Segue abaixo uma proposta de solução para o controle de transação utilizando String, com JTA e Maven. As configurações abaixo necessitam de um container J2EE para funcionarem, o exemplo foi testado no JBoss 4.0.5ga. Com o uso do Spring o controle transacional se torna transparente, sendo então o problema resolvido. Segue tutorial abaixo:

Configurações do Maven

A configuração do Maven para o uso de tais ferramentas é simples.

Somente são necessárias algumas dependências e um repositório para busca-las.

Adicionando dependências

O seguinte trexo deve ser adicionado nas dependências do projeto no seu arquivo pom.xml.

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>2.5.4</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>2.5.4</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>2.5.4</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>2.5.4</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>2.5.4</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>3.3.1.ga</version>
</dependency>
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>persistence-api</artifactId>
<version>1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.7.0</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate</artifactId>
<version>3.2.6.ga</version>
<exclusions>
   <exclusion>
        <groupId>javax.transaction</groupId> <!-- Exclusion to remove a classloader conflit with jta of JBoss -->
        <artifactId>jta</artifactId>
   </exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-annotations</artifactId>
<version>3.3.1.GA</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-commons-annotations</artifactId>
<version>3.3.0.ga</version>
</dependency>

Aqui estão listados todos os jars necessários para o uso das ferramentas mencionadas neste tutorial.

Adicionando repositório

O seguinte trexo deve ser adicionado nos repositórios do projeto para que todas as dependências sejam satisfeitas.

Tal repositório contém algumas das dependências do Hibernate.

<repository>
<id>maven-repository.dev.java.net</id>
<name>Java Dev Net Repository</name>
<url>http://download.java.net/maven/2/</url>
<releases>
     <enabled>true</enabled>
     <updatePolicy>never</updatePolicy>
</releases>
<snapshots>
    <enabled>false</enabled>
</snapshots>
</repository>

Utilização do Spring

Com a utilização do Spring podemos injetar o EntityManager do JPA no Dao, utilizando como provider o Hibernate.

O controle de transação se torna transparente para o desenvolvedor não sendo mais necessário que o mesmo inicie e finalize cada transação.

Vejamos utilizar o Spring no escopo proposto.

Configuração do applicationContext

Abaixo segue uma configuração padrão para o applicationContext da aplicação

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jboss="http://www.springmodules.org/schema/jboss"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd"
default-autowire="byName">
<bean id="dao" scope="prototype"
class="br.com.product.project.commons.dao.DaoImpl">
</bean>
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="jpaProperties">
    <props>
         <prop key="hibernate.transaction.factory_class">org.hibernate.transaction.JTATransactionFactory
         </prop>
         <prop key="hibernate.transaction.manager_lookup_class">org.hibernate.transaction.JBossTransactionManagerLookup
         </prop>
    </props>
</property>
</bean>
<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager" >
<property name="transactionManagerName" value="java:/TransactionManager" />
<property name="userTransactionName" value="UserTransaction" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager" />

<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
</beans>

No xml acima temos várias configurações, vamos detalhar uma por uma.

Injeção do Dao na Aplicação

No XML acima temos a declaração de um Bean chamado dao. Esse bean implementa o Dao que será utilizado na nossa aplicação.

Para utiliza-lo devemos fazer com que o Spring injete o mesmo na camada de Aplicação.

Como essa injeção deve ser feita foge o escopo desse tutorial.

Configuração do EntityManager do JPA

Vemos também no applicationContext configuração do EntityManagerFactory do JPA.

No property jpaVendorAdapter definimos o uso do Hibernate como provider do JPA.

Definimos também algumas propriedades do Hibernate.

Para que o EntityManager seja inicializado no Dao o seguinte fragmento de código deve existir no mesmo:

private EntityManager entityManager;
@PersistenceContext( type=PersistenceContextType.TRANSACTION, name="name" )
public void setEntityManager(EntityManager entityManager) {
this.entityManager = entityManager;
}

Neste fragmento dizemos ao Spring que a variável entityManager vai receber uma instância criada pelo EntityManagerFactory.

Assim o Spring injeta o EntityManager no Dao.

Controle Transacional

No fim do applicationContext vemos a configuração do Controle de Transação.

Definimos o JpaTransactionManager como o controlador de transações, e logo abaixo definimos que o mesmo seja feito através de annotations.

Logo para definirmos quando um método deve ser executado em uma transação tudo que precisamos fazer é adicionar um annotation em cima do mesmo:

@Transactional(propagation = Propagation.REQUIRED, readOnly = false)
public void someMethod(){
// do some operation in a transaction
}

O mesmo annotation pode ser adicionado em uma classe ou em uma interface, agindo assim sobre todos os metodos das mesmas.

Programando o DAO

Uma vez que possuímos o EntityManager injetado no Dao e o controle de transação já está definido a programação do Dao se torna muito simples.

Vejamos um exemplo de um método que insere ou atualiza uma Entidade.

public void save(T t) throws DataBaseException {
try{
   //Consideremos que todas as entidades passadas para esse metodo possuam o metodo getId
   Object id = t.getId();
   if( id != null ){
       entityManager.merge( t );
   else{
       entityManager.persist(t);
       entityManager.flush();
} catch (Exception e) {
   throw new DataBaseException( "Erro ao persistir objeto <" + t.getClass().getSimpleName() + ">", e  );
}
}

Mapeamento no Hibernate com Annotations

O mapeamento das entidades pode ser feito todo via annotation reduzindo o número de XML's para a configuração da aplicação.

O único XML necessário é o persistence.xml, padrão do JPA que explicita as características na Unidade de Persistencia.

Configuração do persistence.xml

Um exemplo de configuração do persistence.xml pode ser visto a seguir

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
     http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
     version="1.0">
<persistence-unit name="name" transaction-type="JTA">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <jta-data-source>java:/MySqlAccounter</jta-data-source>
    <class>br.com.product.project.domain.vo.Home</class>
    <class>br.com.product.project.domain.vo.Room</class>
    <properties>
        <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />
        <property name="hibernate.cache.use_second_level_cache" value="false" />
        <property name="hibernate.cache.use_query_cache" value="false" />
        <property name="hibernate.show_sql" value="true" />
        <property name="hibernate.generate_ddl" value="true" />
    </properties>
</persistence-unit>
</persistence>

No arquivo configuramos a Unidade de persistencia que será usada pelo JPA.

Perceba que definimos um nome para a mesma, esse nome é o mesmo que deve ser adicionado sobre o entity manager no annotation que o injeta no Dao, mostrado no item Configuração do EntityManager do JPA.

A primeira configuração mostra que é o provider do JPA será o hibernate.

Logo em seguida é configurado o endereço do DataSource da base de dados que a Unidade de Persistência irá utilizar.

Em seguida são listadas todas as classes que queremos mapear para que o JPA possa encontrálas e iniciar o mapeamento das mesmas.

No exemplo o dialeto MySQLDialect é usado pois o mesmo se conectará a uma base de dados MySQL, tal variável deve ser alterada de acordo com o SGBD utilizado, também desabilitamos o segundo nível de cache e a cache de queries.

Annotations de Mapeamento

Uma vez que definimos quais classes queremos mapear, agora precisamos inserir metadados nas mesmas para que o mapeamento seja feito corretamente.

Para isso utilizamos os annotations da javax.persistence.*.

Se tivermos a seguinte tabela em nossa base de dados:

CREATE TABLE TAB_HOME (
id INT AUTO_INCREMENT PRIMARY KEY,
address VARCHAR(50)
);

Vejamos um exemplo de mapeamento para a mesma

package br.com.product.project.domain.vo;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.GeneratedValue;

@Entity
@Table(name = "TAB_HOME" )
public class DomainEnumSubscriber {

@Id @GeneratedValue
@Column( name="id" )
private Integer id;

@Column( name="address" )
private String address;

public Integer getId(){
    return this.id;
}

public void setId( Integer id ){
    this.id = id
}

public String getAddress(){
    return this.address;
}

public void setAddress( String address ){
    this.address = address;
}
}

No código usamos o annotation @Entity para mostrarmos que a classe representa uma entidade.

Em seguida usamos o anntation @Table para mostrar qual tabela estamos mapeando.

O annotation @Id mostra que o atributo se referencia a uma chave primária. e o anntation @GeneratedValue que a mesma é gerada automaticamente pelo banco de dados.

Em seguida o annotation @Collumn serve para mapear qual a coluna que o atributo se referencia.

Existem várias anotações cada uma com seus atributos, veja mais na Documentação Oficial.

Mapeamento de Chaves Estrangeiras

Com o JPA podemos mapear as chaves estrangeiras das tabelas para que objetos já sejam inseridos dentro das entidades que as contém. Suponhamos as seguintes tabelas no banco de dados

CREATE TABLE TAB_HOME (
id INT AUTO_INCREMENT PRIMARY KEY,
address VARCHAR(50)
);

CREATE TABLE TAB_ROOM (
id INT AUTO_INCREMENT PRIMARY KEY,
home INT REFERENCES TAB_HOME( id ),
size INT,
);

Podemos mapear essa chave estrangeira de duas maneiras. Fazendo o Objeto Home ter uma lista de todos os comodos que possui (mapeamento do tipo OneToMany), ou fazendo cada comodo possuir a qual casa ele pertence (Mapeamento do tipo ManyToOne).

Mapeamento OneToMany

Para que possamos ter uma lista em uma entidade pai de todas as entidades filhas que a referenciam utilizamos o mapeamento OneToMany.

Para tanto só precisamos utilizar o annotation @OneToMany ao fazer o mapeamento de um atributo de uma das classes mapeadas.

Vejamos um exemplo:

//O atributo mappedby se referencia a uma instancia de Home dentro da classe Room com o nome home
@OneToMany( targetEntity=Room.class, mappedby="home" )
private Collection rooms;

Com isso ao criar o objeto o mesmo busca uma lista de todos os comodos que referenciam a ele de modo lazy.

Mapeamento ManyToOne

Para que possamos ter uma instância de um objeto ao qual uma chave estrangeira aponta utilizamos o mapeamento ManyToOne.

Para tanto só precisamos utilizar os annotations @ManyToOne e @JoinColumn ao fazer o mapeamento de um atributo de uma das classes mapeadas.

Vejamos um exemplo:

@ManyToOne( targetEntity=Home.class )
@JoinColumn( name="home" )
private Home home;

Com isso ao criar o objeto o mesmo busca o objeto ao qual a chave estrangeira se relaciona e o traz de modo lazy.

Mais pode ser encontrado em sites como o de referencia do Spring ou nesse tutorial sobre J2EE.

Por favor, se você leu esse material deixa sua crítica, comentário e sujestões de melhoras

[]'s e até a proxima

Olá ninguém!

2008-06-21T23:23:00.000-03:00

Olá a ninguém que está lendo isso no momento. Ninguém pq esse é o primeiro post do meu primeiro blog. Minha motivação em criar esse blog foi a de inserir aqui algumas idéias sobre programação, processos de software e análises sobre linguagens e frameworks, espero que o conteúdo fique de bom nível e que com isso os leitores comecem a aparecer. Bom, até o próximo e primeiro post com conteúdo.