terça-feira, 15 de setembro de 2015

Java 8 DateTime API - LocalDate e Period

Olá Pessoal, hoje iremos retomar o nosso estudo sobre a nova API de Data do Java 8. Esse artigo é o segundo da série sobre o assunto, você pode ler a primeira parte clicanco aqui. No post anterior vimos as classes Instant e Duration, que são conhecidas por Computer Dates, e são usadas, por exemplo, para medir o tempo de duração de um algoritmo.

Nós humanos geralmente precisamos representar datas mais complexas, com dias, meses, anos, fusos horários. Isso não possível através de Instant. Para tal, precisamos utilizar a classe java.time.LocalDate, ideal para representar datas do tipo Human Dates

LocalDates

Existem basicamente dois tipos de classes para representar datas na nova API, as Local Date/Time (LocalDate e LocalDateTime) e a ZonedDateTime. As datas locais possuem uma data ou hora de um dia, mas sem associação fusos horários, por exemplo, 11/05/1984, que é o em que eu nasci. Porém essa data não representa um instante de tempo preciso. Precisamos usar então a classe ZonedDateTime, com ela podemos criar uma data do tipo: 11/05/1984 11:30 [America/Cayenne], que representaria o exato momento do meu nascimento. Vejamos então um primeiro exemplo do uso de LocalDate.


Como você deve ter notado, diferentemente do que ocorria em java.util.Date, não é possível instanciar uma classe LocalDate diretamente, ela também não pode ser estendida, pois é uma classe final. Além disso, a classe LocalDate é imutável, ou seja, nenhuma operação nela irá modificar os valores instanciados, seus métodos sempre retornarão uma nova instância com as modificações desejadas.

No exemplo acima foi utilizado o método now, que retorna a data corrente do sistema. Em seguida fizemos uso do método of(int ano, Month mes, int dia) que possui uma versão sobrecarregada of(int ano, int mes, int dia). Vale destacar que foi corrigida uma bizarrice que havia na versão antiga da API que usava 0 para Janeiro, e isso causava muita confusão, agora você pode usar Month.MAY ou 5 para criar uma data com mês de Maio.

Manipulando Datas

Vejamos algumas operações importantes que existem na classe LocalDate. Vamos ao código e em seguida comentaremos o que ele faz.

Neste exemplo vemos como é fácil, através dos métodos plusXXX e minusXXX, adicionar ou remover uma medida de tempo de uma data de forma fácil e segura, mesmo que a data precise passar de um mês para o outro ou mesmo de um ano comum para um ano bissexto.

Ajustadores de Tempo

Um outro conceito bacana que foi introduzido na nova API de Datas é o de Temporal Adjuster. Imagine que você deseja implementar uma agendador para algum evento que vai se repetir, por exemplo, toda primeira segunda-feira de cada mês. Você já deve imaginar o trabalhão que dava para fazer isso com a API antiga. Pois bem, agora temos a classe TemporalAdjusters, que possui vários métodos estáticos para operações como essas. Vejamos algumas possibilidades.

Diferença entre Datas

Quando trabalhamos com a classe Instant vimos que para calcular a diferença entre dois Instants usamos a classe Duration. O mesmo resultado pode ser obtido com a classe Period, que armazena a diferença entre duas instâncias de LocalDate. Podemos obter informações como número de dias, meses ou anos passados entre duas datas. Vejamos um exemplo demonstrando o uso de Period.

O método until retorna uma instância de Period, que armazena o tempo passado entre duas datas em anos, meses e dias, isso nos poupa algum trabalho de conversão, mas pode ser que queiramos saber quantos dias absolutos existem entre duas datas, para isso, usamos o  método until sobrecarregado que recebe dois parâmetros, o primeiro é a data que estamos comparando e o segundo é a unidade de tempo que desejamos calcular (os valores permitidos são: DAYS, WEEKS, MONTHS, YEARS, DECADES, CENTURIES, MILLENNIA, ERAS).

Conclusão

A nova API de Datas ficou bastante rica se comparada com a anterior. Apesar do maior número de classes, elas ficaram mais coesas e com responsabilidades bem definidas. Até aqui vimos as datas para computadores, Instant e Duration, e as datas para humanos, LocalDate e Period. No próximo post veremos como utilizar datas com horas e fusos horários. Até o próximo post!

sábado, 5 de setembro de 2015

Contador Binário com Raspberry Pi 2

Fala pessoal! Tô meio sumido do blog, mas hoje resolvi voltar com um post sobre um 'brinquedinho' que tem feito muito sucesso por aí: o Raspberry Pi. Pra quem não sabe, o Raspberry é um computador do tamanho de um cartão de crédito, no qual você pode conetar um monitor, teclado, mouse, e na versão mais nova (Pi 2) vem com porta Ethernet e HDMI. Se você quiser mais detalhes sobre o modelo 2 é só clicar aqui.

Fig. 1 - Raspberry Pi 2 Model B

O Raspberry é ideal para quem deseja explorar a computação em um nível um pouco mais baixo e aprender linguagens como Python ou Scratch (Na verdade dá pra usar várias outras linguagens como C, Java, Ruby, etc). A ideia desse post não é explicar todo o funcionamento do Raspberry, mas sim mostrar um aplicação bem simples escrita em Python e que faz uso da GPIO (General Purpose I/O). Vou deixar pra você a tarefa de pesquisar mais detalhes sobre o Pi (No final do post colocarei alguns links interessantes pra começar).

Digamos que é a GPIO que torna o Raspberry Pi divertido. Através dela podemos enviar e receber dados/sinais de/para dispositivo externos plugados ao Pi. Antes de começarmos a por a mão na massa, vejamos alguns detalhes sobre a GPIO. Na figura abaixo temos a GPIO do Pi 2 (os modelos anteriores possuem tamanho e pinagem diferentes).

Fig. 2 - GPIO Raspberry 2

A contagem dos pinos começa no canto inferior esquerdo da figura 2, e vai do Pino 1 até o Pino 40, na parte inferior direita. Você pode programar os pinos de diversas maneiras. As entradas podem receber sinais de sensores, de um computador ou de outros dispositivos. A saída pode ser usada pra acender LEDs, Displays, ou enviar sinais para outros dispositivos.

A GPIO fornece também pinos com saída de 3.3V, 5V e 0V (Ground ou Terra). E claro, é possível alterar o modo de operação do pino para INPUT ou OUTPUT programaticamente. Na figura a seguir podemos ver a descrição de cada um dos pinos da GPIO.
Fig. 3 - Descrição dos Pinos da GPIO

Hello Raspberry!

Vamos então dar início ao desenvolvimento do nosso programa. Construiremos um contador binário de três bits, ou seja, poderemos contar de 0 a 7 apenas. Para deixar o projeto mais simples utilizaremos LEDs para representar cada bit. Inicialmente o contador irá rodar automaticamente, mas depois acrescentaremos um botão que será usado para incrementar o contador. O programa será construído de forma incremental para você ir se familiarizando com os conceitos abordados. Para o projeto completo precisaremos dos seguintes componentes:
  • Raspberry Pi 2 Model B
  • 3 LEDs
  • 3 Resistores de 270 ohms
  • 1 Resistor de 1 Kohm 
  • 1 Push Button
  • 1 Protoboard
  • Fios para conexão (Macho-Fêmea e Macho-Macho)
Fazendo um LED piscar

A primeira versão do programa irá apenas acender e apagar um LED. Na figura abaixo você pode ver o desenho do circuito montado na Protoboard e na GPIO do Raspberry (Foi utilizado o programa Fritzing para fazer os desenhos).

Fig. 4 - Circuito com 1 LED

No LED a perna maior é o anodo (+) e a menor é o catodo (-), por isso ligamos o Pino 7 (3,3V de saída) no anodo do LED e o Pino 6 (Terra) no catodo. Ligamos um resistor de 270 ohms em série com o LED pra diminuir a corrente sobre ele, a ideal é torno 12 a 30 mA. O cálculo pode ser feito usando a Lei de Ohm, onde: R = V / I   => R = 3,3V / 12mA ~ R = 275 Ohms.

Deixando um pouco o mundo da eletrônica de lado, vamos agora o programa que fará o nosso LED piscar. O código foi escrito em Python e utiliza as libs time e RPi.GPIO. PS: Desde já esclareço que meu conhecimento de Python é bastante limitado, podem ficar a vontade para me corrigir caso eu cometa algum deslize. :)


Vejamos alguns pontos importantes sobre o código. No trecho em #1, o método GPIO.setmode configura a forma como os pinos da GPIO são referenciados, BOARD significa que a referência é a pinagem da placa, a outra opção é BCM, que usa como referência o número após GPIO no esquema da figura 3, ou seja, o pino é 7 no modo BOARD e 4 no modo BCM. Vale lembrar que a referência muda entre as versões do Raspberry.

O trecho em #2 apenas desabilita os warnings durante a execução do programa. O código do trecho #3 é importante, ele configura o pino como saída. Sempre que precisarmos ler ou escrever em um pino é preciso configurá-lo como entrada(GPIO.IN) ou saída(GPIO.OUT).

O trecho em #4 é o que faz com que o LED acenda e apague. O método output recebe 2 parâmetros, o primeiro é o número da pino (BCM ou BOARD) e o segundo é o valor a ser enviado, pode ser usado True, 1 ou GPIO.HIGH para acender, e False, 0, GPIO.LOW para apagar. Utilizamos o método sleep entre os estados apenas para termos o efeito do LED piscando. 

Ensinando o Pi a contar até 7! 

Nosso próximo passo agora é acrescentar mais dois LEDs ao projeto de forma que possamos representar números de 0 a 7 (000 a 111 em binário). Além disso, iremos modificar o programa Python para que ele faça a contagem e exiba o valor do contador através dos LEDs. A figura abaixo mostra o desenho do circuito com 3 LEDs. Os pinos utilizadas para representar os três bits foram: 7, 15, 16. Assim, o número 100 (4) será representado pelos LEDs 7(1), 15(0), 16(0).

Fig. 5 - Circuito com 3 LEDs

Precisamos alterar o programa que irá disparar o contador. Vejamos o código completo primeiro e em seguida farei alguns comentários sobre trechos que considero relevante.

No trecho #1 declaramos um array contendo a lista de pinos onde os LEDs estão conectados, isso vai nos ajudar no momento em que formos setar o estado de cada pino. O método Display recebe como parâmetro o número binário que será exibido, usamos o método zfill (#2) para garantir que enviaremos um número binário de 3 dígitos (001 por exemplo, ao invés de apenas 1), em seguida percorremos os pinos e setamos cada um deles pra 0 ou 1 de acordo com o número a ser exibido.

A contagem dos números é feita no método Count. Nele nós controlamos o valor do contador para este seja reiniciado sempre que atingir o valor 7 (máximo que podemos exibir com 3 bits, ou seja, 111). Em #3 usamos um método utilitário de Python que converte um número decimal em binário, como o valor retornado é uma string no formato '0b111', enviamos a substring a partir do índice 2. Por fim, o método loop executará a contagem até que o usuário interrompa o programa apertando as teclas: CTRL + C (#4), além de retornar os pinos aos seus estados iniciais.

Interagindo com o Pi!

Nosso contador está começando a ficar interessante, mas ainda ainda está faltando algo nele: Interatividade. Até aqui nós utilizamos os pinos da GPIO apenas como saída, mas e se precisarmos enviar alguma informação para o nosso programa? É isso que faremos a seguir. Nossa próxima tarefa será fazer com que o contador binário seja acionado através de um botão, e não mais fique executando de forma automática.

Os pinos da GPIO podem ser configurados como Entrada ou Saída. Como vimos anteriormente, ao configurarmos um pino como Saída, ele enviará uma tensão de aproximadamente 3.3V quando ligado e 0V quando desligado. Como Entrada, para que o Pi entenda o sinal recebido como sendo o valor lógico 1 é preciso uma tensão de entrada entre 1.5V e 3.3V, e para o valor lógico 0 qualquer tensão entre 0V e 1.5V (esses valores podem variar dependendo da versão do Pi). ATENÇÃO: Nunca utilize uma tensão maior que 3.3V em um pino da GPIO, pois você poderá causar danos permanentes em seu Raspberry.

Vejamos então o circuito final do projeto, o contador com os 3 LEDs e um botão para acionar a contagem. O circuito dos LEDs é o mesmo de antes, o botão do tipo push button foi ligado em série com um resistor, em um circuito conhecido como Pull Up Resistor, usado para garantir que o pino de entrada estará em nível lógico 1 enquanto o botão não for pressionado e em 0 quando for apertado.

Fig. 6 - Esquema com 3 LEDs e um botão de acionamento

Fig. 7 - Esquema real montado na protoboard

Por fim, vamos analisar o código que faz a leitura do pressionamento do botão e o acionamento da contagem. As mudanças no código foram poucas. Adicionamos um variável que faz referência ao pino em que o botão está ligado (#1) e configuramos esse pino como INPUT (#2).

A principal novidade está no trecho #3, onde está a lógica de incremento do contador ao pressionarmos o botão, fazendo com que o valor lógico do pino mude de HIGH para LOW (0 ou False). O restante do programa é igual ao que tínhamos desenvolvido no passo anterior. Vejamos então o código final completo.

Conclusão

O Raspberry Pi tem se mostrado uma ótima opção para quem deseja entrar no mundo dos embarcados. Com um tamanho razoavelmente pequeno, porém com uma configuração de hardware bastante generosa, o Pi pode ser usado em projetos bem simples como que fizemos, como em projetos bem sofisticados como: Media Center, Clusters, Arcades, Mini Computadores, dentre outros.

O preço do Pi aqui na República das Bananas ainda é um pouco salgado, algumas lojas chegam a cobrar cerca de R$ 300,00 pelo modelo B 2, um verdadeiro assalto visto que o preço lá fora é de apenas U$ 35.00 (com um dólar a R$ 4,00 ainda assim custaria apenas R$ 140,00). No Mercado Livre existem algumas lojas vendendo a preços mais mais amigáveis, fazendo uma boa pesquisa é possível achar um que caiba no seu bolso. :)

Você pode incrementar o projeto que apresentamos adicionando um outro botão para decrementar o número, exibir a saída através de um display de 7 segmentos, ou até mesmo um display de LCD daqueles usados em calculadoras, por exemplo. Assim que possível irei escrever um outro artigo mostrando como utilizar a linguagem Java para interagir com a GPIO. Espero que tenham gostado e fiquem a vontade para enviar suas críticas e sugestões. Até o próximo post!

Links Interessantes



segunda-feira, 20 de abril de 2015

Novidades do JDBC 4

Apesar de hoje em dia não ser comum utilizar JDBC puro em grandes projetos, embora haja quem o faça, a API continua evoluindo junto com a especificação do JSE.

A nova API, JDBC 4, foi incorporada ao JDK 6 e traz algumas mudanças como: melhor gerenciamento de objetos e suporte a novos tipos de dados, além das já existentes flexibilidade e facilidade de uso.

Uma mudança que a nova versão trouxe é na hora de obtermos uma conexão com o banco. Antes era necessário carregar a classe do driver JDBC antes de chamar o getConnection de DriverManager, por exemplo:

Class.forName("com.mysql.jdbc.Driver");
//Chamada ao DriverManager aqui

Esta chamada não é mais necessária, pois o próprio DriverManager se encarregará de localizar e carregar  a classe do Driver JDBC, para isto, basta que nós adicionemos o .jar no classpath da aplicação.

Outra novidade é o suporte a tipos de dados em XML, que estão definidos na SQL2003. O objeto é o java.sql.SQLXML, podemos fazer por exemplo:

SQLXML xml = Connection.createSQLXML( );

ou ainda:

SQLXML xml = resultSet.getSQLXML( );
InputStream is = xml.getBinaryStream( );

Seu uso é similar aos dos tipos CLOB e BLOB, que são suportados desde à versão 2.0, a nova versão traz  também a classe RowId, que permite fazer o acesso a um registro de forma mais rápida.
Agora é possível executar funções escalares como:
  • CHAR_LENTH, CHARACTER_LENGTH
  • CURRENT_TIME, CURRENT_DATE

Com o advento dos frameworks de ORM, como Hibernate, JPA, ficou cada vez mais raro usar JDBC, talvez você nem mesmo soubesse que a API estava na versão 4.0, tô mentindo? :) Eu penso que é bom conhecer essas APIs mais básicas, pois se soubermos utilizar bem JDBC será mais fácil aprender a usar ORM, assim como o estudo de Servlets/JSP é importante para o aprendizado de frameworks web como JSF, Struts, Vraptor etc.

Há situações em que nós não precisamos ou não queremos utilizar um framework de grande porte, por exemplo, no caso de o projeto pode ser pequeno ou simples demais, ou ainda se tivermos restrições de desempenho ou espaço de armazenamento (sistemas embarcados, por exemplo).

Espero que tenham gostado do post! Até o próximo post então!

quarta-feira, 1 de abril de 2015

Javascript Fundamentos: Parte 2 - Escopo Léxico e Escopo de Função

No post anterior, nós vimos a definição de escopo e como funciona o escopo global do Javascript. Neste artigo irei mostrar o Escopo Léxico, que também é conhecido como escopo estático. Entendê-lo é fundamental para você compreender um outro assunto bacana de Javascript: Closures! Mas não se apresse! Primeiro vamos entender o que é esse tal de escopo léxico.

O escopo léxico tem a ver com o lugar onde suas variáveis e blocos foram escritos no código. Um nome (de uma variável ou bloco) sempre irá se referir ao seu escopo léxico local mais próximo, e essa propriedade não muda, independentemente da pilha da execução da linguagem. Como é que é?? Calma jovem, logo tudo isso fará mais sentido. 

O escopo léxico define como as variáveis são resolvidas em funções aninhadas, de forma que uma função aninhada terá acesso às variáveis declaradas nas funções mais externas. É como se a função interna contivesse todo o escopo das funções externas. Veja o exemplo abaixo:

Para resolver uma variável, a engine do Javascript faz uma busca em todos os escopos visíveis, do mais interno ao mais externo (global). Outra ponto importante de se destacar, é que a busca para ao encontrar a primeira declaração correspondente. Vejamos:

A operação mais interna a ser executada é a função bar, e nela, a chamada console.log(a, b, c). A engine tentará resolver 'a' no escopo de bar, ao não encontrar, ela sobe para o escopo foo, onde estará 'a', que será usado e a busca terminada. O mesmo ocorrerá com 'b', já no caso de 'c', o valor estará dentro do escopo de bar e será usado.

O escopo léxico é definido pelo programador ao escrever uma variável em determinado lugar do código. O mecanismo de interpretação do Javascript saberá então onde localizar o valor a ser atribuído durante a execução do código. Isso seria uma tarefa de compilação, porém como Javascript não é uma linguagem compilada, essa tarefa é chamada de Lexing Time.

Function Scope

Javascript não possui escopo de bloco! Isso confunde a cabeça de quem vem de linguagens como Java, C, C#, por exemplo. Toda função em Javascript cria um novo escopo. Vejamos um exemplo bem simples abaixo:

Como era esperado, a variável 'a' é criada em cada função e não é afetada por outros escopos. Nesse caso ocorre o fenômeno que é conhecido como Shadowing, se uma variável com o mesmo nome é criado em um escopo aninhado esta acaba 'sombreando' o valor declarado no escopo superior.

Já que não existe escopo de bloco em Javascript, estruturas como for ou while não criam um novo escopo. Vejamos qual implicação disso no trecho de código abaixo:

A variável 'i', embora criada dentro do laço for, é visível mesmo fora dele, ou seja, ela na verdade pertence ao escopo da função loop. Em um outro artigo veremos que isso ocorre devido a um comportamento da linguagem Javascript chamado de Hoisting.

No próximo artigo fecharemos o assunto de escopo falando sobre IIFE e Hoisting. Até o próximo post!

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!