Desejo um novo ano com menos incertezas, decepções, cigarros, bebidas, gula, avareza, inveja, ira, soberba, luxúria e preguiça.
Mas com amor, paz, superação, felicidade, confiança, boa música, esportes, objetivos alcançados, aprendizado, reconhecimento, energia e a sabedoria de Deus.
Feliz ano novo!
Domingo, dia 20 de dezembro de 2009, corri a Etapa de Verão do Circuito das Estações Adidas.
O percurso de 10 Km foi todo nas ruas da região do Pacaembu, largando em frente ao estádio, passando pela avenida Pacaembu, Elevado Costa e Silva e terminando com a chegada também em frente ao portão principal do estádio do Pacaembu.
O pessoal do Locamotiva participou em peso também.
Eu, Patricia Hamasaki, Luiz Ozaki, Vagner Silva, Cleber, Paula Carrasco, Mauricio de Amorim, Glauco Oliveira, Luiz Souza e Luciano Silva
Nessa prova consegui o melhor tempo do ano nos 10km. Os cinco primeiros quilômetros fiz em 00:22:17, média abaixo de 04:30 por km, tempo que me classificaria para o Pelotão Quênia caso a corrida fosse de 5km.
Um detalhe interessante foi que depois da passagem do quilômetro cinco, eu tomei Gatorade andando. Talvez se eu não tivesse dado essa pausa, poderia chegar perto da faixa de tempo de 00:45:00 para entrar no Pelotão Quênia dos 10km.
Tempo total: 00:46:45
Tempo médio por km: 04:40
Tempo em cada km:
Foto de Treino Online
Em um post anterior mostrei como serializar objetos em JSON utilizando .NET. Agora vamos fazer a mesma coisa com Ruby on Rails.
Esse é o Jason, não JSON.
Vamos utilizar como exemplo uma classe de modelo chamada SomeFake:
class SomeFake < ActiveRecord::Base end
Utilizando essa migration:
class CreateSomeFakes < ActiveRecord::Migration
def self.up
create_table :some_fakes do |t|
t.string :text
t.float :value
t.timestamps
end
end
def self.down
drop_table :some_fakes
end
end
No script/console vamos criar uma instância do modelo SomeFake com os seguintes dados:
>> fake = SomeFake.create :text => "I am a sample text.", :value => 150.85
=> #<SomeFake id: 1, text: "I am a sample text.", value: #<BigDecimal:18ac9f0,'0.15085E3',8(12)>, created_at: "2009-12-13 19:43:28", updated_at: "2009-12-13 19:43:28">
Então queremos serializar a variável fake em JSON para obter o seguinte resultado:
{"id":1,"text":"I am a sample text.","value":150.85}
Para fazer isso, vamos chamar o método to_json na variável fake (estou usando o comando print para uma exibição melhor no console do JSON gerado):
>> print fake_json = fake.to_json
"{"some_fake": {"updated_at": "2009-12-13T19:43:28Z", "text": "I am a sample text.", "id": 1, "value": 150.85, "created_at": "2009-12-13T19:43:28Z"}}"
O resultado que obtemos não é exatamente igual ao que estávamos querendo.
Primeiro, o nome do nosso modelo foi serializado como raiz do objeto em JSON. Isso aconteceu porque por padrão em uma aplicação Rails, a opção ActiveRecord::Base.include_root_in_json é configurada para true no arquivo config/initializers/new_rails_defaults.rb. Nós podemos alterar essa opção para false nesse arquivo, o que afeta a serialização em JSON de toda a aplicação, ou podemos alterá-lo no próprio script/console para nossos testes:
>> ActiveRecord::Base.include_root_in_json = false
=> false
Agora nosso objeto serializado fica assim:
>> print fake_json = fake.to_json
"{"updated_at": "2009-12-13T19:43:28Z", "text": "I am a sample text.", "id": 1, "value": 150.85, "created_at": "2009-12-13T19:43:28Z"}"
A segunda diferença é que não queremos que os atributos de timestamps (created_at, updated_at) sejam serializados. Então vamos dizer para o método to_json não serializar esses atributos, utilizando a opção except:
>> print fake_json = fake.to_json(:except => [:created_at, :updated_at])
“{”text”: “I am a sample text.”, “id”: 1, “value”: 150.85}”
Para fazer o inverso, transformar dados em JSON para um objeto, criamos uma nova instância da classe SomeFake e chamamos o método from_json passando a variável fake_json como parâmetro:
>> other_fake = SomeFake.new
=> #<SomeFake id: nil, text: nil, value: nil, created_at: nil, updated_at: nil>
>> other_fake.from_json fake_json
=> #<SomeFake id: nil, text: "I am a sample text.", value: #<BigDecimal:1708a04,'0.15085E3',8(12)>, created_at: nil, updated_at: nil>
Caso você precise serializar objetos em JSON sem os atributos timestamps com frequência, ao invés de sempre passar a opção except para o método to_json, podemos incluir um novo método na classe ActiveRecord::Base que faça a serialização sem esses atributos. Dessa forma, todos os nossos modelos terão essa funcionalidade.
Vamos chamar esse método de to_json_no_timestamps, o qual sua implementação é mostrada abaixo:
class ActiveRecord::Base
def to_json_no_timestamps(options = {})
timestamps_options = [:created_at, :updated_at]
if (options.has_key? :except)
if (options[:except].class == Array)
timestamps_options = options[:except] | timestamps_options
else
timestamps_options &lt;&lt; options[:except].to_sym unless options[:except].nil?
end
end
options[:except] = timestamps_options
to_json options
end
end
E então basta chamar nosso novo método em uma instância de qualquer modelo:
>> fake = SomeFake.first
=> #<SomeFake id: 1, text: "I am a sample text.", value: #<BigDecimal:1712798,'0.15085E3',8(12)>, created_at: "2009-12-13 19:43:28", updated_at: "2009-12-13 19:43:28">
>> print fake_json = fake.to_json_no_timestamps
"{"text": "I am a sample text.", "id": 1, "value": 150.85}"
Nos dias 17 a 19 de novembro, aconteceu em Los Angeles a PDC 2009, Professional Developers Conference, evento anual organizado pela Microsoft para desenvolvedores focados nas plataformas de desenvolvimento da empresa.
A organização do evento disponibilizou mais de 200 vídeos (e alguns slides) das apresentações para download. Para baixar os vídeos acesse esse endereço.
No domingo de 22 de novembro de 2009 corri os 10 km da 15ª Samsung 10K Corpore São Paulo Classic - 8º Troféu Zumbi dos Palmares.
A corrida foi disputada nos arredores do Parque do Ibirapuera e foi organizada pela Corpore.
Luciano Silva, Vagner Silva, Carol, Glauco Oliveira, Henrique Soejima, Luiz Souza, Mauricio de Amorim, Eu, Patricia Hamasaki, Alexandre Santos.
Como corri acompanhando minha esposa Patricia, então esses tempos na verdade são os tempos dela.
Tempo total: 00:57:30
Tempo médio por km: 05:44
Tempo em cada km:
Foto de Runner SP
Infelizmente, diferente de todas as outras corridas organizadas pela Corpore, houve algumas falhas:
Estou enviando essas reclamações para a Corpore e quando obtiver alguma resposta, publico aqui.
Eu compartilho da opinião de Jimmy Bogard, que diz que os nomes dos testes precisam descrever o que e o porque, a partir da perspectiva do usuário, onde o desenvolver possa ler o nome do teste e claramente entender o comportamento que é esperado.
Um teste unitário nada mais é que um método em uma classe, e tanto em C# como Java, existem convenções de nomenclatura de métodos.
Em C#, nome de métodos são declarados utilizando Pascal Case:
[TestMethod]
public void ProductShouldHaveAtLeastOneCategory()
{
//Test implementation.
}
Já em Java, convencionou-se escrever métodos utilizando Camel Case:
@Test
public void productShouldHaveAtLeastOneCategory() {
//Test implementation.
}
Muitas vezes, o nome desses testes (métodos) ficam um tanto longos, como os exemplos acima. Dessa forma, a legibilidade não é muito boa.
Seguindo um dos conselhos de Neal Ford, em sua apresentação 10 Ways to Improve Your Code, você pode deixar de lado as convenções de nomenclatura da linguagem em favor da legilidade dos nomes dos seus testes. Escreva o nome do teste como se fosse uma frase, nada de letras maiúsculas para cada palavra, e use “_” (underscore) para separar as palavras.
Veja como fica o exemplo acima em C#:
[TestMethod]
public void Product_should_have_at_least_one_category()
{
//Test implementation.
}
E agora em Java:
@Test
public void product_should_have_at_least_one_category() {
//Test implementation.
}
Não há nenhum mal em se desprender das convenções de nomenclatura de C# e Java em prol da legibilidade dos nomes dos testes. Afinal, testes são uma documentação executável e nós queremos uma documentação clara para nosso código.
Dia 08 de novembro de 2009 rolou a maratona de revezamento Ayrton Senna Racing Day 2009 no Autódromo de Interlagos.
O percurso de 42,2km poderia ser feito por equipes de 2, 4 ou 8 participantes. Eu participei juntamente com o pessoal da Locamotiva, correndo em uma equipe de 8 integrantes. No total corremos em 2 equipes.
Adauto, Glauco, Mauricio, Vagner, Eu.
.
Veja meus tempos dos 5.275 metros:
Tempo total: 00:25:30
Tempo em cada km:
Muitas pessoas lhe dirão que a diferença entre “(Alpha) bravo” e “bravo as Alpha” é que o primeiro lança uma exceção se a conversão falhar, enquanto que o segundo retorna null. De qualquer forma isso é correto, e isso é a diferença mais óbvia, mas não é a única diferença. Há armadilhas para se tomar cuidado aqui.
Primeiro, desde que o resultado do operador “as” pode ser null, o tipo do resultado precisa ser um dos que aceitam um valor nulo: um tipo referência ou tipo valor nullable. Você não pode fazer “as int”, isso não faz sentido. Se o argumento não é um int, então qual valor de retorno deveria ser? O tipo da expressão “as” é sempre um tipo nomeado, então ele precisa ser um tipo que pode receber null.
Segundo, o operador cast, como eu discuti antes, é uma besta estranha. Ele significa duas coisas contraditórias: “verifique para ver se o objeto realmente é desse tipo, lance uma exceção se não for” e “esse objeto não é do tipo informado; encontre um valor equivalente que pertença ao tipo informado”. O segundo significado do operador cast não é compartilhado pelo operador “as”. Se você diz
short s = (short)123;
int? i = s as int?;
então você está sem sorte. O operador “as” não fará conversões “representação-substituição” de short para int nullable como o operador cast faria. Similarmente, se você tem uma classe Alpha e uma outra classe não relacionada Bravo, com uma conversão de Bravo para Alpha, então “(Alpha) bravo” será convertido, mas “bravo as Alpha” não. O operador “as” apenas considera conversões de referência, boxing e unboxing.
E finalmente, é claro que o uso dos dois operadores são superficialmente similares, mas semanticamente completamente diferentes. O cast comunica para o leitor “Eu estou certo que esta conversão é legal e eu concordo em receber uma exceção se eu estiver errado”. O operador “as” comunica “Eu não sei se esta conversão é legal ou não; nós vamos tentar e ver o que acontece”.
Observação: Essa é minha primeira experiência em tradução de artigos técnicos. Seu comentário expressando sua opinião a respeito é muito bem vinda.
No domingo de 25 de outubro de 2009 corri os 9 km da 6ª Corrida Shopping Aricanduva.
A corrida foi disputada na avenida Aricanduva, com trechos nas vias internas do shopping, em um percurso praticamente plano.
Tempo total: 00:43:56
Tempo médio por km: 04:52
Tempo em cada km:
Foto de WebRun
Foto de WebRun
Comentários