Entendo a gem

Uma gem nada mais é que um arquivo .tar.gz.

$ tar -ztvf bundler-0.9.26.gem
-rw-r--r--  0 wheel  wheel   47579 Dec 31  1969 data.tar.gz
-rw-r--r--  0 wheel  wheel     993 Dec 31  1969 metadata.gz

Neste arquivo, você encontra o código Ruby propriamente dito (data.tar.gz) e os metadados (metadata.gz), que é a gem specification (ou apenas gemspec) em formato YAML. Esta gemspec informa, dentre outras coisas, qual é o nome da gem, a versão e dependências do pacote, além dos arquivos que compoem a biblioteca.

Uma gem é composta por uma estrutura mais ou menos definida de arquivos e diretórios, como você pode ver abaixo.

O diretório lib é de longe o mais importante. É nele que todo código Ruby fica armazenado. E é ele que é adicionado ao GEM_PATH, utilizado pelo RubyGems (gerenciador de pacotes) para saber quais bibliotecas estão disponíveis para uso.

O RubyGems substitui o método Kernel#require com sua própria implementação, que faz uma busca pela gem que você precisa utilizando os diretórios adicionados ao GEM_PATH. Então, sempre que você utilizar o método require "some_library", o RubyGems irá procurar por um arquivo lib/some_library.rb, independente de qual gem tenha este arquivo.

Criando a biblioteca HelloWorld

Vamos criar nossa biblioteca HelloWorld, que será empacotada posteriormente como uma gem. O primeiro passo é gerar nossa estrutura de diretórios.

$ mkdir -p hello_world/{lib/hello_world,test}

Crie um arquivo de testes em tests/hello_world_test.rb. Nosso módulo terá um único método chamado say.

require "test/unit"
 
class HelloWorldTest < Test::Unit::TestCase
  def test_say_hello_to_the_world
    assert_equal "Hello World!", HelloWorld.say
  end
end
 

Você pode executar este teste com o comando ruby test/hello_world_test.rb. Ele irá falhar, como era de se esperar.

$ ruby test/hello_world_test.rb
Loaded suite test/hello_world_test
Started
E
Finished in 0.000388 seconds.
 
  1) Error:
test_say_hello_to_the_world(HelloWorldTest):
NameError: uninitialized constant HelloWorldTest::HelloWorld
    test/hello_world_test.rb:5:in `test_say_hello_to_the_world'
 
1 tests, 0 assertions, 0 failures, 1 errors
 

Agora, crie o arquivo lib/hello_world.rb. Nossa implementação é bastante simples.

module HelloWorld
  def self.say
    "Hello World!"
  end
end

Execute o comando ruby test/hello_world_test.rb mais uma vez. Como era de se esperar, o teste irá… falhar novamente. Isso acontece porque não estamos carregando o módulo HelloWorld. Embora você possa resolver isso de várias maneiras diferentes, vamos fazer do modo mais organizado: iremos criar uma rake task para executar nossos testes, adicionando o diretório lib ao $LOAD_PATH.

Crie um arquivo Rakefile com o seguinte código:

require "rake/testtask"
 
Rake::TestTask.new do |t|
  t.libs << "lib"
  t.test_files = Dir["test/**/*_test.rb"]
end

Altere o arquivo test/hello_world_test.rb, adicionando a linha que irá carregar o arquivo hello_world.rb.

require "test/unit"
require "hello_world"  # Added
 
class HelloWorldTest < Test::Unit::TestCase
  def test_say_hello_to_the_world
    assert_equal "Hello World!", HelloWorld.say
  end
end

Rode o teste mais uma vez, só que agora usando o comando rake test.

$ rake test
(in /Users/fnando/Sites/github/hello_world)
Loaded suite /Users/fnando/.gem/spaces/active/gems/rake-0.8.7/lib/rake/rake_test_loader
Started
.
Finished in 0.00031 seconds.
 
1 tests, 1 assertions, 0 failures, 0 errors

Ótimo! Nossos testes estão passando e como terminamos toda nossa implementação, já podemos criar e distribuir nossa gem.

Gerando nosso pacote

Para gerar um arquivo .gem, precisamos escrever nossa gemspec. Crie um arquivo hello_world.gemspec e adicione o código abaixo.

Gem::Specification.new do |s|
  s.name        = "hello_world"
  s.version     = "0.1.0"
  s.description = "A simple gem that says hello to the world!"
  s.summary     = "Say hello!"
  s.author      = "Nando Vieira"
  s.files       = Dir["{lib/**/*.rb,README.rdoc,test/**/*.rb,Rakefile,*.gemspec}"]
end

As opções da classe Gem::Specification são auto-descritivas; para saber mais sobre estas e outras opções, consulte a documentação.

Agora vem a parte mais fácil. Execute o comando gem build hello_world.gemspec e um arquivo hello_world-0.1.0.gem será gerado.

Você pode instalar este arquivo localmente utilizando o comando gem install hello_world-0.1.0.gem --local. Para listar o que foi instalado, execute gem contents hello_world.

$ gem contents hello_world
/Users/fnando/.gem/spaces/active/gems/hello_world-1.0/lib/hello_world/version.rb
/Users/fnando/.gem/spaces/active/gems/hello_world-1.0/lib/hello_world.rb
/Users/fnando/.gem/spaces/active/gems/hello_world-1.0/README.rdoc
/Users/fnando/.gem/spaces/active/gems/hello_world-1.0/test/hello_world_test.rb
/Users/fnando/.gem/spaces/active/gems/hello_world-1.0/Rakefile
/Users/fnando/.gem/spaces/active/gems/hello_world-1.0/hello_world.gemspec

E, claro, nossa gem também será listada com o comando gem list.

$ gem list hello_world -d
 
*** LOCAL GEMS ***
 
hello_world (1.0)
    Author: Nando Vieira
    Installed at: /Users/fnando/.gem/spaces/active
 
    Say hello!

Distribuindo nossa gem

Para distribuir sua gem, é preciso criar uma conta no site RubyGems.org.

Depois, basta executar gem push hello_world-0.1.0.gem; informe seu e-mail e senha cadastrados no RubyGems.org quando solicitado. Se tudo der certo, você verá uma mensagem como esta:

$ gem push hello_world-0.1.0.gem
Pushing gem to RubyGems.org...
Successfully registered gem: hello_world (0.1.0)

Você pode acessar sua gem em http://rubygems.org/gems/hello_world.

DICA: Antes de escrever sua gem, verifique se o nome está disponível. Um simples gem list nome_da_gem -rd já te dará a resposta. A gem hello_world já existia, por isso foi publicada como http://rubygems.org/gems/fnando-hello_world.

Versionamento dos pacotes

É sua responsabilidade definir como será o versionamento de sua gem. Eu utilizo o formato MAJOR.MINOR.PATCH, como em 1.2.3.

• MAJOR: inclui alterações de API e pode quebrar compatibilidade com versões anteriores
• MINOR: inclui novas funcionalidades ou pouca alteração de API
• PATCH: corrige bugs ou traz melhorias em implementações já existentes

No arquivo lib/hello_world/version.rb você pode ter algo como:

module HelloWorld
  module Version
    MAJOR = 0
    MINOR = 1
    PATCH = 0
    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
  end
end

E para finalizar…

Gems como Jeweler (que sempre uso) também podem ajudar na hora de criar, distribuir e manter suas bibliotecas. Mas antes de utilizar uma dessas bibliotecas, entender o processo de criação de gems é fundamental. Afinal, é fazendo que se aprende!

Em muitos projetos, é importante que o usuário informe senhas que tenham um mínimo de complexidade, evitando que sejam facilmente quebradas. Existem muitas soluções feitas em JavaScript, mas não encontrei nenhuma que fosse boa o bastante no backend.

Pensando nisso, criei uma gem chamada Password Strength que faz validação de diversos padrões, a fim de identificar senhas que sejam fracas. Ela é composta por 2 módulos: ActiveRecord e JavaScript.

A validação da senha é feita com base nas seguintes regras:

• Tamanho da senha
• Presença de letras, números e caracteres especiais
• Presença de maiúsculas e minúsculas
• Uso do login/e-mail na composição da senha
• Sequências (123, abc, aaa)
• Repetições

Cada uma dessas regras recebe uma pontuação negativa ou positiva, que irá influenciar no resultado final. Assim, com base nessas regras, podemos classificar as seguintes senhas:

• 123 => fraca
• 123abc => fraca
• aaaaaa => fraca
• myPass145 => boa
• myPass145$ => forte

Instalação

Para instalar, basta executar o comando

sudo gem install password_strength

Agora, configure seu aplicativo para carregá-la. No Rails 2, basta adicionar a linha abaixo ao seu arquivo environment.rb.

config.gem "password_strength"

No Rails 3, adicione a linha abaixo ao arquivo Gemfile.

gem "password_strength"

Se quiser usar o plugin para jQuery, você também precisará dos arquivos password_strength.js e jquery.strength.js.

Usando na prática

O Password Strength permite que você valide senhas sem a necessidade de usar o ActiveRecord.

strength = PasswordStrength.test("johndoe", "mypass")
#=> return an object
 
strength.good?
#=> status == :good
 
strength.weak?
#=> status == :weak
 
strength.strong?
#=> status == :strong
 
strength.status
#=> can be :weak, :good, :strong
 
strength.valid?(:strong)
#=> status == :strong
 
strength.valid?(:good)
#=> [:good, :strong].include?(status)

Muito simples!

ActiveRecord

O Password Strength possui suporte para ActiveRecord 2.3+ (foi testado em 2.3.5 e 3.0.0-beta).

No seu modelo, adicione a validação validates_strength_of.

class User < ActiveRecord::Base
  validates_strength_of :password
end

Por padrão, as opções serão :level => :good, :with => :username. A opção :level define a complexidade mínima requerida e pode ser :good, :strong ou :weak (é desnecessário dizer que a última opção não faz o menor sentido, já que qualquer senha será aceita). Já a opção :with define qual o atributo que deverá ser usado na comparação da senha. Se quiser, pode definir um outro atributo:

validates_strength_of :password, :with => :email

Também é possível proibir senhas que usem determinados caracteres por completo com a opção :exclude. Podemos, por exemplo, evitar que senhas contendo a string asdf sejam usadas:

validates_strength_of :password, :exclude => /asdf/i

Alternativamente, você pode definir uma lista de strings que não devem ser utilizadas:

validates_strength_of :password, :exclude => %w[ asdf qwert zxcv ]

JavaScript

No HTML, adicione os arquivos que você baixou.

<script src="jquery-1.4.2.js" type="text/javascript"></script>
<script src="password_strength.js" type="text/javascript"></script>
<script src="jquery.strength.js" type="text/javascript"></script>

Se você não usa jQuery, pode usar apenas o arquivo password_strength.js e criar o seu próprio adaptador.

A API do JavaScript é essencialmente a mesma, inclusive com as mesmas regras de verificação. Veja:

var strength = PasswordStrength.test("johndoe", "mypass");
strength.isGood();
strength.isStrong();
strength.isWeak();
strength.isValid("good");

Você também pode usar a opção :exclude mas, no momento, apenas expressões regulares são aceitas.

var strength = PasswordStrength.test("johndoe", "password with whitespaces", {exclude: /\s/});
strength.isInvalid();

Se você usa jQuery, pode utilizar o plugin que já vem com o Password Strength.

$.strength("#username", "#password");

A definição acima irá utilizar o campo #username e #password para fazer a validação da senha. Conforme a senha é digitada, uma imagem é colocada ao lado do campo de senha. Por padrão, as imagens utilizadas são /images/{weak,good,strong}.png. Se você quiser, pode alterar esses caminhos:

$.strength.weakImage = "/weak.png";
$.strength.goodImage = "/good.png";
$.strength.strongImage = "/strong.png";

Você também pode sobrescrever o callback padrão.

$.strength("#username", "#password", function(username, password, strength){
	// do whatever you want
});

Se você quiser sobrescrever o callback globalmente, pode fazê-lo da seguinte maneira:

$.strength.callback = function(username, password, strength) {
	// do whatever you want
};

Qualquer dúvida, mande um comentário!

Para dar sua sugestão, crítica ou mesmo avisar de alguma coisa que esteja quebrada, envie um comentário!

Para utilizá-lo, copie-o para sua $HOME.

$ wget http://github.com/fnando/dotfiles/raw/master/gem_completion.sh -O ~/.gem_completion.sh

Adicione-o ao seu arquivo de profile do terminal (~/.bashrc, ~/.bash_profile, ~/.profile, etc).

source ~/.gem_completion.sh

No vídeo abaixo você pode conferir como ficou!

Se o vídeo acima NÃO APARECE, acesse o link diretamente: irb-tweaks.mov.

Também fiz outros tweaks no IRB. Note que o output utiliza o Awesome Print. Particularmente, achei muito melhor que o Hirb. Além disso, exibo a versão do Ruby e qual ambiente do Rails está sendo utilizado.

Eu estava tendo problemas com o Wirble, principalmente na parte de histórico de comandos que nunca funcionou como deveria. Eu criei minha própria versão que, até agora, funciona muito bem!

Se você gostou do meu terminal, dê uma olhada nos links abaixo, pois tem bastante coisa legal!

• http://github.com/fnando/dotfiles/
• http://github.com/fnando/gem-open
• http://github.com/fnando/gemspace
• http://simplesideias.com.br/configurando-o-terminal-no-mac-os-x/

Ele foi feito com Sinatra, ActiveRecord e Hpricot, e está rodando na Dreamhost, em Passenger.

Você pode acessar o Tracker na URL tracker.simplesideias.com.br.

Deixe sua sugestão ou crítica nos comentários.

UPDATE: Agora todas as plataformas são indexadas. Também adicionei filtros por console, ordenação e notificação no Twitter de jogos que você se interessar!

sudo gem install ruby-debug19

Seu uso continua o mesmo. Você chama o método debugger e o interpretador abrirá um prompt onde você pode inspecionar aquele trecho de código, listar variáveis e tudo mais.

Para utilizá-lo no Rails 3.0, que ainda está em versão beta, você precisa adicionar a seguinte regra ao seu arquivo Gemfile.

gem "ruby-debug19"

Simples assim!

E está no ar mais um PDF da série HOWTO, desta vez abordando o RDoc, marcação de documentação para códigos escritos em Ruby.

O RDoc é utilizado por quase todos os grandes projetos como Ruby on Rails e RSpec, dentre muitos outros.

Este guia de 17 páginas mostra como utilizar o RDoc, com muitos exemplos de formatação.

O PDF é gratuito pode ser baixado em http://howtocode.com.br/documentando-projetos-com-rdoc.

Não perca tempo e baixe já a sua cópia!

A primeira coisa que você precisa fazer é instalar a gem.

sudo gem install recurrence

Depois, basta adicionar à biblioteca.

require "rubygems"
require "recurrence"

A maneira mais simples de usar é instanciar um objeto através dos métodos de classe daily, weekly, monthly e yearly, que permitem criar eventos diários, semanais, mensais e anuais, respectivamente.

r = Recurrence.daily

Para retornar a próxima data, você deve utilizar o método Recurrence#next.

r.next
#=> Fri, 18 Dec 2009
 
r.next
#=> Fri, 18 Dec 2009

Você também pode utilizar o método Recurrence#next!, que altera a variável interna de data, como mostra o exemplo abaixo.

r.next!
#=> Fri, 18 Dec 2009
 
r.next!
#=> Sat, 19 Dec 2009

Se você quiser, pode especificar o intervalo de dias que o evento pode se repetir; basta utilizar a opção :starts e :ends.

# define the starting date to 2009-12-24
r = Recurrence.daily(:starts => Date.new(2009, 12, 24))
 
# define the ending date to 2009-12-31
r = Recurrence.daily(:ends => Date.new(2009, 12, 31))

Você também pode passar essas datas como strings, desde que elas sejam interpretadas pelo método Date#parse.

r = Recurrence.daily(:starts => "2009-12-24")

Os atalhos são uma excelente maneira de tornar o código mais semântico, mas em alguns casos é melhor seguir com o bom e velho método new.

r = Recurrence.new(:every => :week, :on => :saturday, :interval => 2)

Como você pode ver no exemplo acima, estamos criando um evento semanal, que acontece aos sábados, a cada duas semanas. Ao utilizar o método Recurrence#next! você terá algo como isso:

r.next!
#=> Sat, 19 Dec 2009
 
r.next!
#=> Sat, 02 Jan 2010

Você também pode especificar uma lista com os dias da semana que o evento deve ocorrer.

r = Recurrence.weekly(:on => [:saturday, :sunday])
 
r.next!
#=> Sat, 19 Dec 2009
 
r.next!
#=> Sun, 20 Dec 2009
 
r.next!
#=> Sat, 26 Dec 2009

Para acessar uma lista com todos os eventos disponíveis, basta utilizar o método Recurrence#events.

r.events
#=> [Sun, 20 Dec 2009, Sun, 27 Dec 2009]

Esse método fará irá guardar a lista de datas geradas, aumentando a performance se ele for acessado mais de uma vez. Se você quiser regerar essas datas, pode utilizar o método Recurrence#events!.

Também é possível verificar se uma data está no intervalo especificado no objeto Recurrence.

r = Recurrence.weekly(:on => :saturday)
 
r.include? "2009-12-19"
#=> true

Como usar na prática

Como você pode ver, o Recurrence é totalmente parametrizado. Essa abordagem permite que você armazene os itens necessários para montar sua recorrência em um banco de dados, por exemplo. Digamos que você tenha um modelo Event, com o seguinte schema:

class CreateEvents < ActiveRecord::Migration
  def self.up
    create_table :events do |t|
      t.string :title,        :null => false
      t.binary :meta,         :null => false
      t.date   :scheduled_to, :null => false
    end
  end
end

Os atributos que serão utilizados no Recurrence são :meta e :scheduled_to. O primeiro irá armazenar o tipo de recorrência e as informações como dia, intervalo, etc. Já o segundo, irá armazenar a próxima data do evento, para diminuir a geração de datas. O modelo Event pode armazenar os atributos como este exemplo:

class Event < ActiveRecord::Base
  serialize :meta, Hash
 
  validates_presence_of :meta, :title, :scheduled_to
end

Veja um exemplo de como cadastrar um evento "Pagamento", que acontece todo mês no dia 5.

options = {:every => :month, :on => 5}
r = Recurrence.new(options)
 
event = Event.new(:title => "Pagamento", :meta => options, :scheduled_to => r.next)
event.save!

Na hora de montar o objeto de recorrência, você pode utilizar algo como isto:

event = Event.first
 
r = Recurrence.new(event.meta.merge(:starts => event.scheduled_to))
r.next
#=> Tue, 05 Jan 2010

Se você precisar exibir um evento mais de uma vez, utilize este mesmo processo e exiba os eventos com o método events.

Finalizando

Criar eventos recorrentes nem sempre é uma tarefa simples, principalmente no que diz respeito à performance. O José Valim fez uma série de contribuições que ajudaram a melhor esse ponto, além de outras funcionalidades como os atalhos.

Para conhecer mais sobre as opções disponíveis do Recurrence, acesse o README do projeto no Github.

Subject

O RSpec possui um método muito útil chamado subject, que retorna uma instância da classe que está sendo utilizada como contexto do exemplo.

describe User do
  it { should_not be_admin }
end

A grande vantagem desta abordagem é que você aumenta consideravelmente a legibilidade de suas especificações. Mas você não precisa utilizar apenas o contexto especificado no método describe; se quiser, você pode definir o seu próprio!

describe User do
  subject { User.new(:admin => true) }
  it { should be_admin }
end

Quando outros tipos de objetos (como módulos ou strings) são passados ao método describe, ele irá retornar o próprio objeto.

Message expectation

O método stub_chain

Sempre que você precisar fazer uma chamada encadeada e quiser verificar o último valor, utilize o método stub_chain. Ele permite transformar um bloco como este

describe "Mocks" do
  before do
    @user = mock()
    @things = mock()
    @recent = mock()
 
    @user.stub!(:things).and_return(@things)
    @things.stub!(:recent).and_return(@recent)
    @recent.should_receive(:count).and_return(100)
  end
 
  it "should return the recent things count from an user" do
    @user.things.recent.count.should == 100
  end
end

em uma coisa bem mais simples como esta

describe "Mocks" do
  before do
    @user = mock()
    @user.stub_chain(:things, :recent, :count).and_return(100)
  end
 
  it "should return the recent things count from an user" do
    @user.things.recent.count.should == 100
  end
end

O método and_return

Você alguma vez precisou acessar um stub mais de uma vez e queria que ele retornasse diferentes valores em cada chamada? Veja este exemplo.

require "open-uri"
 
class Dice
  API_URL = "http://www.random.org/integers/?num=1&min=1&max=6&col=1&base=10&format=plain&rnd=new"
 
  def roll
    open(API_URL).to_i
  end
end

Toda vez que o método roll for chamado, ele irá fazer uma requisição diferente ao http://random.org. Imagine que por algum motivo você precisasse retornar diferentes valores toda vez que o método open você invocado. Tudo o que você precisa fazer é retornar mais de um valor com o método and_return.

describe Dice do
  before do
    subject.should_receive(:open).and_return("1", "4", "2")
  end
 
  it "should not cache request" do
    subject.roll.should == 1
    subject.roll.should == 4
    subject.roll.should == 2
  end
end

O método with

O RSpec disponibiliza uma série de métodos que podem ser usados em conjunto com o método with. Veja alguns exemplos:

module Echo
  extend self
 
  def echo(*args)
    args.inspect
  end
end
 
describe Echo do
  # with any kind of argument
  specify("anything") {
    subject.should_receive(:echo).with(anything)
    subject.echo(1)
  }
 
  # with hash containing values
  specify("hash_including") {
    subject.should_receive(:echo).with(hash_including(:say => "hello"))
    subject.echo(:say => "hello")
  }
 
  # with an instance of String
  specify("instance_of") {
    subject.should_receive(:echo).with(instance_of(String))
    subject.echo("hello")
  }
 
  # with an object that responds to some methods
  specify("duck_type") {
    subject.should_receive(:echo).twice.with(duck_type(:<<))
    subject.echo(Array.new)
    subject.echo(String.new)
  }
end

Para ver mais exemplos, acesse https://gist.github.com/45b97f90a83c8acf3f29.

before e after globais

Muitas vezes precisamos preparar nosso ambiente antes de executarmos nossos testes. Quando isso precisa ser feito em mais de uma especificação, você pode diminuir a duplicação de código utilizando blocos globais.

No seu arquivo spec_helper.rb, você pode utilizar os métodos append_before, append_after, prepend_before e prepend_after.

Spec::Runner.configure do |config|
  config.prepend_after { `rm -rf some/path` }
end

Pending

Em vez de comentar temporariamente exemplos que você não quer que sejam executados, você pode utilizar o método pending. O método pending pode ser utilizado nos blocos de before. Assim, todos os exemplos daquele contexto de describe serão automaticamente marcados como pendente.

describe "Pending examples" do
  before do
    pending
  end
 
  # lots of examples
end

Você também pode deixar apenas um exemplo pendente.

describe "Pending examples" do
  it "should be pending" do
    pending "need to work on it"
    Env.setup!
  end
end

Ou apenas uma parte dele.

describe "Pending examples" do
  it "should be pending with a block" do
    pending("need to working on it as well") do
      Env.setup!
    end
  end
end

Uma outra alternativa (que não é deixar como pendente mas sim desabilitado) é utilizar o método xit em vez de it.

describe "Pending examples" do
  xit "should be pending with alias" do
    Env.setup!
  end
end

Matchers personalizados

Sempre que você perceber que está repetindo um padrão na hora de escrever seus exemplos, automatize o processo criando novos matchers. O RSpec possui duas maneiras diferentes de fazer isso. A mais simples delas é utilizando o método simple_matcher. Crie um módulo chamado TheAnswerMatchers para adicionarmos novos matchers.

module TheAnswerMatchers
  def be_the_answer
    simple_matcher do |given, matcher|
      # save some typing
      the_answer = "the Answer to Life, the Universe, and Everything"
 
      matcher.description = "be #{the_answer}"
      matcher.failure_message = "expected #{given.inspect} to be #{the_answer}"
      matcher.negative_failure_message = "expected #{given.inspect} not to be #{the_answer}"
      given == 42
    end
  end
end

Agora, basta fazer com que o RSpec reconheça esses novos matchers; é só incluir o módulo.

Spec::Runner.configure do |config|
  config.include TheAnswerMatchers
end

E para escrever seus exemplos, você pode usar o matcher be_the_answer:

describe "The Answer to Life, the Universe, and Everything" do
  specify { 42.should be_the_answer }
  specify { "the wrong answer".should_not be_the_answer }
end

Finalizando…

Como você pode perceber, é bem simples escrever exemplos melhores no RSpec. Se você olhar as specs do RSpec, encontrará bastante coisa legal que você normalmente não veria (porque tem muita coisa para ler) no RDocs.

E você, tem alguma dica para compartilhar?

Se você não pode comparacer, pode ver os slides

Gostaria de agradecer aos comentários positivos e, principalmente, aos organizadores. Keep on rockin'!