Welcome

Este blog tem como objetivo centralizar todas as informações que estudo. Meus textos são apenas resumos de livros, cursos e matérias provados com códigos.

Veja também os assuntos Off Topic, Metodologia Ágil e os posts evolutivos Sopa de letrinhas, Ferramentas e Livros.


Eventos:



13 abril 2013

Um pouco sobre Inbox Zero

Em poucas palavras, Inbox Zero tem como objetivo tratar seus e-mails de uma forma que você não gaste tanto tempo lidando com ele, e ao mesmo tempo saiba o que esta pendente ou não. São sugestões para você melhorar seus hábitos com seu e-mail.

Eu comecei a práticar Inbox Zero no começo deste ano (2013), e passado alguns meses, posso afirmar que tem me ajudado bastante. A principal motivação é não ter mais aquela sensação de que estou esquecendo algo. Navegando pelas divisões de pastas pendentes*, é possível saber exatamente o que é necessário ler, responder ou tomar alguma ação.




Inbox Zero foi criado pelo Merlin Mann em 2006, eu acabei conhecendo este assunto em um post da Bluesoft, quando estava estudando sobre 'Getting Things Done' (GTD).

Para quem quiser saber mais ou ver mais detalhes, recomendo fortemente que leia os posts originais do autor. Sendo que fiz um pequeno resumo do meu entendimento, e não estou abordando todos os pontos.

Para melhor o entendimento, o conteúdo deste post foi dividido em 4 partes:

1 – É necessário mudar nossos hábitos:

Você já parou para pensar que algumas vezes acabamos respondendo o último e-mail que recebemos, onde o mais correto seria responder o mais antigo. E pior, este e-mail mais antigo, cada vez fica menos importante e você pode acabar deixando-o de lado.

Alguns lembretes:
- Mentir para você mesmo não irá limpar sua caixa de entrada, deixar para amanhã um e-mail, sendo que amanhã terão outros novos e-mails.
- Não trate cada e-mail como um presente de Natal
- Não use seu e-mail para fazer lista de tarefas (TO DO List)
- Crie filtros para mover ou apagar e-mails recorrentes

2 – Processando seu e-mail:

Uma grande diferença é que normalmente estamos acostumados a ter uma única forma de lidar com o e-mail, onde as vezes apenas checamos o que recebemos e outras vezes respondemos de verdade.

Com Inbox Zero, precisamos separar isto em 2 etapas, onde processar é uma rápida leitura em cada e-mail para saber do que se trata e em seguida tomar uma ação adequada, ou seja, cada e-mail é um 'Open Loop' que precisa ser: Deletado, Delegado, Respondido ou Movido para uma das 'Pastas Pendentes'. Os e-mails que podemos Deletar, Delegar ou que podemos responder em menos de 2 minutos, devemos tomar esta ação no mesmo instante. Os e-mails que precisamos de mais tempo para responder ou não temos todas as informações para tal naquele momento, devemos movê-los para as respectivas pastas.

Desta forma, após o processamento, a caixa de entrada ficará vazia. O que explica o nome Inbox Zero.

3 – Tratando as Pastas Pendentes:

Tirando os e-mails apagados, delegados e respondido no processamento, temos os e-mails que sobraram e que estão aguardando uma ação e estão armazenados em algum lugar nas pastas pendentes (fora da caixa de entrada). Pastas Pendentes podem ser interpretadas como uma estrutura para organizar nossos e-mails. Esta estrutura é livre, cada um pode tratar como bem entender ou achar mais interessante. Apenas é importante lembrar que, esta estrutura deve ser simples, sendo que você não pode ter muitas opções, a tarefa de mover da caixa de entrada para esta estrutura deverá ser simples e rápida.

Abaixo, gostaria de apresentar a estrutura que vem funcionando para mim:
1-RespondTo_soon
2-RespondTo_oneday
3-Todo_soon
4-Todo_ondeday
5-ToRead
6-Archive

 
Desta forma, eu tento todo dia esvaziar as pastas:
1-RespondTo_soon
3-Todo_soon


E quando tenho mais tempo ou simplesmente estou disposto, tento esvaziar as pastas:
2-RespondTo_oneday
4-Todo_ondeday
5-ToRead


A pasta 6-Archive é utilizada para armazenar os e-mails finalizados. Para facilitar a localização dos e-mails arquivados, crio sub-pastas com o assunto e o ano, desta forma, consigo ter uma estrutura que facilita a visualização dos meus e-mails na linha do tempo.

Por último, se você achou interessante e quer começar agora o Inbox Zero, em apenas dois passos é possível iniciá-lo, veja abaixo:

i) Adotar sua estrutura de pastas
ii) Fazer o processamento dos seus e-mails.

Como você deve ter 5 ou 10 anos de e-mails, será quase impossível processar toda esta quantidade. Eu adotei a estratégia de processar meus 2 últimos meses, os demais e-mails apenas movi para uma pasta chamada 'Muito-Antigo'. Desta forma, em poucas horas consegui ter minha caixa de entrada vazia e alguns e-mails nas pastas pendentes.

Finalmente, gostaria de reforçar que o Inbox Zero tem sido muito útlil para minha organização. Também acredito que estou gastando menos tempo com e-mail e me dedicando a fazer outras atividades.





Links:
http://inboxzero.com/articles/
http://www.43folders.com/2006/03/13/philosophy
http://www.43folders.com/2006/04/04/better-practices
http://www.slideshare.net/melvinramos/inbox-zero-1508788
http://inboxzero.com/video
http://www.nikilster.com/thoughts/how-to-win-at-email/#sthash.DchOqz3M.blbBSzC6.dpbs


by rAc
bit.ly/XJeIgJ 
 

21 janeiro 2013

Evite problemas com Logging, Cluster e Multi JVMs

Devem-se tomar algumas precauções ao configurar o log4j em aplicações que rodam em um cluster de servidores de aplicação.

A principal delas é separar os arquivos de log por servidor. 

Por quê? 

Quando se tem em uma mesma máquina mais de um servidor, ou seja, mais de uma JVM haverá concorrência de escrita no arquivo. Basta sua aplicação receber algumas requisições  simultâneas em servidores distintos para os sintomas abaixo serem notados:
·         Mensagens com horários desordenados
·         Mensagens corrompidas
·         Mensagens sobrepostas
·         Mensagens perdidas

Evitar esses problemas é simples.

Solução 1 - Parametrização manual

Adicionar um parâmetro de JVM (VM argument) em cada servidor que o identifique.
-DserverName=”server1”

No log4j modificar o nome/caminho do arquivo para utilizar o parâmetro definido no servidor.
<appender name="appender1" class="org.apache.log4j.DailyRollingFileAppender">
<param name="File" value="/logs/webapp1/application-${serverName}.log"/>
ou
<appender name="appender1" class="org.apache.log4j.DailyRollingFileAppender">
<param name="File" value="/logs/webapp1/${serverName}/application.log"/>

Solução 2 - Parametrização automática

Em clusters com muitos servidores a parametrização manual torna-se dificil manter. Automatizar esse processo não é complicado.

O exemplo abaixo foi desenvolvido para WebSphere, porém, pode ser utilizado como base tanto para ser genérico quanto para outros servidores específicos.

Primeiro, cria-se um ServletContextListener que verifica a existência do parâmetro de JVM e caso não exista ele é adicionado. Esse listener deve ser executado primeiro pela aplicação.

package br.com.billcode.listener;

import java.lang.reflect.Method;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ServerNameListener implements ServletContextListener {

    private static final String SERVER_NAME_KEY = "SERVER_NAME_KEY";

    public void contextDestroyed(ServletContextEvent event) {
        // Do nothing
    }

    public void contextInitialized(ServletContextEvent event) {
       
        String serverNameArgument = event.getServletContext().getInitParameter(SERVER_NAME_KEY);
           
        if (serverNameArgument == null){
            return;
        }
       
        String serverName = System.getProperty(serverNameArgument);
       
        // Verifies if the parameter already exists
        if(serverName != null){
            return;
        }
       
        serverName = generateServerName();
               
        if(serverName == null){
            return;
        }
       
        System.setProperty(serverNameArgument, serverName);
    }

    /**
     * @return The WebSphere Server's display name. 
     */
    private String generateServerName() {
        String serverName = null;

        try {
            Class<?> serverNameClass = Class.forName("com.ibm.websphere.runtime.ServerName");
            Method method = serverNameClass.getMethod("getDisplayName", null);
            serverName = (String) method.invoke(null, null);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }        
               
        return serverName;
    }
}


Segundo, adiciona-se o listener ao web.xml.
<listener>
     <listener-class>
br.com.billcode.listener.ServerNameListener</listener-class
</listener>
 
Terceiro, para o parâmetro de JVM não ficar fixo na aplicação adiciona-se um ContextParam.
<context-param>
   <param-name>SERVER_NAME_KEY</param-name>
   <param-value>serverName</param-value>

</context-param>

Quarto, no log4j modificar o nome/caminho do arquivo para utilizar o parâmetro definido como ContextParam no web.xml.
<appender name="appender1" class="org.apache.log4j.DailyRollingFileAppender">
<param name="File" value="/logs/webapp1/application-${serverName}.log"/>
ou
<appender name="appender1" class="org.apache.log4j.DailyRollingFileAppender">
<param name="File" value="/logs/webapp1/${serverName}/application.log"/>

22 outubro 2012

Dicas para melhorar a utilização do Git

1 - Adicionar configurações de cores

É possível exibir os resultados coloridos dos comandos do Git, para isto:
- Adicionar o conteúdo abaixo no arquivo de configurações do git: ~/.gitconfig

[user]
   name = Roger Camargo
   email = email@...

[color]
   diff = auto
   status = auto
   branch = auto
   interactive = auto
   ui = auto

[color "branch"]
   current = green bold
   local = green
   remote = red bold

[color "status"]
   added = green bold
   changed = yellow bold
   untracked = red

[alias]
   st = status
   ci = commit
   df = diff
   co = checkout
   br = branch
   lg = log --pretty=oneline --graph --date=short --decorate 
 
Resultado:


2 - Exibir o branch corrente no shell

Ao trabalhar com branch, é muito importante saber em qual branch esta no momento, afim de evitar commits em um branch indesejado.
- Adicionar o conteúdo abaixo após a definição da variável PS1 no arquivo ~/.bashrc

# git branch
PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '


Ou uma segunda opção para mostrar a branch em uma cor diferente

# git branch
PS1='\[\033[01;32m\]\w\[\033[01;34m\]$(__git_ps1 " (%s)")\n\[\033[00m\]\u@\h\$ '
 
Resultado:



3 - Instalando ferramenta visual para histórico de alterações

Por padrão o git possui o git log para exibir o histórico de alterações (commits), o GitK é uma versão visual. Para instalar o gitk:

$ sudo apt-get install gitk

Com o gitk instalado, é possível executar os comandos:
  • Para exibir todos os commits de todas os branches
      $ gitk --all 
 
  • Para exibir o histórico de alterações de um arquivo específico:
      $ gitk [arquivo] 
 



4 - Instalando ferramenta para facilitar o merge de arquivos em caso de conflitos

Ao executar o comando git rebase ou git merge, existe a possibilidade de ocorrer um ou mais conflitos.
Uma alternativa mais eficiente para resolver estes conflitos é o kdiff3. Assim após executar git mergetool, será executada uma ferramenta gráfica para ajudar na resolução do problema.

Para instalar o kdiff3:

 $ sudo apt-get install kdiff3

Adicionar configurações da ferramenta padrão de merge no arquivo de configurações: ~/.gitconfig

[user]
   name = Roger Camargo
   email = email@...

[color]
   ...

[merge]
   tool = kdiff3
 
Resultado do git mergetool:

Links relacionados:
http://blog.billcode.com.br/2012/05/comecando-com-git-para-usuarios-de-svn.html


by rAc

http://bit.ly/PNqu5H
 

27 maio 2012

Começando com Git (para usuários de SVN ou CVS)

Este post além de ser um guia para quem esta começando, é uma tentativa de apontar a diferença prática entre o SubVersion (SVN) e o Git. Em outras palavras, não irei mostrar os comandos equivalentes, nem a diferença entre centralizado e distribuído, ou ainda de delta e snapshot. Os quais são conteúdos interessantes e podem ser encontrados em outros artigos.

Acredito que quem está interessado em conhecer mais sobre o Git, no mínimo já teve alguma dificuldade com o SVN ou conhece algumas de suas limitações, bem como tem interesse em utilizar uma ferramenta melhor. Desta forma, não tenho a intenção de convencer quem trabalha com SVN a mudar para o Git. Ao invés disto, mostrar simplesmente as diferenças no contexto de utilização.

Em linhas gerais, é importante entender:
1 – Enquanto no SVN temos apenas um diretório de trabalho (geralmente o trunk do projeto), no Git temos as 3 áreas:
  - repositório local (que contem os branches) 
  - staging área (índice) 
  - working directory
2 – O último commit de cada branch é denominado o HEAD do branch
3 – No Git, diferente do SVN, os branches são locais e sua criação é simples (desta forma, o desenvolvedor tende a criar novos branches para cada atividade do dia a dia)
4 – A importância do comando rebase, antes de fazer merge entre branches (minimizar os conflitos)

A apresentação abaixo mostra através de desenhos os itens acima:

Existe também um resumo dos comandos do git
PDF

Referências
Boas práticas, técnicas para achar problemas e trabalhar com open-source entre outras coisas
http://www.caelum.com.br/curso/online/git

Screencast muito bom, com as explicações das 3 áreas entre outras coisas
http://akitaonrails.com/2010/08/17/screencast-comecando-com-git
http://git-scm.com/book
http://en.wikipedia.org/wiki/Git_%28software%29
http://www.vogella.com/articles/Git/article.html
http://rogerdudler.github.com/git-guide

Links relacionados:
http://www.codeforest.net/git-vs-svn
http://git.or.cz/course/svn.html
http://imasters.com.br/artigo/23356/desenvolvimento/por-que-voce-deveria-mudar-do-subversion-para-git-parte-01
http://www.ibm.com/developerworks/br/linux/library/l-git-subversion-1/
http://thinkvitamin.com/code/why-you-should-switch-from-subversion-to-git/
http://grokpodcast.com/2011/03/10/episodio-22-%e2%80%93-sistemas-de-controle-de-versao-%e2%80%93-parte-1/
http://grokpodcast.com/2011/03/18/episodio-23-%e2%80%93-sistemas-de-controle-de-versao-git-%e2%80%93-parte-2/
http://grokpodcast.com/2011/03/25/episodio-24-%e2%80%93-sistemas-de-controle-de-versao-github-%e2%80%93-parte-3/
http://sixrevisions.com/resources/git-tutorials-beginners
http://gitref.org/remotes
http://learn.github.com/p/intro.html
http://www.bernardofontes.net/blog/trabalhando-com-branchs-no-git-de-maneira-efetiv/

by rAc
http://bit.ly/K51QLh

21 fevereiro 2012

Sugestão de Trackers, Status e Category no Redmine

Este post tem apenas como objetivo uma sugestão das configurações para utilização do Redmine.

Trackers:
São os tipos de tarefas relacionadas a construção de software, que um desenvolvedor trabalha no seu dia a dia.
Feature: Uma nova funcionalidade
Improvement: Melhoria de uma funcionalidade existente
TechnicalDebt: É algo que precisa ser melhorado, porém não esta relacionado as funcionalidades, mas sim ao design de código (refactoring)
Task e Support: São tarefas que não estão diretamente ligadas ao código, por exemplo: um estudo, POC ou ajuda a um usuário.

Também pode-se criar um tracker chamado Backlog, o qual representará itens que poderão ou não tornarem Issues.

Obs: Um item de Backlog pode dar origem a uma ou mais Issues (Feature/Improvement), mas é interessante ligar esta nova Issue ao backlog utilizando o 'Parent task'. Mantendo assim a rastreabilidade.


Status:
São os estados das tarefas: Aberto, Em andamento e Fechado.
É interessante ter um estado chamado Parado, para identificar os impeditivos do projeto.



Workflow:
Com os Trackers e Status criados, é necessário montar o workflow, que basicamente é informar para o redmine quais status são possíveis para cada tracker.
 

Obs: Na configuração acima, o workflow está bem livre, em outras palavras, de um status pode-se mudar para qualquer outro. Por exemplo, uma vez no status InProgress (segunda linha), pode-se mudar para Stopped, Closed ou Canceled, quanto voltar para Open, o que algumas vezes não é o desejado. Neste caso, pode-se desmarcar o Status Open da segunda linha.



Category:
As categorias, diferentemente dos trackers e status, são por projeto.
Desta forma, sua configuração depende de cada caso, mas está relacionada a organização.
Alguns exemplos:

i) módulo: core, web, banco de dados, engine de busca
ii) negócio: contas à pagar, contas à receber, cadastro
iii) time: design, implementação, documentação



by rAc

23 janeiro 2012

Utilizando VRaptor maven archetype

Resumo sobre archetypes:
Maven Archetype é uma ferramenta para gerar templates de projetos.

Pré-requisitos:
- Maven instalado
- Jar do archetype no M2_REPO (ver link no final para mais detalhes sobre repositórios)

Utilização:
- comando mvn archetype:generate (para criar o template do projeto)
- comando mvn eclipse:eclipse (para preparar o projeto para a IDE eclipse)

VRaptor maven archetype
1) Instalação do JAR do archetype:
Na primeira vez, é necessário instalar o jar do archetype no repositório, para isto:
- fazer o download do archetype em
https://github.com/huogerac/vraptor-hibernate-archetype/downloads
(obs: para este exemplo, foi utilizado a versão 0.0.1 que por sua vez utiliza o VRaptor 3.3.1)

- fazer a instalação no repositório local

mvn install:install-file -DgroupId=br.com.caelum.vraptor.archetypes -DartifactId=vraptor-hibernate-archetype -Dversion=0.0.1 -Dpackaging=jar -Dfile=vraptor-hibernate-archetype-0.0.1.jar -DgeneratePom=true


2) Criando um novo projeto VRaptor
- executar o comando abaixo para criar o projeto
mvn archetype:generate -DarchetypeGroupId=br.com.caelum.vraptor.archetypes -DarchetypeArtifactId=vraptor-hibernate-archetype -DarchetypeVersion=0.0.1

obs: será necessário preencher os campos groupid, artifactid e version do projeto que esta sendo criado.

- executar o comando que irá baixar as dependências (conforme o archetype) e preparar o projeto
para ser aberto no eclipse.
mvn -Dwtpversion=1.0 eclipse:eclipse


Neste ponto, o projeto já poderá ser aberto pela IDE eclipse. Também já é possível executá-lo diretamente no tomcat.

links:
http://resumotecnico.blogspot.com/search/label/Maven
http://vraptor.caelum.com.br


by rAc


24 outubro 2011

Primeira aplicação de exemplo REST: RestEasy e Maven

Este pequeno post irá apenas mostrar os passos para se criar uma aplicação REST em Java.
Tem como objetivo ajudar quem esta iniciando nesta tecnologia.

Resumo dos passos:
1) Adicionar as dependências de uma implementação da especificação REST (JSR311 – JAX-RS) ao projeto.
Alguns exemplos: JBoss RestEasy, Apache Wink, Jersey, Restlet ou diretamente com o Java EE 6.
2) Criar uma classe de Recurso com as URIs de serviço
3) Declarar os recursos no descritor da aplicação.

Após os passos acima, apenas é necessário fazer deploy da aplicação.
Também é possível criar uma classe de teste.

Primeira aplicação REST:
(utilizando RestEasy e Maven)
Passo 1) Após criar um novo  projeto maven do tipo web, adicionar no pom.xml as dependências abaixo: 

<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jaxrs</artifactId>
    <version>2.2.1.GA</version>
</dependency>
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jackson-provider</artifactId>
    <version>2.2.1.GA</version>
</dependency>


Passo 2) Criar uma nova classe e adicionar as anotações do JAX-RS:
@Path("/library")
public class LibraryResource {
   private static List<Book> books = new ArrayList<Book>();

   @GET
   @Path("/books")
   @Produces("application/text")
   public Response getBooks() {
       StringBuilder result = new StringBuilder();

       for (Book book : books) {
           result.append(book.getName()).append("\n");
       }
       return Response.status(200).entity(result.toString()).build();
   }

   @PUT
   @Path("/addbooks")
   @Consumes("application/text")
   public Response addBooks(InputStream is) {
   String content = readBooks(is);

   StringTokenizer st = null;
   st = new StringTokenizer(content, ";");
   int count = 0;

   while (st.hasMoreTokens()) {
      count++;
      String book_str = st.nextToken();
      Book book = new Book();
      book.setId(count);
      book.setName(book_str);
      books.add(book);
   }

   return Response.status(200).entity(count).build();
   }

}
obs: O conteúdo dos métodos são apenas ilustrativos, não são códigos de produção, o importante são as assinaturas dos métodos.


Passo 3) Declarar a classe de recurso (LibraryResource) no descritor da aplicação (web.xml):
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

   <display-name>Restful Web Application</display-name>

   <!-- REST Resource -->
   <context-param>
      <param-name>resteasy.resources</param-name>
      <param-value>br.com.bc.rest.service.LibraryResource</param-value>
   </context-param>

   <listener>
      <listener-class>org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap</listener-class>
   </listener>

   <servlet>
      <servlet-name>resteasy-servlet</servlet-name>
      <servlet-class>org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher</servlet-class>
   </servlet>

   <servlet-mapping>
      <servlet-name>resteasy-servlet</servlet-name>
      <url-pattern>/*</url-pattern>
   </servlet-mapping>

</web-app>

Neste ponto, já é possível construir o pacote para fazer deploy.
Como estamos utilizando maven, basta executar o comando:
mvn clean package

Com o pacote gerado na pasta target, pode-se fazer o deploy em um container web.
Para testar nossa aplicação, podemos acessar diretamente no browser a URL http://localhost:8080/rest-first-app/library/books, ou pode-se criar uma classe de teste para simular uma aplicação cliente, de forma a consumir a aplicação REST:


@Test public void addNewBooksToLibraryTest() {
 try {

 URL url;
 String uri = "http://localhost:8080/rest-first-app/library/addbooks";

 //New books
 String content = "Oreilly - RESTful Web Services Cookbook; InfoQ - REST";

 url = new URL(uri);
 HttpURLConnection conn = (HttpURLConnection) url.openConnection();
 conn.setRequestMethod("PUT");
 conn.setRequestProperty("Content-Type", "application/text");
 conn.setDoOutput(true);
 conn.getOutputStream().write(content.getBytes());

 int responseCode = conn.getResponseCode();
 if (HttpURLConnection.HTTP_OK != responseCode) {
  ByteArrayOutputStream errorBuffer = new ByteArrayOutputStream();

  int read;
  byte[] readBuffer = new byte[ERROR_READ_BUFFER_SIZE];
  InputStream errorStream = conn.getErrorStream();
  while (-1 != (read = errorStream.read(readBuffer))) {
   errorBuffer.write(readBuffer, 0, read);
  }
  System.out.println("Request failed, HTTP " + responseCode + ": " + conn.getResponseMessage());
 }

} catch (Exception e) {
 e.printStackTrace();
}
}

obs: Esta classe não entra na categoria de teste unitário, sendo que envolve rede.

É possível fazer o download do exemplo acima ou consultar o código fonte diretamente no github.

obs: Para configurar o projeto, basicamente é necessário executar o comando do maven:
mvn -Dwtpversion=1.0 eclipse:eclipse 
Para mais informações consultar os posts sobre maven



by rAc

30 setembro 2011

HTML5 no Google Developer Day 2011 - São Paulo



Dia 16 deste mês aconteceu o GGD11 aqui em São Paulo. Acabei assistindo apenas as trilhas de HTML5.
Abaixo estão algumas anotações e links.

Accessibility (Rachel Sheare)
Em resumo, para facilitar a navegação de pessoas com algum tipo de deficiência, devemos nos preocupar ao montar páginas htmls, devemos preencher as tags alt, utilizar buttons ao invés de imagens e colocar index para uma correta ordenação através da tecla tab entre outras coisas.

Links:
http://google-axs-chrome.googlecode.com/svn/trunk/developer/gdd_2011/template/index.html#1
http://code.google.com/p/google-axs-chrome/
http://www.googleplus1app.com/google-chrome-extensions-and-accessibility

Modern web applications - HTML5 (Pete LePage)
Apresentação completa: http://petelepage.com/presentations/2011/gdd-br/webapps/

e alguns links em destaque:
http://www.html5rocks.com/en/tutorials/speed/quick
http://code.google.com/intl/pt-BR/apis/identitytoolkit
http://documentcloud.github.com/backbone
http://www.sproutcore.com
http://www.sencha.com/products/extjs
http://lesscss.org
http://sass-lang.com
http://openid.net/connect
http://code.google.com/apis/console
http://www.dzinepress.com/2011/04/the-ultimate-html5-tutorials-and-useful-techniques/
https://code.google.com/p/google-api-javascript-client/

Para analisar performance do seu site:
https://developers.google.com/pagespeed
https://developers.google.com/page-speed

by rAc

hit