Victor Hogemann

2004: Código, direto da máquina do tempo...

2014-05-18T21:45:00.001-03:00

10 anos atrás eu ainda trabalhava na Prefeitura do Rio de Janeiro pelo iPlanRio como Técnico de Redes, mais precisamente eu trabalhava na Secretaria Municipal de Saúde. Então, imagine minha surpresa ao arrumar algumas caixas velhas e encontrar o email abaixo, impresso (impresso!!) em uma folha já amarelada, contendo a listagem completa de um script muito bacalha que eu fiz a exatos 10 anos!

É uma monstruosidade, um shellscript feito pra rodar no Windows usando Cygwin. E pra quê? Hora bolas, naquela época ainda haviam trocentas máquinas rodando Win 9x e nós queríamos que todas falassem com o nosso servidor de Windows Update local. Minha solução foi o script abaixo, que funcionava aplicando um patch de registro em todas as máquinas listadas em um arquivo txt.

Porquê usar Cygwin e shellscript? Com certeza mesmo naquela época o Windows deveria ter ferramentas administrativas pra fazer isso por mim de forma mais fácil, infelizmente tudo que eu conhecia era Linux, e minha cabeça dura e teimosia não me deixariam usar outra coisa que não fosse bash.

Eu lembro vagamente de ter conseguido a lista de IPs das máquinas a serem utilizadas usando o NMap pra achar todas as máquinas Windows 9x da rede, rodei algumas vezes pra ter certeza que tinha todas.

Uma coisa legal do script é o trabalho que eu tive pra conseguir tirar do PING.EXE do Windows o status de um host. Os executáveis do Windows não tem valor de retorno, então não dá pra saber se executaram com sucesso ( 0 ) ou se ouve alguma falha... Pior, no Cygwin não havia um port do ping do GNU, então eu tive que me virar com o que eu tinha.

Agora, porquê imprimir um email? Sinceramente eu não faço ideia, mas provavelmente deve ter a ver com querer olhar o código fora da minha mesa, e não ter um notebook, tablet ou smartphone a mão naquela época!

Em nome da nostalgia, eu me dei ao trabalho de digitar o código a partir do email impresso:

Do Java para o C#

2014-03-09T14:59:00.001-03:00

Depois de 8 anos como desenvolvedor Java estou começando meu primeiro projeto em C#. É uma mudança e tanto pra mim, esse tempo todo meu OS principal sempre foi alguma versão de Linux, ou MacOSX.

Molhando os pés

Depois de 4 semanas eu ainda estou começando a ter o mesmo tipo de produtividade que tinha com meu bom e velho ambiente Java/Linux. Algumas coisas são melhores, outras são piores… mas no geral o resultado tem sido positivo. Minhas primeiras impressões são:

Pontos positivos

O Visual Studio é uma IDE fantástica. Realmente a Microsoft sabe o que está fazendo, tudo é rápido. Existem várias IDEs pra Java, a minha preferida atualmente é o Intellij, mas de longe o VS é mais esperto e agradável.
C# é uma espécie de Java++. As linguagens são muito semelhantes, mas o C# tem aqueles features que só vão estar disponíveis daqui uma versão ou duas do Java pra frente. LINQ é um caso a parte, eu ainda estou engatinhando mas dá pra ver que dá pra fazer miséria com listas, dicionários e outras coleções.
O gerenciador de dependências NuGet é o Maven/Ivy/Gradle do C#, é uma mão na roda e bem integrado com o VS. Nele é que eu percebi o quanto a Microsoft está investindo na comunidade, o NuGet é OpenSource e a maioria dos pacotes disponíveis também é.
Aliás, muitos dos pacotes da Microsoft são OpenSource, e dependem de outros projetos independentes ao invés de tentar reinventar a roda.
O Visual Studio tem um tema com fundo preto, o que é uma grande vantagem pra quem se acostumou com editores como o Sublime Text 2. A única IDE Java que tem algo que chegue perto é o IntelliJ.
Integração com o Git.

Pontos negativos

Se você, como eu, prefere uma abordagem poliglota nos seus projetos, isto é, usando mais de uma linguagem ou ferramentas pra resolver os problemas, o Windows vai impor algumas dificuldades. O principal é que muito do ferramental que eu uso é linha de comando, e nasceu no Linux/OSX.

As ferramentas de linha de comando, e o console da Microsoft, são ainda são muito ruins.
o APT do Ubuntu, e o Brew do OSX não tem equivalentes reais no Windows.
Se você depende de ferramentas que precisam ser compiladas durante a instalação, bem vindo a um mundo de dor. Instalar pacotes do Node.js por exemplo é uma montanha russa de emoções, principalmente quando alguns ainda dependem de instalações funcionais de Ruby, Gems, Python e outras coisas que vem “de graça” no Linux e OSX.
O Windows é muito diferente do ambiente de produção. Sim, seu código vai rodar no ISS, mas todo resto da infra não necessáriamente… Pelo menos não se você estiver pensando em usar coisas como MongoDB, Redis, MySQL. Então é essencial ter o Linux rodando em uma máquina virtual.

Nem tudo está perdido

Eu achei algumas soluções pra alguns dos problemas acima:

Cygwin é um ambiente linha de comando Posix pra Windows. Ele vem com emuladores de terminal muito melhores que o CMD.exe ou o Powershell, ter bons e velhos amigos como Bash e Grep a disposição não tem preço.
Chocolatey pretende ser o Apt para Windows, ele aproveita o repositório do NuGet e tem repositórios próprios pra instalar vários softwares de forma mais organizada. Instalar Ruby, Python e Node.js por ele é muito mais tranquilo que fazer o mesmo manualmente.
Github Windows é o cliente oficial do Github para Windows. E quebra um tremendo galho.
VMWare Player Plus é a opçao gratuíta da VMWare pra quem precisa rodar máquinas virtuais. Eu sei que o Windows tem uma solução embutida nele, e que existe o VirtualBox… mas em termos de desempenho e compatibilidade com Linux ninguém bate o Player Plus.

O que poderia melhorar

Eu sinceramente acho que a Microsoft entendeu o que é comunidade, e como participar dela, inclusive apoiando e encorajando projetos OpenSource. Mas pra o Windows poder ser a opção número 1 dos desenvolvedores muitas coisas precisam melhorar, as principais sendo:

Um ambiente linha de comando Posix. o Cygwin quebra o galho, mas ainda é um hack feito por terceiros. Se a Microsoft realmente quer que o Windows seja atraente para todo tipo de desenvolvedor, e não apenas para aqueles presos aos produtos dela, é necessário que ele se dê bem com Ruby, Python, Node, e que tenha um toolset compatível com o utilizado no Linux e OSX.
Um sistema de pacotes para ferramentas de desenvolvimento e serviços de sistema. Praticamente cada software tem um método de instalação completamente diferente do outro, e não existe forma de estabelecer dependências entre eles… e assim não tem como automatizar a instalação de nada. Ferramentas como Vagrant e Docker mostram como esse tipo de coisa pode ser utiizada pra dar mais poder ao desenvolvedor.

Daqui pra frente

A experiência tem sido positivia até agora, vi mais coisas boas que ruins. E a maioria das coisas ruins tem solução, mesmo que a solução seja instar Linux numa VM. Enquanto durar o projeto em que estou Windows vai continuar sendo meu OS principal. Depois, quem sabe?

Bug idiota no KDE e Kopete

2013-02-04T17:02:00.000-02:00

Voltei pro KDE, e já achei um bug muito imbecil... normalmente eu uso o atalho de teclado Ctrl + Shift + W pra fechar todos os arquivos abertos em um determinado programa, por exemplo um editor de textos ou o Eclipse, mas se você instalar o Kopete isso para de funcionar!

O que acontece é que o Kopete registra esse mesmo atalho pra mudança de status! Um comportamento padrão imbecil na minha opinião... Então se vocês estiverem com o mesmo problema já sabem de quem é a culpa, e basta desabilitar o tal atalho no Kopete pra resolver.

MongoDB 1.8 : assertion db/geo/2d.cpp:355

2012-11-10T12:01:00.000-02:00

This is one of those things that you learn only by doing it... I was hacking with Grails and MongoDB, and suddenly found the error bellow while doing a geospatial query:

db.location.find({ location: { $within: { $box: [ [ 22.873, -43.2 ], [ 20.0, -44.0 ] ] } } })

error: { "$err" : "assertion db/geo/2d.cpp:355" }

You wont find any reference to this specific error, or file, other than the file itself on the MongoDB git repository. But while it took a couple of hours to figure out what was wrong, it's quite simple actually: the points are reversed!

MongoDB expects two points when searching within a box, right-top and bottom-left, in this exact order... at least for version 1.8. So it was just a matter of reversing the points, and everything was working again.

So the correct query would be that bellow:

db.location.find({ location: { $within: { $box: [ [ 20.0, -44.0 ], [ 22.873, -43.2 ] ] } } })

Weblogic: DOMAIN_ROOT e System CLASSPATH

2012-07-16T19:06:00.000-03:00

Conhecimentos adquiridos através do sofrimento... esbarrei em um projeto que carrega os arquivos .properties da pasta DOMAIN_ROOT, isto é, a pasta raiz do seu domínio Weblogic.

Acontece que, por algum motivo que eu desconheço, no Linux o DOMAIN_ROOT não é adicionado ao System Classpath... então qualquer chamada a getClassLoader().getResource("arquivo.properties") vai retornar Null.

Pra resolver isso, basta adicionar ao script setDomainenv.sh, que fica em ${DOMAIN_ROOT}/bin, a seguinte linha:

CLASSPATH=/opt/oracle/middleware/user_projects/domains/my_domain

Substituindo o caminho pelo do seu domínio.

Apanhando do Oracle XE 11g

2012-07-12T01:09:00.000-03:00

Depois de passar os últimos 2 dias tentando instalar a versão "completa" do Oracle 11g em uma máquina virtual, e falhando miseravelmente, voltei meus esforços pra versão XE. E finalmente fui bem sucedido, usando o openSuSE 12.1.

Uma dica em relação a instalação... se tudo for bem, mas na hora de criar o banco de dados começar a dar erro, pode ser que o listener do Oracle não esteja subindo. Isso pode acontecer se o hostname da máquina não estiver listado no arquivo /etc/hosts associado a um IP, como 127.0.0.1 mesmo, ou não resolver via DNS.

Só que meus problemas não acabaram por aí, eu precisava desse Oracle pra restaurar um dump feito usando o utilitário expdp. O que eu não sabia é que o Oracle mantém várias versões de arquivos de configuração de Time zones, mas que a versão XE só vem com a mais recente, 14.

O resultado é esse:

UDI-31626: operation generated ORACLE error 31626
ORA-31626: job does not exist
ORA-39086: cannot retrieve job information
ORA-06512: at "SYS.DBMS_DATAPUMP", line 3326
ORA-06512: at "SYS.DBMS_DATAPUMP", line 4551
ORA-06512: at line 1

Fuçando mais um pouco, e olhando os arquivos de log da importação gerada pelo impdp, eu descobri isso:

ORA-39097: Data Pump job encountered unexpected error -30094
ORA-39065: unexpected master process exception in DISPATCH
ORA-30094: failed to find the time zone data file for version 11 in $ORACLE_HOME/oracore/zoneinfo

O problema é que todo o campo que contiver um valor TIMESTAMP vai estar vinculado a uma versão desses aquivos de Time zone.

Como resolver esse impasse então? Bom, ainda não testei todas as possibilidades mas tem uma coisa que funciona... restaurar apenas os SCHEMAS sem o conteúdo das tabelas, a sintaxe do impdb ficaria assim:

impdp dumpfile=arquivo.dump content=metadata_only

A opção content=metadata_only é o que faz ele ignorar o conteúdo das tabelas. Achei essa num blog muito apropriadamente denominado Annals of Oracle's Improbable Errors.

A outra alternativa é pegar os arquivos de timezone que vem com o Oracle XE e copiar utilizando os nomes das versões anteriores, ou seja, substituindo o 14 por 13, 12, 11, 10... Tem um cara nessa thread dos fóruns da Oracle que jura que funciona, mas ainda não testei.

UPDATE:

Fazer os links simbólicos funciona pra resolver o problema do impdp, fica assim:

linux-1pk6:/home/admin # ls -l /u01/app/oracle/product/11.2.0/xe/oracore/zoneinfo/
total 1156
-rwxr-xr-x 1 oracle dba    6068 Ago 29  2011 readme.txt
-rwxr-xr-x 1 oracle dba   31525 Ago 29  2011 timezdif.csv
lrwxrwxrwx 1 root   root     15 Jul 12 22:50 timezlrg_10.dat -> timezlrg_14.dat
lrwxrwxrwx 1 root   root     15 Jul 12 22:50 timezlrg_11.dat -> timezlrg_14.dat
lrwxrwxrwx 1 root   root     15 Jul 12 22:50 timezlrg_12.dat -> timezlrg_14.dat
lrwxrwxrwx 1 root   root     15 Jul 12 22:50 timezlrg_13.dat -> timezlrg_14.dat
-rwxr-xr-x 1 oracle dba  791430 Ago 29  2011 timezlrg_14.dat
lrwxrwxrwx 1 root   root     15 Jul 12 22:50 timezone_10.dat -> timezone_14.dat
lrwxrwxrwx 1 root   root     15 Jul 12 22:50 timezone_11.dat -> timezone_14.dat
lrwxrwxrwx 1 root   root     15 Jul 12 22:50 timezone_12.dat -> timezone_14.dat
lrwxrwxrwx 1 root   root     15 Jul 12 22:50 timezone_13.dat -> timezone_14.dat
-rwxr-xr-x 1 oracle dba  344448 Ago 29  2011 timezone_14.dat

Rumor: Facebook vai comprar o Navegador Opera

2012-05-25T17:20:00.000-03:00

Alguns sites, desde ontem, estão noticiando a possibilidade do Facebook comprar o browser noroeguês mais querido de todos nós, o Opera!

Forbes: Facebook rumored to be in talks to buy Opera...Engadget: Facebook could be looking into buy Opera

Faz muito sentido, hoje os principais adversários do Facebook são o Google e a Microsoft, ambos no espaço de publicidade online... que é o ganha-pão tanto do Google quanto do Facebook, e um mercado onde a Microsoft quer entrar de qualquer jeito. Ambos tem um Browser, respectivamente o Internet Explorer e o Chrome... e por causa disso ambos conseguem exercer uma pressão enorme na hora de emplacar novas tecnologias pra web, que na realidade vão servir aos seus próprios interesses.

Provavelmente o Facebook também tem sua agenda de quais novas features do HTML5 merecem um tratamento especial, e que maneira mais eficaz de garantir que essas features vão ser adotadas do que implementa-las você mesmo, no seu próprio browser?

Na boa? Do jeito que as coisas estão, os caras poderiam transformar o Opera num cliente dedicado pro Facebook, que por acaso abre outras páginas, e muita gente nem iria notar a diferença...

TDD - O Coelho e a Tartaruga

2012-03-13T17:19:00.002-03:00

Segue uma pequena fábula pra tentar explicar os benefícios de duas técnicas opostas de desenvolvimento: o Go Horse e o TDD, ou Test Driven Development. Clique na imagem para aumentar...

Reunião de Retrospectiva

2012-02-14T17:42:00.001-02:00

Feito pra ilustrar o que é uma reunião de retrospectiva pros novatos lá da Ideais, onde eu trabalho. Clique pra ampliar.

Scaling MySQL : Facebook & Twitter

2011-12-09T09:57:00.001-02:00

Agora que estamos no meio dessa onda de substituir bancos relacionais por outros modelos, o tal NoSQL, esses dois tech talks trazem uma perspectiva diferente ao debate.

A apresentação do Twitter é mais focada em como organizar os dados no banco de forma que seja possível segmentar a informação, e planejar as queries para que a área de impacto seja a menor possível. É um passeio superficial em como foi adaptar a infra-estrutura para acomodar o crescimento. E a pesar de estarem lentamente migrando para o Cassandra, a base de dados para os Tweets continua sendo o MySQL.

clique na imagem pra ver a apresentação no site da infoq

O vídeo do pessoal do Facebook é muito mais focado nas soluções para os problemas do dia-a-dia, operacionais, que eles tem administrando uma base de dados que cresceu 7x nos últimos dois anos. E que tem um volume insano, na casa de dezenas de milhões de transações por segundo. Nesse tech-talk podemos ver o quanto os caras investiram no MySQL, a performance que eles conseguem não veio sem custos, e muita coisa eles mesmos tiveram que desenvolver pra resolver os problemas conforme foram aparecendo... Não é dizer que eles não investigam soluções NoSQL, os caras criaram o Cassandra, e usam o Haddop e HBase no engine de mensagens, mas o core do Facebook ainda depende do MySQL.

Watch live streaming video from fbtechtalks at livestream.com

Em ambos os casos, Twitter e Facebook, existe um uso extensivo de cache. No caso ambos usam o Memcached, que é um cache em memória e distribuído via rede num esquema cliente-servidor.

Vou falar pra vocês que eu acho todas essas soluções NoSQL bem promissoras, em particular o MongoDB é bem legal, mas se pintasse um projeto onde fosse cabível usar MySQL com Memcached... putz, eu não iria reclamar não, seria diversão de primeira.

JDeveloper display issues on Ubuntu 10.11

2011-12-06T12:05:00.001-02:00

I don't really know what's triggering this bug, but it's really annoying and it makes JDeveloper unusable... take a look on what happens:

What a mess...

Right now I think it's a combination of:

XOrg 1.9
Compiz
ATI Drivers
Radeon 43XX cards

How do I fix it? It's kind of a hack, but it sort of works... I had to figure a way to bypass the 2D acceleration provided by the ATI native driver, so it was a matter of switching to the VESA driver, or running anoter XServer on top of the current one, and that's what I did.

At first I went with XNest or Xephyr, but then JDeveloper would appear on a Window inside the XNest window, and it was annoying and not very usable. So instead I used xpra.

xpra is a solution build around xvfb, it renders the application to a virtual framebuffer device so it doesn't need a real video hardware, and you can attach and detach your local xserver to it. Think of it as a X11 version of the screen command.

So, on Ubuntu do:

$ sudo apt-get install xpra
$ xpra start :100
$ DISPLAY=:100 //jdeveloper/jdev/bin/jdev &$ xpra attach :100

This will take care of the rendering issues, and you'll get a window that you can resize at will.

Usar Java da SUN no Ubuntu 11.10

2011-12-01T18:10:00.001-02:00

$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk
$ sudo update-alternatives --config java

Selection Path Priority Status
------------------------------------------------------------
0 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 auto mode
1 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 manual mode
* 2 /usr/lib/jvm/java-6-sun/jre/bin/java 63 manual mode

Press enter to keep the current choice[*], or type selection number: 2

$java -version

java version "1.6.0_26"
Java(TM) SE Runtime Environment (build 1.6.0_26-b03)
Java HotSpot(TM) 64-Bit Server VM (build 20.1-b02, mixed mode)

Tutorial: Twitter com Java, Struts2 e Spring

2011-09-26T21:25:00.000-03:00

Vou mostrar aqui a solução que eu encontrei pra integrar o Twitter com uma aplicação baseada em Struts 2 e Spring. Hoje já existe um projeto do Spring chamado Spring-Social que resolve boa parte do que eu estou explico aqui, mas ainda não parei para entender direito como tudo funciona nele, outro problema é que a pesar dele já se integrar com o Spring-Security e com o Spring-Web-MVC não tem nenhuma integração pronta pro Struts2, que é a minha escolha preferida.

Pegue no GitHub o código fonte completo desse tutorial, mas lembre-se que pra fazer funcionar você ainda vai precisar se registrar como desenvolvedor no Twitter, e registrar uma aplicação para obter as chaves de acesso à API.

O problema

Criar uma solução reutilizável de autenticação no Twitter para aplicações Java, nesse caso baseadas em Spring e Struts2. Eu não consegui encontrar nada 100% pronto, então parti pra integrar as bibliotecas que eu já conhecia. Estou assumindo aqui que você vai guardar as informações de usuário de alguma forma, e por isso tem no seu modelo uma entidade pra isso. Como falei lá em cima, vou usar duas entidades aqui User e TwitterAccount.

A solução

Antes de mais nada, abaixo segue um breve descritivo das principais bibliotecas que eu estou utilizando, não vou me aprofundar muito em como configurar cada uma... o foco aqui é mostrar como utilizar cada uma, com o Twitter4J, pra se autenticar e utilizar o Twitter como uma aplicação cliente.

Struts 2

É um framework para construir aplicações Web em Java, é bem maduro e excepcionalmente versátil. Não é exatamente o mais fácil de aprender, e pode ser até mesmo frustrante tentar se entender com sua configuração, mas depois que se pega o jeito da coisa dá pra ver que ele é muito poderoso sem ser absurdamente complicado.

Spring

É um framework, com muitas, muitas funcionalidades, suporte e integração a trocentas tecnologias. Mas quando falamos de Spring, normalmente nos referimos ao container de IoC. Nele a responsabilidade de instanciar, e associar seus objetos uns com os outros é tirada das suas mãos, o Spring oferece um jeito absurdamente mais fácil de organizar o ciclo de vida da sua aplicação, e de gerenciar o gráfico de inter-dependências entre seus objetos. Se você programa profissionalmente em Java já usa, usou ou vai usar.

Twitter4j

É a biblioteca que eu escolhi para fazer a comunicação com o Twitter. Tem uma API muito fácil, e funciona diretinho, inclusive com a nova autenticação baseada em OAuth. O único problema é que o jeito de usar meio que bate de frente com algumas coisas que o Spring assume, então eu precisei criar uma Factory pra encapsular o Twitter4j.Factory e instanciar os objetos Twitter pelo Spring.

Modelo

Vamos então conhecer nosso modelo de User. Ele é bem básico, nesse caso eu só vou deixar nessa classe base o essencial. A idéia é que essas sejam informações comuns, que eu possa preencher a partir do Twitter. O User está associado a uma ou mais Accounts, que é onde estão todos os detalhes de identificação e acesso ao Twitter.

Olha só, um diagrama ER!

Classe User

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
public class User extends AbstractEntity {

	private static final long serialVersionUID = 1L;
	
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Column(name="id")
	private long id;
	
	@Column
	private String nick;
	
	@Column
	private String name;
	
	@Column 
	private String image;
	
	@OneToMany(fetch=FetchType.EAGER)
	private List accounts;
	
	...

}

Pelas anotações alguns vão perceber que eu estou usando JPA, mas na realidade o jeito que você vai persistir essas informações não é tão importante pra integração com o Twitter.
Account é uma classe base, utilizada pra criar tantos tipos quanto forem necessários. Nesse exemplo iremos utilizar o Twitter, mas é possível criar implementações para Facebook, Google, Foursquare e o que mais for do seu agrado.

Classe Account

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
public class Account extends AbstractEntity {

	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private long id;
	
	@ManyToOne
	private User user;
	
    ...

}

TwitterAccount herda de Account, e adiciona os atributos necessários para processarmos a autenticação.

Classe TwitterAccount

import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.auth.AccessToken;
import twitter4j.auth.RequestToken;

@Entity
public class TwitterAccount extends Account {

	private static final long serialVersionUID = 1L;
	
	@Column
	private Long twitterId;

	@Column
	private String token;
	
	@Column 
	private String secret;
	
	@Transient
	private Twitter twitter;
	
	@Transient
	private AccessToken accessToken;

	@Transient
	private RequestToken requestToken;

    ...

}

Esses são só os atributos, depois vamos ver alguns métodos que vão auxilar no processo de autenticar o usuário no Twitter, e depois resgatar as informações do usuário para não precisarmos autenticar novamente.

Autenticando o Usuário

Vamos dar uma olhada em tudo que acontece entre o usuário clicar em Entrar até o momento em que ele já autorizou a aplicação a acessar sua conta do Twitter.

Continue lendo e esse diagrama vai fazer sentido, eu prometo

TwitterAuthInterceptor

Se você nunca viu Struts2 na sua vida aqui as coisas vão ficar meio nebulosas, mas vamos lá... No Struts2 existe o conceito de Interceptors, que são bem parecidos com os os Servlet Filters, só que eles atuam apenas nas Actions que você definir. Bom, nosso amigo TwitterAuthInterceptor é responsável por verificar se existe uma Account na sessão, e se não houver ver se consegue criar uma verificando um cookie.

É ele o responsável por "lembrar" do usuário entre cada visita ao aplicativo.

TwitterOAuthRequestAction

Aqui que as coisas ficam interessantes, essa Action que é responsável por enviar pro usuário um redirecionamento que vai leva-lo à página de autorização do Twitter, vamos dar uma olhada melhor nele.

@Controller("twitterAuth")
public class TwitterOauthRequestAction implements SessionAware {

	private static final long serialVersionUID = 1L;

	@Autowired
	private TwitterService service;

	private Map session;

	private String redirect;

	public String execute() {

		TwitterAccount account = service.startAuthentication();
		redirect = account.getAuthenticationURL();
		session.put(TwitterService.TWITTER_USER, account);

		return "success";
	}

	public void setSession(Map session) {
		this.session = session;
	}

	public String getRedirect() {
		return redirect;
	}

}

Como você deve ter adivinhado, a mágica mesmo ocorre em TwitterService e TwitterAccount. Vamos dar uma olhada nelas:

TwitterServiceImpl

Esse aqui é o responsável por concentrar a maior parte das ações de criar, autenticar e salvar as contas. Por exemplo, o método public TwitterAccount startAuthentication() que vimos acima retorna uma TwitterAccount pronta para ser autenticada.

public class TwitterServiceImpl implements TwitterService {

	private static final Log log = LogFactory.getLog(TwitterService.class);
	
	@Autowired
	private TwitterAccountRepository repository;
	
	@Autowired
	private TwitterFactory factory;
	
	@Autowired
	private String twitterCallbackUrl = "http://localhost:8080/stamp/twittercallback";
	
	public TwitterAccount startAuthentication() {
		
		try {
			Twitter twitter = factory.getTwitter();
			RequestToken requestToken = twitter.getOAuthRequestToken(twitterCallbackUrl);
			TwitterAccount account = new TwitterAccount(twitter, requestToken);
			return account;
		} catch (TwitterException e) {
			log.error(e);
		}
		
		return null;
	}

        ...

}

Está na hora de darmos mais uma olhada em TwitterAccount, dessa vez no construtor TwitterAccount(Twitter twitter, RequestToken requestToken) e no método TwitterAccount(Twitter twitter, RequestToken requestToken).

Classe TwitterAccount

public TwitterAccount(Twitter twitter, RequestToken requestToken){
		this.twitter = twitter;
		this.requestToken = requestToken;
	}

       ...

	public String getAuthenticationURL(){
		if(this.requestToken == null)
			return null;
		return requestToken.getAuthenticationURL();
	}

Nada demais, certo? Como você já deve ter percebido TwitterAccount encapsula o objeto Twitter do Twitter4J, esse é objeto que vai representar a conexão do usuário com o Twitter, e a maioria das chamadas a API vai ser intermediada através dele.

O método public String getAuthenticationURL() encapsula a chamada ao método de mesmo nome do requestToken que é responsável por mediar a autenticação OAuth. Ele retorna uma URL que direciona para a página do Twitter que pede ao usuário que permita a aplicação acesso a sua conta, uma vez concedida o Twitter redireciona o usuário para a URL definida pela URL twitterCallbackUrl, que no nosso caso aponta para a action TwitterOAuthCallbackAction.

TwitterOAuthCallbackAction

Após o usuário dar permissão para a aplicação no Twitter ele é redirecionado para essa action. O que acontece agora é o seguinte, a aplicação vai tentar verificar se existe um TwitterAccount salvo na sessão, e utiliza-lo para completar a autenticação via OAuth. Procuramos ver também se já existe uma conta prévia para esse usuário, e tentamos recupera-la da persistência, do contrário a cada tentativa de autenticação o usuário acabaria com uma conta nova!

Após a validação da conta com as credenciais enviadas pelo Twitter, salvamos a conta na persistência, e criamos o Cookie para que da próxima vez que o usuário volte não precise autorizar a aplicação novamente com o Twitter, suas credenciais serão salvas juntamente com a conta. No caso eu apenas estou codificando o ID da conta como Base32 e gravando no Cookie, em uma aplicação real provavelmente você vai querer esconder melhor a identificação do seu usuário para evitar que alguém roube a identidade dele no aplicativo.

public class TwitterOauthCallbackAction implements ServletResponseAware {

	private static final long serialVersionUID = 1L;
	private static final Log log = LogFactory.getLog(TwitterOauthCallbackAction.class);
	private String oauth_verifier;
	
	@Autowired
	private TwitterService service;
	
	@Autowired
	private TwitterAccountRepository accountRepository;

	private HttpServletResponse response;
	
	public String execute(){
		
		Map session = ActionContext.getContext().getSession();
		
		TwitterAccount user = service.getFromSession(session);
		
		if(user != null && !user.isAuthenticated()) try {
			user.authenticate(oauth_verifier);
			
			TwitterAccount recycled = recycle(user);
			long id = 0;
			if(recycled != null){
				user = recycled;
				id = user.getId();
			} else {
				id = service.save(user);
			}
			String base32 = Base32.encode(String.valueOf(id).getBytes());
			Cookie cookie = new Cookie(TwitterService.TWITTER_COOKIE,base32);
			cookie.setMaxAge(60*60*24*15);
			response.addCookie(cookie);
		
		} catch (TwitterException e) {
			log.warn("Erro ao processar callback do Twitter",e);
			return "error";
		}
		
		return "success";
	}
	
	/**
	 * Tenta encontrar uma conta de usuário na persistencia
	 * que já tenha sido utilizada, e associa o ID dela
	 * ao usuário com as informações de autenticação
	 * 
	 * @param account
	 */
	private TwitterAccount recycle(TwitterAccount account){
		TwitterAccount recycled = accountRepository.findFirst(account);
		if(recycled != null){
			recycled.recycle(account);
		}
		return recycled;
	}
	
	public void setOauth_verifier(String oauth_verifier) {
		this.oauth_verifier = oauth_verifier;
	}

	public void setServletResponse(HttpServletResponse response) {
		this.response = response;
	}
}

E basicamente é isso, a partir daí você tem um Objeto TwitterAccount na sessão, que encapsula o twitter4j.Twitter, é só explorar um pouco mais o código e ir adicionando as funcionalidades que você precisar, listar os posts do usuário, criar novos, consultar seguidores e etc...

Referências

Twitter4J - http://twitter4j.org/

Struts2 - http://struts.apache.org/2.2.1/

Spring - http://www.springsource.org/

Maven - http://maven.apache.org/

Preparando um novo tutorial...

2011-09-22T16:27:00.002-03:00

Estou estreiando minha conta no github com um projeto pessoal que vou transformar em tutorial, é uma aplicação java usando Maven, Struts2, Spring e JPA que usa o Twitter para autenticar seus usuários. O repositório é o seguinte:

https://github.com/vhogemann/Struts2-Twitter-Integration

O código ainda está bagunçado e com pedaços do que iria ser outro projeto, e eu estou ajeitando tudo pra ficar mais organizado. A ideia é ir adicionando suporte a outras redes sociais conforme a coisa for evoluindo, então primeiro vem o Twitter, depois vou integrar o Facebook, Google, Orkut, e o que mais for aparecendo pela frente.

EHCache com anotações no Spring

2011-09-12T19:06:00.001-03:00

Esse é um artigo que eu estava escrevendo para uma revista, mas por um motivo ou outro nunca encontrei tempo pra deixa-lo no ponto de ser publicado… Pra não ficar pegando poeira no meu HD resolvi publica-lo aqui no blog. Espero que seja útil!

Caches são uma técnica comum para resolver problemas de performance. A ideia por trás é guardar informações para que possam ser reutilizadas, ao invés de arcar com os custos de gerar os dados novamente.

Eles são tão difundidos que podemos os encontrar em praticamente todos os níveis de um sistema, desde o processador, passando pelo sistema operacional, aplicações e entre diversas máquinas interconectadas em uma rede.

É natural então que encontremos implementações de cache para o Java, desde as mais simples até soluções que distribuem gigabytes de dados entre várias máquinas diferentes. Nesse artigo vamos tratar de uma solução em especial, que se integra ao SpringFramework e é bem fácil de ser aplicada na grande maioria dos projetos que o utilizam.

EHCache Spring Annotations

Essa é a solução que é apresentada aqui, um projeto open-source que visa simplificar a aplicação e o uso do cache através do uso de anotações. É o sucessor de outro projeto, o Spring-Cache Module, que foi descontinuado, e não tem mais desenvolvimento ativo.

Spring Framework

Mais que um conjunto de bibliotecas, oferece um conjunto integrado completo de soluções para o desenvolvimento Java. O Spring oferece diversos módulos que facilitam a integração de praticamente todas as tecnologias utilizadas no desenvolvimento J2EE. Também é um projeto open-source, e tem uma grande comunidade de desenvolvedores e usuários ao seu redor.

O EHCache Spring Annotations é uma extensão do Spring, e depende dele para ser utilizado.

EHCache

É uma implementação open-source de cache em Java, popular e amplamente utilizada é a base para a JSR-107 que visa definir uma API comum de cache para a linguagem. A simplicidade e facilidade de utilização contribuíram para sua popularidade.

O EHCache pode ser utilizado de diversas maneiras, por exemplo ele pode fazer caching das requisições enviadas a uma aplicação Web, já enviando a resposta utilizando compressão gzip. Praticamente como implementar um proxy reverso direto na sua aplicação. Para essa e outras utilizações, visite a página do projeto, veja o link ao final do artigo.

Configuração

O primeiro passo é fazer o download da última versão do EHCache Spring Annotations a partir do site, e incluir o jar e suas dependências no classpath. Faça o download no link abaixo:

http://code.google.com/p/ehcache-spring-annotations/downloads/list

Após isso precisamos do EHCache, portanto faça o download da distribuição a partir do site oficial. Vamos utilizar a versão 1.2.4 do ehcache.jar.

http://www.terracotta.org/dl/ehcache-oss-download-catalog

Nos meus projetos prefiro deixar a cargo do Maven a tarefa de baixar e resolver as dependências das bibliotecas que utilizo. O Maven é uma ferramenta completa, que pode gerenciar todo ciclo de vida do seu projeto, do desenvolvimento ao deploy, passando por execução de testes e build do projeto. A listagem 1 mostra o trecho que deve ser incluído ao arquivo de configuração do projeto, pom.xml.

Listagem 1. Configuração do ehcache e ehcache-spring-annotations para o maven

<pom>
...
<dependências>
...
<dependency>
<groupId>com.googlecode.ehcache-spring-annotations</groupId>
<artifactId>ehcache-spring-annotations</artifactId>
<version>1.1.3</version>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>1.2.4</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
...
</dependências>
...
</pom>

Após isso é necessário criar um arquivo para configurar os caches do EHCache, qué chamado ehcache.xml e deve ser colocado no classpath da aplicação. A listagem 2 mostra um arquivo com uma configuração mínima, note que podemos configurar vários caches cada um com características diferentes. Cada caso de utilização requer uma configuração específica, para efeito de exemplo configuraremos um cache apenas em memória:

Listagem 2. O arquivo ehcache.xml

<ehcache>
<cache name="books"
maxBytesOnHeap="50m"
maxBytesOffHeap="200m"
timeToLiveSeconds="100"
overflowToDisk="false" >
</cache>
</ehcache>

Com o EHCache configurado, precisamos agora declarar no contexto Spring da sua aplicação as configurações do ehcache-spring-annotations. Veja na listagem 3 como é simples.

listagem 3. Configuração do contexto do Spring, normalmente o applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring
    http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring/ehcache-spring-1.1.xsd">
   <ehcache:annotation-driven />
   <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"/>
...
</beans>

Existem várias maneiras de configurar os caches no EHCache, existe por exemplo a possibilidade de persistir os objetos do cache em disco, ou então podemos configurar um cache distribuído utilizando o Terracota.

Utilizando o Cache

O funcionamento básico do Ehcache Annotations é interceptar a chamada aos métodos anotados, fazer cache do objeto retornado e utilizar os parâmetros, o tipo do retorno e o nome do método para gerar a chave. Os métodos são interceptados utilizando a implementação de AOP do Spring, podemos anotar os métodos diretamente na Interface, ou então nas Classes que as implementam.

Para marcar métodos para terem seu retorno adicionado ao cache, utilizamos a anotação @Cacheable, que recebe um parâmetro cacheName correspondente ao cache declarado no arquivo ehcache.xml da listagem 2.

Na listagem 4 temos dois métodos anotados com @TriggersRemove, essa anotação indica que quando o método for invocado devemos remover uma, ou todas, das entradas do cache. De outra forma a única maneira dos objetos serem atualizados seria o tempo de expiração configurado no EHCache, o que quase sempre não é o comportamento esperado. Por exemplo, método updateAll na listagem faz com que todo o cache seja invalidado quando atualizamos uma lista de objetos.

Listagem 4. Uma interface anotada com @Cacheable

import com.googlecode.ehcache.annotations.Cacheable;
import com.googlecode.ehcache.annotations.TriggersRemove;
import com.googlecode.ehcache.annotations.PartialCacheKey;
public interface BookManager {
   @Cacheable(cacheName="books",
keyGenerator = @KeyGenerator (
               name = "HashCodeCacheKeyGenerator",
               properties = @Property( name="includeMethod", value="false" )
           )
      )
   public Book load(long bookId);
@TriggersRemove(cacheName="books",
keyGenerator = @KeyGenerator (
            name = "HashCodeCacheKeyGenerator",
            properties = @Property( name="includeMethod", value="false" )
         )
      )
public void delete(long bookId);
   @TriggersRemove(cacheName="books",
keyGenerator = @KeyGenerator (
               name = "HashCodeCacheKeyGenerator",
               properties = @Property( name="includeMethod", value="false" )
           )
      )
   public void update( @PartialCacheKey long bookId, Book book);
   @TriggersRemove(cacheName="books", removeAll=true)
   public void updateAll(List<Book> book);
}

Ambas anotações, @Cacheable e @TriggersRemove, podem receber como parâmetro uma terceira anotação @KeyGenerator. Isso configura a estratégia de geração das chaves do cache, e é importante por um motivo: fazer @Cacheable e @TriggersRemove trabalharem em conjunto.

Como por padrão a geração das chaves do cache leva em conta o nome e o tipo de retorno do método. Os métodos load e delete da listagem 4 acabam gerando chaves diferentes, mesmo possuindo a mesma assinatura. O comportamento desejado nesse caso é que quando o método delete for chamado ele utilize o parâmetro bookId para gerar a chave do cache, dessa forma referenciando o mesmo objeto. Assim os objetos inseridos no cache por load serão invalidados toda vez que houver uma chamada a delete.

Notem a anotação @Properties que define includeMethod como false. É isso que faz as chaves geradas considerarem apenas os parâmetros passados. Dessa forma as chaves geradas pela invocação de load e delete serão iguais para os mesmos valores passados.

Finalmente temos @PartialCacheKey, que permite que apenas alguns parâmetros da assinatura de um método sejam utilizados na criação da chave do cache. No caso do método update no exemplo anotamos o parâmetro bookId para que as chaves geradas sejam as mesmas de load e delete. Assim quando chamado, ele irá invalidar a entrada correspondente no cache, e da próxima vez que recuperarmos um objeto utilizando o método load ele irá pular o cache, e buscar o objeto atualizado.

Alguns cuidados

“A otimização prematura é a raiz de todos os males”
- Donald Knuth, Computer Programming as an Art

A pesar de ser um recurso muito valioso para resolver problemas de performance, a utilização do cache deve ser estudada de maneira cuidadosa. No mundo ideal sua aplicação deveria funcionar a contento sem precisar recorrer a nenhum tipo de cache, portanto comece o projeto com esse objetivo. Não espere que utilização de caches seja uma bala-de-prata que irá resolver todos os seus problemas. Muitas vezes o cache só vai mascarar o problema, como uma consulta mal escrita no banco de dados, ou um problema de rede que torna a chamada a um WebService muito lenta.

Portanto, na maioria dos casos, o cache deve ser a última coisa a ser implementada no projeto, quando tudo mais já funciona, e outras soluções de otimização foram aplicadas.

Caso planeje utilizar cache em disco, ou cache distribuído, certifique-se de que os objetos colocados em cache implementem a interface Serializable. Caso contrário eles serão descartados, e uma mensagem de alerta será enviada para o log. Outra recomendação é implementar métodos equals e hashCode para suas classes.

Se você opera num ambiente distribuido tenha em mente que por padrão o cache é local, e que isso vai fazer que as informações a respeito de um mesmo recurso possa variar nos diversos caches de cada uma das instâncias da sua aplicação.

Nada vem de graça: o custo do cache

Os caches aceleram a execução e o acesso aos recursos utilizados por sua aplicação, mas o custo disso é memória. Quanto mais informações no cache, mas memória será utilizada.

A memória disponível para sua aplicação é limitada pelo parâmetro -Xmx da JVM, que configura o máximo de HEAP que poderá ser alocado. Quando utilizamos uma JVM 64bit esse limite é alto o suficiente para que em termos práticos você possa alocar toda memória disponível, ou quase toda, para sua aplicação. Mas no caso de uma JVM 32bit o limite máximo é de 2GB.

Então ao configurar seus caches, tenha em mente esses limites.

Mesmo que memória não seja um problema, definir um cache gigantesco pode não ser uma boa ideia. O importante aqui não é saber quantos objetos colocar em cache, mas sim saber quais. Informações que são alteradas muito pouco, ou nunca, e são lidas várias vezes são os candidatos ideais para irem para o cache, ao contrário de informações que são alteradas constantemente.

Além disso tudo, a má utilização do cache pode ter um impacto negativo na performance da sua aplicação. Conforme o uso de memória aumenta, também aumenta o tempo gasto pelo Garbage Collector da JVM, e quando a quantidade de memória alocada chega aos Gigabytes as interrupções feitas para GC começam a ser perceptíveis.

Por isso, como toda otimização o uso de cache requer planejamento e um bom entendimento do problema a ser resolvido.

Conclusão

O EHCache Spring Annotations é uma solução que se encaixa bem tanto para novos projetos, quanto para projetos já existentes que utilizem o SpringFramework. A necessidade de se adaptar o código é mínima, quando necessária.

Isso o torna uma adição valiosa ao conjunto de ferramentas a sua disposição na hora em que for necessário tirar aquele “pouquinho a mais” da sua aplicação, seja para melhorar sua performance ou seja para escalar a aplicação a um número maior de usuários.

Links

http://code.google.com/p/ehcache-spring-annotation - EHCache Spring Annotations

http://ehcache.org - EHCache

http://springsource.org - SpringFramework

http://terracotta.org - Terracotta, desenvolvedores do EHCache.

Cada projeto tem seu próprio dialeto

2011-05-31T09:09:00.001-03:00

Isso é uma coisa que eu percebo em todos os projetos em que participei, e onde uma equipe convive durante algum tempo. Depois de um tempo os conceitos, processos, classes, métodos e interfaces do sistema se entranham de tal forma na conversa do dia-a-dia que um dialeto particular àquele projeto acaba surgindo.

É nessa hora que dá realmente pra ver quais são as entidades "fortes", aquelas que dominam a conversa. Eu acho que nessa hora também conseguimos perceber se a modelagem do sistema consegue refletir a realidade do problema que está sendo resolvido. Se o "dialeto" consegue ser utilizado entre pessoas de áreas diferentes, do programador, passando pelo designer até o cliente ou o cara de vendas isso é um bom indicador que a modelagem capturou, mesmo que num nível mais alto, a essência do problema.

Será que existe alguma técnica de modelagem que se preocupe com isso? Em criar antes de mais nada uma linguagem pela qual diversas pessoas consigam entender e discutir determinado problema, ou será que isso é apenas um produto natural do processo de desenvolvimento?

Não sei, mas é o que eu vou tentar fazer daqui por diante. Antes de mais nada ter certeza que todos estão falando a mesma língua, e a respeito da mesma coisa... E acho que isso vale pra outras coisas além do desenvolvimento de software.

Por que existe uma classe Void em java?

2011-05-04T12:04:00.001-03:00

Resumindo o artigo, serve basicamente nos casos onde você está tentando determinar o tipo de retorno de um método por reflexão, e então é preciso representar a keyword void como uma classe de algum jeito.

Why does Void class exist in JDK | Javalobby

Xoom a venda

2011-04-25T14:11:00.001-03:00

Encontrei esse numa loja da Vivo, 2K tendo que contratar plano de dados! Por isso que o iPad vende tanto...

Chegou a hora novamente...

2011-04-20T20:46:00.000-03:00

de experimentar o NetBeans! Todo relase eu baixo, instalo, e testo alguns projetos nele pra ver se a grama é realmente mais verde "do outro lado da cerca". E toda vez eu volto pro Eclipse.

Alguns destaques:

- Suporte ao draft do Java 7

- Maven 3

- Maior integração com o Weblogic

NetBeans Community News

Install Adobe AIR on 64-bit Ubuntu 10.10

2011-04-19T18:50:00.000-03:00

Grabbed this from the official Flash Patform Blog, and it's working nicely as far as I can tell. Allowed me to install the Yammer client on my Kubuntu 10.10 64bit desktop.

Install Adobe AIR on 64-bit Ubuntu 10.10 (Adobe Flash Platform Blog)

On the go

2011-04-18T22:37:00.001-03:00

Instalei o app do blogger pra android, vamos ver se agora eu consigo escrever aquelas ideias que acabam se perdendo no caminho pro trabalho, ou no meio da madrugada. Não sei se rola a mesma coisa com vocês, mas eu sempre acabo escrevendo bem menos do que gostaria... ou do que acho que vou escrever.

Aliás isso é uma das coisas que me deixa meio puto com o twitter... Quando o espaço que tem lá acaba e você ainda tem aquela uma ou duas palavrinhas a acrescentar. Eu gosto de trabalhar um pouco as coisas que vou escrever, e o twitter é meio brochante nisso.

Também com a quantidade de coisas e pessoas por lá não rola mesmo entupir os posts de texto, por que ficaria impraticável separar e ler o que aparece de interessante.

Viram? Acabei entupindo isso aqui de texto, e era só pra falar do app do Blogger...

O que eu quero de Natal : Nokia + Android

2011-02-09T08:33:00.001-02:00

A Nokia está perdida num mato sem cachorro, por anos dominou o mercado de celulares high-end com um hardware impecável e um SO estável e hiper otimizado... Só que veio o iPhone e mudou as regras do jogo.

De repente ter o melhor hardware, com a maior quantidade de features não era mais suficientes. Diabos, o iPhone foi lançado sem ter metade das features do n95, e ainda assim foi o produto da década! Depois vieram os primeiros Android, que eram meio esquizitos mas que num período de 2 anos deixaram a Nokia pra trás e estão se equiparando com o iOS em termos de usabilidade.

E, pasmem, até a Microsoft conseguiu se organizar e tirar da manga um SO moderno das cinzas do WinMobile 6... que arda no inferno por toda eternidade.

Já ouvi dizer que o problema é que na Nokia o software sempre ficou em segundo plano, e que o desenvolvimento era todo feito em função do hardware. Claramente a Apple mostrou que com uma grande tela touchscreen e o software certo o hardware pode ficar em segundo plano.

Se é assim, entāo no meio de tantos fabricantes lançando celulares com Android, um que poderia se destacar apenas pelo hardware é a Nokia. ( e não por estragar o OS com skins e customizaçoes meia boca. Sim Motoblur, estou olhando pra você )

A combinação Nokia + Android Vanilla + Atualizações frequentes seria matadora!

Bom, não custa sonhar...

Uruguaiana

2011-02-08T19:13:00.001-02:00

Parece que estão querendo acabar mesmo com o camelodromo da Uruguaiana. Desconfio que exista toda sorte de interesses por detrás disso, um ou outro até legítmo... como sanear toda aquela área pra revitalizar o Centro.

O foda é que se conseguirem isso vai gerar um problema ainda maior, que é pra onde vai aquela massa de comerciantes? Caso substituam com um shopping center, algo que falta no Centro, provavelmente alguns vão conseguir se estabelecer nele... Mas e os outros? Periga aumentar ainda mais a quantidade de ambulantes que entopem ruas e calçadas, e contribuem pra o inferno que é caminhar por lá.

Se removerem o camelodromo a única certeza que eu tenho é que alguns poucos vão se dar muito bem enquanto a maioria sofre com as consequências.

Desenvolvendo pra iOS : Objective-C

2011-02-06T18:43:00.001-02:00

Vou contar a experiência que eu tive desenvolvendo o App de duas lojas Online ( não posso citar nomes ) pra iOS. Quero tirar isso da minha cabeça e colocar escrito, pra depois poder fazer o mesmo com a experiência que eu tive desenvolvendo pra Android.

Uma história em capítulos

O primeiro App passou por duas iterações, uma primeira versão que não era muito mais que uma casquinha ao redor de um browser, e uma segunda versão com muito mais telas nativas mesmo. Essa foi a fase do deslumbramento, quando tudo ainda tinha aquele cheirinho de novo e eu ainda estava aprendendo a linguagem e os meandros do SDK.

Depois o projeto ficou meio de lado, voltei pra meus afazeres normais, e tome-lhe Java nas idéias. Apareceu a oportunidade de fazer uma versão Android, que eu também fiz, e depois disso já tinha até passado meu MacBook pra minha esposa, comprado um Dell e esquecido das minhas aventuras no iOS.

Foi quando pintou o segundo App pra fazer, e eu tive que voltar pro Mac e pro iOS. O que o tempo não faz, depois daquela sensação de novo ter passado é que dá pra perceber realmente o que a plataforma tem de bom e ruim, principalmente depois de ter feito uma aplicação pra Android, que é funcionalmente igual a da versão iOS.

Então, como a história é comprida vou contar aos pouquinhos começando pela linguagem utilizada no SDK do iOS, o Objective-C. Vão ser só minhas impressões, não espere encontrar aqui um tutorial completo da linguagem.

Objective-C

Antes de falar o que eu acho do Objective-C, acho melhor explicar um pouco da orígem e listar as características dela. Assim fica mais fácil de vocês entenderem o que ela tem, ou não, de legal.

Ele é uma extensão do C, isto é, qualquer programa feito em C vai compilar num compilador ObjC.

O SMALLTALK foi a fonte de inspiração para implementação OO dele. Então imagino que a sintaxe pareça absurdamente alienígena pra quem está acostumado com C++ ou Java.

Uma das heranças do SMALLTALK é o fato de você não chamar métodos, mas sim enviar mensagens. Na prática isso significa que todas as associações entre métodos e classes são feitas em runtime, ao invés de em tempo de compilação como em C++ e Java. Como efeito você pode enviar mensagens a objetos mesmo que eles não saibam como responder a elas.

Outra coisa bem diferente é que você pode enviar mensagens para objetos nulos sem que isso detone um erro, como o NPE do Java por exemplo. É uma coisa que pode te deixar coçando a cabeça imaginando por quê determinada parte da aplicação não funciona como esperado.

É uma linguagem dinamicamente tipada, pelo menos no que diz respeito aos ponteiros pra objetos. Existe o tipo especial "id" pra ser associado a objetos de tipos desconhecidos.

Outra é que como o Java, o ObjC permite reflexão nos seus objetos. Isto é, você consegue a partir de uma referência a um objeto consultar informações a respeito da classe, como o nome de métodos e seus parâmetros por exemplo.

A gerência de memória é via contagem de referência, mas isso não é feito automaticamente, ou seja, ObjC não tem Garbage Collection. Lembrar de incrementar e decrementar manualmente as referências aos seus objetos é algo bem trabalhoso, que pode levar a alguns bugs bem chatos de encontrar durante o desenvolvimento. Isso mesmo, você vai estar jogando ponteiros de um lado para outro como no bom e velho C.

Como C++ a interface das classes é declarada em um arquivo, e a implementação em outro. O que leva a você ter que repetir diversas vezes a mesma declaração pra métodos e variáveis.

E finalmente a sintaxe, que não é parecida com nenhuma linguagem OO criada nos últimos 20 anos... Minha mente ainda leva um tempo até sair do "modo Java" para o "modo ObjC". Sério, ObjC pode ter o C como ancestral comum da maioria das linguagens utilizadas hoje, mas é como você comparar mamíferos placentarios com os monotremos, tecnicamente são dois grupos de mamíferos, mas as diferenças... Objective-C é o ornitorrinco das linguagens de programação.

Isso é a declaração da interface de uma classe:


@interface Application : SomeSuperclass {
    OtherClass* variable;
    BOOL aboolean;
}

@property (nonatomic,retain) OtherClass* variable;

+ classMethod;
+ classMethodWith:( id ) referenceParam and:(BOOL)booleanParam;

- (id) instanceMethod;
- (OtherClass*) instanceMethodReceiving:( int ) anIntparam and:( NSString* )aStringParam;

@end

E abaixo segue a parte da implementação:


@implementation Application

@synthetize variable; //Isso gera "getters e setters"

-( id ) instanceMethod{
  
  id localvar = [[SomeClass alloc] init];
  
  [localvar somemethod: @"with string param value"];
  
}

@end

A Wikipedia tem uma artigo a respeito do ObjC que trata do assunto a exaustão : http://en.wikipedia.org/wiki/Objective-c

Veredito

Na minha humilde opinião o Objective-C é o ponto mais fraco de todo o SDK do iOS. A pesar de ser possível aplicar todos os conceitos e padrões de orientação a objetos que você possa conhecer, no final das contas você ainda vai estar lidando com uma sintaxe tenebrosa e gerenciando memória na unha.

Existe uma piada circulando na internet que o Objective-C foi criado para combater o princípio DRY (Don't Repeat Yourself), contra-atacando com o WET: Write Everything Twice (or trice). Sério mesmo, em pleno século XXI ainda estamos separando a interface da implementação? Fora isso, declarar a mesma variável 3 vezes espalhadas em 2 arquivos diferentes? Isso é sério mesmo?

Existe um papo de que a Apple está investindo no Ruby para substituir o Objective-C. Isso já é realidade pra aplicações do OSX, e quanto mais cedo isso acontecer no iOS melhor.

iOS vs Android

2011-01-18T10:03:00.001-02:00

Minha breve opinião a respeito de desenvolver pra iOS/iPhone e pra Android.

iOS é um Trem Bala, você pode chegar a onde precisa muito fácil, e muito rapidamente. Infelizmente você fica limitado ao que a Apple planejou, qualquer desvio do caminho e você está por conta própria.

Android é uma Land-Rover, pode não ser tão confortável ou rápida quanto um trem-bala... mas uma vez que você pegue a manha vai te levar onde você quizer.