Pretendemos traduzir este e também os outros livros. O problema é que precisamos de voluntários para nos ajudar nas traduções para que o processo seja mais rápido. Caso contrário pode demorar um pouco.

Abraço,
André Faria

grande abraço!

O espírito eh esse mesmo. As soluções aqui mostradas só fizeram aumentar minha curiosidade / ansiedade em aprender Ruby.

Fico um pouco perdido / receoso / pé atrás quando vejo as trombetas do apocalypse serem anunciadas para o bom e velho Java (que não foi o seu caso), porém sem um benchmark para comparar.

Neste post tive a oportunidade de avaliar alguns prós e cons em cada abordagem - e a lição que aprendi é que vai ser muito bom quando puder incorporar uma nova arma (Ruby) ao meu arsenal!

Parabéns pelo post e pelas respostas, e aguardo ansiosamente pela realização do próximo Workshop da Fratech no Rio.

Abs!

Do ponto de vista de expressão, a única coisa complexa no código groovy e ruby foi o uso da Regex para filtrar o ano. Não acho que a parte de iteração no mapa seja menos expressivo que em Java (Concordo que regex não é tão expressivo, mas o poder da regex na simplicidade do ruby/groovy não poderia ficar de fora do meu exemplo).

Se o desafio foi e de organizar a lista em tipos (Artigos, Interviews, etc..) O código Ruby que eu (um newbie em ruby) gerei foi o seguinte:

require ‘csv’

rows = CSV::Reader.parse(File.open(’publications.csv’),’;')
@items = []

rows.each { |row|
if row[0] == ‘Article’ or row[0] == ‘News’
@items < < row
end
}

range = 2005..2009

range.each {|year|
puts year

@thisYearItems = []
@items.each {|item|
if (item[1] =~ /#{year}$/) != nil
@thisYearItems << item
end
}

numItems = @thisYearItems.size

puts "A quantidade de materias desse ano foi: #{numItems}"

average = (numItems/12)
puts "A media de materias por mes nesse ano foi: #{average}"

weekAverage = (average/4)
puts "A media de materias por semana nesse ano foi: #{weekAverage}\n\n"
}

Mas a minha surpresa maior foi em groovy:

import java.math.*

List lines = []

new File('publications.csv').splitEachLine(';') { line ->
lines.add(line)
}

itens = lines.findAll { it[0] == ‘News’ || it[0] == ‘Article’ }

def range = 2004..2008

range.each { year ->
println year
numItens = itens.findAll{it[1] =~ /${year}$/}.size
println “A quantidade de materias desse ano foi: ${numItens}”

def average = (numItens/12).round(new MathContext(1)) as BigInteger
println “A media de materias por mes nesse ano foi: ${average}”

def weekAverage = (average/4).round(new MathContext(1)) as BigInteger
println “A media de materias por semana nesse ano foi: ${weekAverage}\n\n”

}

Acrescentei apenas 1 linha de código em groovy. Talvez em Ruby dê pra fazer algo tão compacto quanto em Groovy. Se algum usuário avançado de Ruby quiser nos ajudar nesse empasse. Caso contrário acredito que é indiscutível a superioridade do Groovy, pelo menos nesse exemplo.

Java ficou bem mais complexo dessa vez. Isso porque o exemplo é bem curto. Coloque isso em escala e calcule a diferença na quantiade de linhas de código. Não estou dizendo aqui que eu detesto Java. Trabalhei com Java muito tempo e ainda trabalho para alguns clientes. Mas o Groovy me oferece o poder completo da JVM. Eu poderia por exemplo usar o mesmo TreeMap que vc usou em Groovy. (Em Ruby também dá se usarmos o JRuby. Mas não é tão integrado quanto o Groovy).

Em termos de “expressão de código”, Java tomou uma surra na parte do parsing do arquivo. A solução Ruby é de longe mais enxuta e elegante.

Porém, na segunda parte do código, não é tão trivial para um curioso ler e entender a lógica em Ruby. Por exemplo, como é que “23/05/2008″ foi compreendido como 2008? Ou seja, já requer do curioso um pouco mais de conhecimento da sintaxe da linguagem. Minha impressão é que o código em Java nesta parte é mais claro / fácil de compreender.

Não dá pra negar porém o argumento de se obter objetos completos com pouco esforço, e de vc possuir mais facilidades “built-in” para manipulá-los. Neste quesito as linguagens dinâmicas (posso chamar assim?) levam grande vantagem.

Em Java vc precisaria declarar uma classe
Publication[type, date, cmm], contendo um construtor
Publication(String type, String date, String cmm), com toda sorte de lógica de converter String para os tipos adequados (exemplo String->Date).

Porém, como nada na vida é de graça (there’s no free lunch), perde-se a checagem de tipos (o que é discutível, pois é algo que alguns amam e outros odeiam). Eu particularmente gosto desta feature.

Tb acredito que fica mais fácil determinar a “fronteira”, de um objeto em Java. Ou seja, para saber o que faz parte desse objeto (e o que não faz), basta olhar a declaração de sua classe. Mas aí já falo sem ter uma base de comparação de como Ruby lida com isso.

Para o novo desafio, a solução mais simples (sem criar uma nova classe) em Java, já apresenta novo teor de complexidade (mapas de mapas), com menos expressividade para o negócio (porém não chega a ser tão complexa):

TreeMap> typeMap = new TreeMap();

…
String type = split[0];
if (!typeMap.containsKey(type))
typeMap.put(type, new TreeMap());
Map tmap = typeMap.get(type);
tmap.put(y, tmap.containsKey(y) ? tmap.get(y)+1 : 0);
…
for (Integer y : m) {
…
for (String type : typeMap.keySet()) {
// qtde de artigos por tipo no ano “y”
typeMap.get(type).get(y);
}
}

Gostaria de ver a solução em Ruby para poder comparar…

Por fim, tenho muita curiosidade em aprender Ruby, porém respeito muito essa “panela velha” que bota comida no meu prato… Todos sabemos que Java é muito poderosa, e nem sempre é bem utilizada…

Acredito que o ditado “O Java de hoje é o Cobol de amanhã” é apenas uma versão computeira da música “Pais e Filhos”. Cada linguagem tem o poder e a importância característicos de seu tempo e dos problemas que ela resolve neste tempo.

Abs!

Imagine uma situação onde o TreeMap não se encaixe e acrescente aí as linhas de código para organizar essa lista.

Mas a maior diferença e essa sim faria dobrar a quantidade de linhas de código é o fato de que o TreeMap não contém um objeto completo com todos os dados. Ele é apenas um Map contendo o ano e a quantidade de itens de cada ano. Experimente imprimir a quantidade de cada tipo (Articles, News, Presentations e Interviews). Mais uma vez a diferença iria aparecer.

Se você reparar, no exemplo em Groovy e Ruby, cada objeto originado era um objeto completo, com Tipo, Data e Autor. Como é que faz isso em java?

Abração