Arquivo

Textos com Etiquetas ‘Ruby on Rails’

Obtendo dados originais de atributos modificados no ActiveRecord

22 de outubro de 2010

Como todo bom framework de Mapeamento Objeto-Relacional (ORM), o ActiveRecord do Ruby on Rails mantém os dados originais dos atributos que são alterados. Com isso, você obter esses valores antes de salvar os novos.

Vamos ver alguns métodos que lhe ajudam a saber quais atributos foram alterados, bem como seus valores novos e originais.

Como exemplo usaremos um classe de modelo chamada Order com os seguintes atributos:

Imaginando que já temos pedidos cadastrados no banco de dados, através do console, vamos recuperar um pedido e atribuí-lo a uma variável chamada order:
> order = Order.first
=> #<Order id: 8567520, user_id: 506715721, number: "R222442710", total: #<BigDecimal:4607440,'0.3498E2',8(8)>, state: "new", completed_at: "2010-08-07 17:24:37">
> y order
--- !ruby/object:Order
attributes:
id: "8567520"
number: R222442710
total: "34.98"
state: new
completed_at: 2010-08-07 17:24:37
user_id: "506715721"
attributes_cache: {}
=> nil

Através do método changed?, sabemos se houve alguma modificação nessa instância de Order:
> order.changed?
=> false

Vamos modificar os atributos number e state:
> order.number = "NEW012345"
=> "NEW012345"
> order.state = "in_progress"
=> "in_progress"
> order.changed?
=> true

Agora o método changed? retorna true, mas não informa quais atributos foram alterados. Para obter uma lista de todos atributos alterados, seus valores originais e seus valores novos, usamos o método changes:
> order.changes
=> {"number"=>["R222442710", "NEW012345"], “state”=>["new", "in_progress"]}

O retorno é um hash onde as chaves são o nome dos atributos alterados e os valores são um array com dois itens: o valor original do atributo e o novo valor do atributo.

Por exemplo, você poderia fazer isso para recuperar o valor original do atributo state:
> order.changes["state"][0]
=> “new”

Existe também o método privado changed_attributes que retorna uma hash contendo somente os valores originais dos atributos modificados. Temos acesso a ele usamos o método Object#send:
> order.send :changed_attributes
=> {"number"=>"R222442710", "state"=>"new"}

E o método (também privado) attribute_was, que recebe como parâmetro o nome de um atributo como string:
> order.send :attribute_was, "state"
=> "new"

Então agora você está pensando em tornar esse último método público? Esqueça! O ActiveRecord já fez melhor.

O módulo ActiveRecord::AttributesMethods declara para cada atributo do modelo os métodos existentes na classe em que seu nome se inicia com “attribute”. Vamos listar os métodos privados da nossa instância da classe Order que atendem esse padrão:
> y order.private_methods.grep /^attribute_/
---
- attribute_change
- attribute_before_type_cast
- attribute_changed?
- attribute_was
- attribute_will_change!
=> nil

Para cada método acima, existe seu correspondente por atributo no modelo. Basta substituir “attribute” pelo nome do atributo. Veja os exemplos com o atributo state na classe Order:
> order.state
=> "in_progress"
> order.state_changed?
=> true
> order.state_change
=> ["new", "in_progress"]
> order.state_was
=> “new”

Você pode criar novos métodos que ficam disponíveis para todos os atributos. Basta registrar o sufixo do método na classe modelo usando o método de classe attribute_method_suffix e criar um método privado com o padrão attribute_[sufixo] que recebe como parâmetro o nome do atributo.

Com um exemplo fica mais fácil de entender:

class Order < ActiveRecord::Base
  attribute_method_suffix "_cool?"

  private
  def attribute_cool?(attr)
    puts "Yes, #{attr} with value #{read_attribute(attr)} is cool!"
  end
end

> order.total_cool?
Yes, total with value 34.98 is cool!
=> nil

No final das contas, o que você precisa fazer para obter o valor original de um atributo modificado é chamar o método [nome_do_atributo]_was:
> order.number_was
=> "R222442710"
> order.state_was
=> "new"

Lembrando que depois que salvamos as alterações no banco de dados, todo esse estado de alterações é removido:
> order.save
=> true
> order.changed?
=> false
> order.changes
=> {}

Ruby , , , ,

Usando o Passenger 3.0 em modo standalone em aplicações Rails

19 de outubro de 2010

O Phusion Passenger é um módulo para os servidores Apache e Nginx para rodar aplicações Web Ruby, como por exemplo aplicações Ruby on Rails.

Ontem foi lançada a sua versão 3.0 do Passenger e entre as novidades está o Phusion Passenger Standalone (também chamado de Phusion Passenger Lite) que pode ser utilizado em ambiente de desenvolvimento, ao invés do Mongrel ou WEBrick.

O processo de instalar e subir o Passenger em teoria é simples, mas tive que instalar algumas dependências no meu Mac OS X para poder utilizá-lo. Abaixo listo os passos que percorri na minha instalação.

Primeiro de tudo, instalei a gem do Passenger:

$ gem install passenger

Successfully installed daemon_controller-0.2.5
Successfully installed spruz-0.1.5
Successfully installed file-tail-1.0.5
Successfully installed passenger-3.0.0
4 gems installed

Depois, todo feliz, fui iniciar o Passenger:

$ passenger start

Recebi as seguintes mensagens dizendo para atualizar a RVM:

Nginx core 0.8.52 isn’t installed

Phusion Passenger Standalone will automatically install it into:

/Users/Prodis/.passenger/standalone/3.0.0-i386-ruby1.8.7-x86_64-macosx-10.5/nginx-0.8.52

This will only be done once. Please sit back and relax while installation is
in progress.

Checking for required software…

* GNU C++ compiler… found at /usr/bin/g++
* GNU make… found at /usr/bin/make
* A download tool like ‘wget’ or ‘curl’… found at /opt/local/bin/curl
* Ruby development headers… found
* OpenSSL support for Ruby… found
* RubyGems… found
Your RVM wrapper scripts are too old. Please update them first by running ‘rvm update –head && rvm reload && rvm repair all’.

Então eu atualizei a RVM:

$ rvm update --head && rvm reload && rvm repair all

E tentei de subir o Passenger de novo:

$ passenger start

E aí obtive essas mensagens indicando que eu não tinha Curl com suporte a SSL:

Nginx core 0.8.52 isn’t installed

Phusion Passenger Standalone will automatically install it into:

/Users/Prodis/.passenger/standalone/3.0.0-i386-ruby1.8.7-x86_64-macosx-10.5/nginx-0.8.52

This will only be done once. Please sit back and relax while installation is
in progress.

Checking for required software…

* GNU C++ compiler… found at /usr/bin/g++
* GNU make… found at /usr/bin/make
* A download tool like ‘wget’ or ‘curl’… found at /opt/local/bin/curl
* Ruby development headers… found
* OpenSSL support for Ruby… found
* RubyGems… found
* Rake… found at /Users/Prodis/.rvm/wrappers/ree-1.8.7-2009.10/rake
* rack… found
* Curl development headers with SSL support… not found
* OpenSSL development headers… found
* Zlib development headers… found
* file-tail… found
* daemon_controller >= 0.2.5… found

Some required software is not installed.
But don’t worry, this installer will tell you how to install them.

Press Enter to continue, or Ctrl-C to abort.

——————————————–

Installation instructions for required software

* To install Curl development headers with SSL support:
Curl was found, but it doesn’t support SSL.
Please download Curl from http://curl.haxx.se/libcurl and make sure you install it with SSL support.

If the aforementioned instructions didn’t solve your problem, then please take
a look at the Users Guide:

/Users/Prodis/.rvm/gems/ree-1.8.7-2009.10/gems/passenger-3.0.0/doc/Users guide Standalone.html

Fui até a URL indicada, entrei na página de downloads do Curl e baixei o arquivo curl-7.21.2.zip. Descompactei o arquivo zipado e instalei o Curl com os seguintes comandos:

$ ./configure --with-ssl

$ make

$ sudo make install

Mais uma vez executei o comando para iniciar o Passenger:

$ passenger start

E dessa vez o Nginx foi instalado:

Nginx core 0.8.52 isn’t installed

Phusion Passenger Standalone will automatically install it into:

/Users/Prodis/.passenger/standalone/3.0.0-i386-ruby1.8.7-x86_64-macosx-10.5/nginx-0.8.52

This will only be done once. Please sit back and relax while installation is
in progress.

Checking for required software…

* GNU C++ compiler… found at /usr/bin/g++
* GNU make… found at /usr/bin/make
* A download tool like ‘wget’ or ‘curl’… found at /usr/local/bin/curl
* Ruby development headers… found
* OpenSSL support for Ruby… found
* RubyGems… found
* Rake… found at /Users/Prodis/.rvm/wrappers/ree-1.8.7-2009.10/rake
* rack… found
* Curl development headers with SSL support… found
* OpenSSL development headers… found
* Zlib development headers… found
* file-tail… found
* daemon_controller >= 0.2.5… found

Downloading Nginx…
# curl http://sysoev.ru/nginx/nginx-0.8.52.tar.gz -f -L -o /tmp/Prodis-passenger-standalone-28027/nginx-0.8.52.tar.gz
Installing Phusion Passenger Standalone…
[*********************************************] Copying files… -
All done!

E finalmente consegui subir o Passenger em modo standalone:

$ passenger start

=============== Phusion Passenger Standalone web server started ===============
PID file: /Users/Prodis/Lab/quick-todo/tmp/pids/passenger.3000.pid
Log file: /Users/Prodis/Lab/quick-todo/log/passenger.3000.log
Environment: development
Accessible via: http://0.0.0.0:3000/

You can stop Phusion Passenger Standalone by pressing Ctrl-C.
===============================================================================

Note que para usar o Passenger não utilizamos mais script/server ou rails server, somente o comando passenger start na raiz da aplicação Rails.

Uma coisa interessante do Phusion Passenger Standalone é que você não precisa iniciá-lo a partir da aplicação. Você pode passar como parâmetro para o comando start o caminho da sua aplicação Rails:

Prodis ~/Downloads [ree-1.8.7] $ passenger start ~/Lab/webstore/ -p 3001

=============== Phusion Passenger Standalone web server started ===============
PID file: /Users/Prodis/Lab/webstore/passenger.3001.pid
Log file: /Users/Prodis/Lab/webstore/passenger.3001.log
Environment: development
Accessible via: http://0.0.0.0:3001/

You can stop Phusion Passenger Standalone by pressing Ctrl-C.
===============================================================================

Note que eu passei também no parâmetro -p a porta em que eu quero minha aplicação fique disponível.

Para a lista completa os parâmetros do comando start do Passenger, use o help:

$ passenger start --help

Ruby , , , , , ,

Use o método tap ao invés de returning

4 de outubro de 2010

Há um tempo atrás eu falei neste post sobre o método returning em Ruby on Rails e como ele facilita a criação de uma variável já atribuindo valores a ela.

A partir da versão 2.3.9 do Ruby on Rails, o método returning da classe Object se tornou obsoleto. Seu uso irá gerar um alerta informando para usar o método tap, nativo da classe Object no Ruby, no seu lugar:

DEPRECATION WARNING: Object#returning has been deprecated in favor of Object#tap.

O intuito dessa alerta é facilitar a migração de uma aplicação Rails 2.3.9 para a nova versão 3.0, já que nessa última versão do Rails o método returning foi removido.

Vamos ver os mesmos exemplos do post anterior, agora utilizando Object#tap.

Primeiro, um exemplo criando uma variável normalmente, atribuindo valores a ela e depois retornando-a como resultado de um método:

def some_values
  values = []
  values << "first element"
  values << "second element"
  values
end

some_values # => ["first element", "second element"]

E agora usando o método tap:

def some_values
  [].tap do |values|
    values << "first element"
    values << "second element"
  end
end

some_values # => ["first element", "second element"]

E um exemplo de um método auxiliar para testes de RSpec retirado de uma aplicação real:

def variants
  [].tap do |variants|
    5.times do |priority| do
      variants << Factory.build(:variant, :priority => priority)
    end
  end
end

Ruby , , , ,

Múltiplos construtores em Ruby (minha versão)

10 de setembro de 2010

Ontem, através de uma mensagem no Twitter do André Moreira, estava lendo um post no blog do Rinaldi Fonseca falando sobre múltiplos construtores em Ruby. Comecei a escrever um comentário, que acabou se tornando muito grande. Então achei melhor escrever aqui para expressar minha opinião a respeito.

Na primeira parte do post é mostrado a utilização de métodos de classe para construir um novo objeto passando parâmetros diferentes dos recebidos no construtor, onde foi usado esse exemplo:

class Carro
  attr_accessor :marca, :placa, :dono

  def initialize(marca, placa, dono)
    @marca, @placa, @dono =  marca, placa, dono
  end

  def Carro.carro_sem_dono(marca, placa)
    new marca, placa, "SEM DONO"
  end

  def Carro.carro_sem_placa(marca, dono)
    new marca, "SEM PLACA", dono
  end
end

carro = Carro.new "Ferrari", "ABC1234", "João"
carro_sem_dono  = Carro.carro_sem_dono "Vectra", "ABC5678"
carro_sem_placa = Carro.carro_sem_placa "Palio", "José"

puts carro.inspect           #<Carro: @dono="João", @placa="ABC1234", @marca="Ferrari">
puts carro_sem_dono.inspect  #<Carro: @dono="SEM DONO", @placa="ABC5678", @marca="Vectra">
puts carro_sem_placa.inspect #<Carro: @dono="José", @placa="SEM PLACA", @marca="Palio">

Os métodos carro_sem_dono e carro_sem_placa seguem o Factory Method Design Pattern (Padrão de Projeto Método Fábrica) e atuam como uma DSL na classe Carro. Desse modo, não há necessidade da redundância do nome da classe no ínicio de cada método fábrica:

class Carro
  attr_accessor :marca, :placa, :dono

  def initialize(marca, placa, dono)
    @marca, @placa, @dono =  marca, placa, dono
  end

  def self.sem_dono(marca, placa)
    new marca, placa, "SEM DONO"
  end

  def self.sem_placa(marca, dono)
    new marca, "SEM PLACA", dono
  end
end

carro = Carro.new "Ferrari", "ABC1234", "João"
carro_sem_dono  = Carro.sem_dono "Vectra", "ABC5678"
carro_sem_placa = Carro.sem_placa "Palio", "José"

puts carro.inspect           #<Carro: @dono="João", @placa="ABC1234", @marca="Ferrari">
puts carro_sem_dono.inspect  #<Carro: @dono="SEM DONO", @placa="ABC5678", @marca="Vectra">
puts carro_sem_placa.inspect #<Carro: @dono="José", @placa="SEM PLACA", @marca="Palio">

Já na segunda parte do post é mostrada uma maneira de se passar um bloco para o construtor da classe Carro e assim inicializar seus atributos:

class Carro
  attr_accessor :ano, :marca, :modelo, :dono, :cor, :tipo

  def initialize(&block)
    instance_eval &block
  end
end

carro = Carro.new do
  self.ano    = "2000"
  self.marca  = "Gol"
  self.modelo = "Exemplo"
  self.dono   = "Dono exemplo"
  self.cor    = "Vermelho"
  self.tipo   = "Tipo exemplo"
end

puts carro.inspect #<Carro: @ano="2000", @marca="Gol", @modelo="Exemplo", @dono="Dono exemplo", @cor="Vermelho", @tipo="Tipo exemplo">

Eu particularmente gosto do tipo de inicialização de atributos de um novo objeto permitada nas classes da camada Model de Ruby on Rails. O método new dessas classes (que herdam de ActiveRecord::Base) podem receber tanto um hash quanto um bloco com os valores dos atributos. Dessa maneira, a classe Carro poderia ser inicializada assim:

carro = Carro.new :ano => "2000",
                   :marca => "Gol",
                   :modelo => "Exemplo",
                   :dono => "Dono exemplo",
                   :cor => "Vermelho",
                   :tipo => "Tipo exemplo"

#ArgumentError: wrong number of arguments (1 for 0)

Eu disse poderia. Não pode, pois o construtor new espera um bloco e não um hash, e Carro não é uma classe Model do Rails.

Para solucionar isso, podemos modificar o construtor da classe Carro para receber um hash de atributos ao invés de um bloco. Então atribuímos cada valor presente no hash para seu respectivo atributo:

class Carro
  attr_accessor :ano, :marca, :modelo, :dono, :cor, :tipo

  def initialize(attributes = nil)
    attributes.each do |attr, value|
      self.send("#{attr}=", value)
    end unless attributes.nil?
  end
end

carro = Carro.new :ano => "2000",
                   :marca => "Gol",
                   :modelo => "Exemplo",
                   :dono => "Dono exemplo",
                   :cor => "Vermelho",
                   :tipo => "Tipo exemplo"

puts carro.inspect #<Carro: @ano="2000", @marca="Gol", @modelo="Exemplo", @dono="Dono exemplo", @cor="Vermelho", @tipo="Tipo exemplo">

Mas e se quisermos também ter a opção de inicializar a classe Carro passando um bloco? Sem problemas, usamos o comando yield passando como parâmetro self se um bloco foi fornecido:

class Carro
  attr_accessor :ano, :marca, :modelo, :dono, :cor, :tipo

  def initialize(attributes = nil)
    attributes.each do |attr, value|
      self.send("#{attr}=", value)
    end unless attributes.nil?

    yield self if block_given?
  end
end

carro = Carro.new do |c|
  c.ano    = "2000"
  c.marca  = "Gol"
  c.modelo = "Exemplo"
  c.dono   = "Dono exemplo"
  c.cor    = "Vermelho"
  c.tipo   = "Tipo exemplo"
end

puts carro.inspect #<Carro: @ano="2000", @marca="Gol", @modelo="Exemplo", @dono="Dono exemplo", @cor="Vermelho", @tipo="Tipo exemplo">

Nessa implementação sempre irá prevalecer o que vier no bloco. Então se você passar um hash e um bloco para o construtor ao mesmo tempo (o que é uma bizarrice), os atributos que coincidirem terão o valor que foi passado no bloco:

carro = Carro.new(:ano => "2000", :marca => "Gol", :modelo => "Exemplo") do |c|
  c.modelo = "MODELO DO BLOCO"
  c.dono   = "Dono exemplo"
  c.cor    = "Vermelho"
  c.tipo   = "Tipo exemplo"
end

puts carro.inspect #<Carro: @ano="2000", @marca="Gol", @modelo="MODELO DO BLOCO", @dono="Dono exemplo", @cor="Vermelho", @tipo="Tipo exemplo">

Esses eram meus comentários sobre o interessante assunto de construtores em Ruby.

Ruby , , , , , , ,

Returning em Ruby on Rails

5 de agosto de 2010

Quantas vezes você já criou algum método em Ruby que inicializa uma variável, atribui valores a ela e depois a retorna?

Veja o exemplo abaixo:

def some_values
  values = []
  values << "first element"
  values << "second element"
  values
end

some_values # => ["first element", "second element"]

A linha 2 é cria um array vazio, depois são atribuidos valores nas linhas 3 e 4, e finalmente na linha 5 o array é retornado pelo método.

Em Ruby on Rails existe o método returning da classe Object que facilita nossa vida nesses casos:

def some_values
  returning values = [] do
    values << "first element"
    values << "second element"
  end
end

some_values # => ["first element", "second element"]

Na linha 2 chamamos o método returning passando a variável que será retornada já atribuindo seu valor inicial. Dentro do bloco, nas linhas 3 e 4, então atribuímos os valores ao array.

Há também esse outro tipo de sintaxe:

def some_values
  returning [] do |values|
    values << "first element"
    values << "second element"
  end
end

some_values # => ["first element", "second element"]

Funciona da mesma forma, mas acaba sendo não tão intuitivo como o código anterior.

Veja um trecho de código utilizando o método returning, de um método auxiliar para testes de RSpec retirado de uma aplicação real:

def variants
  returning variants = [] do
    5.times do |priority| do
      variants << Factory.build(:variant, :priority => priority)
    end
  end
end

E olhe só como é simples a implementação do método returning:

def returning(value)
  yield(value)
  value
end

Ruby , , ,

[fisl11] O que rolou de Ruby e Ruby on Rails

27 de julho de 2010

Como nas edições anteriores, esse ano no fisl11 tivemos várias palestras relacionadas com Ruby e Rails.

Quarta, 21 de julho

No primeiro dia, mostrei o uso do Spree, uma plataforma completa de comércio eletrônico desenvolvida em Ruby on Rails, como base de um novo sistema de loja virtual da Locaweb.

Nessa apresentação foram mostradas algumas técnicas de metaprogramação Ruby para lidar com as extensões do Spree e organizar melhor seu código.

Os slides da palestra “Locaweb + Spree: transformando código aberto em um projeto comercial” estão disponíveis nesse link:
http://www.slideshare.net/Prodis/locaweb-spree-transformando-cdigo-aberto-em-um-projeto-comercial

Quinta, 22 de julho

Neste dia, Daniel Lopes iniciou o “Mini-curso de Ruby e Rails”, introduzindo a linguagem de programação Ruby e os primeiros passos de Ruby on Rails. Essa primeira parte do curso teve duas horas de duração com a sala lotada.

Sexta, 23 de julho

“Lapidando Ruby” foi uma palestra muito interessante de Mauricio Szabo. Foram apresentadas algumas práticas para deixar seu código Ruby mais limpo, e outras técnicas para que seus testes fiquem mais claros e compreensíveis.

Os slides dessa palestra estão disponíveis nesse link:
http://www.slideshare.net/mauricioszabo/lapidando-ruby

A exemplo do dia anterior, a segunda parte do “Mini-curso de Ruby e Rails”, de Daniel Lopes, também teve sua sala lotada. O foco foi em montar uma aplicação simples em Ruby on Rails.

Sábado, 24 de julho

No último dia do fisl11, tivemos praticamente uma Maratona Ruby on Rails.

Para começar, Fabio Akita apresentou em duas horas “Ecossistema Ruby on Rails”, falando sobre o que se formou em volta do Ruby on Rails, como soluções completas em diversas áreas como deployment, e filosofias de empreendedorismo e desenvolvimento ágil.

Os slides dessa palestra estão disponíveis nesse link:
http://www.slideshare.net/akitaonrails/fisl-11-ecossistema-ruby-on-rails

Logo em seguida, tivemos mais uma apresentação do Fabio Akita, dessa vez sobre “Dicas de Desenvolvimento Web com Ruby”, onde foram mostradas algumas soluções simples para resolver o problema de lentidão de aplicações Web, por conta do entendimento pobre da arquitetura Web e suas alternativas.

Os slides dessa palestra estão disponíveis nesse link:
http://www.slideshare.net/akitaonrails/fisl-11-dicas-de-desenvolvimento-web-com-ruby

E o vídeo usado na apresentação está em:
http://dl.dropbox.com/u/1732133/dicas-de-desenvolvimento-web-com-rails.zip

E para finalizar a maratona, Daniel Lopes deu a terceira e última parte do “Mini-curso de Ruby e Rails”, finalizando a aplicação Ruby on Rails iniciada no segundo dia do treinamento e mostrando várias dicas interessantes sobre Rails.

Os slides de todo mini-curso estão disponíveis nesse link:
http://www.slideshare.net/danielvlopes/minicurso-ruby-e-rails

E o código fonte está em:
http://github.com/danielvlopes/fisl

.
Além disso, a galera do #HoraExtra esteve presente programando e publicando aplicações pequenas, desenvolvidas em Ruby on Rails, durante todo o fisl11. Mais detalhes do como isso aconteceu, você pode ver aqui.

Um abraço a todos os Railers que estiveram presentes ou que acompanharam virtualmente mais esse grande evento.

Eventos, Ruby , , , , , , , , ,

[fisl11] Sala de recepção dos palestrantes

25 de julho de 2010

O site do fisl11 trouxe várias notícias durante o evento.

Estava dando uma olhada nessas notícias e encontrei uma foto minha na sala de recepção dos palestrantes, onde conversei com um rapaz que trabalhava na comunicação do evento sobre minha apresentação.

Foto retirada do site do fisl11

Foto retirada do site do fisl11

Veja um trecho da notícia:

…Fernando Hamasaki de Amorim, da Locaweb, já está com sua palestra pronta e aguardando. “Transformando código aberto em um projeto comercial” às 20h na sala 41E de hoje.

Fernando pretende apresentar um estudo de caso onde ele irá relatar os desafios e dificuldades, vantagens e desvantagens em utilizar código aberto para criar um novo sistema. “Vou falar também de códigos aberto em detalhes e mostrar como se ganha dinheiro com software livre. O código é aberto, mas alguém ganha com isto”, explicou. Mais detalhes vale a pena conferir a palestra de Fernando.

.
Para ver a notícia completa, acesse o link abaixo:
http://softwarelivre.org/fisl11/noticias/sala-de-recepcao-dos-palestrantes-esta-lotada

Eventos , , , , , , , , ,

[fisl11] Slides da apresentação Locaweb + Spree: transformando código aberto em um projeto comercial

22 de julho de 2010

Veja os slides da palestra “Locaweb + Spree: transformando código aberto em um projeto comercial” que foi apresentada em 21/07/2010 no fisl11.

Agradeço a todos que estiveram presentes.

Eventos , , , , , , , , ,

[fisl11] Confirmadas data e hora da palestra Locaweb + Spree

12 de julho de 2010

Está confirmada data, hora e sala da minha palestra “Locaweb + Spree: transformando código aberto em um projeto comercial” no fisl11.

A apresentação será no dia 21/07 às 20h na sala 41-E fisl 5.

Veja também:

Eventos , , , , , , , , ,

[fisl11] Minha proposta de palestra foi aceita

21 de junho de 2010

Nos dias 21 a 24 de julho, será realizado em Porto Alegre o fisl11, o 11º Fórum Internacional de Software Livre.

O FISL é o maior evento de software livre da América Latina e a edição do ano passado atingiu a marca de 8.244 participantes.

Entre os assuntos que serão abordados, estão:

  • Linux, Ubuntu, KDE, BSD
  • Desenvolvimento em Ruby, Java, PHP, Python, Perl e Smalltalk
  • Desenvolvimento de Jogos, Multimídia e Streaming
  • Gerenciamento de Dados (SGBD, Storage, backup…)
  • Hardware, Sistemas Embarcados e Robótica
  • Segurança
  • Software livre e negócios
  • Educação e Inclusão Digital

Minha proposta de palestra “Locaweb + Spree: transformando código aberto em um projeto comercial” para o fisl11 foi aceita.

Segue o resumo da palestra:

Os desafios, benefícios, dificuldades e lições aprendidas que a equipe de desenvolvimento de SaaS da Locaweb teve na utilização do Spree, uma plataforma de comércio eletrônico de código aberto, como base de seu novo sistema de loja virtual multi-usuário, desenvolvido em Ruby on Rails. O poder e o dinamismo do Ruby tiveram destaque, com grande utilização de metaprogramação nas extensões do Spree.

Eventos , , , , , , , , ,