1up4developers

Dica para quem usa o Nginx como web server de aplicações Rails e já apanhou para habilitar HTTP Basic Authentication ou para gerar as senhas criptografadas em MD5.

Para habilitar o auth_basic, basta adicionar dentro do bloco server do arquivo nginx.conf:

location ~ / {
        auth_basic            "Restricted";
        auth_basic_user_file  htpasswd;
        passenger_enabled on;
}

Um detalhe importante: se estiver rodando sua app com Passenger, inclua a linha passenger_enabled on;

Ah, já estava esquecendo das senhas. Elas devem ficar no arquivo htpasswd, no mesmo diretório do arquivo nginx.conf e precisam seguir o formato user:senha em cada linha. Por exemplo:

user:sd5dsjo23PwdSh
admin:mdePW2hgrPddSA

O detalhe é que a senha precisa ser criptografada em MD5. Uma maneira fácil (e que funciona) de fazer isso é executando:

ruby -e "puts 'usuario:' + 'senha'.crypt('md5')" >> htpasswd

Sucesso!

Este post serve mais como “cola” de referência, pois toda vez que vou fazer isso eu não encontro fácil no google e nunca lembro. Por sinal é mega simples, é só editar o config/application.rb e remover a linha:

require 'rails/all'

E substituir por:

require "active_record/railtie"
require "action_controller/railtie"
require "action_mailer/railtie"
require "active_resource/railtie"
require "sprockets/railtie"

Após isso, já não aparece mais as tasks de testes, e você pode remover a pasta test.

$ git rm -r test/

Pra finalizar, já segue a dica de alterar a task default, no final do Rakefile é só colocar:

Rake::Task[:default].prerequisites.clear
task :default => :spec  #no caso do rspec

Sucesso!

Se você ainda não trabalha com Ruby pois acha complicado demais instalá-lo, chega de desculpas! Esse tutorial for dummies ajudará a instalar o Ruby através do RVM de forma direta, sem enrolação.

Partindo de uma instalação do Ubuntu 11.04 zerada, começamos com os pré-requisitos para instalar o RVM:

user@ubuntu:~$ sudo apt-get install git-core curl

Basta confirmar a instalação dos pacotes, em seguida executar o comando (extraído do site oficial do RVM):

user@ubuntu:~$ bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)

A seguir, o output completo gerado por esse comando indicará os pacotes e libs necessários para a instalação do Ruby.

(...)

dependencies:
# For RVM
  rvm: bash curl git

# For Ruby (MRI & ree)  you should install the following OS dependencies:
  ruby: /usr/bin/apt-get install build-essential bison openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake

(...)

Installation of RVM to /home/user/.rvm/ is complete.

Agora, basta instalar essas libs através do apt-get:

user@ubuntu:~$ sudo apt-get install build-essential bison openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake

Com as dependências instaladas, abra um novo console (para re-carregar o RVM), e comece a instalar o Ruby, no caso, o MRI 1.8.7:

user@ubuntu:~$ rvm install 1.8.7

Esta operação levará alguns minutos. Quando concluída, você terá o Ruby 1.8.7 e o Rubygems 1.8.6 instalados. Para testar tudo, execute os seguintes comandos:

user@ubuntu:~$ rvm use --default 1.8.7
Using /home/user/.rvm/gems/ruby-1.8.7-p352

user@ubuntu:~$ ruby -v
ruby 1.8.7 (2011-06-30 patchlevel 352) [i686-linux]

user@ubuntu:~$ gem -v
1.8.6

Pronto! Agora você tem o Ruby e Rubygems instalados e prontos para o uso. Caso queira conferir, o output dos comandos acima está disponível neste gist.

Fique ligado no próximo post: Gemsets e Bundler. Qualquer dúvida, use os comentários.

Sentado num quarto de hotel, longe de casa, com a televisão passando imagens sem som, uma tela de computador cheia de parênteses na minha frente, sentindo uma imensa felicidade por ganhar a vida fazendo aquilo que escolhi, e principalmente, por (re)descobrir o quão divertido e empolgante pode ser esse caminho.

Meu filho, de um ano e meio, me ensina todo dia a ser curioso, a não parar de aprender, me relembra como é bom descobrir o mundo, entender como as coisas funcionam, aprender com os erros. Vejo nele a alegria de perceber pequenas coisas, de querer mais, por mais que isso algumas vezes incomode quem está ao redor.

As pessoas costumam crescer, buscam conforto, buscam um canto macio e aquecido para encostar, um cubículo para se sentar todo dia fazendo o mesmo trabalha de sempre, sem aprender, sem questionar, muitas vezes em entender, ouvindo e dizendo as mesmas coisas todos os dias. As pessoas crescem e perdem aquela alegria da criança ao aprender, se esquecem como é bom entender, perguntar o porquê, colocar a mão onde não é para mexer.

Eu não consigo entender como alguém escolhe se tornar um programador, um desenvolvedor, e não alimenta a curiosidade, não alimenta a vontade de aprender. É pelo salário, já me disseram. Pode ser, mas garanto que estão perdendo o melhor da brincadeira. Eles vão conseguir uma vida confortável, comprometer o orçamento com o que quer seja e logo o lado financeiro não será mais suficiente. Surgirá uma sensação de vazio, de inutilidade, de frustração por trabalhar com algo que não traz nenhuma satisfação, por desperdiçar metade do dia numa vida vazia, metade da vida numa função sem atrativos.

Com a participação de alguns amigos, passamos a compartilhar experiências, conhecimento e novidades com os demais colegas de trabalho. Existem sempre aqueles que nunca estão interessados, como queiram. Mas existem aqueles que logo se tornam sedentos por conhecimento, por novidades, que começam a compartilhar o que sabem, o que descobriram, e isso começa a formar um círculo virtuoso. Essas pessoas passam a relembrar daquela alegria infantil de aprender e entender o mundo, e começam a contaminar as pessoas ao redor, aumentando esse círculo. O ambiente de trabalho passa a ter um clima melhor, apesar de tudo; as pessoas passam a se respeitar mais, a se conhecer melhor, a nutrir admiração uns pelos outros. Obrigado a todos por isso.

Não deixe aquela curiosidade infantil e a vontade de descobrir o mundo morrerem em você. Vale todo o esforço, eu posso garantir.

A cilada típica em ambientes corporativos:

E agora, quem poderá nos ajudar?

Infelizmente, e-mails e reuniões, mesmo em ambientes ágeis, são inevitáveis, e na maioria das situações, tóxicos. Reuniões de 2 horas de duração ou 50 emails diários são sinais claros de que as coisas não andam muito bem.

Atitudes ágeis tendem a evitar “enrolações” que desviem o foco da equipe ou desacelerem a produtividade. A seguir, algumas estratégias e dicas que podemos aplicar para quebrar um pouco essas práticas corporativas cascateiras, ajudar a manter o foco da equipe e produzir mais.

Reuniões

Simplesmente evite reuniões, com temor! Tente resolver os problemas com conversas cara-a-cara, na sua mesa mesmo. Se precisar discutir um assunto por mais de 5 minutos, convide as pessoas envolvidas para um cafézinho, de preferência em pé.

Se não puder evitar a reunião, defina com antecipação: 1) o(s) objetivo(s) e 2) a duração máxima. Limite qualquer reunião a no máximo 5 participantes e duração de 15 minutos. Acredite: é suficiente.

Se um problema for muito complexo para ser resolvido em uma reunião de 15 minutos, quebre o problema em problemas menores, e discuta um de cada vez. Os próximos problemas devem ser discutidos somente quando o problema anterior for resolvido.

Antes de começar qualquer discussão, faça com que todos presentes tomem ciência dos objetivos e da duração máxima. Assim que alcançarem os objetivos ou o tempo se esgotar, termine a discussão imediatamente! Não dê oportunidade para que alguém inicie uma nova discussão desnecessária.

Diga não! Em certas ocasiões, é a melhor resposta. Se você não é o responsável por determinado problema, desconhece ou não pode ajudar plenamente, simplesmente diga “não, obrigado”.

E-mails

Alguns problemas podem ser resolvidos com um simples e-mail, é verdade. A única regra que devemos seguir é a do “passa, repassa ou paga”. Não deixe os e-mails passarem das tréplicas. Se depois de 3 e-mails o problema ainda não foi resolvido, convide os envolvidos para tomar um cafezinho.

E-mail não é chat. O time deve conversar cara-a-cara, incluindo os clientes. Trocar mais do que 5 e-mails diários entre a equipe é um mau sinal. Se não puder falar pessoalmente, use o telefone ou skype ao invés de mandar um e-mail que pode ser facilmente ignorado pelo destinatário.

E-mail não é documentação. Não é preciso enviar um e-mail a cada decisão tomada pelo cliente ou pelo time. Se algo importante foi decidido, converse pessoalmente com os envolvidos.

Finalmente, use o e-mail com sabedoria, para trocar informações importantes e relevantes entre a equipe. E-mail não deve ser regra, e sim um suporte para comunicação entre a equipe. Lembre-se: quanto mais e-mails você enviar, maior a chance de ser ignorado.

Resumo

Reuniões e e-mails são tóxicos. Evite-os! Se não puder evitar, use-os com sabedoria.

Se identificou com alguma situação? Acha que essas dicas “choveram no molhado”? Concorda, discorda, quer complementar algo? Use os comentários.

Reflexão: quais dessas práticas você aplica no seu cotidiano profissional?

Um amigo escreveu isso há algum tempo e tive a oportunidade de reler hoje.

Sometimes things go wrong: hardware is not acting as expected, the API you rely on is not reliable, some vital information is missing. But you don’t care, as you are a hero, a tough Charles Bronson-like guy that will accomplish the mission no matter what.

Another project is saved? Maybe. But someone made a very stupid choice and will pay for it. And I’m talking about you, Bruce Lee.

In six months nobody will remember the adversities you’ve been through. The sleepless nights. The weird bugs. The managers on you back, asking for status reports every five minutes. But something will linger: your name in the source code. It will be there in the SCM, ready to prove that you are a lousy coder and committed buggy/ugly code.

So, next time you find yourself in this kind of situation, take a deep breath and raise the red flag. Share the problem. It’s not fair to chain yourself to something bad just to show that you are tough.

Eu deveria ter levado esse texto impresso para a Venezuela.

Update em 02/05:
Igor Musardo repostou esse post, e adicionou um excelente vídeo da palestra do DHH na Rails Conf 2009. Recomendo que assistam.

This is my first blog post and I decide to write in English because writing is a good way to learning and I’d like to improve my English, so post a comment if you see some grammar errors.

JRuby has helped me a lot bringing Ruby test “culture” into Java with RSpec.
In this series of blog posts I will show how I’m doing tests with Java legacy code. I will try cover topics including testing dao, service, controller and view layers.
In this part, we’re going to set up our development environment, write a RSpec example and implement with Java through JRuby. We’ll also get continuous testing running with infinity test gem.

The first thing we need is install rvm (Ruby Version Manager), JRuby and Ruby Gems.

bash << ( curl rvm.beginrescueend.com/releases/rvm-install-head )

rvm.beginrescueend.com/rvm/install/ for more info.

Install JRuby:

rvm install jruby

Set rvm to use JRuby:

rvm use jruby

Install RSpec:

gem install rspec

Once you have finish installation let’s start code with a example that expresses a form of payment orders available in Brazil called Boleto.

Create the initial project structure like this:

-boleto
  -spec
  -src
    -com
      -legacy
  -build

Open up spec/boleto_spec.rb and make it look like this:

require "date"
require "java"
java_import "com.legacy.Boleto"
 
describe Boleto do
  it "calculates due days" do
    boleto = Boleto.new
    boleto.due_date = java.util.Date.new(Date.parse("2011-01-15").ctime)
    boleto.payment_date = java.util.Date.new(Date.parse("2011-01-25").ctime)
    boleto.due_days.should == 10
  end
end

Let’s run the example and watch it fail.

jruby -J-cp build -S rspec spec/boleto_spec.rb

NameError: cannot load Java class com.legacy.Boleto

Now write just enough code to make it pass on src/com/legacy/Boleto.java like this:

package com.legacy;
import java.util.Date;
public class Boleto {
  private Date dueDate;
  private Date paymentDate;
 
  public Date getDueDate() { return this.dueDate; }
  public void setDueDate(Date dueDate) { this.dueDate = dueDate; }
  public Date getPaymentDate() { return this.paymentDate; }
  public void setPaymentDate(Date paymentDate) { this.paymentDate = paymentDate; }
  public Integer getDueDays() { return 10; }
}

Also we need to compile the java class.

javac -d build/ src/com/legacy/Boleto.java

Instead of run the example by manual command again, let’s install a continuous testing gem:

wget --no-check-certificate\

www.github.com/tomas-stefano/infinity_test/tarball/master\

 -O infinity_test.tar.gz
tar -zxvf infinity_test.tar.gz
cd tomas-stefano-infinity_test-{version}
gem build infinity_test.gemspec
gem install infinity_test-1.0.2.gem

What we have done here is install infinity_test gem that contains a path to pass arguments to specific versions of Ruby.

Let’s run the example with continuous testing gem:

infinity_test --rspec --rubies=jruby+"-J-cp build"

Now we can write a test for code on spec/boleto_spec.rb and Infinity Test automatic runs the test.
Also we can create a .infinity_test file, like this:

infinity_test do
  use :rubies => %w(jruby),
    :specific_options => {'jruby' => '-J-cp build'},
    :test_framework => :rspec
  notifications :lib_notify   # for linux / growl for mac
end

And run:

infinity_test

https://github.com/tomas-stefano/infinity_test/wiki/Customize-Infinity-Test for more info.

However, we have to compile the java classes when they change. The solution we came up with is to use editors like eclipse or eclim. This kind of editor auto-recompile Java files whenever they change.

Last notes

• I’ve posted the code for boleto here https://github.com/andref5/rspec-java
• More info about JRuby
  • https://github.com/jruby/jruby/wiki
  • pragprog.com/titles/jruby/using-jruby
• More info about RSpec
  • relishapp.com/rspec
  • kerryb.github.com/iprug-rspec-presentation
  • pragprog.com/titles/achbd/the-rspec-book
• More info about Infinity_test
  • https://github.com/tomas-stefano/infinity_test
• More info about Ruby
  • mislav.uniqpath.com/poignant-guide/book/

Em um mega resumo, trabalhando muito no Sitefique.me. Acho que este post é uma maneira de mostrar porque está difícil de postar coisas novas, e ao mesmo tempo, oferecer algum conteúdo para nossos leitores.

Hoje em dia, com frameworks “modernos”, é relativamente rápido fazer um site e colocá-lo no ar. O difícil é escrever para o seu público alvo.

Quando se faz uma gem ou lib, o seu público alvo é o desenvolvedor e isto facilita muito, pois você sabe o que ele busca e espera do seu “produto”. Agora, lançar um produto onde o público alvo é o usuário iniciante/intermediário, muda muito as coisas.

Sem entrar em mais detalhes, preparei uma compilação do que venho lendo, estudando e usando, para ajudar nesta nova jornada de montar um produto do zero. São assuntos profundos, que toco de forma superficial (ficou legal né!