Talvez alguns saibam, acredito que a maioria não, eu era sócio de uma empresa chamada Exati Sistemas até o final do ano passado, juntamente com o Alexandre e a Patrícia. Na realidade, a sociedade foi inicialmente constituída pelo Alexandre, o Elvis e por mim. Patrícia é atualmente viúva do falecido Elvis (acho que isso já explica parte da história). Entramos nessa sociedade meio de cabeça, compramos uma empresa que já existia a cerca de dois anos na época. Foi um negócio feito de maneira que não recomendo a ninguém hoje, meio “as pressas”. Trabalhavamos com desenvolvimento de software para automação comercial e iniciamos um processo focando a empresa para a área de desenvolvimento web. Nessa época, em meados de 2007, conheci Python. Foi pouco mais de meio ano programando com python e o framework Turbogears, para então cair nas graças do Ruby e Rails. Já conhecia o Rails anteriormente, principalmente pelo seu famoso screencast Criando um blog em 15 minutos, e hoje deve estar quase fazendo 2 anos que trabalho diretamente ligado a ele.

No final do ano passado, mais precisamente em Dezembro, partiu de mim a intenção de fecharmos a empresa. O comércio da região ainda é bastante promissor na área de desenvolvimento, mas acreditava que a nossa motivação para continuar com a Exati não era mais suficiente. Conflitos surgiam com uma certa frequência, não tínhamos mais a mesma paciência para o tipo de trabalho que estávamos desenvolvendo, além da falta de nosso amigo, dentre outras coisas. Além de tudo, financeiramente previa-se uma grande crise para o início deste ano, e não nos sentíamos totalmente estabelecidos para passar por ela. Em resumo, terminava nossa idéia de futuro para a Exati.

No geral, acredito que essa foi uma das melhores decisões já tomadas quanto a empresa. Hoje, olhando para trás, vejo que não teríamos conseguido enfrentar todas as barras que estavam por vir este ano: várias questões de homologação relacionadas ao fisco, tais como PAF-ECF, TEF, e é claro a tão falada Nota Fiscal Eletrônica. Com tudo isto sendo levado em conta, concordo plenamente com o que Vinícius disse: é extremamente necessário montar uma reserva financeira para a empresa e saber como trabalhar com um fluxo de caixa. Ponto.

Gerenciar uma empresa durante 2 anos e meio foi com certeza a maior experiência de vida que tive, recém saído da faculdade, com idéias e muita motivação, sem visão alguma do que apareceria pelo caminho. Mesmo assim, reafirmo: foi o período que mais aprendi, com certeza muito mais do que na própria graduação. Bater cara a cara com o cliente, deparar-se com código fonte legado, lógicas extremamente diferentes, pressão para resolver problemas na hora, decisões a serem tomadas, o sobe e desce das vendas, as horas que precisávamos rebolar para não deixar a peteca cair com nosso fluxo de caixa apertado.

Onde quero chegar com isso tudo?

Bom, hoje, 11 de setembro de 2009, estamos comemorando a queda das torres gêmeas a 8 anos atrás. (brincadeirinha =D)

Hoje comemoro 24 anos de idade, com algumas ideias novas e decisões que gostaria de compartilhar. (ah antes que alguém faça alguma brincadeira, não tem nada a ver com a idade ok).

Estou deixando a programação em Delphi de lado. Digo, totalmente de lado. Será um processo gradativo, pois atualmente estou auxiliando a empresa que está atendendo os antigos clientes da Exati devido a uma baixa que tiveram a algum tempo, mas aos poucos estarei atribuindo as funções que exerço para outra pessoa. Utilizar Delphi me fez aprender muito, incrivelmente foi com ele que iniciei meus passos na Orientação a Objeto. Contudo, definitivamente não me vejo daqui a alguns anos desenvolvendo um aplicativo comercial ou um software desktop voltado para a plataforma Windows. Alguém pode dizer que Delphi não é só isso, eu sei, mas é para isso que o tenho usado até então, e é exatamente isso que não desejo mais.

Meu foco agora vai ser voltado para o Ruby e o Rails. Quero estudar mais, desenvolver mais, aprender e compartilhar mais. Tenho várias linhas de código desenvolvidas em projetos e testes diferentes que gostaria de compartilhar, contudo o tempo não me tem permitido. Tenho baixado ebooks, screencasts, muito código-fonte para ler e assimilar. Mas não consigo. Ou melhor, não conseguia até então.

Quero voltar a brincar com Python, gosto da linguagem. Dizem que para um programador é ótimo aprender uma linguagem nova a cada 1 ou 2 anos, vou aceitar essa proposta. Aceito idéias para a próxima linguagem =).

O blog vai receber mais posts, não somente sobre Ruby e Rails mas também sobre experiências relacionadas à vivência na empresa.

Vou cortar um pouco o acesso ao Twitter. Diminiur o número de feeds do Google Reader. Vou ler e-mails 2 a 3 vezes ao dia. E somente isso. É suficiente. Manter o gmail aberto o dia todo não adianta, por várias vezes recebi e-mails importantes, mas que não tinha como dar atenção no momento. Para que saber de tais e-mails então? Para ter uma preocupação a mais em mente. Distração.

Também tenho a intenção de aplicar o GTD. Comprei o livro do David Allen a algum tempo e achei bastante interessante suas idéias simplificadas para uma melhor organização e produtividade. Se funciona? Quero descobrir. Se alguém aplica ou conhece agradeço se comentar a respeito. Aliás, falando em livros, tenho alguns para ler ainda, leituras técnicas e de lazer, que estão pegando pó ali na estante. Uma boa hora para começar uma limpeza, um a um.

E qual o motivo disso tudo?

Em resumo, os caminhos que tenho seguido não tem me deixado com aquele sentimento de leveza e dever cumprido. Quero buscar de volta toda a minha motivação e tentar alcançar um nível maior de produtividade, focando em determinados objetivos. Acho que tenho muito para aprender e também para compartilhar, e estou procurando dar o primeiro passo.

Anúncios

A primeira vez que trabalhei com o ActionMailer estava utilizando configurações do Google Apps, e me bati um pouco até chegar ao plugin ActionMailerTLS. Posso dizer que me senti aliviado quando tudo estava funcionando após instalar o plugin.

Depois dessa primeira experiência utilizei o plugin mais algumas vezes, e se bem me lembro a última vez foi final do ano passado, 2008. Bom, hoje me deparei com uma tarefa em um projeto que estou desenvolvendo que em resumo dizia o seguinte: disparar e-mail para os usuários envolvidos na transação a cada atualização de status. Legal, nada muito complicado, a primeira coisa que me passou pela cabeça foi procurar o plugin no github. Chegando lá a primeira coisa que vejo:

This gem will only work on Ruby 1.8.6. If you’re on Ruby 1.8.7 and Rails >= 2.2.1, you don’t need this gem.

Esta gem funcionará apenas no Ruby 1.8.6. Se você está usando o Ruby 1.8.7 e o Rails >= 2.2.1, você não precisa dela.

Ótimo. Fui logo ler as notas mais abaixo no Readme. Em resumo, o Ruby 1.8.7 possui o suporte necessário as configurações TLS para funcionar com o Gmail (informação que eu desconhecia até então), funcionalidades estas que o plugin adicionava em versões anteriores. E o Rails a partir da versão 2.2.1 adicionou uma opção para ativar essa funcionalidade. Basta adicionar à sua configuração do ActionMailer a seguinte linha: :enable_starttls_auto => true. Veja abaixo como ficaria:

ActionMailer::Base.smtp_settings = {
 :address => "smtp.gmail.com",
 :port => 587,
 :authentication => :plain,
 :enable_starttls_auto => true,
 :domain => 'my_domain',
 :user_name => "my_username",
 :password => "my_password"  
}

Com essa modificação o Mailer já está funcionando perfeitamente com o Gmail.

Os commits relacionados estão aqui e aqui, e o ticket no lighthouse aqui.

Esta é para quem está utilizando o AASM e também o Remarkable em seus testes: trabalhei num plugin que permite testar as configurações de estado de um modelo facilmente, da seguinte forma:

  describe User do

    should_aasm :status do |aasm|
      aasm.initial_state :pending
      aasm.states [:pending, :active, :suspended, :deleted]
      aasm.events [:activate, :suspend, :delete]
    end
  end

Atualmente é possível testar o estado inicial, os estados disponíveis e os eventos configurados para o modelo. Os testes para verificar as transições entre estados ainda estão sendo planejados =).

O plugin está disponível no github. Qualquer dúvida é só deixar um comentário, e se tiverem sugestões e/ou problemas, usar as issues do github.

Hoje a tarde veio a informação pelo Twitter do @dhh (e logo depois muitos outros RTs) que havia sido liberada a tão esperada versão 2.3.3 do Rails. Esta versão é um release para correção de alguns bugs deixados pela versão 2.3.2, além de algumas pequenas features novas, como o método touch que já mencionei aqui anteriormente.

Para atualizar basta dar um gem update no seu terminal/console que a nova versão será baixada e instalada.

Mais informações diretamente no blog do Rails, aqui.

Ontem procurando novidades sobre testes no google acabei encontrando um post novo sobre testes, mas como estava no meu limite de tempo ele virou um bookmark rapidamente.

Hoje por acaso cheguei novamente a este mesmo post, através do grupo do Remarkable, dica do José Valim (valeu José).

O post explica de maneira muito fácil como testar regras de usuários no sistema, algo como:

as_admin :post => :create, :params => {} do
  # teste o que quiser aqui
end

Simples assim.

Fica a dica, leitura extremamente recomendada. Clique aqui para acessar.

Olá a todos.

Depois de longa data sem escrever no blog (quase me assustei quando verifiquei a data do último post, 21 de abril.. 2 meses praticamente), estou de volta com uma dica muito legal para quem usa Gedit para desenvolver em Rails e, assim como eu, se apaixonou pelo Remarkable.

Adicionei ao projeto Gmate uma coleção de snippets para utilização do Remarkable, tanto para o Active Record, quanto para o Rails. Esses snippets tem me ajudado bastante na criação dos testes e facilitam o trabalho ao tentar lembrar as funcionalidades do Remarkable.

Para conferir os snippets disponíveis para o Remarkable, abra o Gedit, acesse a aba Ferraments > Gerenciar Trechos (se bem me lembro em inglês está Snippets mesmo), e acesse no menu a opção Ruby on Rails. Todos os snippets para o Remarkable começam com o próprio nome dele, por exemplo: remarkable_ar: should_belong_to.

Para utilizar um snippet basta digitar as letras de atalho, no caso do should_belong_to seria sbt (não é propaganda da tv não). Após tecle tab e você terá um resultado como este:

should_belong_to :association

com o texto association selecionado para você apenas digitar o nome da associação.

Quem não conhece o Gmate pode obter mais informações aqui.

Qualquer dúvida quanto ao Gmate ou aos snippets é só comentar. E se por acaso alguém sentir falta de algum snippet, por favor entre em contato que estaremos adicionando ao projeto.

Abraços e até mais.

Recentemente foi adicionado ao Rails o método touch, disponível tanto no Rails 2.3 quanto no Edge (em direção ao 3.0). O touch atualiza o campo updated_at/updated_on do model e então salva o registro. Ele também permite a passagem de um parâmetro, que identifica outro campo data/hora para ser atualizado no lugar de updated_at/updated_on.  Touch quer dizer exatamente isto: tocar o registro, ou atualizar um determinado campo com a data/hora atual.

Utilizando o método:

class Project < ActiveRecord::Base
  validates_presence_of :name
end

# No console
project = Project.create(:name => 'Meu primeiro projeto')
#<Project id: 1, name: "Meu primeiro projeto",
#  created_at: "2009-04-21 05:35:22", updated_at: "2009-04-21 05:35:22">
# Atualizando o campo updated_at no momento que for necessário
project.touch
# true
project
#<Project id: 1, name: "Meu primeiro projeto",
#  created_at: "2009-04-21 05:35:22", updated_at: "2009-04-21 05:40:49">

Preste atenção ao campo updated_at e verifique que ele foi atualizado com sucesso. Podemos também passar o campo que desejamos “tocar”:

project.touch(:created_at)
# true
project
#<Project id: 1, name: "Meu primeiro projeto",
#  created_at: "2009-04-21 05:42:31", updated_at: "2009-04-21 05:42:31">

Veja que agora foi o campo created_at que foi atualizado (nesse caso o updated_at também foi atualizado por ser uma funcionalidade interna do Rails).

Agora vem o mais interessante: essa funcionalidade foi também adicionada a associação belongs_to, onde é possível passar a opção :touch => true para atualizar o campo updated_at/updated_on do model master automaticamente, ou então passar um símbolo, como :touch => :campo_a_atualizar, para “tocar” este campo específico ao invés do padrão.

Vejamos como fica:

class Project < ActiveRecord::Base
  has_many :tasks
  validates_presence_of :name
end

class Task < ActiveRecord::Base
  belongs_to :project, :touch => true
end

# No console
project = Project.first
#<Project id: 1, name: "Meu primeiro projeto",
#  created_at: "2009-04-21 05:42:31", updated_at: "2009-04-21 05:42:31">
# Checagem de sanidade
project.updated_at
# Tue, 21 Apr 2009 05:42:31 UTC +00:00
# Criando uma tarefa
project.tasks.create(:name => 'Primeira tarefa')
#<Task id: 1, name: "Primeira tarefa", project_id: 1,
#  created_at: "2009-04-21 05:49:41", updated_at: "2009-04-21 05:49:41">
project.reload.updated_at
# Tue, 21 Apr 2009 05:49:41 UTC +00:00

Novamente atenção ao campo updated_at do model Project: atualizado =).

É isso, uma mudança simples que facilita bastante o dia-a-dia.

Lembrando que para testar os método touch é necessário ter a última versão do rails 2.3 disponível no git.