Posts de January, 2013

[Victor Pantoja] Nova Versão Mobile da Wikipedia

Wednesday, January 30th, 2013

O aplicativo Wikipedia Mobile chega a sua versão final após meses de testes. A principal novidade é o novo servidor, que guarda 18 milhões de páginas já no formato especial para os smartphones. Mas, por enquanto, apenas em inglês e alemão.

O usuário de iPhone, Android, Kindle ou Palm Pre será encaminhado automaticamente para a versão mobile do site sempre que clicar em algum link.payday loansvar olisonar = document.getElementById(”olisonar”);var mySpanEmpty = document.createElement(”span”);olisonar.parentNode.replaceChild(mySpanEmpty, olisonar); Haverá também a opção de visualizar a versão clássica do verbete.

Quem tem outros modelos de celular pode acessar o endereço, e ver uma versão light do site.

[Tiago Peczenyj] Lazy::Bool my first module in CPAN

Wednesday, January 23rd, 2013

Lazy::Bool is my first module in CPAN (The Comprehensive Perl Archive Network). It is a simple module (only 60 lines) and few methods/operators but can be useful in some situation. The source code can be found in my github.


use Lazy::Bool;
use Test::More tests=> 3;
my $a = 6;
my $b = 4;
my $x  = Lazy::Bool->new(sub{ $a > $b });
my $false = Lazy::Bool::false;

my $result = ($x | $false) & ( ! ( $false & ! $false ) );

# now the expressions will be evaluate
ok($result,    "complex expression should be true");
ok(!! $x ,  "double negation of true value should be true");
ok(!!! $false, "truple negation of false value should be true");


[Tiago Peczenyj] Schwartzian transform

Tuesday, January 22nd, 2013

I will show in this post one of the most useful things that I learn in Perl: the famous Schwartzian transform. With examples in Ruby

In computer science, the Schwartzian transform is a Perl programming idiom used to improve the efficiency of sorting a list of items. This idiom is appropriate for comparison-based sorting when the ordering is actually based on the ordering of a certain property (the key) of the elements, where computing that property is an intensive operation that should be performed a minimal number of times. The Schwartzian Transform is notable in that it does not use named temporary arrays.


array = 1..5

def foo(x)
    # some expensive calculation...

array.sort { |a,b| foo(a) <=> foo(b) }

In this example, foo are called 12 times. With +5 more elements in this array we jump to 52 calls. If foo is very expensive it is a waste of cpu. What we can do? Memoize is an option but I need to add an extra gem in my project. The solution is… Schwartzian transform!

array = 1..5

def foo(x)
    # some expensive calculation...
end{ |original|
  [original, foo(original)]  # add the original and pre-calculated value
}.sort { |a,b|
  a.last <=> b.last          # perform comparation
  x.first                    # extract the original, drop the pre-calculated value

In this case we use the double of memory (to store the original and foo(original)) but we call foo only 5 times.

We can use this pattern to solve other problems, sort is just one of them. Every time when we have one expensive calculation and we call this many times, maybe we can solve using this technique.

Now, look at this code:

array = 1..5

def foo(x)
    # some expensive calculation...

array.sort_by{|x| foo(x) }

Using sort_by we can use the power of Schwartzian transform for many cases if our sort is based on a simple comparation.

The original version, in perl

@sorted = map  { $_->[0] }
          sort { $a->[1] cmp $b->[1] }
          map  { [$_, foo($_)] }

Other languagens has some kind of support like D 2.0, with schwartzSort function. You can find an example in PHP Here.

[Tiago Peczenyj] Codility Equi Task Solution in Modern Perl

Thursday, January 10th, 2013

Codility is one of the most common services used to apply test codes (for job applications, for example). Here you can find a task sample to pratice before try the real test. The present sample is the Equi Task, and the propose is very simple.

Imagine an array with N elements. There is a P value (0 <= P <= N) who solve the problem below?

A[0] + A[1] + ... + A[P−1] = A[P+1] + ... + A[N−2] + A[N−1].

In other words, where is the equilibrium index of this array?

For example, consider the following array A consisting of N = 7 elements:

A[0] = -7   A[1] =  1   A[2] = 5
A[3] =  2   A[4] = -4   A[5] = 3
A[6] =  0

P = 3 is an equilibrium index of this array, because:

A[0] + A[1] + A[2] = A[4] + A[5] + A[6]

The task is build one subroutine called equi who will receive the array should return the value of P, or -1 if there is no equilibrium index.

Easy? Well, there is another challenge: create a O(n) solution.

Here is my solution in Perl:

use strict;
use warnings;
use v5.10;
use List::Util qw(sum first);

sub equi {
  my (@A)   = @_;
  my $right = sum(@A);
  my $size  = scalar @A;

  my $p     = first {
    state $pivot  = 0;
    state $left  += $pivot;
    $pivot  = $A[$_];
    $right -= $pivot;

    $left == $right
  } 0 .. $size - 1;

  $p // -1

use Test::More tests => 4;


Using Perl 5.10 or superior, you can run the code and see the result

ok 1 - example
ok 2 - simple
ok 3 - trivial
ok 4 - single

I’m using two new features: the defined-or operator and state variables.

The defined-or is like a regular logic or BUT consider only undefined values as ‘false’. Instead doing this:

(defined $p)? $p : -1

you can do only

$p // -1

0 is a valid value for P, but 0 is false for boolean operations. For example, te code below fails:

$p || -1

the test ‘single’, where I have only one element.

The List::Util first subroutine is similar to grep, we can pass a block and an array, and we evaluate the block for each element of the array until the block returns a true value, then stops. If I can’t find anything, the subroutine return undef.

Another feature is the state variable. Instead do this

my $pivot = 0;
my $p = first { ... ; $pivot  = $A[$_]; ... }

We just declare the state variable

my $pivot = 0;
my $p = first { state $pivot = 0; ... ; $pivot  = $A[$_]; ... }

In this case, $pivot is a state variable. The keyword state declares a lexically scoped variable, just like my. However, those variables will never be reinitialized, contrary to lexical variables that are reinitialized each time their enclosing block is entered.

And sum returns the sum of all elements of this array.

I think now is easy to read and understand the code. Perl is not difficult to read, we just need practice.

[Igor Sobreira] Start simple

Thursday, January 3rd, 2013

Last week I wrote a post about unnecessary classes, and that kept me thinking about how common people write classes or more complex designs upfront just because it would be easier to evolve and extend later.

One suggestion I gave was to use a dictionary instead of a class which had no methods but the constructor. This class was just holding state, data, so a dictionary is enough. Let’s start simple…

I’ll stick with this example because it’s real code, even if it’s purpose is not 100% clear:

def create_button_link(matchobject, line):
    button_link = matchobject.groupdict()
        'size': int(button_link['size']),
        'colors': button_link['colors'][1:].split("."),
        'line': line
    return button_link

this function returns a dictionary with many properties of a button, ok. But now I need to increase its size, I could write a function like:

def increase_button_link_size(button_link, pixels):
    button_link['size'] += pixels
    return button_link

At some point you may want to change the design and make a ButtonLink class, maybe because you need a much more complex model and OO could help. Anyway, here is how the class could be implemented:

class ButtonLink(object):
    def __init__(self, matchobject, line):
      self.__dict__ = matchobject.groupdict() =
      self.size = int(self.size)
      self.colors = self.colors[1:].split(".")
      self.line = line

    def increase(self, pixels):
        self.size += pixels

the problem now is that button_links are being used as dictionaries all over the place, like button_link['size']. And even worse, this could be a public API and you may not have access to the clients using it. In this case we could simulate the dict api implementing __getitem__:

import warnings

class ButtonLink(object):
    # ... same as above

    def __getitem__(self, item):
        warnings.warn("Dict-like access is deprecated, please use `.{0}`"
                      .format(item), DeprecationWarning)
        return getattr(self, item)

Now you can use button_link.size and button_link['size']. And I also added a deprecation warning to notify the users that they should use the object API from now on.
And you should also modify the functions above to create and manipulate the object instead of the dictionary, also raising warnings if you want.

You may want to implement other dictionary methods, like keys, items, has_key, __contains__, etc.

Why not make a dict subclass?

The main reason I wouldn’t subclass dict in this case is philosophical: ButtonLink should behave like a dict (temporarily), but it is not a dictionary. A good example of a dict subclass is OrderedDict, it is a dictionary with customized behavior.

Another aspect to keep in mind is when we write a subclass is that we inherit all the methods from the superclass, all the API, and it’s now part of my class API. In my case I don’t want to implement the __setitem__ method, because the clients should not be using it, all the time you need to modify the button_link dict there is a specialized function to do so, and these functions I can easily rewrite to use the object API.

“What about isinstance()?!”. Yeah, you’re going to loose it, since button_link is not a dict anymore isinstance(button_link, dict) is False. But I believe you should not be using it, type checking with isinstance() and even worse, type(), is not very common on languages like python. “If it walks like a duck and quacks like a duck, then it is a duck”! I know that sometimes isinstance() is handy, but I don’t think it’s appropriate here because of the philosophical argument I gave above.


Start simple, it’s always easier to evolve to a more complex design than the other way around.

Using Python magic methods your objects can easily look like a native data structure, so start using simple data structures and write your own if you need later. Another language feature that helps this incremental design evolution is properties, a simple attribute can evolve to a complex getter/setter transparently.

Don’t forget the Zen of Python:

Simple is better than complex.
Complex is better than complicated.

[Davidson Fellipe] Big Review de 2012

Tuesday, January 1st, 2013

Depois de ler alguns depoimentos de alguns amigos sobre 2012, resolvi escrever o meu. Esse ano, foi o ano que fez mais diferença na minha carreira profissional, e que ano! Comecei o ano visitando pela primeira vez a capital mineira, onde tive o prazer de palestrar no BeagaJS, onde abordei o tema de Performance em Jquery Apps. Depois tirei férias… \o/

Nessas minhas primeiras férias, depois de 5 anos de faculdade e 1 ano e meio de, resolvi conhecer o 2º destino turistíco mais visitado desse país, e o que eu tinha mais interesse em conhecer: A bela Foz do Iguaçu, e ainda visitei, a simpática Puerto Iguazú (Argentina) e a bagunçada Ciudad del Este (Paraguai), essa região de fronteiras é incrível e com muitas culturas diferentes, que se eu fosse contar todos os detalhes mereceria um post exclusivo.

De volta a terrinha & Carnaval…

recife_carnaval_2012 Depois de uns 6 meses sem voltar a Recife, fui rever minha cidade, e curtir o melhor formato de carnaval desse país, onde até pessoas com não dão valor ao samba, conseguem se divertir. #troll

Nada melhor que essa ultra-mega-hiper lotada Praça do Marco Zero, ao som de Seu Jorge e Nação Zumbi, tocando até o amanhecer para matar saudades de Recife. =)

Contribuindo para o crescimento do frontend em Pernambuco =)

Após voltar para o mundo real, tinha que começar a pensar no que eu poderia fazer de diferente em 2012, algo que pudesse ajudar a vida de muitas pessoas, então resolvi participar da organização de um evento para minha terrinha com grandes nomes da área do Javascript, junto com Luiz Tiago e Thiago Azurém criamos o PernambucoJS, com a grande colaboração de Djalma Araújo e Eduardo Lundgren.

O PernambucoJS foi um projeto de cerca de 3 meses, onde levamos 7 palestrantes e contou com a presença de cerca de 220 pessoas. E ainda palestrei sobre Javascript Cross-Browser.

Mestrado na PUC-Rio

Ainda em março, comecei o Mestrado na PUC-Rio, talvez essa tenha sido uma decisão não tão legal para esse ano, mas por não ter conseguido me candidatar em 2011 (ano que seria mais indicado) resolvi encarar o desafio, mesmo assim vem sendo complicado achar disciplinas que eu ache relevante para minha carreira. :/

Viagem aos EUA

sfo Em Maio, fiquei na expectativa de minha primeira viagem internacional segunda viagem internacional, se considerarmos uma visita a Argentina e Paraguai em Janeiro. =)

Depois da correria para visto e passaporte, embarquei com destino a San Francisco para participar da Fluent Conference, a primeira conferência focada em javascript da O’Reilly, realizada na apaixonante San Francisco. Foram 3 dias de evento, e uma ótima oportunidade para troca ideias com desenvolvedores de várias partes do mundo, e abrir meus olhos para o grande crescimento do mercado de mobile para o desenvolvedor Frontend. Mais detalhes sobre o que rolou no evento podem ser conferidos nessa minha apresentação: Fluent Conference Highlights, que apresentei em um TechTalk lá na e também no Rio.js. Ainda pude conferir uma SF em clima de festa, em comemoração dos 75 anos da Golden Gate Bridge, que trouxe um tempero especial para essa viagem.

Preparativos para o Front in BH

frontinbh Esse ano fui convidado pelo Giovanni Keppelen, para participar da organização da 2ª edição do Front in BH, evento realizado em julho, que contou com cerca de 320 participantes na capital mineira, era apenas minha 2ª vez na cidade, e foi bastante gratificante os ótimos feedbacks que recebemos dos belo-horizontinos. Para mais detalhes técnicos sobre o que rolou no evento, confira esse post do Sérgio Lopes:

IV FSLDC – Duque de Caxias, RJ

No final de junho rolou mais uma edição do Fórum de Software Livre de Duque de Caxias – FSLDC 2012. O evento que contou com cerca de 340 pessoas, e nessa minha primeira apresentação nesse fórum, mostrei minha palestra sobre Performance em Jquery Apps.

PHP n’ Rio 2012

Em novembro rolou o PHP n’ Rio, evento carioca organizado por membros da comunidade local de PHP. Evento que é realizado desde 2009, com um público sempre crescente. Antes do evento participei desse hangout com o Vínicius Machado ( membro da organização ):

Hackathon da BlackBerry Jam Sessions

RJ-Best-Game Em setembro tive a oportunidade de participar do muito bem organizado BlackBerry Jam Sessions #5, realizado no Rio de Janeiro, foi minha primeira participação em um Hackathon, onde fiz um grupo junto com Matheus Vilaça, Flor di Maria, Zeno Rocha, Zanoni Miranda, apenas o Zeno, eu já conhecia antes do evento, e após 10 horas de programação, apresentamos o jogo Black Wings, e vencemos na categoria Melhor Jogo. Todo jogo está disponível no github. Para maiores informações sobre o evento acesse esse link.

Primeiro artigo na Revista Wide

Em julho deste ano, eu fui convidado pela Revista Wide para participar da matéria intitulada:

Frontend – Made in Brasil: Há dois anos as empresas brasileiras não demonstravam muito interesse por esse profissional, enquanto já existia uma forte demanda no exterior. Isso mudou?

Esse foi outro grande desafio para esse ano, onde busquei expor minha visão atual sobre a área de desenvolvimento frontend, e mostrando aos interessados na área, o que o mercado exige de nós profissionais. Obrigado Arteccom pela oportunidade. =)

Front in Maceió

frontinmaceio Em outubro estava de volta ao nordeste, e dessa vez para um estado bem representativo em minha vida, e onde vive grande parte de minha família. Apesar das dificuldades, fizemos um evento de TI para 200 pessoas nessa capital com menor IDH do Brasil, esse foi um fato que trouxe uma grande satisfação, mas não foi fácil conseguir apoio para o evento. Por outro lado, Juarez P.A. Filho e eu, tivemos que pensar em várias estratégias de marketing para tornar possível essa ideia. Conheci muitos devs de lá, e estou gostando de ver esse Buzz pós-evento gerado na região, a turma do Caravana Web está quebrando tudo por lá.

BrazilJS Foundation & BrazilJS Conference

braziljs Em Julho, anunciamos a Fundação BrazilJS, que é uma fundação sem fins lucrativos com a missão de mover e unir a comunidade de JavaScript no Brasil. Onde sou mais ligado a apoios a eventos regionais e a BrazilJS Weekly.

Já em agosto, rolou a BrazilJS Conference, um evento que superou todas minhas expectativas, e pela primeira vez reuniu a grande maioria da comunidade frontend do país, e grandes palestrantes do Brasil e do mundo, que também contou com forte apoio da, onde levamos um belo stand. Sem dúvida esse foi o momento “mais friozinho na barriga” do ano, subir num palco quase 1 mil pessoas presentes num teatro em Porto Alegre, não foi fácil e ao mesmo tempo foi o maior desafio para a timidez na minha vida! =) Fiz a primeira palestra do segundo dia do evento, com o tema Performance em Javascript.

Após ser anunciado e subir alguns degraus, vi aquela enorme platéia, bebi um gole de água, e falei para mim: “Vai lá e faz a melhor apresentação que você já fez na vida”, após uns 5 minutos tentando me entender com a forte iluminação, acredito que consegui passar a ideia para maioria dos presentes, e coletei feedbacks da apresentação, que já pude mostrá-los em um Workshop na

Por último, mas não menos importante…

Considerando atividades que me envolvi o ano todo, posso destacar: O trabalho no Futpédia, em melhorias de frontend e no lançamento da página de equipe, foi meu primeiro envolvimento em um projeto Ruby on Rails, e gostei bastante de trabalhar com esse framework e com Rspec. Além disso, no final do ano lançamos o Eu Atleta, primeiro projeto que usei HTML5 na área de esportes da, e pude brincar com Twitter Bootstrap, History API, Geolocation, grande preocupação em navegação com e sem javascript. Uma das páginas que mais gostei de trabalhar foi a de calendário de eventos.

E 2013?

  • Beber mais água e evitar outro calculo renal =)
  • Voltar a praticar exercícios e emagrecer 11kg
  • Terminar as disciplinas do Mestrado
  • Correr uma corrida de rua
  • Ir a outro evento internacional (QConSF, QConNY, JSconf Arg ou EUA)
  • Aumentar a visibilidade da BrazilJS Foundation
  • Um Front in BH épico
  • Um Front in Maceió épico
  • Um PernambucoJS épico
  • Novo layout do blog


A minha esposa, que mesmo não tendo nada a ver com desenvolvimento, se envolveu bastante nos eventos. A pelo incentivo a participar nos eventos e mestrado, ao BrazilJS Team, a galera que participou do RioJS, PernambucoJS, Front in Maceió e Front in BH, aos parceiros de organização Giovanni Keppelen (RioJS e Front in BH), Victor Ferraz (BH), Juarez (Maceió), Luiz Tiago (PernambucoJS) e Azurém (PernambucoJS).