Anthony Accioly

Life's too short not to be Irish! E um pouco de bruxaria com Emmet

2015-08-13T19:35:00.001-03:00

Pessoal, sei que o blog anda meio (muito) encostado, mas vou fazer o possível para publicar um post de vez em quando. O motivo da minha ausência prolongada? Me mudei para a cidadezinha de Athlone no centro da Irlanda. A vida é boa aqui na terra do Bono Vox, mas tudo que é novo demanda uma certa dose de energia, tempo e dedicação. Em breve pretendo escrever um pouco sobre como funciona o processo de imigração e as vantagens e desafios de viver no exterior.

Enquanto não tenho mais como dar aulas presenciais em São Paulo, continuo disponível para dar aulas remotas. Para aqueles que necessitam de aulas presenciais tenho boas indicações de instrutores. A melhor maneira de falar comigo continua sendo o formulário de contato.

Para não escrever um post sem nenhum conteúdo técnico, segue um pouco de bruxaria com o Emmet.

O que é o Emmet você me pergunta? É mais fácil mostrar do que explicar!

Abra o bom e velho JSFiddle, clique no quadro para HTML, digite o conteúdo abaixo e aperte TAB.

table.minhaClasse>tr#linha_$*3>td{Coluna 1 - $}+td{Coluna 2 - $}

Mágico não? Perfeito para HTML e CSS; flexível o suficiente para rodar no seu navegador, no seu editor de texto e no seu IDE.

Eu tenho me divido entre Java e Python no dia a dia. Independentemente da linguagem server side, o Emmet vem me ajudado muito no front end. Tanto o IntelliJ IDEA quanto o PyCharm possuem suporte nativo para Emmet. Existem também plugins para Netbeans e Eclipse. Até o pessoal do Visual Studio pode usufruir da funcionalidade com o Web Essentials. Você torce o nariz para IDES? Sem problemas, existem plugins para vim, Sublime, Emacs e até mesmo para o Notepad++.

Eu uso o Emmet em tantas janelas diferentes que chego a me esquecer que o suporte não é nativo do SO.

O Emmet na verdade é escrito em JavaScript. O fato de boa parte desses plugins estarem levantando engines de JavaScript como o V8 dá nó na cabeça desse dinossauro que vos fala. Com a morte do NPAPI (pelas mãos da Google), podemos dar por encerrada a era dos moribundos Java Applets. Enquanto isso JavaScript nunca esteve mais vivo... JavaScript is everywhere!

Software development: Private classes and onsite training - get in touch.

O que é Data Science? Por onde começar?

2014-09-25T19:25:00.000-03:00

Essa é uma era de revoluções: Computação em nuvem; popularização do acesso a Internet com conexões de dezenas (ou mesmo centenas) de megabits; data sets históricos com petabytes (ou mesmo exabytes) de informações; milhões de dados "quentes" sendo produzidos e consumidos por sistemas de sistemas a cada piscar de olhos; computação ubíqua e infinitas possibilidades.

Todos esses avanço vêm alavancando novas tendências de mercado. Estão se popularizando tecnologias e técnicas antes dominadas por poucos, restritas principalmente aos meios acadêmico, governamental, militar e financeiro; utilizadas apenas por instituições que possuíam os recursos e expertise necessários para operar nessa escala.

Buzzwords como Big Data e Fast Data estão na boca dos profissionais de TI, analistas de negócios e empreendedores. Esses tópicos andam sendo discutidos abertamente em todo tipo de conferência de mercado. Livros (inclusive romances) foram escritos sobre o obscuro mundo dos Quants: Nerds com seus PhDs em estatística, física e matemática aplicada. Figuras curiosas que deixaram (ou foram rejeitados) pela academia e ganharam o mercado... Gênios renegados com seus modelos para troca automatizada de títulos, com seus portfólios para gestão de riscos e com suas gordas contas bancárias.

Mas afinal o que é Data Science? De acordo com a Wikipedia, Data Science é o estudo da extração de conhecimento a partir de dados. Uma ciência que incorpora técnicas e teorias das mais diversas áreas de conhecimento (computação, engenharia, matemática, estatística, economia, etc).

A demanda por profissionais especializados em Data Science cresce em ritmo acelerado. Aos poucos isso tudo está despertando o nosso interesse. Nós "programadores comuns", escritores de "Software commodity" que mantém o mundo girando. Assuntos como aprendizado de máquina, inferência estatística e modelos de regressão deixam de ser exclusividade de dissertações e artigos acadêmicos, perdem a aura de superioridade e caem no gosto das abelhas e zangões trabalhadores. Há muito a aprender; um passo de cada vez. A hora de soprar o pó da capa daquele velho livro de estatística básica encostado na prateleira finalmente chegou.

E se você é como eu, há muito a aprender. Já fui um aluno muito orgulhoso do meu desempenho, sempre ostentando meu parco conhecimento sobre estatística com um livro do Bussab em mãos. Fui uma das três ovelhas da minha turma que conseguiu passar direto em estatística na primeira oferta da disciplina da USP Leste (com uma "excelente" nota 7.2, a melhor nota da turma... Considerando a dificuldade da disciplina na época 7 valia mais do que 10). Passei a dar aulas particulares de estatística para alunos com as mais diversas origens (meus colegas, alunos de administração e economia da FGV e Mackenzie, alunos de outros cursos e departamentos da USP, etc). Eis uma época em que eu "conhecia" distribuições como a normal, binomial, hipergeométrica, Poisson, t de Student, etc; também "sabia" fazer testes de hipóteses, calcular erros e taxas de confiança de cabeça e até mesmo ousava me aventurar um pouquinho com inferência e o básico de Estatística Bayesiana.

O problema é que tudo isso está para Data Science como um curso de lógica de programação está para desenvolvimento de software (ou ainda como o Ping Pong está para o Tênis de Mesa) . O que aprendi naquela época é importante, porém esses são apenas fundamentos. O básico do básico em um nível de abstração bem distante daquele que está sendo utilizado para resolver problemas na prática.

Na verdade Data Science possui três grandes pilares muito bem ilustrados nesse Diagrama de Venn do site do Drew Conway:

Diagrama de Venn do Drew Conway

Em resumo, você pode ser um hacker excepcional, aprender sobre ferramentas e técnicas de ponta, conhecer muito sobre determinado assunto, porém não ter conhecimento matemático suficiente para entender o que está fazendo (muito menos interpretar resultados). Essa é a frente "perigosa" que mais comete erros do tipo tomar uma correlação por causa e efeito sem investigar variáveis de confusão.

Na outra ponta não é muito difícil você esbarrar com acadêmicos que possuem grande conhecimento tecnológico e estatístico, porém com pouco conhecimento sobre o assunto no qual estão trabalhando. Geralmente o conhecimento desse grupo sobre o problema que estão tentando resolver é de natureza teórica (e muitas vezes extremamente desatualizado); sabe aquele grupo que faz complexos experimentos de laboratório sem nunca ter realmente vivenciado ou entendido o problema que está tentando resolver? Esse tipo de profissional pode produzir estudos bem interessantes, ~~distorcer~~ categorizar dados e chegar a conclusões ~~insignificantes~~ únicas. Podem até mesmo propor soluções "geniais" para problemas em aberto (que geralmente são inviáveis ou de aplicação muito limitada por esbarrarem em alguma constraint básica desconhecida pelo autor). Enquanto penso que esse grupo é menos perigoso do que o primeiro, a quantidade de estudos do tipo Seinfeld (sobre o nada) gerando ruído na comunidade científica também é bastante preocupante.

Finalmente a pesquisa tradicional continuará existindo e continuará sendo relevante. Porém, sem o componente hacker pesquisa não é Data Science. Muitos autores criticam Data Science como um termo mercadológico para descrever estatística. Enquanto essa critica não é totalmente injusta, acredito que há uma distinção válida. Conhecer a distribuição normal não me faz um estatístico; saber criar um modelo e rodar uma simulação no MATLAB não faz do estatístico um Data Scientist.

O aspecto hacker da coisa rapidamente me encantou. Tenho que admitir que passei muito tempo engatinhando, brincando com diversas ferramentas e possibilidades, lendo livros e tutorais puramente focados em tecnologia. Eu poderia passar horas falando de HPC e HTC. Poderia falar de BI, CEP e DW. Poderia falar de soluções analíticas na nuvem como BigQuery e Redshift. Ainda vou escrever um artigo dedicado ao ecossistema Hadoop. Enfim, há muita coisa a ser aprendida nessa frente.

Apesar disso tenho que reconhecer minha pequenez. Quanto mais explorava esse Universo mais me deparava com papers descrevendo soluções altamente sofisticadas para problemas que eu desconhecia (geralmente usando abstrações matemáticas que eu também desconheço). Foi nesse momento que resolvi desmanchar o castelo de cartas que construí e começar do zero. E não é que a vida fica mais fácil quando procuramos conhecimento de base?

Sou um grande fã da Coursera, e acabei me deparando com a especialização gratuita sobre Data Science. Uma verdadeira "pós-graduação" com nove cursos (e um projeto final). A espacialização aborta o básico sobre métodos estatísticos e ferramentas computacionais, passa por técnicas de tratamento e visualização de dados, inferência, modelos de regressão, aprendizado de máquina e finalmente produtos baseados em dados. Essa especialização é um verdadeiro Data Science tour de force elaborado por três professores do Departamento de Bioestatística da Johns Hopkins University.

Achei muito interessante como os primeiros cursos da especialização conseguem ensinar cientistas a utilizarem ferramentas com Git e um IDE enquanto ensinam nerds da computação sobre métodos estatísticos e afins. Apear do material denso, os cursos não são difíceis ou massantes. A abordagem é bastante prática, focada em R e seu enorme ecossistema (incluindo pacotes e tecnologias correlatas). Você vai aprender sim sobre métodos estatísticos, experimentando na prática com data sets reais.

R é uma tecnologia "simples", porém o caminho para se tornar um especialista é longo e pode ser desafiador até para programadores experientes. A linguagem é extremamente expressiva, própria para tratamento estatístico e visualização de dados em memória (ainda que essa não seja toda a verdade, veja minha resposta no Stack Overflow sobre como utilizar R com data sets grandes demais para serem tratados inteiramente em memória), utilizando uma combinação de elementos que podem parecer estranhos para programadores de linguagens C-Like. Para mencionar alguns pontos: A linguagem adota algumas características da programação funcional (o curso de Programação Funcional em Scala me ajudou muito nessa frente), também conta com a expressividade da vetorização, escopo léxico e diversas tentativas de implementar orientação a objetos (que coexistem na linguagem).

100% Open source e parte do Projeto GNU, o ambiente R se tornou a base de um fortíssimo ecossistema para aplicações científicas. Esqueça suas experiências traumatizantes com código da plataforma Weka, esqueça aquelas implementações de LVQ e SOM caseiras feitas em C, Python e Java (sim, eu também fiz isso na faculdade). Tome a pílula vermelha e venha brincar com os pacotes do CRAN (bem como pacotes mais especializados de fontes como o Biocondutor). Use o que há de mais moderno em termos no mercado; use implementações extremamente robustas de algoritmos clássicos; brinque com código instável recém saído do forno (da acadêmia e da indústria). Há soluções para todos os gosto.

Ainda não cheguei na parte mais avançada do curso (atualmente estou cursando o terceiro módulo - Getting and Cleaning Data - pela terceira vez, por pura falta de tempo). Mas o que já aprendi sobre métodos e variáveis estatísticas, tratamento de dados, etc, compensou. Com certeza a especialização já me tornou um programador melhor... Mas o mais importante de toda essa experiência foi que, com os cursos, percebi toda a enormidade teórica e a base matemática sustentando as Buzzwords de mercado. Não há o que temer nessas frentes (com paciência, bons livros e bons instrutores você consegue dominar qualquer assunto).

P.S. Pelo preço simbólico de $49 você pode obter um certificado verificado para o curso (obviamente isso também requer que você passe no curso com um score mínimo). Enquanto o certificado atualmente não tem muito valor (seja no mercado seja na acadêmia), não é de todo ruim possuir um certificado com o logo da Johns Hopkins. Enquanto não coloco esses certificados no meu currículo oficial, já os incluí no meu perfil do LinkedIn (e, contrariando minhas expectativas, isso está chamando a atenção de empresas dentro e fora do país).

Média POSCOMP 2014

2014-09-22T21:35:00.001-03:00

Pessoal, peço desculpas pelo longo intervalo sem postar aqui no Blog. Além das atividades da 7RTC (agradeço quem puder dar um jóinha no Facebook), estou com algumas coisas novas acontecendo, incluindo:

Um novo emprego em uma empresa especializada em conciliação chamada Ainstec (estamos contratando Programadores Java, Programadores APEX, Programadores PL/SQL e Analistas de Negócios; interessados por favor entrem em contato).
Algumas atividades de treinamento e desenvolvimento para uma empresa parceira da Zimbra.
Dois projetos freelancer para empresas no exterior.

Com tudo isso acontecendo ao mesmo tempo fiquei com pouco tempo livre. Quando consigo uma folguinha venho tentado contribuir com o Stack Overflow Em Português; responder perguntas por lá é uma maneira bem interessante de "devolver" para a comunidade (aguardem um post sobre minhas "melhores contribuições" para o SOpt).

Bom, vamos ao que interessa. A pedido dos leitores do blog estou repetindo a dose de 2013 e compartilhando uma planilha para estimativa da média do POSCOMP 2014 (exame unificado para ingresso na Pós-Graduação em Computação). Também relanço aqui a planilha para correção da prova conforme gabarito provisório de 2014. Seguem os links:

Sintam-se livres para divulgar os links como bem entenderem (as visões da planilha aqui no site podem estar defasadas em relação ao conteúdo no Google Spreadsheet; recomendo acompanhar os resultados diretamente pelo link).

Ajuda para administrar e melhorar a planilha é sempre bem vinda (interessados por favor entrem em contato).

Quem quiser mais informações sobre o exame podem encontrá-las nesse post de 2013 e no post anterior de 2010.

UPDATES

25/09 14:30 - A planilha já conta com aproximadamente 200 entradas, a média estimada está em 26.1 pontos. Obrigado ao Iago do Grupo de Facebook POSCOMP 2014 por ter colocado a planilha no ar e divulgado para a galera. Por sugestão do pessoal do grupo foram incluídos colunas opcionais para o nome e a instituição de origem.
18/10 14:00 - No dia 16 foi divulgado o gabarito definitivo do POSCOMP 2014. As questões 24, 32 e 33 foram anuladas. A planilha para correção da prova já foi atualizada. A planilha para estimativa da média permitirá, temporariamente, a edição dos resultados (por favor evitem duplicar entradas).
31/10 11:30 - O resultado oficial foi divulgado. Média oficial 24,1 - Desvio Padrão 6,5. Esse ano tivemos uma participação menor (276 vs 445 pessoas do ano passado). A média oficial ficou um pouco abaixo da média amostral. Infelizmente a média oficial ficou também fora do intervalo de confiança por exatamente 1 ponto (que bom que eu não trabalho no Datafolha :). De qualquer maneira agradeço a todos que participaram!

Java IDES - One shortcut to rule them all

2013-10-08T16:38:00.001-03:00

"Three IDES for the Java-kings under the sky,

Seven were once famous in their halls of stone,

Plenty of others for Mortal Men doomed to die,

One shortcut to the Productivity Lord on his dark throne

In the Land of Java where the Shadows lie.

One shortcut to rule them all, One shortcut to find them,

One setting to bring them all and in the darkness bind them

In the Land of Java where the Shadows lie."

- J. R. R. Tolkien, The Lord of the Rings (slightly hacked)

I've been a polyglot programmer and multi-IDE user for several years... And as any all-arounder, I am not the most productive expert on any of them. IDES are huge beasts! It takes time to learn and to allow all of its functionality to sink in and it takes even more time to learn how to do things efficiently.

Memorizing highly specific keyboards shortcuts of each IDE is one of the many actives that can become tedious or even completely unachievable if you switch between IDES frequently. Still, all in all I do prefer this road, since every IDE has its unique qualities. I'm a huge believer of the motto "Use the right tool for the job." Quoting Abraham H. Maslow's Psychology of Science: "I suppose it is tempting, if the only tool you have is a hammer, to treat everything as if it were a nail." Please avoid temptation!

So let's check out how to cheat and increase productivity by learning "Tool tamer" shortcuts for the most popular IDES in Javaland.

The idea behind this article is that if you can learn how to find desired functionality in the sea of options that one IDE has to offer, then you can teach yourself to be more productive with it. If you can configure all of your IDES to use the same shortcut to access the desired functionality then congratulations, you have just created a shortcut to rule them all.

Eclipse

If you make a living out of Java, chances are that you have spent some time with Eclipse, either because you love it or because that's what everyone else in your company uses! Eclipse is the only IDE that an entire army of (not that enthusiastic) Java Developers have ever learned how to use: it often offers the ~~only~~ best third-party plugins for a certain software stack. Eclipse is the most popular IDE in Javaland. Developed by an impressive foundation - backed by a giant group of technology companies and fueled by a vibrant community - the extremely customizable SWT-based IDE conceived by IBM isn't going away anytime soon.

If you don't know how to do something in Eclipse, just resort to the handy Quick Access functionality (Ctrl+3) and type the desired action (say, "Extract Variable").

If you don't like Ctrl+3 just bind the Quick Access command to some other key combination. In order to do this follow these steps:

Navigate to Windows → Preferences
In the right menu open General → Keys
Locate and select Quick Access
Change its binding to the desired key combination
Click on Apply and OK

Netbeans

"The only IDE you need" was the Netbeans motto back when Sun shined. It is intriguing to observe how a lot of my colleagues dismiss this very crafty IDE as "slow"... This might have been true once upon a time when Netbeans hadn't yet reached its fourth release, the VMs were not optimized for Swing Applications, and computers were shipped with way less memory and very poor graphic cards. Nowadays Netbeans is a very responsive IDE with amazing UI Design Tools (JavaFX anyone?), a great out-of the-box experience for Java SE and Java EE, out-of-the-box support for a variety of Java tools and frameworks, plus a surprisingly competent out-of-the-box support for other programming languages (such as PHP, Groovy and C/C++). Netbeans surely lives up to its motto, and does this with a clean, hassle-free philosophy which makes it the perfect IDE to use in classroom.

Much in the same fashion of Eclipse, Netbeans exposes a Quick Find command which can be triggered with Ctrl+l. Although unlike Eclipse, Netbeans tries to find a lot of things by default (Types, Symbols, Help references, Maven artifacts and so on). So if your goal is to find an IDE functionality it is advisable to narrow the search category (accessible with Shift+F10 when the cursor is on the search bar) to Action.

I have never really liked Ctrl+l as a shortcut to Quick Find. So Thanks Sun for shortcut customization. To change your keymap, do the following:

Navigate to Tools → Options
Click twice on the Keymap button located at the top Toolbar
Look for "Quick search"
Click in the Shortcut cell (or on the small ellipsis button) to edit
Type your new key combination
Click on OK

IntelliJ IDEA

How does a company make money out of a Java IDE when programmers can just download very good IDES such as Eclipse and Netbeans for free? Easy, you make the best tool on the market! And that's exactly what JetBrains did with IntellliJ IDEA. But don't take my word for it: just read what Martin Fowler has to say about IntelliJ (in its way, Martin Fowler is the IT version of Tom Hanks, we can always borrow his credibility). While there is a free Community Edition (which is good enough to run the amazing Scala Plugin, light years ahead of the competition) the good stuff comes with a price tag.
Is it worth it? Sure! I think that IntelliJ is indeed the Best Java and Polyglot IDE there is. I feel that developing with IntelliJ is a pleasure. Yes, I think that it can read my mind. And yes, I'm sold. But no, I'm not on commission, although if someone at Jetbrains ever reads this article and feel like donating a lifetime IntelliJ license, I'm all for it!

God is in the details! And IntelliJ Find Actions command has a very different (and, in my option, way better) approach for searching actions than Eclipse and Netbeans top right corner search boxes... Ctrl+Shift+a makes IntelliJ pop up a contextual menu right in the middle of your code. Easy, fast and to the point.

If Ctrl+Shift+a stresses your fingers (or your brain), no problem - here is the receipt to change it:

Navigate to File → Settings
At the left menu click on Keymap
Look for "Find action"
Click twice on it to customize the shortcuts
Click on Apply and OK

And that's all: you've learned how to find your actions and teach yourself new shortcuts using three of the most popular Java IDES. Plus you have mastered how to customize key bindings according to your desires. Now come on, don't be a Hobbit (or eight Hobbits, also know as a Hobbyte)! Use the precious shortcut... Rule them all!

POSCOMP 2013

2013-10-01T00:18:00.001-03:00

PARA POSCOMP 2014 CLIQUE AQUI

Quem leu meu artigo "POSCOMP 2010" sabe que o POSCOMP é um exame de múltipla escolha com 70 questões, exigido pelos melhores programas de pós-graduação em Ciências da Computação / Engenharia da Computação / Engenharia de Sistemas / Sistemas de Informação / Informática e áreas correlatas no Brasil.

Se você pretende entrar em programas de mestrado / doutorado em computação na USP, UNICAMP, UFSCar, UNIFESP, PUC-Rio, UFRJ, UFMG, UNB, UFPE, UFPR, IME–RJ, UFRGS, UFSC, etc é recomendável prestar o exame. Esses programas geralmente usam o POSCOMP tanto na seleção de mestrandos e doutorandos quanto como critério para distribuição de bolsas.

O exame é divido em três grandes áreas: Matemática, Fundamentos da Computação (que contém a maior parte das questões) e Tecnologia da Computação.

O objetivo dos candidatos buscando vagas em programas de excelência é ficar acima da média geral. Essa é historicamente baixa. A média de acertos entre 2002 e 2011 foi de aproximadamente 25 questões (~35%). Isso mostra o nível de exigência do exame.

Eu prestei o exame em 2010. Com os resultados do exame garanti vagas em bons programas de pós-graduação, incluindo o Programa de Engenharia de Sistemas e Computação na COPPE / UFRJ e no Departamento de Informática da PUC-Rio, ambos conhecidos pela excelente produção científica e pelo conceito máximo na avaliação da CAPES.

É claro que esses programas levam em consideração muitas outras coisas além do POSCOMP. Dentre elas: histórico acadêmico, cartas de recomendação, envolvimento com atividades de pesquisa (Iniciação Científica e publicações), currículo, etc. Um fator importante é buscar uma área de pesquisa de seu interesse e, dentro dessa área, orientadores que possam guiá-lo em suas atividades de pesquisa (é costumeiro que alunos de pós-graduação sigam a linha de pesquisa de seus orientadores).

Nesse domingo (29/09/2013) voltei ao IME-USP para prestar o POSCOMP pela segunda vez. Segue a prova com gabarito oficial

POSCOMP-2013

Para candidatos interessados em prestar o POSCOMP em 2014, tomei a liberdade de fazer upload dos 4 últimos exames para o Scribd (extraídos do site da SBC).

Segue o link: http://www.scribd.com/collections/4356586/POSCOMP

Boa sorte a todos que estão aguardando os resultados oficiais!

PS: Se você prestou o POSCOMP por favor deixe um comentário com suas impressões sobre o exame.

UPDATES

Criei uma planilha no Google para estimarmos a média de 2013.
Link: Média POSCOMP 2013
Gabarito provisório substituído pelo definitivo.
Planilha para correção da prova conforme gabarito definitivo.
Link: Correção POSCOMP 2013

MOOC - Princípios de Programação Funcional em Scala

2013-09-21T22:50:00.003-03:00

Gostaria de aproveitar esse post para divulgar um excelente curso online gratuito na Coursera.

Trata-se do curso Princípios de Programação Funcional em Scala (Functional Programming Principles in Scala). Segue link: https://www.coursera.org/course/progfun.

O instrutor do curso é ninguém menos do que Martin Odersky, criador da linguagem Scala, fundador da empresa Typesafe e Pesquisador na École Polytechnique Fédérale de Lausanne.

Eu acompanhei a segunda versão do curso fora de época e posso atestar a qualidade em primeira mão. De fato o curso da Coursera é utilizado como parte das atividades na EPFL, ou seja, alunos do Professor Odersky se matriculam normalmente na Coursera junto a outros milhares de candidatos ao redor do mundo; na primeira versão do curso mais de 50.000 pessoas se inscreveram (veja as estatísticas).

O tom do curso é bastante acadêmico, entrando em detalhes sobre modelo de substituição logo na primeira aula e navegando no mundo de funções de alta ordem, currying, covariância, contravariância, pattern matching, tuplas, parâmetros implícitos, monoides, streams, etc. Mas acredito ele seja também de grande valia para a indústria. Meus colegas de trabalho sempre me escutam tagarelando sobre Scala... Principalmente quando esbarro em pedaços de código longos e difíceis de ler em Java com contrapartidas intuitivas e sucintas em Scala. Além disso, cada vez mais linguagens Orientadas a Objetos vem adotando construções típicas de linguagens Funcionais como genéricos (introduzidos no Java 5) e expressões lambda (suportadas em C# desde a versão 3.0 e e pelo Java 8 previsto para Março de 2014).

Nada como adicionar uma linguagem "híbrida", concebida com expressividade e escalabilidade em mente, 100% interoperável com Java (e seu enorme ecossistema) e altamente performática ao seu conjunto de skills. Além do que, aprender a mentalidade da programação funcional te faz um programador melhor em geral... Após minha experiência com Scala acabei descobrindo jóias do Apache Commons e Google Guava que possibilitam escrever código Java muito mais limpo. Também reforcei meu padrão de pensar mais / escrever menos código (os exercícios do curso realmente te fazem quebrar a cabeça, e no fim das contas as soluções são sempre simples).

O curso tem duração de sete semanas. A cada semana o aluno recebe o material de estudo (incluindo vídeos do Martin Odersky) e uma atividade de programação (com data de entrega para a próxima semana). O aluno pode submeter os exercícios através de um plugin do sbt (ferramenta de build popular entre desenvolvedores Scala). A correção dos exercícios é feita automaticamente em servidores (no Amazon EC2) que rodam testes unitários e analisadores estáticos de código contra a solução submetida. O aluno recebe uma nota de 0 a 10 e feedback sobre seu exercício de maneira quasi-instantânea. A correção leva em consideração:

Testes unitários
Estilo (indentação, espaços em branco, etc)
Boas práticas da programação funcional em Scala (evitar casts, variáveis locais mutáveis, uso de return, etc)
Prazo de entrega (cada dia de atraso desconta 20% da nota)

O aluno pode submeter respostas para o mesmo exercício até cinco vezes com o objetivo de refinar sua implementação. São aprovados no curso (com direito a certificado oficial) alunos que obtiverem média acima de 60%.

Além do arsenal para correção automática de exercícios, o curso conta com um rico fórum de discussão em que alunos podem interagir, formar grupos de estudo e submeter / responder questões. Os fóruns são moderados por assistentes voluntários (comunidade) e staff oficial do curso para garantir a qualidade das discussões (bem como evitar que os alunos "colem").

A experiência do curso é muito enriquecedora, definitivamente vale a pena.

E ainda dá tempo de se matricular! A data de entrega para o primeiro exercício é dia 25/09/2013... No pior caso, se você perder essa data é possível passar no curso sem entregar o primeiro exercício (obtendo boas notas nos demais exercícios).

Então o que está esperando? Venha participar!

Slides- Escalabilidade Web / DevOps e PaaS

2013-09-17T21:19:00.002-03:00

Slides da palestra "Escalabilidade Web: Sharding, Indexação, CDN, NoSQL, DevOps, Cloud, PaaS e a Vida Real" na EACH - USP Leste.

Agradeço ao Professor Eler e a todos que participaram!

This is an embedded Microsoft Office presentation, powered by Office Online.

Linux em 2013 - Primeiras impressões do openSUSE 12.3 e KDE 4

2013-09-08T05:42:00.000-03:00

Recentemente, um pouco decepcionado com o Ubuntu 13.04, comecei a procurar outras distros Linux para uso no dia a dia.

E como o cenário das distros mudou de alguns anos para cá! Eu sou da época em que suas escolhas se resumiam a:

distribuições baseadas em Gnome ou KDE,
DEB, RPM ou "compile você mesmo" (Gentoo style!).

Não me leve a mal, já existiam várias distros voltadas a desktops e outros sistemas de arquivo além do ext, mas a vida para o típico usuário Linux costuma ser bem mais simples.

No servidor boa parte de nós rodava RHEL, seu primo CentOS ou o Debian. Para o desktop os grandes nomes eram Ubuntu e Fedora. Aqui no Brasil, nosso querido (e descontinuado) Kurumin escrito pelo Carlos Morimoto, bem como o Conectiva Linux (que, após fusão com o Mandrake, deu origem ao Mandriva Linux que deu origem ao Mangeia) fizeram muito sucesso...

Mas nada pode parar a evolução. Foram lançados os controversos Gnome Shell e KDE 4, que desagradaram parte dos usuários acostumados com a tradicional metáfora de escritório. A Canonical lançou o Unity e começou a distribuí-lo por padrão com o Ubuntu; surgiram também outros projetos como MATE para agradar os usuários leais ao Gnome 2 e Cinnamon para quem desejava uma interface tradicional em cima do Gnome 3 (ambos distribuídos com Linux Mint, outra distro fantástica que pretendo revisar em breve). Projetos como o Xfce e LXDE, que antes viviam na escuridão também ganharam popularidade.

Eu não tenho cojones para tecer opiniões sobre a fragmentação dos ambientes de desktop Linux (nem na camada mais baixa dos display servers como X11, Wayland e Mir). Então deixo um vídeo do Bryan Lunduke, apaixonado o suficiente por Linux para cutucar a ferida:

(Assistam também Why Linux Doesn't Suck - 2013)

Enfim, com ou sem fragmentação, eu brinquei o suficiente com o Windows, OS X e primos do Linux como Solaris e FreeBSD para saber em qual SO quero desenvolver... E esse SO é o Linux! De preferência em uma distro com UI agradável e responsiva.

Fico feliz quando o sistema vem pré-instalado com o Compiz (ou similar) e tem todo o eye candy para as tarefas mundanas. Fico ainda mais feliz quando o sistema me permite desativar todos os efeitos visuais com um click ou tecla de atalho, de forma que eu possa rodar uma instância do Eclipse, outra do JDeveloper, uma terceira do SQL Developer, dois domínios do Weblogic, um terminal com 5 abas em SSH e o Chrome com 30 abas abertas sem que o sistema tenha que desperdiçar recursos com transparência e efeitos de transição (sim, estou falando sério, já trabalhei com tudo isso tudo - e muito mais - simultaneamente!). Nessas situações extremas você pode perceber a eficiência do mecanismo de memória virtual e sistema de arquivos do Linux.

Um outro fator importante para decidir entre distros é o ciclo de vida. Enquanto o suporte de 5 anos para versões LTS do Ubuntu é interessante, eu sempre preciso de algum aplicativo de versões mais novas do SO (nem sempre disponíveis através de Backports). O suporte por apenas 9 meses das versões comuns do Ubuntu é insano para uso no trabalho (infelizmente o Mint, baseado em Ubuntu, segue o mesmo ciclo de vida de 9 meses). Esse é um ponto muito positivo do openSUSE que mantém suporte por pelo menos 18 meses (na verdade, duas releases + dois meses).

Outro ponto positivo do openSUSE é a forte comunidade (não tão grande quanto a do Ubuntu ou Fedora, mas muito prestativa, educada e entusiástica) e o "apadrinhamento" pela Novell.

Quem me conhece sabe que eu costumo torcer o nariz para distros com KDE e RPM (más experiências com o Fedora), mas a recomendação de amigos e a elegância da distribuição me levaram a experimentar algo novo (no VirtualBox é claro).

Pouco mais de uma semana após a instalação e estou tão satisfeito que em breve promoverei o SO à sua própria partição (junto ao Windows 7 - ~~como me arrependo de ter instalado o Windows 8~~ - e Mint 15).

O download e instalação são muito simples (estilo next, next, next). Estão disponíveis Live CDs Gnome e KDE, bem como um DVD capaz de instalar ambos os desktops e uma vasta seleção de software (o DVD funciona como um repositório).

O boot é rápido; a interface é limpa, bem trabalhada e fluída. O KDE, na minha opinião, sempre deixou o Gnome no chinelo em termos de configuração / customização, mas sempre me pareceu demasiadamente burocrático e pesado... Não é o caso dessa versão.

Eu vou ser honesto e admitir que ainda sou, por natureza, um usuário Gnome 2 / Unity e que fico um pouco perdido com conceitos do KDE como atividades. Dito isso, para um dinossauro até que não demorei muito para me encontrar no Plasma... É tudo muito intuitivo, não leva mais de alguns minutos para descobrir e entender os painéis, widgets e folder views.

Plasma

Nem me dei ao trabalho de customizar a aparência do sistema. Na verdade essa foi a distro com o tema padrão mais bonito que já encontrei (isso é, para quem gosta de preto).

Isso não significa que não existam maneiras de personalizar papéis de parede, temas, decorações de janela, etc; inclusive os aplicativos de customização do KDE contam com botões para baixar mais recursos na internet (um bom site para começar é http://kde-look.org/)

Decorações de Janela

Outro ponto que me preocupava é se eu conseguiria instalar versões razoavelmente atuais dos softwares que uso. Para minha surpresa não senti tanta falta do gigantesco repositório do Ubuntu e seu ecossistema de PPAs. Entre os repositórios padrões do openSuse, RPMs disponíveis na internet e os típicos softwares distribuídos nos formatos bin e tar.gz encontrei tudo que precisava (Java, Scala, IDEs, versões recentes do Mercurial, Git, Maven, sbt, etc). Mesmo softwares da Oracle que historicamente sempre foram "seletivos" em relação a distros instalaram sem nenhum problema (ainda não usei todos exaustivamente, mas por enquanto tudo parece estar em ordem).

Um ponto forte do openSUSE é o mecanismo One Click Install que adiciona repositórios, verifica dependências, faz a instalação e configura atualizações automáticas para determinado software em um único passo através de botões em websites e arquivos YMP distribuídos pela internet. Combine esse mecanismo com um portal que agrega pacotes oficiais e não oficiais e você tem o melhor dos mundos.

Package Search

Falando em atualizações, essa é uma área muito transparente e funcional no openSUSE. Atualizações disponíveis aparecem na área de notificação e, caso o usuário deseje atualizar um pacote, os softwares Apper e YaST (esse último é muito superior ao Ubuntu Software Center, e, na minha opinião, mais intuitivo do que o Synaptic) se encarregam de todo o processo.

Apper

YaST

Algo admirável do KDE é a flexibilidade para customização das teclas de atalho. O ambiente oferece configurações para atalhos globais, atalhos específicos de cada aplicação e mesmo de aplicativos no menu. Olha o Alt+Shift+F12 para desabilitar os efeitos visuais aí ;).

Configuração de atalhos globais

É claro que, por melhor que uma distro seja, sempre existem alguns probleminhas:

Esbarrei em um bug do kdesu quando a senha do root contém aspas duplas (")
A performance do flash é abismal (mas pode ser culpa da VM)
A versão do Amarok pré-instalada é muito bonita, mas achei bastante instável:

Amarok

Não consegui fazer o IntelliJ 13 EAP funcionar (admito que isso é pedir um pouco demais)
Chrome resolveu achar que o 7u25 não é a versão mais atual do Java e bloquear o plugin (nada que um --allow-outdated-plugins não resolva, e pelos reports que li isso não tem nada a ver com o openSUSE)

Em suma: O openSUSE é uma distro rápida, polida, completa, bem documentada, com vasto apoio da comunidade e da Novell; além disso possui excelentes ferramentas de administração e um ecossistema de software de fazer inveja em muitas distros por aí. Definitivamente recomendo para trabalho e dia a dia.

IDE Updates

2013-06-23T17:29:00.000-03:00

Após longo período em hiato, segue um breve relate das novidades no mundo dos IDES Java:

O Netbeans 7.3.1 está fantástico. Definitivamente ganhou a corrida por novas features (destaque para o suporte a Java EE 7, HTML 5 e JPQL). Tratando-se de primeira impressões esse me parece ser o melhor IDE do ano.

A Early Access Preview do IntelliJ IDEA 13 também promete! Apesar do foco da nova versão ser desenvolvimento Android, tive a impressão de que o IDE está bem mais rápido no que em sua encarnação 12. Apesar do pessoal da Jetbrains alertar novos usuários de que a qualidade de versões EAP pode ser inferior a de versões Beta, achei a v13 bastante estável. Recomendo!

Sobre o Eclipse Kepler (atualmente na versão RC3), enquanto na minha máquina (Ubuntu - 64 bits) o ambiente ficou um pouco instável (com exceções em background e freezes), a diferença de performance em comparação ao Juno é notável. As novas versões do m2e e m2e-wtp melhoraram bastante o suporte a projetos Maven (configurações intrusivas à parte, pela primeira vez o Eclipse parece estar se aproximando das outras IDES nesse quesito); para os usuários de Git o EGit está quase tolerável... Destaque para a força do ecossistema, com parceiros abraçando o Kepler antes mesmo da sua primeira versão estável: OEPE, JBoss Tools e STS sendo alguns dos principais exemplos.

P.S. Tive meu primeiro contato com o IntelliJ em uma versão EAP, antes da primeira versão comunitária ser lançada... Desde então comprei e renovei licenças do IDE duas vezes!

JAR Hell - Um guia prático

2012-12-29T02:41:00.001-02:00

O que é JAR Hell?

JAR Hell é um termo cunhado para descrever de forma genéricas problemas relacionados ao ClassLoader. Suas variações mais comuns acontecem quando:

Duas ou mais classes diferentes, com o exato mesmo nome qualificado acabam sendo incluídas no projeto (e.g, duas versões diferentes da biblioteca ASM no Classpath).
Duas ou mais bibliotecas no Classpath dependem de versões diferentes das mesmas classes (e.g., Hibernate e Spring dependendo de versões diferentes da biblioteca ASM).

Sintomas do JAR Hell

JAR Hells possuem algumas peculiaridades marcantes, mesmo assim nem sempre seu diagnóstico é óbvio; várias vezes uma situação de JAR Hell vem mixada com outros tipos de problemas como ausência de dependências transitivas no Classpath e omissões em arquivos de configuração.

Eis alguns sintomas quem indicam um problema de JAR Hell:

Estão sendo disparados NoSuchMethodError, NoSuchFieldError ou IllegalAccessError.
ClassCastException entre classes iguais ou compatíveis.
Problemas de serialização / deserialização.

Outra pista que aponta para uma situação de JAR Hell acontece quando um ou mais dos problemas mencionados acontecem de forma intermitente, e particularmente quando dão a impressão de estarem relacionados a questões de build / ambiente (e.g., aparecem no ambiente de homologação mas não no de desenvolvimento; builds pelo IDE funcionam / builds pela ferramenta de Integração Contínua não; com o servidor em modo de desenvolvimento tudo funciona mas em modo de produção não; com JVMs da Sun tudo funciona e com JRockit não).

Isso ocorre pois quando há duas ou mais classes com o mesmo nome qualificado no Classpath, a lógica que determina qual delas será carregada fica codificada no ClassLoader utilizado, ou em última instância, na lógica dos ClassLoaders de base da própria JVM.

Prever qual versão de uma classe será carregada é uma tarefa difícil devido a cadeia complexa de ClassLoaders tipicamente presente em soluções enterprise. O próprio ClassLoader escolhido para abrir determinada classe pode variar conforme o estado do container e código da aplicação.

Em geral o ClassLoader que carrega uma classe também fica responsável por carregar todas as outras classes utilizadas por ela; essas classes e o valor de suas variáveis estáticas são então cacheados em memória (e.g., na famigerada PermGen). Isso significa que - salvo exceções em que o ClassLoader se torna elegível para Garbage Collection e a JVM é otimizada para fazer unloading de classes - uma vez que determinada versão de uma classe seja carregada ela permanece em memória, em um namespace relacionado ao ClassLoader, até fim do processo.

Resolvendo Problemas de JAR Hell

Os passos lógicos para resolver JAR Hells são:

No caso de classes duplicadas dentro do domínio da sua aplicação: Detectar e excluir versões antigas da classe duplicada. Preferencialmente deixar somente uma classe de cada tipo no Classpath, i.e., não há necessidade da mesma classe estar presente em vários JARS da aplicação, sendo recomendável refatorar as classes repetidas para um JAR a parte.

No caso de incompatibilidade entre bibliotecas de terceiros: Fazer upgrades e / ou downgrades das bibliotecas para uma combinação com dependências transitivas compatíveis. Uma ferramenta para gerenciar dependências ajuda muito.

Se por algum motivo não for possível eliminar versões duplicadas de uma classe ou encontrar bibliotecas compatíveis, como último recurso é possível escrever ClassLoaders personalizados. Esse é um tópico avançado que fico devendo para um próximo post. Classifico o uso de ClassLoaders customizados como um último recurso pois eles aumentam a Entropia do Software, são de difícil manutenção e, se não forem bem arquitetados, podem gerar todo tipo de problemas (NoClassDefFoundError, java.lang.OutOfMemoryError: PermGen space, etc).

Encontrando classes duplicadas

Geralmente essas classes estão em bibliotecas do EAR (APP-INF/lib), WAR (/WEB-INF/lib), ou do Servidor de Aplicação.

Para saber de que JAR / diretório determinada classe está sendo lida utilize os seguintes métodos:

public static URL getLocation(Class clazz) {
    return clazz.getProtectionDomain().getCodeSource().getLocation();
}
public static URL getLocation(String className) 
    throws ClassNotFoundException {
    return getLocation(Class.forName(className));
}

Exemplos de chamada e resposta (para um projeto mavenized):

System.out.println(getLocation(EntityManager.class)); 
/* 
 * file:/home/anthony/.m2/repository/javax/persistence/
 * javax.persistence/2.0-SNAPSHOT/javax.persistence-2.0-SNAPSHOT.jar 
 */
System.out.println(getLocation(
    "org.apache.commons.lang.builder.ReflectionToStringBuilder")); 
/* 
 * file:/home/anthony/.m2/repository/commons-lang/commons-lang/
 * 2.6/commons-lang-2.6.jar 
 */

Um bom lugar a ser analisado são clientes de Web services gerados automaticamente, principalmente quando mais de um serviço depende do mesmo XSD. Nesse cenário é comum que vários clientes sejam gerados a partir de WSDLs diferentes, todos contendo suas próprias versões da mesma classe.

Na verdade todo tipo de código gerado automaticamente merece atenção: Classes JAXB geradas com xjc, entidades JPA repetidas em diferentes projetos EJB, etc.

Problemas de compatibilidade entre bibliotecas de terceiros

Para resolver esse tipo de JAR Hell é necessário encontrar versões compatíveis das bibliotecas (e.g., uma versão do Spring e do Hibernate que possam funcionar com a mesma versão da biblioteca ASM), ou, em casos de total incompatibilidade, escrever ClassLoaders customizados.

Geralmente esse tipo de erro acontece com bibliotecas populares como como Apache Commons, Javassist e ASM que são dependências para uma grande quantidade de frameworks e bibliotecas.

Devido a dependências transitivas (e.g., seu projeto depende da biblioteca A que por sua vez depende da biblioteca B que depende da biblioteca C e assim sucessivamente), encontrar versões compatíveis de bibliotecas pode se tornar uma tarefa enfadonha.

Para aliviar o trabalho do programador ferramentas poderosas como Maven, Ivy e Buildr estão disponíveis. Com essas ferramentas é possível especificar as bibliotecas (e versões / intervalos de versões) que seu projeto necessita em arquivos de configurações; essas ferramentas fazem então o download dos artefatos - e suas dependências transitivas - a partir de uma hierarquia de repositórios de software (como o gigantesco Repositório Central), ajustam o Classpath da aplicação para compilação / execução / testes e ainda empacotam bibliotecas dentro dos EARs, WARs, etc para distribuição quando cabível.

Caso ocorra algum conflito o desenvolvedor pode trocar facilmente a versão de determinada biblioteca no arquivo de configuração e deixar que a ferramenta faça o trabalho duro por ele.

Enquanto uma ferramenta como o Maven não se aplica a todo tipo de projeto (pois introduz suas próprias complexidades), eu costumo usá-lo pelo menos para fazer download das dependências do projeto e exportá-las com o Dependency plugin. Fico devendo um tutorial sobre esse assunto para um próximo post.

Bibliotecas do Servidor de Aplicação vs Bibliotecas do Projeto

Pessoalmente tento, sempre que possível, usar bibliotecas do próprio servidor (que passaram por todo o processo de homologação do Java EE, e, por via de regra - mas não como verdade absoluta - são compatíveis). Para esclarecer, não estou pedindo para ninguém abrir mão das bibliotecas (por favor, reuso na cabeça!), apenas recomendo pesquisar se o próprio servidor de aplicação já não fornece uma versão da biblioteca desejada ou algo equivalente (e.g., Hibernate x Eclipselink para JPA).

Não se preocupe em sempre incluir a versão bleedin edge de uma biblioteca no projeto. Geralmente as versões disponibilizadas pelo Application Server são mais do que suficientes (salvo exceções em lugares que ainda estão rodando Application Servers homologados para versões anteriores ao Java EE 5). Minha experiência nesse ponto é que quando você coloca uma biblioteca bleedin edge no projeto ela acaba permanecendo lá por mutos anos e eventualmente se torna legada (ninguém quer mexer em bibliotecas da aplicação por motivos óbvios, incluindo JAR Hells), enquanto que ao fazer referência as bibliotecas do App Server, a evolução vem lenta porém certamente conforme upgrades planejados para versões mais novas do container.

Enquanto há bons argumentos contra depender do container (e.g., reduzir o trabalho de infraestrutura ao fazer deploy das bibliotecas; ter menos problemas ao fazer upgrade do servidor de aplicação e ter mais controle sobre o que está sendo utilizado no projeto), eu pessoalmente acho que é um trade-off válido.

Eis um exemplo de como referenciar uma biblioteca no weblogic-application.xml (EAR).

<wls:library-ref>
    <wls:library-name>jersey-bundle</wls:library-name>
    <wls:specification-version>1.1.1</wls:specification-version>
    <wls:implementation-version>1.1.5.1</wls:implementation-version>
</wls:library-ref>

Fico devendo exemplos de sobre como referenciar bibliotecas no JBoss AS, GlassFish, WebSphere, etc.

Na verdade, como deixei muitos pontos em aberto nesse post (como escrever um ClassLoader, como exportar dependências do Maven e como referenciar bibliotecas nos principais servidores de aplicação), aceito sugestões sobre o tema de posts futuros. Por favor deixem seu comentário ou enviem uma mensagem através do formulário de contato.

SCMs e Pastebins - O que fazer com o seu código “pessoal”

2012-02-21T14:09:00.001-02:00

Para quem está em busca de ferramentas para lidar com aquele código extra que acabamos escrevendo fora do trabalho e / ou do escopo do sistema de controle de versão da empresa como:

Coleção de scripts diversos para automação (i.e., scripts de do programador vagabundo... Aqueles que quebram um galhão mas nunca ficam apresentáveis o suficiente para você mostrar para os outros).
Testes com JavaScript e JQuery.
Snippets de código que fazem as coisas acontecerem em determinada linguagem / framework e na hora “h” sempre esquecemos.
Código de exercícios e tutoriais.
Projetinhos Open source.

Eu recomendo fortemente o Bitbucket da Atlassian (empresa que criou o JIRA).

Endereço: http://bitbucket.org/

O Bitbutcket disponibiliza gratuitamente repositórios para controle de código fonte (Mercurial, e mais recentemente Git) com interface de administração / navegação web... Além de Wikis, Issue Trackers e toda a parafernalha típica de sites do género.
O grande diferencial em relação a serviços semelhantes (SourceForge, Google Code, GitHub, etc) é que você pode criar uma quantidade ilimitada de repositórios privados (pessoais ou compartilhados com até cinco pessoas). O que faz do Bitbucket o lugar perfeito para colocar todo aquele código que fica jogado no seu HD e eventualmente é perdido.

Para quem não conhece, também sou fã de dois outros serviços:

http://jsfiddle.net/ - Ferramenta do tipo pastebin em que você digita o código JavaScript / HTML / CSS em suas respectiva seções e visualiza o resultado final no iframe inferior direito. Ótimo para aqueles testes rápidos, perfeito para JQuery. Se quiser salvar o código, o jsfiddle gera uma URL para você (não requer cadastro).

http://ideone.com/ - Mesmo princípio do jsfiddle, porém mais voltado para server side. Possui compiladores e interpretadores de mais de 40 linguagens (como Java, C#, C++, VB.NET, Groovy, Ruby, Scala, etc). Você digita o código - opcionalmente também os valores de entrada - e a ferramenta compila / interpreta o programa mostrando a saída (ou erros) em uma interface web. Muito bom para SQL.

Planilha para economizar com o Skype

2011-12-29T03:26:00.001-02:00

Usuários de longa data do Skype sabem que o aplicativo pode diminuir significativamente sua conta de telefone. Alguns exemplos:

Qualquer tel. no Canadá → R$0,06 por minuto, mais taxa de conexão de R$0,09 ^[1].
Tel. fixo no Rio de Janeiro → R$0,09 por minuto, mais taxa de conexão de R$0,189 ^[1].
Celular no Brasil → R$0,54 por minuto, mais taxa de conexão de R$0,189 ^[1].

Bem melhor do que as tarifas do meu Net Fone (R$1,09, R$0,27 e R$1,53 respectivamente).

Outro ponto a ser considerado é que a qualidade da ligação é ótima: Com uma banda larga veloz e um bom microfone o uso do Skype é praticamente imperceptível para a outra ponta. Inclusive é possível configurar o Skype para exibir seu número de celular no identificador de chamadas do destinatário da ligação.

Gostou? Então que tal economizar ainda mais?

O Skype permite a compra de créditos em 15 moedas diferentes, cada qual com sua tabela de preços e taxas de conexão. Como o Skype não atualiza seus preços frequentemente e a taxa de câmbio sofre variação, é possível economizar bastante escolhendo a melhor moeda para comprar seus créditos. A diferença de preço é tão grande que a manobra vale a pena mesmo considerando a taxa de IOF de 6.38% incidente sobre compras internacionais no cartão de crédito.

Pensando nisso criei uma planilha no Google Spreadsheet que extrai informações sobre tarifas diretamente do site do Skype, bem como as cotações das moedas através do Google Finance. A planilha permite saber quanto custa sua ligação via Skype para o destino desejado e qual a melhor moeda para comprar seu crédito de acordo com a taxa de câmbio do momento (cotações sujeitas a atraso de 20 minutos de acordo com o disclaimer do Google).

Visão em tempo real da planilha para ligações para celulares do Brasil:

Planilha em tela cheia

Com a cotação da Libra Esterlina em R$2,8945 como no momento da escrita desse post, é possível economizar mais R$0,15 por minuto ao ligar para celulares no brasil (12.6p = R$0,39 já acrescentando IOF).

A planilha serve como um "aplicativo web" permitindo que você preencha os dados da ligação e descubra a melhor moeda a ser utilizada de acordo com as características da sua chamada:

Para obter uma cópia editável da planilha siga os seguintes passos:

Entre no Google Docs com sua conta do Google (é gratuito).
Clique no link da planilha para abri-la em uma nova janela.
Faça uma cópia do planilha clicando no menu File → Make a Copy:

Pronto, sua cópia da planilha é editável e privada. Desse momento em diante você pode acessar o Google Docs, abrir sua cópia da planilha, preencher os dados da ligação (Call Info) e receber informações atualizadas sobre preços do Skype. Não é necessário fechar e abrir a planilha para obter novas cotações, isso é feito automaticamente em background.

Algumas dicas:

Na primeira vez que você abrir a planilha pode demorar um pouco para que os preços sejam exibidos. Da mesma forma, na primeira vez que você clicar no combo box Destination pode demorar um pouco para que os países sejam carregados.
Se ocorrer algum erro para obter uma cotação ou preço do site da Skype espere meia hora e tente de novo (lembre-se que a internet segue o princípio do melhor esforço :D).
Para mudar sua moeda clique em cima dos seus créditos e, no pop-up que irá abrir, clique no link Change indicado pela figura abaixo:
De acordo com documentação do Skype uma taxa extra de conversão pode incidir sobre seus créditos durante a operação de troca de moeda. Dessa forma, a melhor estratégia para economizar é comprar créditos de acordo com as ligações pretendidas e esgotá-los antes de mudar de moeda. Trocar de moeda várias vezes para economizar alguns centavos por ligação não vale a pena pois a taxa extra de conversão incidirá sobre todo o seu crédito restante.
Lembre-se que em compras por cartão de crédito a taxa de câmbio aplicada será determinada pela operadora do cartão próximo a data de fechamento da sua fatura. Logo, como em toda transação financeira, há riscos envolvidos - no caso, o da moeda escolhida super valorizar frente ao real. Eu venho comprando créditos em Libras Esterlinas e Wons sul-coreanos já faz algum tempo (mais de 2 anos) e não passei ainda por nenhuma situação em que essas moedas valorizassem o suficiente para fazer a compra em real valer a pena. Pelo contrário, em boa parte das vezes o real valoriza frente as outras moedas fazendo com que a operadora de cartão de crédito me debite a diferença. Tenha em mente porém que a taxa de câmbio é dependente do cenário econômico, e que o governo brasileiro tem um longo histórico de uso de manobras para controlar o câmbio (lembrando que manter o real desvalorizado frente ao dólar é um dos objetivos do Ministro Guido Mantega). Use a planilha por sua conta e risco.
Uma boa prática é comprar o crédito um pouco antes da sua fatura vencer, de forma a correr menos riscos relacionados a flutuação cambial.
Uma alternativa para não assumir o risco da flutuação cambial é usar o serviço de pagamentos PayPal que permite a conversão da moeda estrangeira em real através de uma cotação pré-fixada. Dessa forma você sabe exatamente o quanto será debitado do seu cartão de crédito na hora da compra. O trade-off é que as taxas de câmbio pré-fixadas não são tão competitivas quanto as pós. Novamente, no cenário econômico dos últimos dois anos, em nenhuma das compras que fiz a taxa pré-fixada valeria a pena.

Para encerrar o post com um conteúdo um pouco mais voltado para desenvolvedores, veja que essa planilha somente foi possível graças às funcionalidades fantásticas do Google Spreadsheet, em especial ImportHtml, ImportXML, e Google Finance. O recurso de listas suspensas também é muito interessante. Estou oficialmente distribuindo a planilha sob Licença Creative Commons. Sinta-se livre para estudar as fórmulas e criar trabalhos derivados.

Taxa de conexão é aplicada somente uma vez por ligação. Preços da modalidade Pré-pago. É possível obter tarifas menores e isenção da taxa de conexão assinando um pacote mensal.

Java: == vs equals()

2011-05-08T21:25:00.014-03:00

Operadores e métodos de comparação são fonte de muitas dúvidas para programadores que estão iniciando em Java. De fato, o operador ==, os métodos equals e hashCode são tópicos do Java Standard Edition 6 Programmer Certified Professional Exam para quem busca o título Oracle Certified Professional Java Programmer (antigo SCJP). Várias questões cobram, direta ou indiretamente, conhecimento sobre o assunto.

O operador == é usado para comparação entre tipos primitivos:

int x = 10;
if (x == 10) {
  System.out.println("x é 10!");
}

Já para tipos complexos o programador pode se surpreender com o resultado. O operador == só "funciona" com referências para o mesmo objeto:

public class Pessoa {
    
    private String cpf;

    public Pessoa(String cpf) {
        this.cpf = cpf;
    }
    
    public static void main(String[] args) {
        Pessoa p1 = new Pessoa("111.111.111-11");
        Pessoa p2 = new Pessoa("111.111.111-11");
        Pessoa p3 = p1;
        
        System.out.println(p1 == p2); // false
        System.out.println(p1 == p3); // true
    }
    
}

Esse resultado remete a uma decisão de design da linguagem. A regra de negócios para determinar se dois objetos são iguais é específica para cada aplicação. Enquanto o compilador pode assumir que duas referências para o mesmo objeto são iguais, assumir que dois objetos diferentes com os mesmos valores são iguais seria perigoso. Só porque uma pessoa tem um carro do mesmo modelo e cor do que o seu, isso não significa que os carros são iguais e você pode pegar o carro dela.

Eis o motivo de existência do método equals na classe Object. Para quem não está familiarizado com essa classe, ela serve de superclasse para todas as classes em Java, logo, seus métodos são universais, podendo ser chamados a partir de qualquer instância de qualquer objeto disponível em tempo de execução. A fim de definir a regra de comparação para objetos de uma classe deve-se sobrescrever o método equals no corpo da mesma:

public class Pessoa {
    
    private String cpf;

    public Pessoa(String cpf) {
        this.cpf = cpf;
    }

    // Adaptado do código gerado pelo Netbeans
    @Override
    public boolean equals(Object obj) {
        // Um objeto é sempre igual a ele mesmo
        if (this == obj) {
            return true; 
        }
        // Um objeto nunca deve ser igual a null
        if (obj == null) {
            return false;
        }
        /* Uma pessoa só pode ser igual a outra pessoa.
         * Caso uma pessoa possa ser igual a uma de suas subclasses
         * use !(obj instanceof Pessoa)
         */
        if (getClass() != obj.getClass()) {
            return false;
        }
        // Converte a referencia para uma pessoa
        final Pessoa other = (Pessoa) obj;
        // Duas pessoas só podem ser comparadas se possuem CPF
        if (this.cpf == null || other.cpf == null) {
            return false;
        }        
        // Duas pessoas são iguais se possuem o mesmo CPF
        return this.cpf.equals(other.cpf);
    }
    
    public static void main(String[] args) {
        Pessoa p1 = new Pessoa("111.111.111-11");
        Pessoa p2 = new Pessoa("111.111.111-11");
        Pessoa p3 = p1;
        
        System.out.println(p1.equals(p2)); // true
        System.out.println(p1.equals(p3)); // true
    }
    
}

Agora sim... Veja que no meu exemplo duas pessoas só são iguais se possuem o mesmo CPF. Outros sistemas poderiam adotar critérios diferentes para comparar duas pessoas, ou mesmo comparar pessoas com outros objetos (do tipo Batatinha por exemplo). Observe que a comparação entre CPFs também foi feita através de equals; isso é possível pois a classe String (API padrão do Java) sobrescreve o método equals (o mesmo é valido para várias outras classes como Integer, Long, Boolean, etc).

Quem acompanhou até aqui deve estar se perguntando o que acontece se houver uma chamada para equals sem que seja feita a sobrescrita do método. Não passe vontade! Vá lá, comente o método equals e rode a aplicação. Eu espero...

Pronto? Eis o resultado:

System.out.println(p1.equals(p2)); // false
System.out.println(p1.equals(p3)); // true

Acontece a mesma coisa do que se utilizássemos o operador ==, ou seja, os objetos são comparados por referência. Para os curiosos, segue a implementação no método equals na classe Object que justifica o porquê:

public boolean equals(Object obj) {
   return (this == obj);
}

Uma regra que exige certo grau de disciplina do desenvolvedor é sempre sobrescrever o método hashCode junto com o método equals. Se essa regra não for respeitada, várias classes do Java que dependem da função hash do objeto apresentarão comportamento inconsistente para o mesmo (exemplos dessas classes são as collections HashSet e HashMap).

O que é uma função hash e para que ela é utilizada fico devendo para um próximo post. Por enquanto assuma que o método hashCode deve mapear um objeto qualquer para um número inteiro para fins de comparação.

Lendo o javadoc do método hashCode, um ponto importante do contrato que deve ser respeitado é: Se a comparação entre dois objetos com equals retornar true os objetos devem possuir o mesmo hashCode (o inverso não é verdadeiro, ou seja, dois objetos com o mesmo hashCode não necessariamente precisam retornar true para a função equals). Segue uma implementação gerada pelo Netbeans que atende a esse contrato para a classe Pessoa:

@Override
public int hashCode() {
   int hash = 5;
   hash = 37 * hash + (this.cpf != null ? this.cpf.hashCode() : 0);
   return hash;
}

Observe que:

Toda pessoa com o mesmo CPF possui o mesmo hashCode.
Como para o método equals, String e várias outras classes do Java sobrescrevem o método hashCode, sendo possível reaproveitá-lo em nossas implementações.

Cuidado: O uso incorreto do operador == com objetos complexos pode introduzir bugs difíceis de serem rastreados. Veja o seguinte exemplo com strings:

String s1 = "abacate";
String s2 = "abacate";
String s3 = new String("abacate");

System.out.println(s1 == "abacate"); // true
System.out.println(s1 == s2); // true 
System.out.println(s1 == s3); // false

Nesse caso s1 e s2 foram criados a partir do mesmo literal “abacate”. A JVM, por motivos de performance / eficiência no consumo de memória fez com que somente uma String contendo o valor “abacate” fosse de fato criada e ambas as referências apontassem para ela (através de um pool de strings). Já em s3 houve a criação de um objeto diferente em memória (com new), logo, o operador == irá retornar false.
Sempre é possível usar o método intern para obter o objeto String presente no pool, apto a ser comparado com o operador ==. Porém, esse é o típico caso em que você deve se perguntar qual a vantagem de fazer isso (e se o motivo não for convincente, simplesmente não faça).

Resumindo:

Use == para primitivos.
Use equals para tipos complexos.
Verifique sempre se as classes dos objetos que você está tentando comparar sobrescrevem equals corretamente.
Se não sobrescreverem, sobrescreva equals de acordo com sua regra de negócio.
Se você sobrescrever equals deverá também sobrescrever hashCode.

Dica: Gerando os métodos equals e hashCode com seu IDE favorito:

Netbeans: Alt + Insert → equals() and hashCode()
Eclipse: Menu Superior → Source → Generate hashCode() and equals()
IntelliJ: Alt + Insert → equals() and hashCode()

Curiosidade: Veja que os IDES produzem implementações diferentes, porém válidas para ambos os métodos.

UPDATE: A pergunta Comportamento das diferentes formas de comparação em Java no Stack Overflow em Português está levantando algumas questões bem interessantes sobre esse assunto. Vale a pena conferir.

Netbeans 7.0

2011-05-05T20:50:00.011-03:00

Uma nota rápida sobre o Netbeans 7.0.

Brinquei com o IDE nas últimas semanas e tive uma experiência excelente.

Segue uma lista das minhas features favoritas:

Melhorias no suporte ao Weblogic. Bingo! Estrelinha dourada para a Oracle. Não nego que o o Weblogic é meu Application Server predileto. A combinação Weblogic + Netbeans tem tudo para no futuro se tornar o melhor ambiente de desenvolvimento Java EE do mercado.
Suporte ao Tomcat 7 e melhorias no suporte ao GlassFish. Subi alguns projetos de médio porte no Tomcat e fiz redeploy várias vezes sem esbarrar em nenhum OutOfMemoryError: PermGen space (outros programadores reportaram a mesma coisa; parabéns à equipe do Tomcat). O tempo de turnaround para deploy em ambos os containers também está menor no meu computador. Na minha opinião o Netbeans atualmente possui o melhor suporte para Java EE 6 entre todos os IDES do mercado (seguido de perto pelo IntelliJ).
Suporte ao JDK 7 não poderia faltar. As sugestões automáticas são bem legais para ajudar programadores a se acostumarem com o operador diamante, try-with-resources, multi-catch, switch sobre Strings, etc.

Ao contrário do que muita gente desconfiada (inclusive eu) acreditava, parece que há esperança para o Netbeans dentro da Oracle. Quanto mais suporte às tecnologias estratégicas da companhia for implementado no Netbeans (mesmo que através de plugins) melhor. Além do suporte ao banco de dados Oracle e ao Weblogic, aguardo melhorias no suporte à BPEL e Hudson. Ficaria muito feliz também se um dia a Oracle implementasse suporte para Weblogic Portal e SOA Suite no IDE. O Netbeans seria com certeza uma alternativa interessante ao JDeveloper e ao OEPE.

Faça o download da versão atual aqui.

Satisfação imediata com o banco de dados H2

2011-03-29T23:22:00.051-03:00

Até hoje lembro do meu primeiro contato com bancos de dados (aproveito para avisar que os próximos parágrafos terão pouco a ver com a tecnologia do título. Se a idéia é aprender sobre o uso de H2, pule direto para cá). Eu estava no segundo ano da faculdade, era bolsista e tinha todo o tempo livre do mundo, então decidi instalar e configurar um ambiente de desenvolvimento com uma versão antiga do Ubuntu e uma versão mais antiga ainda do PostgreSQL.
Foi uma experiência bastante ~~enlouquecedora~~ enriquecedora. Em um único sprint aprendi como trabalhar com autenticação e autorização no Linux e no PostgreSQL. Eu lembro o quanto penei para trocar a senha do usuário postgres, executar o comando psql com esse usuário, criar um novo usuário que coincidisse com o meu login do Linux no banco, criar um novo banco com o mesmo nome do usuário, criar um novo schema nesse banco para testes e assim por diante. Depois que consegui conectar no banco com o meu usuário usando o comando psql levei mais pelo menos um dia para descobrir como conectar via JDBC.
Não satisfeito com todo esse trabalho, alguns meses depois resolvi compilar e instalar na unha uma versão mais nova do banco com uma série de extensões... Foram dias brigando com o comando make (e as dependências da instalação), switches do SGBD, arquivos de configuração e coisas de dia a dia do Linux como chown, chmod, ln, configuração da variável PATH, Sys-V, etc. Quando finalmente consegui fazer tudo rodar direito eu já estava me sentindo bem familiarizado com o Linux (bem... vivendo uma ilusão na verdade, pois eu poderia ter adicionado meia dúzia de repositórios com binários que facilitariam bastante o processo).
Não preciso nem dizer que graças a minha falta de experiência tachei o PostgreSQL de complicado, acadêmico e burocrático antes mesmo de começar a usá-lo.
Um ano depois, já no mercado de trabalho, tive um contato inicial bem menos traumático com o MySQL. Um apt-get e meia dúzia de pequenas edições em arquivos de configuração depois e tudo já estava rodando em um ambiente com Apache + PHP + phpMyAdmin + MySQL. Criei os bancos e tudo que precisava com o phpMyAdmin (tomando o cuidado de criticar injustamente o pgAdmin em toda oportunidade de comparação que tive), modelei o banco com o DBDesigner (depois conheci o MySQLWorkbench que uso até hoje) e consegui conectar via JDBC na primeira tentativa. Foi rápido e satisfatório.
Semanas depois quando descobri que as foreign keys não funcionavam (devido a engine default MyISAM) e que as constraints do tipo CHECK eram silenciosamente ignoradas, não me importei muito com o trabalho extra de alterar a engine de trocentas tabelas e reescrever o código das constraints CHECK do lado da aplicação. Em contraste passei meses implicando com coisas menores do PostgreSQL como o fato de ter que especificar mais colunas do que realmente precisava na cláusula GROUP BY, bem como o uso de DISTINCT ON, ILIKE, etc.
Moral da história: Eu admito ter um peso e duas medidas para os dois mais populares SGBDs Open Source do mercado. Depois de ter desenvolvido muitas aplicações e participado da instalação e configuração de diversos outros bancos (como Oracle, DB2, SQL Server, Sybase, etc) nos mais diversos ambientes - com diferentes requisitos (e camadas de complexidade) - posso dizer que ambos os bancos são ótimos. Mesmo assim, quando a escolha cabe a mim, eu acabo usando o MySQL. E por que? Porque em um período crucial do meu aprendizado acabei tendo uma experiência mais satisfatória com ele.

Hoje tenho a grata oportunidade de treinar outros programadores. Volta e meia isso significa ajudá-los em seus primeiros passos com SQL. Por experiência própria, sei que esses primeiros contatos com o SGBD podem fazer toda a diferença na formação do aluno. Só aprenderão aqueles que fizerem exercícios, e só farão exercícios aqueles que conseguirem quebrar a barreira da instalação e configuração do ambiente.
A situação ideal seria que meus alunos pudessem criar bancos e executar todo tipo de comando SQL sem burocracia. Também é importante que usem um banco de dados confiável, com bom suporte aos padrões de SQL e que rode nos mais diversos sistemas operacionais. Se o banco puder rodar embbeded ajuda bastante, pois dessa forma é possível criar exercícios que vão direto ao ponto em projetos pré-configurados.

Conheça o H2, um banco de dados puramente implementado em Java que faz tudo isso. Em um único jar com pouco mais de 1Mb ele traz: um poderoso SGBD que pode rodar tanto em modo embbeded quanto client-server, um driver JDBC tipo 4 e várias ferramentas como uma interface de administração web com Auto Completion para SQL.
É possível fazer o download do instalador para Windows, do zip multi-plataforma, ou ainda apenas do jar do SGBD. Com o jar ou a versão zipada nenhuma instalação é necessária. Basta clicar duas vezes em h2-[versão].jar que o console do banco aparecerá no seu navegador padrão. Se o seu sistema suportar o conceito de “Área de notificação” (classe SystemTray do Java) um ícone amarelo também deve aparecer; a partir deste você pode, a qualquer momento, acessar o console.

Na tela de login você deve indicar uma URL JDBC para o banco. A parcela da URL depois do jdbc:h2: aponta para um arquivo no sistema operacional - o caminho pode ser absoluto (começando com “/”), relativo ao diretório atual (começando com “./”) ou ao diretório do usuário no SO (começando com “~/”). Também será necessário entrar com o login e senha do administrador.
Se a URL apontar para um arquivo não existente o banco será criado (verifique que um arquivo [nome do banco].db apareceu no local indicado); também será criado um usuário administrador com o login e senha informados.

Pronto, isso é tudo que precisa ser feito para criar um banco e acessá-lo em modo embbeded. Para que múltiplos processos possam acessar o mesmo banco concorrentemente basta adicionar o parâmetro AUTO_SERVER=TRUE no fim da URL. Por exemplo:
jdbc:h2:~/Projetos/DBs/h2/RH/RH;AUTO_SERVER=TRUE
É possível ainda fazer com que um dos processos aja exclusivamente como servidor e os outros exclusivamente como clientes. Clientes podem conectar em servidores remotos via TCP/IP ou SSL (veja a documentação aqui).
Uma vez conectado, a tela de administração aparecerá. No lado esquerdo você verá todos os objetos (schemas, tabelas, usuários, constraints, etc) do banco em uma Tree View. No lado direito você pode entrar com comandos SQL (contando com a funcionalidade de Auto Completion para te ajudar). O resultado dos comandos é exibido na parte inferior da tela.

Que tal um Test Drive do banco? Vamos criar um pequeno schema definido pela figura abaixo, populá-lo, e executar algumas queries de complexidade média para ver como a engine responde.

Começando pelo DDL, vamos criar as tabelas e constraints:

-- ----------------------------------------------------
-- Tabela departamento
-- ----------------------------------------------------
CREATE TABLE departamento 
(
  -- IDENTITY = BIGINT + auto incremento + PRIMARY KEY
  id IDENTITY ,
  nome VARCHAR(45) NOT NULL ,
);

-- Constraint nomeada
ALTER TABLE departamento 
ADD CONSTRAINT departamento_nome_unq UNIQUE(nome);

-- ----------------------------------------------------
-- Tabela funcionario
-- ----------------------------------------------------
CREATE TABLE funcionario 
(
  id IDENTITY ,
  nome VARCHAR(255) NOT NULL ,
  -- Valor default
  salario DECIMAL(10,2) NOT NULL DEFAULT 545.00,
  departamento_id INT NOT NULL ,
);

-- Foreign Keys não poderiam faltar 
ALTER TABLE funcionario 
ADD CONSTRAINT funcionario_departamento_fk 
FOREIGN KEY (departamento_id) REFERENCES departamento (id);

-- Funciona!
ALTER TABLE funcionario
ADD CONSTRAINT funcionario_salario_chk CHECK (salario >= 545.00);

-- ----------------------------------------------------
-- Tabela bonus
-- ----------------------------------------------------
CREATE TABLE bonus 
(
  id IDENTITY ,
  valor DECIMAL(10,2) NOT NULL DEFAULT 0.00 ,
  -- Que tal usar uma função?
  data DATE NOT NULL DEFAULT CURRENT_DATE ,
  funcionario_id BIGINT NOT NULL ,
);

ALTER TABLE bonus 
ADD CONSTRAINT bonus_funcionario_fk
FOREIGN KEY (funcionario_id) REFERENCES funcionario (id);
 
-- Precisa de índices? Sem problemas
CREATE INDEX bonus_data_idx ON bonus(data);

Bem direto né? E agora inserts de múltiplas linhas a la MySQL:

INSERT INTO departamento (nome) 
VALUES ('Administrativo'),  
       ('TI'), 
       ('Vendas');     

INSERT INTO funcionario (nome, salario, departamento_id)  
VALUES ('Auxiliar Administrativo', 2000.00, 1),
       ('GP I', 5500.00, 1),
       ('GP II', 7000.00, 1),
       ('Programador I', 3000.00, 2),
       ('Programador II', 6000.00, 2),
       ('Programador III', 10000.00, 2),
       ('Vendedor I', 1500.00, 3),
       ('Vendedor II', 4500.00, 3);
   
INSERT INTO bonus (valor, data, funcionario_id)
VALUES (15000.00, '2010-03-20', 7),
       (15000.00, '2010-07-03', 7),
       (20000.00, '2009-09-09', 8),
       (60000.00, '2010-10-06', 8),
       (45000.00, '2010-11-15', 8);

Veja que todas as constraints estão sendo respeitadas (tente inserir um funcionário que ganhe menos de R$545,00 ou atribuir um valor inválido em um campo que tenha uma foreign key e você se deparará com um exceção).
Mas e as queries? Vamos resolver um primeiro exercício: Determinar, para cada departamento, a quantidade de funcionários e o salário médio.

   SELECT 
         d.nome AS `Departamento`, 
         COUNT(f.id) AS `Numero de Funcionários`, 
         ROUND(AVG(f.salario),2) AS `Média Salarial`
    FROM  
         departamento d 
         LEFT OUTER JOIN funcionario f ON (d.id = f.departamento_id)
GROUP BY
         d.id
ORDER BY
         d.nome;

Perfeito. Essa query usa de tudo um pouco, alias, group by, order by, joins e funções (veja a documentação). Repare que temos o melhor de dois mundos: um banco que não exige a repetição de colunas funcionalmente dependentes na cláusula group by e respeita as constraints do tipo CHECK.
Mas que tal complicar um pouco mais? A definição do exercício número dois é: Encontrar todos os vendedores que ganharam mais de R$10.000,00 em bônus nos últimos doze meses; determinar o total de bônus recebidos por cada vendedor no perído e ordená-los de acordo (começando com o vendedor com a maior soma de bônus e terminando com o vendedor com a menor).

SET @MESES = 12; 
SET @BONUS = 10000.00;

  SELECT 
         f.id,
         f.nome AS `Vendedor`,
         SUM(b.valor) AS `Bonus` 
    FROM
         funcionario f 
         INNER JOIN departamento d ON (f.departamento_id = d.id)  
         INNER JOIN bonus b ON (f.id = b.funcionario_id)
   WHERE
         d.nome = 'Vendas'
         AND b.data >= DATEADD('MONTH', -@MESES, CURRENT_DATE)
GROUP BY
         f.id 
  HAVING
         `Bonus` >= @BONUS
ORDER BY
         `Bonus` DESC;

Novamente tudo no lugar. Aí está nossa cláusula having, múltiplos joins e até mesmo o uso de variáveis. Deixo para o leitor brincar com subqueries, UNION, MINUS, EXCEPT, INTERSECT, etc.
O H2 têm uma quantidade de funcionalidades que deixa muitos outros bancos conhecidos no chinelo. Saindo do básico (views, sequences, triggers, stored procedures, controle de transações, controle de usuários, roles, análise de planos de execução , etc) algumas features interessantes que lembro de cabeça são o modo in memory (com ótima performance, excelente para caches), a habilidade de emular outros databases, queries recursivas, suporte a índices do tipo full text (nativos ou integrados ao Lucene) e suporte básico a clusterização.
Os veteranos de Java que sentem calafrios quando escutam a combinação de palavras embedded database podem ficar tranquilos. Uso o H2 já há alguns anos e nunca tive sequer um banco corrompido. Cheguei a fazer testes em que bati forte no banco com o JMeter para estressar um aplicativo web e observei um curva de degradação de performance bem saudável. O controle transacional é confiável (inclusive quando operações do H2 participam de transações XA), e, no geral, o otimizador de queries faz um bom trabalho (apesar de algumas limitações).
Bom para não escrever um artigo ~~muito~~ tendencioso, informo que o H2 não deve ser considerado um substituto para databases tradicionais em ambiente de produção. Segue um link do site oficial que fala sobre algumas de suas limitações (diga-se de passagem, 4TB de armazenamento é um limite bastante generoso). Também é necessário dizer que por padrão o banco usa table locks, o que reduz bastante a performance quando uma tabela sofre muitos comandos de escrita concorrentes (porém, já existe suporte experimental a MVCC).
Comprou a idéia? Não custa experimentar, é grátis.
Ah! Já que estamos falando de dinheiro, quem está por trás desse banco é o Thomas Müller, o mesmo criador do HSQLDB. Esse segundo banco você já deve ter usado mesmo que não saiba... Por padrão ele é incluído nos softwares Mathematica, Open Office Base, Liferay, JBoss, Jira, Hibernate e JForum, além, é claro, do super renomado software de contabilidade Open Source que escrevi na faculdade, o AAS hehehe). Você encontra um dotão “Donate” do PayPal na página do H2.

Exame - POSCOMP 2010

2010-11-23T01:23:00.022-02:00

O POSCOMP - Exame Nacional para Ingresso na Pós-Graduação em Computação - foi aplicado no dia 17 de Outubro de 2010 em diversos locais do país (bem como do Peru).

Apenas um bom desempenho na prova não garante vaga em nenhum programa de pós-graduação de primeira linha; estes utilizam também critérios como cartas de recomendação, publicações, participação em programas de iniciação-científica e congressos, atividades extracurriculares, bolsas, prêmios, desempenho na graduação, etc. Todavia, o exame caracteriza uma etapa importante (e muitas vezes decisiva) dos processos seletivos.

A prova unificada é conveniente para o candidato que pode pleitear vagas em diferentes Universidades sem se deslocar. Na maioria dos casos o único exame necessário para ingressar em programas de Pós-Graduação em Computação é o POSCOMP (em São Paulo, por exemplo, isso vale para programas como os da USP, Unesp, Unicamp, ITA e UFScar). Entretanto cabe ao candidato se inscrever separadamente nos processos seletivos de cada instituição.

Mas não pense que o POSCOMP é moleza. Esse ano os candidatos conseguiram, em média, 29.3 acertos nas 70 questões de múltipla escolha. Históricamente a média de acertos é menor do que 50%.

As Universidades por padrão não estabelecem "notas de corte" para seus programas de Pós-Graduação, porém, utilizam as notas como critério de comparação entre candidatos.

A SBC publicou em seu site os exames e gabaritos das provas de 2002 a 2007. Candidatos que prestaram o exame nos últimos 3 anos também tiveram acesso aos gabaritos através de uma área restrita do site, mas por algum motivo a SBC ainda não divulgou links abertos para os demais interessados.

Como prestei POSCOMP esse ano no IME/USP, obtive acesso ao exame e gabarito oficial que divulgo abaixo:

Prova POSCOMP - 2010 no Scribd

Dica: Resolver provas anteriores é uma maneira excelente de se preparar para os exames que estão por vir.

Heráclito dá as boas vindas ao meu Blog

2010-11-15T22:27:00.010-02:00

“Nada é permanente salvo a mudança” já dizia Heráclito em 500 a.C.. É isso o que faz da inércia algo tão fascinante (e por mais que nos custe admitir, desejável).

Difíceis de observar são as mudanças que todo (ênfase em todo) ser germina em si mesmo e em tudo com que tem contato. Mudanças radicais com conseqüências a longuíssimo prazo; mudanças que muitas vezes parecem medíocres na janela de tempo de uma vida.

Sofremos com a ilusão de insignificância, com a aparente lentidão e com as dificuldades para promover qualquer transformação substancial... Na minha opinião isso ocorre por distorção de escala, pela completa inabilidade em perceber o que é realmente importante em centenas, milhares, milhões, bilhões (ou mais) de anos.

Mas esse não é um Blog religioso e esse não é um tópico de auto-ajuda. Toda essa introdução foi para contextualizar o leitor sobre aquilo que acredito:

- Acredito que o homem seja um agente de transformação. Acredito em fazer mais e em fazer melhor. Acredito em aprender tudo o que puder. Acredito não só em aplicar, mas também em propagar o que aprendi. Acredito em acrescentar, introduzir melhorias, opiniões e mesmo erros no bolo de conhecimento humano. Acredito em capacitar pessoas que aplicarão o que eu aprendi, que serão responsáveis por novas melhorias, formarão opiniões, consertarão meus erros e capacitarão outras pessoas que, por sua vez, farão a mesma coisa.

Não é por coincidência que acabei trabalhando com desenvolvimento de software e com Internet, não é por coincidência que estou montando uma escola para capacitar outras pessoas para fazerem a mesma coisa e não é por coincidência que estou escrevendo esse Blog.

Vivemos na era da globalização, usamos meios de telecomunicação cada vez mais abrangentes, estamos batendo nas portas da democracia da informação, finalmente caminhando em direção ao conhecimento universalmente acessível. Não tenho dúvida de que a revolução da Tecnologia da Informação marcará o século XXI, isso já é bem visível nos âmbitos corporativo, político e econômico.

Aqui disponibilizarei gratuitamente conteúdo pertinente para desenvolvedores de software e entusiastas de TI sob Licença de Atribuição Creative Commons. Sinta-se livre para compartilhar e criar obras derivadas de tudo aquilo que for postado nesse Blog (incluindo enxertos de código e texto, anexos e tudo mais que for aproveitável), tomando apenas o cuidado de incluir um link visível para http://a.accioly.7rtc.com em seu trabalho.

Como vivemos em um mundo capitalista e um programador / professor também precisa comer, convido os interessados a ingressarem em aulas particulares, cursos e eventos da 7RTC. Mande um e-mail para contato@7rtc.com, que eu responderei assim que possível.

Welcome and Enjoy!

ps: Não se esqueça de assinar o Feed ou o Serviço de Notícias por E-Mail para ser notificado sobre novas postagens no Blog.