Danilo Sato

It all started when I tweeted:

wish I could get hold of a chain of named_scopes without performing any query (which means it can’t be dynamically composed) #activerecord

My team has currently been performing some refactorings on our Rails app and one of our goals is to move complex find queries into more composable/meaningful/maintainable named scopes. Contrary to my expectations, when you call a named scope, Active Record performs a find(:all) query implicitly as you finish your statement:

class Shirt < ActiveRecord::Base
  named_scope :red, :conditions => {:color => 'red'}
  named_scope :clean, :conditions => {:clean => true}
end
 
>> red_proxy = Shirt.red
  Shirt Load (0.3ms)   SELECT * FROM "shirts" WHERE ("shirts"."color" = 'red')
+----+-------+-------------------------+-------------------------+-------+
| id | color | created_at              | updated_at              | clean |
+----+-------+-------------------------+-------------------------+-------+
| 5  | red   | 2009-11-16 18:36:37 UTC | 2009-11-16 18:36:37 UTC | false |
| 6  | red   | 2009-11-16 18:36:37 UTC | 2009-11-16 19:15:18 UTC | true  |
+----+-------+-------------------------+-------------------------+-------+
2 rows in set
>> red_proxy.clean
  Shirt Load (0.4ms)   SELECT * FROM "shirts" WHERE (("shirts"."clean" = 't' AND "shirts"."color" = 'red'))
+----+-------+-------------------------+-------------------------+-------+
| id | color | created_at              | updated_at              | clean |
+----+-------+-------------------------+-------------------------+-------+
| 6  | red   | 2009-11-16 18:36:37 UTC | 2009-11-16 19:15:18 UTC | true  |
+----+-------+-------------------------+-------------------------+-------+
1 row in set
>>

So, even though I can compose named scopes, I can’t defer the query to the point I define which operation to execute. I’m obviously not the first one who had this problem, but it seems like this won’t be fixed until a new solution is proposed in Rails 3.

In our particular case, we didn’t even need the proxy object, but just a hash representation of the composed query parameters. We’re using ActiveRecord::Extensions (ar-extensions) to perform some UNION queries to aggregate results, and it expects a list of hashes that represent each query. It would be nice if I could grab the hash from my named scopes without performing the query…

The documentation points to a proxy_options method that you can use to test your named scope, but it didn’t solve my problem, since it only returns the hash for the last scope in your chain:

>> Shirt.red.proxy_options
=> {:conditions=>{:color=>"red"}}
>> Shirt.red.clean.proxy_options
=> {:conditions=>{:clean=>true}}

The solution, after digging a while through the source code, was to use an internal method that’s used during the merge algorithm, called current_scoped_methods:

>> Shirt.red.clean.current_scoped_methods[:find]
=> {:conditions=>"("shirts"."clean" = 't' AND "shirts"."color" = 'red')"}

This is not a perfect solution, but saved me the trouble of performing the merge myself. I hope the Rails 3 solution addresses these issues and that this post saves me some time digging through ActiveRecord source code if I need this before then :)

Since last December, my friend Ivan Sanchez invited me to help him organize a Coding Dojo in London, at Skills Matter. We’ve only had a few sessions so far, but it’s been great fun going to regular Dojo sessions again, since I left Brazil 1 year ago. In the last session, I did a prepared Kata in Ruby, using RSpec and Ivan did a great job of summarizing some of the lessons learned in his blog.

Our next session will be next Thursday, February 12th and you have to subscribe on the Skills Matter website if you want to attend. To join our discussions of which problems to tackle, which languages to use, join our mailing list. We’re also publishing the source code from the sessions on Github, and some of the sessions are being published as podcasts/videos on the Skills Matter website. I hope to see some of you on Thursday!

The new version of Synthesis 0.2.1 was just released and the great news is that my experimental work with visualizations was integrated into the master branch! Just sudo gem update synthesis to grab the latest version.

Why Visualizations?

“…reducing the volume and increasing the value of test code by connecting the dots.”

As George pointed out in his first post about Synthesis, it helps you to connect the dots of your tests, to increase your confidence in the system. I like to think of it as a mock coverage tool. When you use a mock in your test, you’re explicitly stating what interaction you expect to happen. How do you really know that the actual object will behave as you expect? You probably need a unit test around it to guarantee it does what it should. Synthesis helps you connect those dots, breaking your build when a mocked expectation is not met in the “real world”.

By using it in a real project, I noticed that the textual output was getting quite verbose. While coding, I was usually only interested in the failure expectations, but when I stopped to look at the whole output, I noticed there were a lot of interesting information hidden in there. If only I could have a better representation of that information…. that’s exactly what software visualization is all about! I had to dig into Synthesis internals to understand how to hook a different report formatter, but the end result ended up being quite good:

Generating Visualizations

To generate such a visualization, first make sure you have sexp_processor installed (sudo gem install sexp_processor) you need to configure your Synthesis rake task to use the dot formatter:

Synthesis::Task.new do |t|
  t.adapter = :rspec
  t.pattern = 'spec/**/*_spec.rb'
  t.formatter = :dot  t.formatter_out = 'synthesis.dot'end

This will create a synthesis.dot file that can be used to generate a Graphviz image. You can download and install Graphviz for your prefered platform (there’s even a Mac OS X version), but all you need is the command line dot tool to generate your visualization. Just execute:

dot -Tpng -o synthesis.png synthesis.dot

This will create a synthesis.png image file that will show your tested expectations in green, and untested expectations in red. You can generate other output files by changing the -T option (try ps, pdf for a higher quality). There are still a lot of things to improve in the formatter and any feedback is welcome, but it proved to show some interesting information in my last project, as you can depict in the following picture (notice that the app is mainly composed of 2 subsystems that don’t share dependencies):

Tip: Running Synthesis with Rails

Recently, when trying to use Synthesis in a Rails project, I had some problems that took me a while to figure out. As always, the solution was quite small, so I thought it would be nice to share it with everyone. To run Synthesis on a Rails project, make sure you add the following lines to your Synthesis rake task:

Synthesis::Task.new do |t|
  RAILS_ENV = "test"  Rake::Task['environment'].invoke # This may make your build slower. Use only if needed  t.pattern = 'test/**/*_test.rb'
end

Give Synthesis a try in your project and let us know how it goes. You might be disappointed in the beginning about how many expectations you’re not testing, but even if not all of them really require a test, it is still a very valuable information to have. Let me know if you have any issues with the dot formatter as well, as I’m sure there are a lot of kinks to be sorted out. Feedback is always welcome!

I’m back from a 2 week “conference season” in Brazil and Argentina, but before I share my experiences on those conferences, I want to talk about my first session at the São Paulo Coding Dojo since I left in February. It was very unusual and pleasant for different reasons: first of all, George had arrived in Brazil for Rails Summit Latin America and I took him to the session; second, it was held at one of the participant’s house, instead of the usual venue at the University of São Paulo (which made it possible to add a taste of fresh baked pizzas to the retrospective); third, we decided to try out a different session format called, in lack of a better name, ÃœberDojo which I will try to describe in this post. Hugo has already explained how they came up with the new format in his blog.

In an ÃœberDojo, the setup is different than a regular session: there are more than one laptop and no projector. The number of laptops may vary depending on the number of participants, but we were 14 and decided to have 4 pairs, so 4 laptops were available. We laid out the laptops in 2 tables and chose 2 different problems to be solved in 2 different languages. We would go with Python and Ruby, but George argued in favour of having different programming paradigms to enrich the discussions, so we ended up coding in Ruby and Haskell. The problems we chose were already familiar to most of the participants since the goal of the session was to try out the new format rather than solving a difficult problem or learning a new language: Minesweeper and Bank OCR were the chosen problems.

The dynamics of the session are similar to a Randori session, but with multiple pairs coding at the same time. We used a fixed timebox of 7 minutes to switch the pairs (when the round is over, the driver leaves the pair, the observer becomes pilot, and a new observer joins from the audience). The big difference in this format is that it’s impossible for everyone to follow the same train of thought, and there’s always more people than seats available so there’s a lot more chatting happening. When a new member joins the pair, it’s very likely that he will have almost no previous experience with the code being developed (similar to a real-life environment?), so everyone can exercise their ability to read and write readable code. In the original idea, people who were not coding were not supposed to follow what the other pairs were doing, but we ended up helping other pairs with less knowledge on the languages and/or environment. I have to admit I sometimes tried to stick around one of the pair stations because the approach to the solution and the discussions were getting interesting :-)

At the end we held our usual retrospective with food (a lot of pizza) and everyone seemed to have enjoyed the session. I particularly felt the energy and the innovation happening and was very excited with the results. We coded for more than 1:30 hours and it was very hard for me to leave the code unfinished. Although it was a lot of fun, I think for this kind of session to be successful, the participants need to be familiar with a Dojo session and its dynamics (TDD and Pair Programming in particular). Hugo was also a very good moderator, using a pairing matrix to keep track of who was pairing with who, to keep at least one experienced member on each pair, and to put different people in different pairs at each round. The code from that session is available at GitHub.

I see some benefits to trying out this type of session. Solving the same problems in different languages (and paradigms) made it possible to have a rich discussion at the end. For example: when solving the Bank OCR problem in Haskell, pattern matching made it easy to make progress on the first steps, while the Ruby version was getting stuck with a lot of nested if/else statements. Another benefit of this type of session is that you can cope with programmers in different levels of experience. In a traditional Dojo session, you always go as fast as your least experienced participant. In this session, you have different streams of development happening at the same time, so a faster pair can make more progress on their turn. Finally, I think this environment is much more similar to what you might encounter in “real-life”: you develop code for others to read and you have to understand what others were doing while you were absent.

I hope you try out this format in your Dojo and share your experiences. What other types of session are you trying out in your local Dojos? Would you have a better name for this new session format? Leave your comments!

The main reason I went to the conference was to present my experience report on Wednesday about running a Coding Dojo in São Paulo since last year with my friends: Hugo and Mariana. I just made the slides available for download, as well as the published paper. Feel free to comment and send questions and comments about our unanswered questions.

The overall feedback we got from the 30 minutes presentation was very good and we decided to do a Live Dojo at the Open Jam in the next available slot. Besides me, Hugo, and Mariana, Emmanuel and Arnaud from the Paris Dojo showed up, Ivan Sanchez from the Floripa Dojo as well, and other people joined us during the session.

We did a Randori session solving the Blocks Problem in Ruby/RSpec, switching pairs every 7 minutes. Although we didn’t finish the problem, it generated some interesting discussions about exposing the internal state vs. a representation of the state to the tests, and how valuable it is to introduce a data structure that you don’t need now but will soon need.

The problem generated some interest and, on the following day, Arnaud had scheduled a slot on the Opem Jam, and we decided to tackle the problem again, but this time in Haskell. Dan and Liz were also there and it was really cool to see the same problem from a different perspective. We discussed how some features of a functional language forces you to think in a different way (I still don’t quite understand Monads, by the way) :-)

Another interesting learning point was: In our paper, we discussed a whole topic about issues with people pairing in different environments (operating system, keyboard layout, shortcut keys, IDEs, …) at every meeting. At the Open Jam, Dan proposed that we used a local Mercurial repository to share the progress on development (pushing at each TDD step for the next pair to continue working on the problem). This allowed him to work on his Mac with a Dvorak layout, while we were using Emacs on a Linux laptop. The other benefit of this approach is that it allows people to experience how Continuous Integration works in practice, committing as often as possible, whenever it makes sense to do so. Good stuff!

I was kindly invited by my friend Carlos Eduardo (e-Genial) to give 2 webinars to the brazilian Ruby/Rails community in the next months (in Portuguese). So, add to your calendar:

• 19/Jul/2008: “Merb: web development with Ruby without Rails“
• 13/Sep/2008: “BDD with RSpec“

Both webinars will be held at 3:00PM (brazilian time) via Treina Tom, a great e-learning/e-conference tool developed by Carlos. More details can be found at the event website. Hope to see you there!

O David Chelimsky, core developer da equipe do RSpec, anunciou hoje o lançamento da versão 1.1.0 na lista de discussão do projeto. Essa versão é um grande marco para o projeto, trazendo novas funcionalidades e diversas melhorias:

• Story Runner: Como já falei aqui no blog, o projeto RBehave foi integrado ao core do RSpec, ganhando o nome de Story Runner. Com isso, o RSpec se torna um framework full-stack para BDD. Além de definir o comportamento do seu código, você também pode colaborar com seu cliente através de cenários executáveis, escrevendo os testes de aceitação para sua aplicação. A possibilidade de escrever story tests em texto puro é um grande passo nessa direção. Quem assistiu minha palestra no Rio on Rails teve a oportunidade de ver uma demonstração dessa funcionalidade.
• Integração com o Rails 2.0: A nova versão está integrada com o novo Rails 2.0. O plugin RSpec on Rails também foi atualizado para aproveitar a funcionalidade dos story tests na sua aplicação Rails.
• Transição fácil do Test::Unit: Uma funcionalidade bem interessante para quem está migrando do Test::Unit para o RSpec. Para migrar, você precisa apenas:

1.  
   1. incluir um ‘require spec’ no seu arquivo de teste;
   2. trocar a definição da subclasse de TestCase ‘class ClassContextTest < Test::Unit::TestCase’ por uma descrição do tipo ‘describe “class in context” do’;
   3. Converter os métodos de teste ‘def test_should_do_this’ por blocos ‘it “should do this” do’;
   4. Transformar asserts ‘assert_equal 2, some_calculation’ em shoulds ‘some_calculation.should == 2′;
   5. remover a dependência com Test::Unit, removendo o ‘require ‘test/unit’

• Exemplos encadeados: Agora você pode escrever um bloco “describe” dentro de outro.

Essa era a notícia que eu estava esperando desde minha primeira palestra sobre o assunto na RejectConf’SP) e, depois do lançamento do Rails 2.0 na semana passada, a integração com o RSpec finalmente chegou. Aproveitem!

 

sudo gem update rspec

 

Esse fim de semana tive a oportunidade de conhecer o Rio de Janeiro e participar do Rio on Rails, organizado pelo pessoal da ImproveIt. O sábado foi repleto de Ruby e Rails e no domingo tive um tempinho para passear e conhecer um pouco da cidade maravilhosa.

 

 

Os organizadores estão de parabéns. As palestras foram muito bem escolhidas e acho que deram um bom gostinho de como é divertido programar em Ruby e Rails para quem nunca tinha experimentado. Como sempre, eventos são uma excelente oportunidade de conhecer gente nova e trocar experiências e o Rio on Rails não deixou a desejar. Conheci o Ronaldo Ferraz, que falou um pouco sobre DSLs, o Demetrius Nunes, um dos pioneiros na adoção de Rails no Brasil, o Eduardo do site o Curioso, todo o pessoal da Improveit e do projeto Lucidus e mais um monte de gente que não vou lembrar do nome, mas que estavam presentes para fazer mais um grande evento da comunidade Rails no Brasil.

 

 

Minha palestra sobre BDD e RSpec foi uma evolução da palestra no RejectConf’SP. Com mais tempo para explicar os conceitos e fazer uma demonstração mais calma, acho que consegui passar uma idéia melhor da experiência de programar com BDD em Ruby e Rails. Os slides já estão disponíveis aqui, assim como o esqueleto da aplicação demo que desenvolvi, com o passo-a-passo da demonstração. Quem quiser também consegue pegar a versão final do código apresentado.

 

 

Uma coisa legal que eu consegui terminar de preparar para a apresentação foram algumas das novidades do RSpec 1.1.0, como o Story Runner (integração com o RBehave, que eu apresentei no screencast do Dojo@SP), os plain text story tests e o protótipo do editor de story tests no browser.

 

 

Para rodar os exemplos, você precisará do Rails 1.2.6 (não fiz update pro 2.0 na palestra pois o patch da integração do RSpec com o Rails novo saiu na sexta a noite e não quis arriscar a demonstração ao vivo), do RSpec e do Rcov, caso queira verificar a cobertura (gem install rcov). Quem gostou da integração do Autotest com o Growl que eu usei na demonstração, pode pegar meus arquivos de configuração no Google Groups do Dojo@SP (não esqueça de instalar o Autotest com ‘gem install ZenTest’).

 

Continuando com a maratona, participei de mais um evento excelente. Sou um pouco suspeito para falar pois dessa vez tive a oportunidade de ajudar na organização do primeiro RejectConf para a comunidade Ruby e Rails brasileira. Não posso deixar de agradecer ao Akita, à Caelum e ao Prof. João Eduardo Ferreira do CCSL/IME-USP pelo apoio e ajuda na organização do evento.

 

 

Apesar de termos atrasado um pouco o cronograma, já sabíamos que isso podia acontecer (big design up-front não funciona :P). No entanto, a qualidade dos palestrantes e a participação do público em geral superou e muito minhas expectativas.

 

 

Foi muito bom conhecer algumas pessoas pessoalmente, como o Eduardo Fiorezi, o Vinicius, Tapajós e o pessoal da ImproveIt, além de reencontrar amigos e conhecidos, como o Carlos Villela, o Fernando Meyer, o Fabio Kung, Paulo e Jonas da Caelum, o Hugo e o George (ainda não o conhecia) do Pagestackr, meus amigos do IME (Pedro, Dairton, Giuliano, Fabricio, Jef) e muitos outros que com certeza estou esquecendo de listar.

 

 

Palestras e Palestrantes

 

Do ponto de vista técnico, todas as palestras foram excelentes. O conteúdo abrangia diferentes níveis de conhecimento, agradando aos iniciantes e aos desenvolvedores mais avançados. Todo o material vai ser disponibilizado, assim como os vídeos gravados no evento.

 

Os palestrantes estão de parabéns! Foi incrível como algumas palestras pareciam se “linkar” umas com as outras. Parecia até que havíamos combinado algo antes :-)

 

RSpec e RSpec on Rails

 

Minha palestra foi curta e, apesar de uns probleminhas técnicos (bugzinhos), correu tudo bem. Eu falei brevemente sobre o conceito de Behaviour-Driven Development e mostrei um pouco de código ao vivo. Desenvolvi uma aplicação demo para obter feedback (positivo ou negativo) das palestras e deixei meu notebook ligado para quem quisesse votar durante o evento. Apesar de alguns problemas com a rede wireless, algumas pessoas conseguiram acessar e votar. Tirei um screenshot do widget criado pelo Safari 3 mostrando o resultado final da votação. É claro que o placar é irrelevante a não ser pelo fato de que o coffee-break venceu disparado!! :-)

 

 

Os slides da minha palestra já estão disponíveis para download, assim com o código-fonte da aplicação demo e as notas que usei na implementação ao vivo.

 

 

Se você tem alguma sugestão para melhorar minha palestra, por favor deixe um comentário. Você gostou ou não gostou da minha palestra? Aprendeu alguma coisa? O bug na demonstração atrapalhou muito? Você prefere ver código ou slides? Essa palestra será a base do que vou apresentar no próximo evento de dezembro, o RioOnRails, por isso sua opinião é muito importante. Lá terei mais tempo para elaborar os conceitos e mostrar um demo mais completo e detalhado. Espero vocês lá!

 

 

Mais uma vez, todos os que participaram estão de parabéns. Tenho consciência que podemos melhorar muitas coisas para o ano que vem, mas o importante é que demos o primeiro passo. Acredito que daqui pra frente a comunidade Ruby e Rails brasileira só tende a crescer.

 

Se você é de São Paulo ou do Rio de Janeiro, nunca me (ou)viu falar ao vivo e estiver interessado em me conhecer para bater um papo, vai ter algumas chances nos próximos meses. Depois de participar de um evento de Software Livre, de XP e de Python nesse ano, vou apresentar algumas palestras para a comunidade Java, Ruby e Rails. Detalhes a seguir…

09/Nov e 10/Nov: Conexão Java '07 Hands On

No dia 10 de Novembro, das 11:30 – 13:00, vou apresentar uma palestra sobre Métodos Ágeis chamada “Agile Methods for the Traditional Guy”. Espero que o título não assuste as pessoas, pois o tema é legal e a idéia é dar uma introdução geral sobre os princípios do Manifesto Ágil, XP, Scrum, Lean, discutir problemas dos métodos tradicionais e desmistificar alguns mitos sobre Métodos Ágeis. As inscrições podem ser feitas pelo site do evento (com desconto até o dia 31/Out) e o evento acontecerá na Universidade Anhembi Morumbi da Vila Olímpia.

Quem for participar terá a chance de assistir ótimas palestras de alguns amigos: o Carlos Villela vem apresentar o keynote e falar sobre o “Arquiteto de uma nota só”; o Phillip Calçado vem reapresentar a ótima palestra sobre arquitetura do JustJava (dessa vez sem o Paulo), além de coordenar uma atividade que promete ser divertida: a Oficina do Arquiteto; O Fernando Meyer vai falar sobre DSLs e ANTLR; o Alexandre Magno vai falar sobre Scrum, dentre outras palestras muito boas.

Além das palestras, estarão acontecendo também mini-cursos em paralelo. O pessoal da Caelum vai ensinar Hibernate, AJAX e JSF, Java ME e JPA. Pelo que conheço da qualidade dos cursos deles, são mini-cursos ótimos e imperdíveis se você estiver interessado em aprender um pouco sobre essas tecnologias.

17/Nov: RejectConfSP '07

No fim de semana seguinte (sim, no meio dos feriados) estou ajudando o Fabio Akita a organizar a primeira RejectConf em São Paulo. A idéia é juntar a comunidade Ruby e Rails para mini-apresentações (de 10 a 30 minutos) sobre diversos assuntos, além do networking, troca de conhecimentos e diversão :-)

O evento vai acontecer no IME-USP, no Auditório Jacy Monteiro, das 11:00 – 17:00. As inscrições são gratuitas estão atualmente com lista de espera, mas pode ser feitas neste formulário. Quem estiver interessado em apresentar algum tópico, basta preencher este outro formulário.

Minha mini-palestra será sobre RSpec e RSpec on Rails. Quem quiser um gostinho de como é programar com RSpec/RBehave pode assitir o screencast #01 do Dojo@SP.

08/Dez: Rio on Rails

Por fim, mais um evento da comunidade Rails, organizado pelo Vinicius e o pessoal da Improve It. O evento está confirmadíssimo e acontecerá no SENAC, das 9:00 – 18:00. As inscrições custarão R$50,00 e estarão disponíveis em breve no site do evento (disponibilizado pela Improve It nos próximos dias).

O assunto será RSpec e RSpec on Rails novamente, mas dessa vez terei mais tempo para me apresentar.

Nos vemos por lá!

Acredito que os eventos serão bastante divertidos e informativos e espero que ninguém durma de tédio nas minhas apresentações :-). Faça sua inscrição e deixe um alô nos comentários para saber se devo te encontrar por lá!