sábado, 28 de março de 2015

It's Time!

Quem nunca xingou o Java ao ter que lidar com datas que atire a primeira a pedra! Apesar das muitas críticas, a API de Datas sofreu pouca, ou quase nenhuma, alteração desde a sua criação. No Java 1.0 existia apenas a classe java.util.Date, que era muito simplista, tanto que teve a maioria de seus métodos depreciados no Java 1.1, quando surgiu a classe Calendar.

Mesmo com Calendar, a API ainda apresentava alguns problemas de design, tais como, o ano de Date começando em 1900, meses começando em 1 e dias começando 0. Junte isso ao fato de as classes não serem thread-safe, levando a um potencial surgimento de comportamentos estranhos em ambientes concorrentes. Por fim, os objetos gerados a partir de calendar são mutáveis, permitindo alterações indesejadas, como as do exemplo abaixo:


Pra contornar esses problemas, muitos desenvolvedores optavam por escrever suas próprias classes pra lidar com data. Nessa meio tempo, surgiu uma das bibliotecas que foi a base para a construção da nova API de Data, a Joda-Time. Stephen Colebourne, criador da Joda-Time, é um dos líderes da JSR-310, base para especificação da nova API de Date/Time.

Dentre as principais mudanças da nova API, podemos destacar:
  • Imutabilidade das classes
  • Classes Thread-safe
  • Melhor design de classes, com domínios bem definidos
  • Separação de cronologias
As classes da nova API foram colocadas em um novo pacote: java.time. Ao todo, foram criadas 15 novas classes, além de uma nova classe para exceções e três novos enums. Como já é marca do Java, a compatibilidade com as versões antigas foi mantida, e as classes da API antiga ganharam novos métodos que interagem com a API nova. 

Para uma melhor didática e separação, iremos abordar essas classes com detalhes em alguns artigos. Nesse primeiro artigo iremos falar da classe Instant.

Instant 

Um instante é um ponto na linha do tempo. Essa classe deve ser usada eventos de timestamp (marcas de tempo) em uma aplicação, como por exemplo, saber em que exato momento do tempo um determinado evento ocorreu. Ela lembra muito o método System.currentTimeMillis(), só que sua precisão é de nanosegundos. Outras características relevantes dela são:
  • O instante 0 (Zero) é 01/01/1970 T00:00:00 (conhecido como Era Unix)
  • O instante mínimo, Instant.MIN, é simplesmente 1 bilhão de anos atrás
  • O instante máximo, Instant.MAX, é a data 31/12/1000000000 :)
  • O instante atual é obtido através do método: Instant.now()
  • Um dia em Java, tem exatamente 86400 segundos 

No código a seguir, podemos ver algumas formas de usar a classe Instant:


Podemos já de cara ver que os métodos plusSeconds e minusSeconds retornam um objeto do tipo Instant. Isso é o que garante a imutabilidade da classe, isso quer dizer que nenhum chamada de método irá causar efeitos no seu objeto, ao invés disso, uma nova instância é retornada com o valor modificado. A última linha prova que t1 não sofreu nenhum efeito com a chamada do método t1.plusSeconds(10), isso faz com que o objeto possa ser seguramente manipulado em ambientes concorrentes.

Duration

Como você fazia pra medir o tempo de execução de uma determinada operação, lembra?


Agora existe uma classe especializada em fazer esse tipo de operação: Duration. Uma Duration representa a quantidade de tempo decorrido entre dois instantes (Instant). Ela modela a quantidade de tempo em segundos ou em nanosegundos, porém ela possui métodos para calcular o tempo em milissegundos, minutos, horas e dias. Vejamos como ficaria a classe anterior usando Instant e Duration:

Pra finalizar, a classe Duration possui uma maneira de ser 'instanciada', isso pode ser feito através dos métodos of. Isso pode ser útil, por exemplo, caso você queira fazer uma comparação entre dois períodos. Digamos que eu queira comparar se um determinado algoritmo é 10 vezes mais rápido que outro. Podemos fazer isso da seguinte maneira:

Ainda há muito o que explorar no pacote java.time. Neste post vimos duas de suas classes, Instant e Duration, além de alguns exemplos de como usá-las para resolver problemas de marcação e medição de tempo. No próximo artigo iremos conhecer mais duas classes, LocalDate e Period. Então, até o próximo post!

PS: Me perdoem pelo infame trocadilho no título deste post. Obrigado :)

sábado, 21 de março de 2015

Javascript Fundamentos - Parte 1: Escopo Global

E aí pessoal! Vamos ao primeiro post do meu novo blog? A primeira linguagem que escolhi pra falar foi a que eu considero ser uma das mais poderosas linguagens já criadas: Javascript! Uma linguagem que evoluiu bastante, especialmente nos últimos anos, quando ela deixou de ser usada apenas pra dar mais interatividade às páginas (exibir alertas, capturar cliques, etc) e foi parar no lado do servidor (V8 e Node.js).

Bem, mas eu não vou dissertar aqui sobre a história do Javascript, se você quiser saber mais sobre ela, você pode clicar aqui. Também não vou falar sobre os conceitos básicos da linguagem, como por exemplo, criar uma variável, exibir alertas, capturar eventos, etc. Neste, e em outros posts, irei tratar de assuntos mais interessantes como: escopos, this, modules, closures, functions, prototypes, etc.

Javascript não é nenhum bicho de sete cabeças, mas como toda linguagem, possui suas nuances. Por ser uma linguagem de script, além de dinamicamente e fracamente tipada, permite uma experiência de uso bem simplificada. É possível escrever e testar um código javascript de forma rápida, você só precisará ter um browser instalado e usar um editor de texto qualquer.

Essa relativa simplicidade, porém, traz consigo um grande perigo: o de todo mundo achar que sabe Javascript! Especialmente aqueles que vêm de outras linguagens como Java, C#, PHP, etc. E ao pular os conceitos fundamentais, acabam se deparando com comportamentos estranhos em seus códigos. Nesta série de artigos pretendo abordar alguns desses conceitos que podem causar 'problemas'.

Depois desta introdução, mais longa do que eu gostaria que fosse, vamos ao primeiro conceito fundamental: Escopo! Entender escopo é essencial para compreender como suas variáveis interagem com as outras partes de seu código. Na maioria das linguagens a coisa é bem simples. Em Java, por exemplo, você aprende que existe o escopo de bloco ou de método, escopo de instância e o escopo de classe (uma espécie de escopo global). Mas e em Javascript, será que a coisa é muito diferente?

O primeiro escopo que iremos aprender em Javascript é o chamado Global Scope. Se você já escreveu algum código Javascript na sua vida, certamente você já declarou alguma variável no escopo global. O trecho de código abaixo mostra um exemplo bem simples dele:

Onde você lê global, entenda window. Isso quer dizer que uma variável nesse escopo será acessível por qualquer código em uma janela (ou aba) do seu browser. Legal né? A menos que você tenha vários arquivos Javascript diferentes carregados nessa janela. Enxergou a bronca? Aqui pode acontecer o famoso sombreamento de variáveis (shadowing), que ocorre quando temos duas variáveis declaradas com o mesmo nome em escopos diferentes.

Entretanto, o escopo global é importante quando realmente precisamos compartilhar algo através de múltiplos escopos. Vários frameworks fazem uso dele, como o jQuery, por exemplo. Esse tipo de estrutura também é chamado de namespace, e é graças a ele que você consegue fazer coisas como esta:

Você cria um namespace como uma forma de encapsular suas variáveis dentro dele, evitando conflito com outras bibliotecas (o tal do shadowing), e assim, o seu namespace fica no escopo global e suas variáveis ficam aninhadas nele. Existe uma forma mais legal (e mais moderna) de evitar colisões de nomes, que são os módulos, mas isso a gente vai ver em um outro momento. Antes, vejamos como criar o nosso próprio namespace global:

Bom galera, para o post não ficar maior do que já está, vamos dar uma paradinha por aqui. O escopo global é certamente o mais simples de entender, apesar de ele causar alguns problemas, como o da colisão de nomes, vimos que esses problemas podem ser contornados com o uso de namespaces ou modules (veremos isso depois).

No próximo post a gente continua falando de escopos, e aí falaremos sobre os escopos local, de função e o escopo léxico. Como já nos livramos dessa parte introdutória, prometo que os próximos posts serão mais interessantes. Então, até o próximo post!

sexta-feira, 20 de março de 2015

Boas vindas!

Fala pessoal! Me chamo Robson, e alguns de vocês já devem me conhecer (ou não..kkk) através do blog Javeiro. Após muito tempo sem fazer novas postagens, decidi descontinuar o Javeiro e criar um novo blog com um foco mais abrangente. Aqui você poderá encontrar artigos sobre programação de uma maneira geral, não mais focado em uma linguagem específica. 

Continuarei, claro, falando sobre Java, linguagem com a qual eu tenho mais experiência. Porém, como um amante da programação que sou, me atreverei a falar sobre outras linguagens que tenho experimentado nesses últimos anos, tais como Javascript (e frameworks), Ruby (rails), Scala (Functional Programming na verdade), entre outras.

De vem em quando trataremos, porém como menos foco, de outros assuntos do universo da TI, tais como Boas práticas, Arquiteturas de Software, Design Patterns, NoSQL, Orientação a Serviços, etc.

Convido você a não apenas ler, mas a contribuir com o blog, seja na forma de sugestões de assuntos, de melhorias, fazendo críticas, elogios ou mesmo corrigindo erros que eventualmente eu venha cometer em algum artigo. Peço também que ajude a divulgar o blog através das suas redes sociais, ou no seu próprio blog.

Em breve publicarei os primeiros artigos. Apareça por aqui depois para conferir, ou se preferir, seja um seguidor e receba notificações sempre que um novo artigo for publico. 

É isso! Obrigado pela visita e até o próximo post!