Circuito das Estações Adidas 2009 – Etapa Primavera – 10km

Domingo, dia 27 de setembro de 2009, corri a Etapa de Primavera 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 [...]

Link deste post

Portraits and Photography

Clique aqui para a versão em Português.

My latest passion has been portraiture and photography in general.

From an old hobby, the interest only grew even more after I discovered the Strobist website. David Hobby teaches everything about lighting your little flash unit, and the secret is: use it off your camera.

A photographer named Jeremy Cowart created a movement called Help Portrait, check the video here and the Help Portrait website. On December 12th photographers from around the world will go out in the streets and reach people in need, and simply take their photographs. This is to help people that would never been able to pay for a photograph. The idea is: shoot and deliver the prints later. Just that. Connections will be made and you’ll learn a lot about people.

Inspired by a post on Zack Arias blog, I started to take some portraits right away. This is in preparation for the Help Portrait official day. So I went ahead and asked if a local retirement home would open their doors so I could photograph (for free) all of their 60 residents, elderly ladies and men. They were very happy to get this offer and yesterday I could do the photo session.

I’m really happy with the results. Many of the ladies and men were very happy about the photos. Some were not excited about having a photo taken, so for these I’d just showed some of the previous photos and let them decide. After this, some got excited and let me take their photos. Soon I’ll be able to see their joy when I deliver them the prints.

I started to process some of the images, and the best ones I posted on Flickr. I’ll be printing all photos and giving to them.

I learned that from very small things we can make people in need a little more happier. I saw a phrase written on their car that read “Love never gets old”.

Check some of the elderly portraits I shot on the retirement home.

---

Minha recente paixão tem sido retratos e fotografia em geral.

A partir de um hobby antigo, o interesse cresceu ainda mais depois que descobri o site Strobist. David Hobby ensina tudo sobre como iluminação com flashs portáteis, e no final das contas o segredo é: use ele fora de sua câmera.

Um fotógrafo chamado Jeremy Cowart criou um movimento, o Help Portrait. Confira o vídeo aqui e o site do Help Portrait. Em 12 de dezembro fotógrafos do mundo inteiro vão sair nas ruas, encontrar pessoas com algum tipo de necessidade (seja pessoas sem-teto, crianças órfãs, ou qualquer tipo de necessidade), e simplesmente vão dar um presente: tirar uma fotografia delas e depois levar a foto impressa. Isto será feito para ajudar aqueles que talvez nunca poderiam pagar por uma fotografia. Conexões serão feitas e você vai aprender bastante coisas sobre pessoas.

Inspirado por um post no blog de Zack Arias, comecei a tirar alguns retratos imediatamente. Esta é uma preparação para o dia oficial do Help Portrait. Fui em frente e perguntei em uma casa de repouso da cidade, se eu poderia visitá-los e tirar fotos (gratuitas) de todos seus 60 residentes. Eles ficaram muito felizes com a oferta e ontem eu pude fazer a sessão de fotos.

Estou muito feliz com os resultados. Muitos das senhoras e senhores ficaram felizes com a idéia de tirar fotos. Alguns não ficaram muito animados com a idéia, mas nestes casos eu mostrava as fotos de outras senhoras e alguns se animavam depois disso. Em breve vou poder ver a alegria deles ao receberem as fotos em mãos.

Comecei a processar algumas das imagens, e postei algumas das melhores no Flickr. Vou imprimir todas as fotos e dar de presente para eles.

Aprendi que com pequenas coisas você pode fazer pessoas em necessidades um pouco mais felizes. Vi uma frase escrita em um carro deles escrita assim “O amor nunca envelhece”.

Confira alguns dos retratos das senhoras da casa de repouso.

Link deste post

Como gerenciar a dependência entre entidades e repositórios?

Engraçado que esse é um assunto onde há sempre mais um “ponto” a acrescentar. Motivados pelo excelente post da Caelum e discussão do GUJ (onde ambos não são tão recentes assim), eu e o Eduardo Amuri discutimos mais alguns pontos… Alguns deles podem já ter sido abordados nos links anteriores, mas vale a revisão.

Eu ia pular a questão inicial, mas vou revisar para que facilite o entendimento do resto do post para quem não leu os links acima. Uma entidade pode conhecer/utilizar um repositório? Acho que a resposta é óbvia: Sim. Repositórios são conceitos de negócios, fazem parte do domínio, e por isso não há nada de errado em uma entidade conhecer um repositório. Não vou entrar no mérito de como o repositório deve ser implementado, não é o meu interesse no momento. Mas vamos lá… Ok, podemos ter entidades que dependem de um repositório, e o problema é: como gerenciar essa dependência?

A seguir, discutimos algumas abordagens para resolver esse problema e chegamos em algumas conclusões, das quais gostaria de compartilhar.

Sugestão I: Receber o repositório pelo construtor
A entidade deve possuir um construtor que receba a dependência.

Vantagens:

• A dependência fica explícita, ou seja, não há como criar uma entidade sem entregar a dependência já resolvida.

Problemas:

• Torna o código menos legível, afinal sempre que for instanciar uma entidade, deve-se injetar seu repositório.
  Ex: Pessoa mauricio = new Pessoa ( repositorioDePessoas );
• Imagine uma entidade que depende de mais de um repositório (por quê não?). Imagine passar os diversos repositórios no construtor. Menos legível ainda…
  Ex: Pessoa mauricio = new Pessoa ( repositorioDePessoas, repositorioDeXPTO, repositorioDeXYZ );
• Isso fica pior ainda quando definimos um construtor que receba algum atributo, por exemplo.
• Ex: Pessoa mauricio = new Pessoa ( “mauricio”, “aniche”, repositorioDePessoas, repositorioDeXPTO );

Testabilidade:

• É fácil injetar um mock no lugar da dependência, para facilitar o teste unitário da entidade.

Sugestão II: Definir um setter para a dependência
A entidade deve ter um método setDependencia() que receba a dependência.

Vantagens:

• Elimina o problema de resolver a dependência no momento da criação do objeto.

Problemas:

• Você precisa setar a dependência sempre que for utilizar, e isso pode ser um problema. Você precisará fazer todo o tempo algum tipo de validação no código da entidade para saber se a dependência já foi injetada ou não.
  Ex: public List<XPTO> pegaXpto(int abc) { if(repositorio!=null) repositorio.pegaX(abc); }

Testabilidade:

• Também é fácil injetar um mock no lugar da dependência.

Sugestão III: Utilizar o próprio repositório para injetar repositórios nas entidades
Conforme sugerido pelo Paulo Silveira e pelo Fabio Kung no post, sempre que um objeto for recuperado pelo seu repositório, o mesmo deve se “auto-injetar” antes de devolver o objeto.

Vantagens:

• A complexidade do gerenciamento desse dependência fica escondida no código do repositório.
• O código a ser implementado, de maneira geral, é simples.

Problemas:

• Apesar de ser simples, deve ser replicado em todos os métodos do repositório. Se o método do repositório retornar uma lista, por exemplo, deve-se repetir o processo em todos os elementos dessa lista.
• Apenas as entidades que são recuperadas pelo repositório recebem a dependência. Entidades criadas em qualquer outro ponto do projeto não recebem essa dependência de forma automática. Isso pode causar o problema levantado na sugestão II.
• Caso a entidade mude e venha a depender de um outro repositório, você terá muito código para alterar.

Testabilidade:

• Da mesma maneira que o repositório injeta a dependência (através de um setter), pode-se injetar um mock.

Sugestão IV: Injetar o repositório por AOP
Uma idéia bastante interessante seria injetar a dependência por AOP. Dessa maneira não importaria como o bean é instanciado, seja ele feito pelo JPA, Hibernate, etc, ou pelo programador. Essa foi uma sugestão levantada pelo Alessandro Lazarotti, nesse post do GUJ.

Vantagens:

• O código fica bastante claro.

Problemas:

• A implementação de um aspecto geralmente não é trivial.

Testabilidade:

• Dependendo do modo que o aspecto for implementado, talvez não seja tão trivial injetar a dependência. Para facilitar, pode-se criar um setter exclusivamente para isso, mas não é muito elegante.

Sugestão V: Resolver a dependência dentro da própria entidade
A idéia seria a própria entidade resolver a sua dependência. No caso, ela mesma invocaria o framework de DI, e recuperaria a instância da dependência. Pode-se até pensar em uma Factory para que a entidade não dependesse diretamente de uma implementação de framework de DI.

Vantagens:

• Solução bastante simples.
• Acaba com o problema da necessidade da entidade validar se a dependência foi injetada ou não, já que ela mesma vai resolver.

Problemas:

• Não é muito elegante fazer com que a própria classe resolva suas dependências.

Testabilidade:

• Como é a própria classe que resolve a dependência, você precisará de um setter para conseguir injetar um mock. Como dito acima, não é muito legal.

(*) Além do que foi citado acima, existe um outro problema, ortogonal ao das dependências, e diz respeito diretamente à implementação desse projeto em particular. Por estarmos discutindo uma aplicação web, o contexto do Spring está guardado dentro do contexto web. Para que um POJO qualquer recupere esse contexto, ele precisaria conhecer o servletContext. Ainda não encontrei uma maneira muito clara para resolver isso, mas minha sugestão é criar uma classe singleton que conteria um atributo com uma instância de contexto do Spring, e essa instância seria injetada por um filter ou um listener qualquer, que subiria logo após ao listener do Spring. A partir daí, todas as classes de domínio fariam acesso à esse singleton para capturar o contexto.

Portanto, é possível gerenciar essa dependência de diversas formas, todas elas com suas vantagens e desvantagens. E você, como faz?

Link deste post

My take on the .NET ecosystem

(A tradução deste artigo para o português estará disponível em breve.)

I’ve been working – both academically and professionally – with the .NET stack since 2003 and although I didn’t meet the rough edges of .NET 1.0 and Visual Studio 2002, I did saw the steep transition from Framework 1.1 to 2.0 and the smoother 3.0 and 3.5 steps. Right now we’re once again in a period of transition which seems to stale the .NET world for a couple of months at every release cycle. It seems the world is waiting for .NET 4.0 and whatever wasn’t good enough on the previous version–such as the Entity Framework–is not going to be further developed by the community. While in theory this represents a golden opportunity for alternative libraries to gain some momentum, in practice corporate developers do realize that the cost of changing legacy applications they simply don’t want to touch outweighs the cost of sitting still while Microsoft puts the latest bells and whistles to the “branded” library and the mainstream community starts blogging with some useful prototypes people can reproduce.

That said, what seems to be wrong? Well, for starters, it is important to point out that the Microsoft ecosystem, while extremely diverse and rich, could be said to have roughly two kinds of developers: those who by and large are using exclusively the System.* and Microsoft.* namespaces, and dragging-and-dropping like crazy; and those who are producing more exotic code by relying on third-party–free and commercial–libraries. The latter will necessarily be coming from or occasionally wandering off to a non-Microsoft platform. Additionally, if you think in terms of the Dreyfus model, you’ll most likely find more individuals with ‘proficient’ or ‘expert’ skill levels among the group not relying solely on the Microsoft stack. Microsoft has come a long-way in order to provide to such a heterogeneous community and for that it had to make compromises: shall always be agnostic; shall never be opinionated; will always feel like a duck–can’t seem to fly, swim nor walk properly, but does it all.

At the end of the day, what’s the product of this policy? Pulverization, it seems. If you look at what the community has produced to specialize the loose ends Microsoft left in its framework, you’ll find a mess. A mess of great code, but a mess nevertheless. While Ayende Rahien, Jeff Brown, Jimmy Nilsson, Miguel de Icaza and others may be strong voices on the community, it doesn’t feel like they’ve ever sat down and met each other. But why should they? Has Microsoft set an example in the first place? One thing is for certain: if the community has grown up like that, it has only done so because it was following Microsoft’s steps. There are many areas where it’s easy to see overlapping bits in the framework where you don’t feel collaboration and reuse took place: Linq to SQL vs. Entity Framework, PLINQ vs. CCR, ASP.NET vs. ASP.NET MVC, WCF vs. ASP.NET MVC . . . the list goes on. None of the elements of each pair are exactly like the other (and it was never intended that they should), but I guarantee you’ll find repeated functionality. The point is: if Microsoft is repeating itself and some of its many areas are evolving at some extent unaware of their neighbor’s progress, why shouldn’t the community? Hey, why reuse if we can come up with a new wheel, right? Well, wrong . . .

The very community Microsoft fed and raised could be what is holding .NET back today. And if that is so, then Microsoft itself is to blame. While it’s useless to compare the .NET community to others, I’m sure that it wouldn’t hurt if we had the Java maturity and scope or the RoR openness. Instead, what we have is some great software being produced by individuals who sadly can’t embrace the whole world, some great software being produced by companies, but which stay proprietary (and will remain so because it cost them a lot of money to develop and because, to put it simply, they’re just too damn afraid of open-source), and no cohesion whatsoever. (The reason universities aren’t producing more with the Microsoft stack despite their aggressive programs such as DreamSpark, ImagineCup and MSDNAA is beyond me. Maybe the company is simply trying too hard to fit in.) Meanwhile, Microsoft’s policy has been (up until now, read along) of watching what’s a must-have in the community and either bringing it in or recreating it (ORM, IoC and logging comes to mind). Kind of a crazy self-embrace-and-destroy-ish strategy.

Folks like Scott Guthrie and Erik Meijer, however, have been pushing a different agenda. They and their colleagues (Hanselman, Haack, Block etc.) have realized that Microsoft hasn’t been leading the evolution of this industry for some time and that the grass on the other side could indeed be greener. Microsoft has a lot to teach and certainly has a lot to learn, and those guys were the ones who step up and started making a difference. This is a generation of bloggers, start-ups and self-management models, and where accountability and transparency are prime values. Microsoft, I think, has caught up with that, a sign that the times have changed and that Ozzie is indeed continuing where Gates left off, taking the company into the future. The important thing is that the industry, as whole, ends up better at the end of the day.

Microsoft has to keep in that track. Opening ASP.NET MVC, embracing jQuery and the Mono Project, for example, were great moves and, not surprisingly, they came on Guthrie’s watch. While Microsoft has made some design decisions for the developers–and make no mistake: some of them, namely the agnostic die-hards, won’t like these decisions–they’ve reached a tipping point in the history of the ecosystem. Microsoft’s somewhat controversial new endeavor, CodePlex Foundation, is rapidly gaining popularity and will be subject of a lot of scrutiny by the community in the next months. What has changed in the strategy, is that instead of messing around with what the community has produced, Microsoft is indirectly providing guidance (with processes, techniques, legal mechanisms etc.) for commercial and open-source developers to lift themselves (and their work) up by their own bootstraps. As reported by Jon Tørresdal at InfoQ, Scott Bellware explains:

Microsoft has been forced to build new products from scratch to provide Microsoft customers with the value that open source projects have proven and delivered. These projects are often far less robust and mature as the open source that inspired them. The protections offered by the CodePlex foundation are also a turning point that frees up Microsoft resources to focus on integrating existing value rather than duplicating it, and risk missing the value targets offered already by open source.

All of this points to an evolving shift in culture and values toward the freedom to choose solutions based on merit rather than mere intellectual property risk mitigation.

This shift in culture and values toward meritocracy and the benefits that come from open competition that stands a chance of taking Microsoft and Microsoft customer community in a brand new directions that can provide more value from the Microsoft stack than we’ve seen yet.

When collaboration and cooperation start taking place (hey, isn’t it high time people started seeing value on using distributed-VCS?), projects can evolve naturally and in an orderly fashion. No reason why it should be different from what’s already been happening for ages in the unix-like open-source front. In the future, there’s a great chance we’ll see things like a package manager for libraries, common repositories, self-organizing and integrated communities, and flourishing projects. In the end, my take is that, under this strategy, Microsoft’s ecosystems grows stronger, gains market share, and all that without compromising the company’s business model.

* * *

This blog is about technology, business administration and engineering. I’ll be watching how the Microsoft ecosystem evolves from here on and I hope to be writing again soon about some predictions I guessed right. Meanwhile, I’ll focus on how to create great software by mashing .NET stuff up, I’ll be visiting different platforms either by professional necessity or by sheer curiosity (the latter more often than the former), and I’ll occasionally be visiting topics on business models and human relations. That’s sharpshooting.

Link deste post

Nova página com livros que eu já li

Criei uma nova página mostrando os livros que eu já li. Nessa página estou utilizando um widget de uma ferramenta muito legal chamada Shelfari, que funciona como uma “prateleira virtual”. Lá é possível cadastrar os livros que você já leu, pretende ler ou que está lendo atualmente. Além disso, você pode cadastrar amigos e divulgar seus livros [...]

Link deste post

gitosis setup step-by-step

This is the first post of the git series - small useful tips for the everyday git.

This tutorial is about [Gitosis] setup. From the project's readme:

Gitosis aims to make hosting git repos easier and safer. It manages multiple repositories under one user account, using SSH keys to identify users. End users do not need shell accounts on the server, they will talk to one shared account that will not let them run arbitrary commands.

For this recipe, we will use some conventions:

• user@local$ for commands that should be run at your local machine.
• user@srv$ for commands that should be run at your server.
• git@srv$ for commands that should be run with the git user (we'll create this later, delete this user or use another name if you already has it on your server).
• all root access will be done through sudo.
• lines ending with \ must be typed in one line

We will need a linux server; my setup will be based on a ubuntu system, but you can use almost any *nix flavor.

You will need to have an ssh server installed as pre-requisite - run sudo apt-get install ssh to install it. (thanks DJC)

1. Install Compilation Tools & required libs for git

   user@srv:~$ sudo apt-get install build-essential libssl-dev \
   zlib1g-dev libcurl4-openssl-dev libexpat-dev
   

2. Download & uncompress Git sources

   user@srv:~$ wget http://kernel.org/pub/software/scm/git/git-1.6.4.4.tar.bz2
   user@srv:~$ tar -jxvf git-1.6.4.4.tar.bz2
   

3. Build & install git

   user@srv:~$ cd git-1.6.4.4
   user@srv:~/git-1.6.4.4$ make prefix=/usr/local NO_TCLTK=1 all
   user@srv:~/git-1.6.4.4$ sudo make prefix=/usr/local NO_TCLTK=1 install
   user@srv:~/git-1.6.4.4$ cd 
   

4. Install required python libs

   user@srv:~$ sudo apt-get install python-setuptools
   

5. Download & install gitosis

   user@srv:~$ git clone git://eagain.net/gitosis.git
   user@srv:~$ cd gitosis
   user@srv:~/gitosis$ sudo python setup.py install
   

6. Create our git user

   user@srv:~$ sudo useradd -s /bin/bash -U -d /var/lib/git -m -r git
   

7. Generate the gitosis-admin ssh key (if you don't have one already)

   user@local:~$ ssh-keygen -t rsa -C user
   

   press enter for the default location, then provide it with a passphrase

   copy the generated public key to server

   user@local:~$ scp ~/.ssh/id_rsa.pub user@srv:/tmp/user.pub
   

8. Log in as the newly created git user

   user@srv:~$ sudo su - git
   git@srv:~$ 
   

9. Initialize gitosis

   git@srv:~$ gitosis-init < /tmp/user.pub
   Initialized empty Git repository in /var/lib/git/repositories/gitosis-admin.git/
   Reinitialized existing Git repository in /var/lib/git/repositories/gitosis-admin.git/
   

10. Adjust some permissions on admin repository

    git@srv:~$ chmod +x ~/repositories/gitosis-admin.git/hooks/post-update
    

11. Clone the gitosis-admin repository

    user@local:~$ git clone git@srv:gitosis-admin.git
    Initialized empty Git repository in /home/user/gitosis-admin/.git/
    remote: Counting objects: 5, done.
    remote: Compressing objects: 100% (4/4), done.
    remote: Total 5 (delta 0), reused 5 (delta 0)
    Receiving objects: 100% (5/5), done.
    

12. Voilà! Your gitosis setup is working! Let's take a look at gitosis's structure:

    gitosis.conf
    keydir/
    keydir/user.pub
    

13. To finish our recipe, lets add a new user & a new repository
    Let's call our new user john
    Get john's ssh public key and put it inside keydir/john.pub
    Add to gitosis.conf:

    [group new-repo]
    writable = new-repo
    members = user john
    

14. As gitosis is managed by git itself, let's commit our changes:

    user@local:~/gitosis-admin$ git status
    # On branch master
    # Changed but not updated:
    #   (use "git add <file>..." to update what will be committed)
    #   (use "git checkout -- <file>..." to discard changes in working directory)
    #
    # modified:   gitosis.conf
    #
    # Untracked files:
    #   (use "git add <file>..." to include in what will be committed)
    #
    # keydir/john.pub
    no changes added to commit (use "git add" and/or "git commit -a")
    user@local:~/gitosis-admin$ git add keydir/john.pub gitosis.conf
    user@local:~/gitosis-admin$ git commit -m "added new-repo + john keys"
    [master ad62139] added new-repo + john keys
     2 files changed, 4 insertions(+), 0 deletions(-)
     create mode 100644 keydir/john.pub
    user@local:~/gitosis-admin$ git push origin master
    Counting objects: 8, done.
    Compressing objects: 100% (5/5), done.
    Writing objects: 100% (5/5), 1.02 KiB, done.
    Total 5 (delta 0), reused 0 (delta 0)
    To git@srv:gitosis-admin.git
       bdc4dbc..ad62139  master -> master
    

15. Finally, let's john push his work to the shiny new repository:

    john@local2:~/new-repo$ git remote add origin git@srv:new-repo.git
    john@local2:~/new-repo$ git push origin master
    Counting objects: 3, done.
    Delta compression using up to 2 threads.
    Compressing objects: 100% (2/2), done.
    Writing objects: 100% (3/3), 241 bytes, done.
    Total 3 (delta 0), reused 0 (delta 0)
    To git@srv:new-repo.git
      * [new branch]      master -> master
    

16. C'est fini! A complete setup running. Enjoy!
    If you have any doubts / corrections, please comment!

Link deste post

Cheeseburgers, Ruby e magia negra

Vamos usar um pouco de magia negra do Ruby para encontrar uma alternativa à implementação clássica do Design Pattern Decorator apresentado pela GoF. . Este post é a continuação de dois anteriores: Cheeseburgers, Decorators e Mocks Cheeseburgers, Decorators e Ruby Se você ainda não os leu, recomendo que o faça para entender o contexto do exemplo onde estamos aplicando o [...]

Link deste post

Novidades no Ruby 1.9

Para quem ainda não sabe, Nando Vieira, figurinha carimbada já na comunidade Rails – se você não o conhece e nem o segue, deveria – entrou na empreitada de escrever tutoriais de assuntos que rodeiam Ruby e Ruby on Rails, a série HowTo e o último lançamento recebeu o título: “O que mudou no Ruby 1.9“. O assunto é abortado de forma sucinta, sem rodeios e vai direto ao ponto, sem blábláblá. O melhor, o preço é pechincha! Só 10 pratas, isso mesmo, DEZ REAL!

Publicado emtutorial Tagged: howto, nando vieira, tutorial

Link deste post

Mac OS X Software Update não funciona

Quando ainda estávamos na Webco, meu MacBook foi configurado para pegar as atualizações de nosso servidor interno. Até então funcionava e era bem rápido, pois como o servidor fazia o download de todas as atualizações para si, quando nossos Mac Books iam fazer os devidos updates, usava essa cópia local e ficava bem mais rápido o update. Mas devido as mudanças que ocorreram, “perdemos” nosso servidor central de updates e como minha máquina apontava para esta, não mais conseguia fazer os updates. Mas nada que um começo de férias para resolver esse problema. Resolvi solucionar esse problema e não foi fácil achar a solução, então resolvi colocar aqui para quem precisar.

Ná pagina de suporte da apple, onde descreve para configurar conforme descrevi acima, tinha o que eu queria que era o endereço para o catalogo, mas o bendito arquivo “/etc/swupd/swupd.plist” não existia. Como faz? Busca prá lá… busca pra cá… Até que cheguei em outra página que explica como configurar o Software update sem o Open Directory, onde cheguei até o arquivo “/Library/Preferences/com.apple.SoftwareUpdate.plist“, no qual era só trocar o endereço do atributo CatalogURL para um servidor local, mas eu queria trocar para o servidor original, logo…

1) Abrir o “Property List Editor”

2) Abrir o arquivo /Library/Preferences/com.apple.SoftwareUpdate.plist

3) Editar o attributo CatalogURL com o valor “http://swscan.apple.com/content/catalogs/index.sucatalog"

Publicado emtutorial Tagged: apple, mac os x, software update

Link deste post

Palestra: Web Performance Client Side

Há algumas semanas tive a oportunidade de palestrar internamente em dois eventos aqui na Locaweb:

• Locaweb Tech Day: um evento de dia inteiro que ocorre a cada 2 meses, onde cada pessoa pode palestrar sobre um assunto de interesse;
• Palestras Técnicas: ocorre às quintas-feiras, durando 1 hora. Uma pessoa por semana palestra sobre um assunto técnico.

Nas duas oportunidades palestrei sobre como fazer um site ficar mais rápido, e abrir num “estalo”. O título das palestras foi: Web Performance Client Side.

Se você já parou pra pensar em otimização de um website, vai perceber que o lado server side (sua aplicação Rails, PHP, etc) conta na velocidade de carregamento, mas na prática representa muito pouco. Isto acontece porque uma requisição é processada pelo servidor em 200 milisegundos, digamos, enquanto o mesmo site pode levar 10 segundos para carregar no browser. Então qualquer otimização que ocorra em server-side só vai afetar a quantidade de pessoas que podem acessar seu site ao mesmo tempo. Não afeta a velocidade individual que cada pessoa vai ter ao navegar nas páginas de seu site.

E para melhorar a velocidade client-side, a que realmente importa na maioria das vezes, existem várias técnicas inteligentes e interessantes. Na apresentação que coloquei no SlideShare, você pode pegar um apanhado com as últimas técnicas para desenvolvimento web com vistas à performance no browser.

Existe muita coisa mesmo na apresentação, e é imperdível pra quem trabalha com Desenvolvimento Web.

Veja a apresentação sobre Web Performance Client Side no SlideShare. Ou baixe o PDF, mas para isso você precisa ter conta no SlideShare.

Link deste post