terça-feira, 21 de fevereiro de 2017

Tagged under:

ITA oferece 10 cursos EAD e em português gratuitos

Javeiros,

O ITA (Instituto Tecnológico de Aeronáutica) está oferecendo cerca de 10 cursos de GRAÇA e em PORTUGUÊS pela plataforma do coursera, os cursos estão sendo ministrados por instrutores muito bem capacitados.

O que é o ITA?

Criado em 1950, o ITA é o instituto de ensino superior do Comando da Aeronáutica (COMAER), localizado no Departamento de Ciência e Tecnologia Aeroespacial (DCTA). Mantém cursos de graduação em engenharia (Aeronáutica, Civil-Aeronáutica, Eletrônica, Mecânica-Aeronáutica, Engenharia de Computação, Aeroespacial), especialização, extensão e pós-graduação stricto sensu (Mestrado, Mestrado Profissionalizante e Doutorado).

Quais são os cursos?

- Introdução ao Controle de Sistemas

Resumo: Este curso apresenta os principais conceitos do controle de sistemas e mostra suas vantagens e importância para a sociedade moderna. Você vai entender o que é o controle de sistemas e como o controle com realimentação funciona, e passará a perceber a sua presença em diversas situações em seu dia-a-dia, na natureza, no corpo humano e em diversos dispositivos, desde os mais simples até os mais complexos.

Você vai perceber a necessidade de modelos teóricos para a análise e o projeto do controle de sistemas e aprenderá como verificar se um sistema atende a determinados requisitos de desempenho. Você também aprenderá como projetar um controle simples de modo a obter o melhor desempenho possível de um sistema de controle. Este é apenas o primeiro passo em direção a um vasto campo do conhecimento e lhe dará a base e a segurança necessárias para avançar em seus estudos no maravilhoso mundo do controle de sistemas.

Instrutores: Jackson Paul Matsuura e  Rubens Junqueira Magalhães Afonso


- Controle Usando a Resposta em Frequência

Resumo: Neste curso você aprenderá a obter  a resposta em frequência de um sistema Linear e Invariante no Tempo (LIT) e a usá-la para projetar controladores que atinjam requisitos de reposta transitória e em regime estacionário. Você aprenderá a obter o diagrama de Bode a partir de dados de amplitude e fase de entradas e saídas senoidais. Também será capaz de esboçar o diagrama de Bode de um sistema dada a sua função de transferência. Outrossim, será capaz de representar a resposta em frequência na carta de Nichols-Black.

A fim de se determinar a estabilidade do sistema, você aprenderá a aplicar o critério de Nyquist, que faz uso da resposta em frequência em malha aberta e permite determinar se um sistema será estável em malha fechada. Ao fim do curso, você será capaz de projetar controladores com dinâmica, isto é, com polos e zeros, portanto mais complexos do que um simples ganho de realimentação. Essa flexibilidade permitirá que você projete controladores para satisfazer simultaneamente requisitos de sobressinal e tempo de resposta que seriam impossíveis de atender com um simples ganho. Também poderá com isso alterar as características da resposta em regime estacionário, aumentando as constantes de erro sem alterar (muito) a resposta transitória.

Por fim, você aprenderá a projetar controladores do tipo PD, PI e PID, que estão entre os mais disseminados em aplicações de engenharia de controle.

Instrutores: Jackson Paul Matsuura e  Rubens Junqueira Magalhães Afonso


- Arquitetura de Software em Projetos Ágeis

Resumo: Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, produzindo software de qualidade devido ao uso de técnicas ágeis mais automatizadas; mas você talvez ainda sinta necessidade de organizar o software desenvolvido segundo aspectos arquiteturais, tornando-o mais flexível para mudanças e evolução.

O objetivo deste curso é expor você a conceitos e técnicas para modelar e evoluir, de forma ágil, a arquitetura do software sendo desenvolvido.

Os conceitos apresentados neste curso no contexto da programação Java incluem o seguinte: conceitos de arquitetura de software; conceito de dívida técnica; uso de arquiteturas de referência e padrões arquiteturais; identificação de desafios técnicos; prototipação focada na demonstração da arquitetura; arquitetura de testes; identificação e planejamento do "momento mais responsável"; planejamento de tarefas de arquitetura; "spikes" de projeto e de arquitetura; "walking skeleton"; gerência da dívida técnica; monitorando atributos de qualidade; inspec'ão contínua.

Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de reestruturar em termos arquiteturais e implementar partes da aplicação Web final com o componente de gamificação enriquecido constantes do Trabalho de Conclusão da Especialização, aplicando onde apropriado as técnicas e conceitos apresentados neste curso.

Instrutores: Clovis Fernandes e Eduardo Guerra


- Controle de Sistemas no Plano-s

Resumo: Após esse curso você será capaz de esboçar o Lugar Geométrico das Raízes (LGR - Root Locus) do denominador da Função de Transferência em Malha Fechada a partir dos polos e zeros da Função de Transferência em Malha aberta.
Você também será capaz de projetar controladores de avanço de fase para atender simultaneamente requisitos de desempenho de amortecimento e de velocidade da resposta. Você também será capaz de projetar controladores de atraso de fase para atender requisitos de erro em regime permanente sem alterar as características de estabilidade e da resposta transitória do sistema. Você verá que os controladores PD e PI podem ser considerados como casos especiais dos controladores de avanço e de atraso de fase e verá também que você pode combinar os dois tipos de controladores em controladores de avanço e atraso de fase ou em controladores PID.
Por fim você será capaz de modelar o efeito do atraso de transporte em um sistema com realimentação e de contrapor esse efeito projetando um controlador ou fazendo ajustes em um controlador já projetado.
Desso modo dado um sistema linear e invariante no tempo e requisitos de amortecimento, velocidade e erro em regime permanente você será capaz de projetar um controlador que fará com que o sistema em malha fechada atenda simultaneamente a esses três tipos de requisitos.
E você aprenderá tudo isso usando o MATLAB, uma ferramenta computacional extremamente útil para a análise, projeto e simulação de sistemas.

Instrutores: Jackson Paul Matsuura e Rubens Junqueira Magalhães Afonso


- Desenvolvimento Ágil com Padrões de Projeto

Resumo: Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, graças às boas práticas e princípios exercitados nos cursos anteriores; mas você talvez não se sinta ainda confortável em lidar com cenários mais complexos, onde é difícil desenvolver software com código de qualidade com flexibilidade suficiente para facilitar a implementação de mudanças repentinas de requisitos. 

O objetivo deste curso é oferecer a você um aprofundamento em técnicas de programação orientadas a objetos pelo uso de padrões de projeto no contexto de desenvolvimento ágil.

Os conceitos apresentados neste curso no contexto da programação Java incluem o seguinte: compreendendo padrões de projeto; tipos básicos de padrões de projeto; reúso através de herança ( Null Object, Template Methode e Factory Method); delegando comportamento com composição (Strategy, Bridge, State e Observer); composição recursiva (Composite e Chain of Responsibilities); envolvendo objetos (Proxy, Decorator e Adapter); estratégias para objetos (Static Factory Method, Singleton, Builder e Abstract Factory); modularização (Dynamic Object Factory, Service Locator e Injeção de Dependência); adicionando operações (Command, Double Dispatch e Visitor); gerenciando muitos objetos (Facade, Mediator e Flyweight); outros tipos de padrões de projeto..

Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar partes da aplicação Web final com o componente de gamificação enriquecido constantes do Trabalho de Conclusão da Especialização, aplicando onde apropriado alguns dos padrões apresentados neste curso durante a refatoração na prática TDD.

Instrutores: Clovis Fernandes e Eduardo Guerra


- Desenvolvimento Ágil com Java Avançado

Resumo: Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, graças às boas práticas e princípios orientados a objetos e TDD exercitados nos cursos anteriores; mas você talvez não se sinta ainda confortável em projetar programas para Web e com dados armazenados em banco de dados, bem como em aplicar conceitos mais avançados de Java.

O objetivo deste curso é enriquecer sua experiência com conceitos avançados de Java, programação de aplicações Web e acesso a banco de dados no contexto de modelagem ágil.

Os conceitos apresentados neste curso no contexto da programação Java incluem o seguinte: APIs fundamentais do Java: tipos genéricos, reflexão e anotações; expressões lambda do Java 8; aplicação Web com Java: Java Servlets, páginas JSP, padrão MVC e teste de aplicação Web com Selenium; e acesso a banco de dados em Java: JDBC, desenvolvimento de aplicação empresarial e testes com DBUnit.

Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar de modo ágil uma versão inicial da aplicação Web em associação com o componente de gamificação constantes do Trabalho de Conclusão da Especialização, com base nas boas práticas exercitadas neste curso.

Instrutores: Clovis Fernandes e Eduardo Guerra


- Princípios de Desenvolvimento Ágil de Software

Resumo: Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, graças às boas práticas e princípios orientados a objetos, TDD e conceitos avançados de Java aplicados à Web e banco de dados exercitados nos cursos anteriores; mas você talvez não se sinta ainda confortável em planejar e gerenciar o desenvolvimento das aplicações com base em modernas práticas de modelagem ágil.

O objetivo deste curso é expor você às principais técnicas e princípios de desenvolvimento ágil, em especial aos que se popularizaram pela sua utilização no framework Scrum e na metodologia XP (Extreme Programming). Apresentamos o Scrum&XP, uma combinação apropriada do framework Scrum com a metodologia XP – Extreme Programming, sem no entanto afirmar que você estará aprendendo tudo sobre Scrum ou sobre XP.

Os conceitos apresentados neste curso incluem o seguinte:

* Manifesto ágil e princípios de desenvolvimento ágil

* Requisitos de software na forma de user stories e backlog de produto

* Eventos e reuniões do Scrum&XP: Sprint, Sprint Planning, Planning Poker, Daily Scrum, Sprint Review e Sprint Retrospective, TDD e Programação em Pares

* Papéis do Scrum: Product Owner, Time de Desenvolvedores e Scrum Master

* Tarefas, Sprint Backlog, Quadro de Tarefas e Diagrama Burndown

Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar de modo ágil um sistema que incorpora um componente de gamificação constante do Trabalho de Conclusão do Programa de Cursos Integrados, com base nas boas práticas ágeis exercitadas neste curso com o Scrum&XP apresentado.

Instrutores: Clovis Fernandes e Eduardo Guerra


- Técnicas Avançadas para Projeto de Software

Resumo: Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, produzindo software de qualidade e flexível o suficiente para facilitar a execução de mudanças repentinas de requisitos; mas você talvez ainda sinta necessidade de aplicar técnicas mais avançadas e automatizadas para agilizar o desenvolvimento de código de produção e de testes.

O objetivo deste curso é expor você a conceitos e técnicas mais avançados que estendem e fazem uso do TDD de forma mais prática e automatizada para projetar software com maior nível comprovável de qualidade.

Os conceitos apresentados neste curso no contexto da programação Java incluem o seguinte: padrões de passos no TDD; Acceptance TDD (ATDD); desenvolvimento guiado pelo comportamento (BDD – Behavior-Driven Development); aplicando padrões de projeto por meio do TDD; refatoração para padrões de projeto; refatorando código de teste; boas práticas ao criar casos de testes; técnicas automatizadas para avaliação do código Java.

Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar partes da aplicação Web final com o componente de gamificação  enriquecido constantes do Trabalho de Conclusão da Especialização, aplicando onde apropriado as técnicas e metodologias apresentadas neste curso.

Instrutores: Clovis Fernandes e Eduardo Guerra


- TDD – Desenvolvimento de Software Guiado por Testes

Resumo: Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, com método e organização graças às boas práticas e princípios exercitados no curso anterior; mas você talvez não se sinta ainda confortável em projetar programas usando técnicas ágeis, como o desenvolvimento guiado por testes (TDD). 

O objetivo deste curso é expor você aos princípios e práticas de desenvolvimento guiado por testes, tanto para modelar quanto para desenvolver aplicações e componentes de software, sem abandonar os conceitos e princípios de orientação a objetos aprendidos no curso anterior. De fato, pregamos que tais conceitos e princípios fortalecem o emprego do TDD no desenvolvimento ágil de software com mais qualidade. Este curso terá um grande foco em atividades hands-on, permitindo a você captar todos os aspectos práticos da técnica e facilitar a sua aplicação quando estiver projetando e desenvolvendo software de maneira ágil nos próximos cursos.

Os conceitos de desenvolvimento de software com Java apresentados neste curso incluem o seguinte: revisão de testes de unidade; automação de testes; desenvolvimento guiado por testes; ciclo do TDD; refatoração de código de produção; ciclo de refatoração; uso de objetos stubs e mocks; boas práticas no TDD; modelagem de software por meio do TDD.

Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar, agora usando o TDD, versões modificadas e estendidas do componente de gamificação constante do Trabalho de Conclusão da Especialização, com base nas boas práticas exercitadas neste curso.

Instrutores: Clovis Fernandes e Eduardo Guerra


- Orientação a Objetos com Java

Resumo: Neste curso, assumimos que você já sabe desenvolver programas pequenos em Java, mas você talvez não se sinta ainda confortável em projetar programas mais complexos com método e organização. 

O objetivo deste curso é fazer você compreender os princípios de orientação a objetos por meio da linguagem Java e saber como eficientemente aplicar esses princípios na prática quando projetando e desenvolvendo software de maneira ágil. Os conceitos discutidos e experimentados por você neste curso serão a base para você poder compreender os novos conceitos apresentados nos cursos seguintes desta especialização.

Os conceitos Java apresentados neste curso incluem o seguinte: revisão de conceitos básicos de orientação a objetos, tais como classes, objetos, métodos e atributos, variáveis de instância e de classe; responsabilidades, colaborações e cartões CRC; testes de unidade, uso de plataforma IDE como o Eclipse; herança, classes concretas e abstratas, interfaces, modificadores de acesso, encapsulamento, métodos de acesso; aprofundamento nos conceitos de polimorfismo, sobrecarga e sobreposição; associação de classes, agregação e composição; exceções, delegação e acoplamento abstrato. Em seguida, vocês serão apresentados aos principais princípios usados para organizar o desenvolvimento de programas orientados a objetos com qualidade, dentre os quais, os princípios "Tell, Don't Ask!" e "Law of Demeter". Sempre que conveniente, cada conceito será representado por meio de diagramas  UML. Você será exposto a propriedades e anotações em Java.

Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que você será capaz de implementar versões iniciais do componente de gamificação constante do Trabalho de Conclusão da Especialização, com base nas boas práticas exercitadas neste curso.

Instrutores: Clovis Fernandes e Eduardo Guerra


Bem, espero encontrar vocês no curso de TDD. Só uma observação os cursos são de graça, mas caso você queira gerar o certificado de conclusão terá que pagar uma taxa.

Abraços.

segunda-feira, 6 de fevereiro de 2017

Tagged under:

JVM Links (#04)


Opa! Estão abertas as inscrições para o NoSQL-BA a maior conferência de banco de dados não relacionais do nosso estado, você vai ficar de fora dessa? Vamos contar com a presença de palestrantes de empresas como Amazon, Microsoft e Oracle, acesse o site do evento para maiores informações.
Esse post foi feito pelo João Reis para o Blog do VivaReal e é simplesmente sensacional. Vivemos em um mundo repleto de informações, expectativas e possibilidades. Embora muitas vezes sobrecarregados, nos sentimos motivados a começar algo novo todos os dias sem necessariamente finalizar o que ontem estava em nossas mãos. Você Consegue me dizer quantas vezes no ano passado você finalizou uma atividade antes de começar um novo? Quantas coisas você foi tocando em paralelo com aquela sensação de trabalhar, trabalhar e não ver resultado?
Indicado por: Mateus Malaquias
A JSR-371 é uma especificação nova do mundo Java que vai trazer mudanças interessantes para o desenvolvimento de aplicações MVC o Daniel Dias fez um exelente post explicando a diferença básica entre Action-Based e Component-Based além de criar uma aplicação passo a passo.
Indicado por: Mateus Malaquias
O modelo relacional é o tipo mais utilizado pela maioria dos bancos de dados mais populares do mercado, mas ao passar dos anos o volume de dados foi crescendo e a forma de se extrair informações foram se tornando cada vez mais custosas nesse modelo, o que levou a criação de novas técnicas como por exemplo utilizar datawarehouses para geração de relatórios, views materializadas etc. Além disso novas necessidades surgiram como escalabilidade, baixo tempo de leitura e resposta e flexibilidade de modelagem, esse novo ambiente fez com que algumas pessoas questionassem a forma de armazenamento de dados e desse pensamento surgiu o NoSQL (not only SQL).
Mas o que é o NoSQL? É melhor que o modelo relacional? Nesse post irei explicar o que acho importante saber sobre a tecnologia.
Indicado por: Ivan Queiroz
Nesse HANGOUT Achilles Froes bate um papo com Vagner Oliveria, administrador do TI na Bahia e Co-Leader do SQL Server BA, sobre a importância das comunidades no seu crescimento profissional.
Indicado por: Mateus Malaquias
Elder Moraes recentemente fez um post no blog do Sou Java informando que esses últimos dias foram movimentados dentro do JCP, abrindo excelentes oportunidades para a iniciativa Adopt a JSR.
Três JSR’s muito importantes entraram em “Public Review”. Quem sabe esse não é o momento que você estava esperando para se envolver com o futuro do Java?
Indicado por: Mateus Malaquias

domingo, 5 de fevereiro de 2017

Tagged under: , , , , , ,

Vamos falar um pouco mais de Nosql

Texto originalmente publicado no blog de Antonio Lazaro e replicado no JavaBahia.

Para quem ainda não sabe nós (Comunidades Java Bahia + Python Bahia + Universidade Católica do Salvador - UCSAL) estamos organizando uma conferência sobre Nosql que acontecerá entre 30/03 e 01/04. Virão nomes de peso sobre o assunto e contamos com apoio de grandes empresas, como Amazon e Microsoft, além claro, da UCSAL.

As incrições para o evento foram abertas oficialmente na última sexta-feira e podem ser feitas nesse link.

Mais informações do evento podem ser obtidas no site oficial.

Para ajudar a trazer mais informações sobre o tema, estamos divulgando informações sobre NoSQL. O nosso amigo Ivan Queiroz iniciou o movimento de posts para trazer conhecimento sobre o assunto e também para ajudar na divulgação do evento e eu decidi dar continuidade. Se ainda não leu o post de Ivan, recomendo que leia, pois ele apresenta conceitos iniciais e fala da classificação desses bancos.

Introdução

Os bancos de dados não relacionais, ou também conhecidos como NoSQL (not only SQL) surgem com objetivo de trazer novas opções de armazenamento de dados diferentes dos nossos modelos relacionais que são baseados em schemas. Sabemos que em computação não existe bala de prata, então não vamos dizer que é a melhor solução para tudo e que deve ser usada sempre, mas deve ser uma opção que deve ser considerada antes de dar uma solução em um projeto. Estamos apresentando um conceito que é conhecido como persistência poliglota.

Definindo tipos

Os bancos NoSQL estão classificados em 4 grande tipos. São eles:

  • Chave-valor - Os registros são armazenados como uma coleção de elementos indexados que são recuperados por uma chave. Funciona muito bem para informações no formato de listas;
  • Colunar(column family) - Registro são armazenados em uma tabela, mas cada registro pode possuir várias colunas;
  • Documento - Cada registro é um documento que pode ou não fazer parte de uma coleção;
  • Grafo - Os registros são nós em um grafo interligados por arestas que representam o tipo de relacionamento entre eles;
  • Multimodelo - Suporta mais de um paradigma.

Quando usar?

Fica ai uma questão, em qual contexto é sugerido o uso de cada tipo de banco desse? Vou trazer alguns cenários com exemplos para ajudar nesse entendimento (lembrando que não pretendo definir, apenas apresentar alguns cenários)

Chave-valor:

  • Exemplos de contexto onde pode ser usado:
    • Armazenar dados de sessão, preferência e perfil de usuário
    • Dados do carrinho de compras
    • Não é recomendado o uso quando a data de persistência é algo importante
    • Usualmente utilizado como mecanismo de cache
  • Exemplos de empresas que usam:
    • Twitter
    • Github
    • Stackoverflow
  • Exemplos de bancos desse tipo:

Colunar (column family):

  • Exemplos de contexto onde pode ser usado:
    • Tratamento de largo volume de dados (a partir de Terabytes) com demanda de alta performance em leitura e escrita e alta disponibilidade
    • Aplicações distribuídas entre diversos datacenters
    • Aplicações que podem tolerar uma curta inconsistência entre os dados da replica
    • Aplicações com campos dinâmicos
  • Exemplos de empresas que usam:
    • IBM
    • Apple
    • Netflix
  • Exemplos de bancos desse tipo:

Documento:

  • Exemplos de contexto onde pode ser usado: (fonte):
    • Os dados não se encaixam no modelo relacional
    • Quando seus dados são na verdade objetos
    • Quando sua aplicação valida a consistência dos dados, não o banco
    • Quando o projeto da aplicação é orientado ao domínio
    • Quando seu projeto precisa se adaptar a mudanças
    • Quando a escalabilidade é importante
    • Quando você não precisa de transações e ACID (atomicity, consistency, isolation, and durability)
  • Exemplos de empresas que usam:
    • Cisco
    • Google
    • Ebay
  • Exemplos de bancos desse tipo:

Grafo:

  • Exemplos de contexto onde pode ser usado:
    • Toda vez que for necessário persistir um grafo. Um grafo é um elemento composto de um nó e uma relação.
    • Cada nó representa uma entidade e uma relação, é uma ligação entre essas entidades.
    • Exemplo mais comum: rede social.
    • Dados espaciais, sistemas de recomendação também usam esse tipo de banco de dados.
  • Exemplos de empresas que usam:
    • Nasa
    • Walmart
    • Linkedin
  • Exemplos de bancos desse tipo:

Multimodelo

  • Exemplos de empresas que usam:
    • Fox Sports
    • Dell
    • Ericsson
  • Exemplos de bancos desse tipo:

Fontes:
- Post introdutório no blog de Ivan Queiroz
- Livro da Casa do Código - NoSQL Como armazenar os dados de uma aplicação moderna
- http://tech.leroymerlin.com.br/devemos-usar-nosql-e-mongodb
- Nosql Database (reune todos bancos Nosql disponíveis)
- http://www.slideshare.net/steppat/nosql-por-que-e-quando-usar
- http://christiano.me/persistencia-poliglota-e-nosql-palestra-fisl/
- https://neo4j.com/why-graph-databases/
- https://www.thoughtworks.com/insights/blog/nosql-databases-overview
- http://www.3pillarglobal.com/insights/exploring-the-different-types-of-nosql-databases

sexta-feira, 3 de fevereiro de 2017

Tagged under: , , ,

Abertas as inscrições para NoSQLBa 2017 (Conferência sobre Nosql)

Estão abertas as inscrições para o NoSQL BA. Conferência sobre a tecnologia NoSQL que acontecerá em Salvador nos dias 30/03 (quinta-feira), 31/03 (sexta-feira) e 01/04 (sábado), entre 09:30 e 17:00, no campus de Pituaçu da Universidade Católica do Salvador (UCSAL). Teremos no evento presença de nomes de referência do mercado nacional no assunto e alguns cases bem interessante. Também temos apoio de empresas gigantes (Microsoft, Amazon,Oracle).

Sobre Nosql:
Os banco de Dados NOSQL (not only SQL) foram criados, principalmente, para resolver problemas com aplicações web que precisam operar com gigantescas cargas de dados além de poder escalar com grande facilidade. Esses tipos de banco de dados vem sendo usados com muita frequência em redes sociais como Twitter, Facebook, além de persistência em aplicações nas nuvens. Outro ponto importante a citar é a crescente adoção destas novas tecnologias, inclusive em mercados mais conservadores, tais como instituições financeiras e agências governamentais, seus motivos são diversos normalmente para solucionar problemas com flexibilidade, escalabilidade, latência e performance. Para demonstrar, compartilhar essas tecnologias foi criado o evento NOSQL-BA.

O que teremos no evento
  • Palestra: Palestra normal do evento
  • Debate (Fishbownl): O Fishbowl é um formato de discussão em grupo que promove o diálogo e a troca de experiência entre os participantes da sessão e permite que todos tenham as mesmas chances de opinar e expressar seus pontos de vista.
  • Workshop: Um mini-curso (4 horas).
As inscrições devem ser feitas nesse link.
Programação completa do evento (grade sujeita a alteração)
Palestrantes do evento. (grade sujeita a alteração)
Mais informações sobre evento no site.

Mais informações sobre o assunto, recomendo que vejam esse link introdutório feito por nosso amigo Ivan Queiroz.

Estamos informando o evento com mais de um mês de antecedência, então pessoal, negociem com seus líderes/chefes/gerentes. Caso seus superiores informem que não usam a ferramenta, recomendo que apresentem o link introdutório do Ivan Queiroz.e o site do evento, pois essa tecnologia não é do futuro. Ela é presente, e as principais soluções do mercado estão usando (Facebook, Twitter, Buscapé, Globo.com) e possuem cases com essa tecnologia. Não é a bala de prata, mas é uma ferramenta para o desenvolvedor ter conhecimento e saber quando utilizar.

Abraço e vejo vocês lá no evento! Qualquer dúvida, entre em contato com a equipe do Java Bahia ou comente nesse post que responderemos brevemente.

sexta-feira, 27 de janeiro de 2017

Tagged under: , , ,

Revisando Padrões com Java 8: O Padrão Template Method

Post original em: http://blog.ivanqueiroz.com/2017/01/revisando-padroes-java-8-template-method.html

No último post da série sobre padrões foi explicado o padrão Strategy, uso, vantagens e desvantagens e uma ótica de utilização com o Java 8. Continuando a série falarei do padrão Template Method seguindo a mesma linha e com exemplos. Será que conseguimos utilizá-lo com as features do Java 8? Vamos ver.
"Estamos presos ao modelo, somos parte dele."
-- V de Vingança

Template Method

Esse padrão define um modelo (template) de algoritmo, com pontos de extensão para serem utilizados por subclasses que irão adicionar comportamentos sem alterar a estrutura do algoritmo.


Aplicabilidade

Podemos utilizar quando:
  • queremos escrever as partes invariáveis de um algoritmo somente uma vez e deixar a implementação das partes variáveis para as suas subclasses;
  • existe comportamento em comum entre as subclasses, então movemos (uma refatoração) esse comportamento para uma classe comum, evitando duplicação de código;
  • queremos controlar a extensão das subclasses. Define-se um método template e a partir dele chamar várias hook operations (um método padrão geralmente vazio) que podem ter os comportamentos definidos pelas subclasses.

Implementação

Criei a classe Lutador que é a classe cliente que utiliza o algoritmo implementado pelo template:
public class Lutador {

    private MetodoLuta metodo;

    public Lutador() {
    }

    public void mudarMetodo(MetodoLuta metodo) {
        this.metodo = metodo;
    }

    public void finalizar() {
        metodo.finalizar();
    }
}

O método finalizar() chama o algoritmo de uma instância da subclasse de MetodoLuta que é o template de como o algoritmo será executado:

public abstract class MetodoLuta {

    private static final Logger LOGGER = LoggerFactory.getLogger(MetodoLuta.class);

    public MetodoLuta() {
    }

    protected abstract String desafiarOponente();

    protected abstract void socarOponente(String oponente);

    protected abstract void chutarOponente(String oponente);

    protected abstract void atirarMagiaOponente(String oponente);

    public final void finalizar() {

        String oponente = desafiarOponente();
        LOGGER.info("Lutador desafiado: {}.", oponente);
        socarOponente(oponente);
        chutarOponente(oponente);
        atirarMagiaOponente(oponente);

    }

}

Criei as subclasses MetodoForcaBruta e MetodoAgil que implementam os métodos abstratos.

Antes do Java 8

Para utilizar o padrão é só criar uma instância da classe cliente, configurar o template e chamar o método executor do algoritmo:
Lutador lutador = new Lutador();

lutador.mudarMetodo(new MetodoForcaBruta());
lutador.finalizar();

lutador.mudarMetodo(new MetodoAgil());
lutador.finalizar();
A saída da execução evidencia a mudança do algoritmo:
com.ivanqueiroz.templatemethod.MetodoLuta - Lutador desafiado Lutador de Karatê Milenar.
com.ivanqueiroz.templatemethod.MetodoForcaBruta - Soco forte no Lutador de Karatê Milenar pelo alto.
com.ivanqueiroz.templatemethod.MetodoForcaBruta - Chute forte giratório no ar em direção ao Lutador de Karatê Milenar
com.ivanqueiroz.templatemethod.MetodoForcaBruta - Hadounken de fogo no Lutador de Karatê Milenar
com.ivanqueiroz.templatemethod.MetodoLuta - Lutador desafiado Lutador de Sumô.
com.ivanqueiroz.templatemethod.MetodoForcaBruta - Soco rápido na linha de cintura do Lutador de Sumô
com.ivanqueiroz.templatemethod.MetodoForcaBruta - Chute médio com duas pernas na linha dos pés do Lutador de Sumô
com.ivanqueiroz.templatemethod.MetodoForcaBruta - Chute do pássaro giratório no Lutador de Sumô

Após o Java 8

Para utilização do Java 8 deixarei de utilizar classes abstratas e irei utilizar interfaces com uma das novidades do Java 8 o controverso Default Method.

Default Method

Essa novidade do Java 8 gerou alguns questionamentos de design da linguagem por permitir herança múltipla caso existam interfaces com default methods com a mesma assinatura. Mas particularmente acho que trouxe muito mais benefícios do que malefícios, pois essa decisão permitiu a alteração da API sem quebrar códigos antigos.
Bom, voltando ao que interessa, criei a interface MetodoLutaIf (que será o template) baseada na classe abstrata MetodoLuta, somente transformando o método finalizar() no default method:

public interface MetodoLutaIf {

    static final Logger LOGGER = LoggerFactory.getLogger(MetodoLutaIf.class);

    public String desafiarOponente();

    public void socarOponente(String oponente);

    public void chutarOponente(String oponente);

    public void atirarMagiaOponente(String oponente);

    public default void finalizar(){

        String oponente = desafiarOponente();
        LOGGER.info("Lutador desafiado: {}.", oponente);
        socarOponente(oponente);
        chutarOponente(oponente);
        atirarMagiaOponente(oponente);

    }
}

Após criar as implementações MetodoAgilImpl e MetodoForcaBrutaImpl o código executor ficará da seguinte maneira:
LutadorAtual lutadorJava8 = new LutadorAtual();

lutadorJava8.mudarMetodo(new MetodoAgilImpl());
lutadorJava8.finalizar();

lutadorJava8.mudarMetodo(new MetodoForcaBrutaImpl());
lutadorJava8.finalizar();
Analisando o código, não houve grande ganho do uso de Default Method (do ponto de vista na sintaxe), já que a interface possui mais de um método a ser implementado não podemos utilizar lambdas para passar novas implementações. Veremos então como seria, criei a interface MetodoXiterIf e a classe LutadorPreguicoso que utiliza o template:

public interface MetodoXiterIf {

    static final Logger LOGGER = LoggerFactory.getLogger(MetodoXiterIf.class);

    public String desafiarOponente();

    public default void soltarMagiaEmCima() {
        LOGGER.info("Hadouken na cara de {}", desafiarOponente());
    }

    public default void soltarMagiaEmbaixo() {
        LOGGER.info("Hadouken nas pernas de {}", desafiarOponente());
    }

    public default void soltarMagiaNoAr() {
        LOGGER.info("Hadouken na cabeça de {}", desafiarOponente());
    }

    public default void finalizar() {
        LOGGER.info("Lutador desafiado: {}.", desafiarOponente());
        soltarMagiaEmCima();
        soltarMagiaEmbaixo();
        soltarMagiaNoAr();
    }
}

Agora fica possível utilizar a sintaxe lambda na execução do código:

LutadorPreguicoso lutadorXiter = new LutadorPreguicoso();

lutadorXiter.mudarMetodo(()->"Lutador de sumô");
lutadorXiter.finalizar();

lutadorXiter.mudarMetodo(()->"Lutador de Karatê Milenar");
lutadorXiter.finalizar();

E ter o resultado esperado:

MetodoXiterIf - Lutador desafiado: Lutador de sumô.
MetodoXiterIf - Hadouken na cara de Lutador de sumô
MetodoXiterIf - Hadouken nas pernas de Lutador de sumô
MetodoXiterIf - Hadouken na cabeça de Lutador de sumô
MetodoXiterIf - Lutador desafiado: Lutador de Karatê Milenar.
MetodoXiterIf - Hadouken na cara de Lutador de Karatê Milenar
MetodoXiterIf - Hadouken nas pernas de Lutador de Karatê Milenar
MetodoXiterIf - Hadouken na cabeça de Lutador de Karatê Milenar

Vantagens e desvantagens

As vantagens principais para mim do Template Method são:
  • o reaproveitamento de código comum;
  • controlar a sequência da execução das subclasses ou implementações;
  • ter pontos que chamam código ainda não implementado (hook);
  • com o Java 8, podemos utilizar mais de um template, reutilizando mais código.
E as desvantagens:
  • no caso da implementação com as classes (pré Java 8) devemos tomar cuidado com os modificadores de métodos para garantir o contrato da superclasse com os clientes;
  • por outro lado na implementação com interfaces (pós Java 8) os métodos não podem ser finais, o que não garante o comportamento do algoritmo;
  • com o uso de Default Methods deve-se ter cuidado com a herança múltipla;
  • após instanciar um algoritmo, não será possível alterar o passo da execução;

Finalizando

Apesar de parecer não haver muito ganho em utilizar a abordagem com o Java 8, é preciso estar atento a esses ganhos no contexto de sua aplicação, é como um jogo de estratégia onde o que vale é saber equilibrar as perdas e ganhos. Pode-se discutir que não seja adequado utilizar interface para a construção do Template Method, já que não é intenção do padrão deixar que as subclasses (ou implementações) consigam alterar o contrato de execução, mas se dentro do contexto da minha aplicação os benefícios de utilizar lambdas ou múltiplas interfaces superarem os problemas (ou eles sejam mitigados) por quê não usar?
Nesse post tive a intenção de justamente mostrar que os padrões não são soluções perfeitas, são boas soluções que devemos utilizar com cuidado, sempre observando as consequências.
Um forte abraço e até a próxima.

Código no Github

https://github.com/ivanqueiroz/padroes-projeto-java

Créditos

segunda-feira, 23 de janeiro de 2017

Tagged under:

JVM Links (#03)




Queria começar o JVM Links de hoje falando sobre a abertura das chamadas de trabalho para o NoSQL-BA, esse que vai ser o maior evento de NoSQL no nosso estado, já temos algumas comunidades apoiando o evento e aguardamos o envio da sua talk.

1. E o futuro do Java! – Hipsters #27

=> O Michael 'Mister M' Nascimento bateu um papo muito legal com a galera da Caelum/Alura
a respeito do futuro do Java. Se você curte Podcast esse episodio é um prato cheio para entender como as coisas acontecem por trás da cortina do Java.

2. Mesmo Que Você Seja Um Programador No Cargo, Seja Desenvolvedor Na Atitude...

=> Nem só de assuntos técnicos vive uma comunidade. O Antonio Lazaro (Popete)
fez um texto muito excelente no blog da comunidade sobre uma conversa que a gente em off falando um pouco
sobre perfil profissional, leitura 100% recomendada.

3. Revisando Padrões com Java 8: O Padrão Template Method

=> Lembra do Ivan Queiroz? Ele continua sua saga revisão padrões de projetos e abordando conceitos do Java 8. Não precisa ser um Expert para ler os textos do Ivan, a linguagem utilizada é bem simples recomendo leitura para aprender duas coisas ao mesmo tempo.

4. Comunidade, por onde começar?

=> Hoje estamos com um JVM Links com bastante coisa voltada para comunidade. O Ramon Mota
fez um excelente post falando a respeito da sua experiência de como foi começar a participar de uma comunidade, como a comunidade tem feito ele melhorar cada vez mais e de bônus tem bastante dica de como começar.

5. Combinando AngularJS com Java EE: aplicações clientes com a robustez do Java

=> E a gente continua olhando para aplicações RESTFULL, dessa vez a palestra fica por conta do Rodrigo Candido que é Especialista em Java e líder do Grupo de Usuários Java de SC. Nessa palestra O rodrigo busca mostrar como o  AngularJS tem atraído muita atenção dos desenvolvedores, e a maioria das aplicações utilizando esse framework precisam comunicar por meio de APIs web. Esta palestra abordará como construir uma aplicação em AngularJS utilizando tecnologias backend Java EE. Ao final você entenderá os benefícios do uso destas tecnologias, bem como padrões e boas práticas aplicadas nesse modelo de desenvolvimento.
Tagged under:

Mesmo que você seja um programador no cargo, seja desenvolvedor na atitude...

Recentemente, em um bate-papo com @Mateus Malaquias e @Ivan Queiroz estávamos conversando sobre perfis profissionais diversos que encontramos ao longo de nossa jornada, tanto nas empresas que trabalhamos, como nos encontros dos JUGs e outros eventos que participamos.

Uma dica que sempre passamos, principalmente nas universidades/faculdades para os futuros profissionais da área de desenvolvimento é sobre o perfil profissional esperado não apenas pelo mercado de trabalho, mas também pela comunidade. Como se destacar? Quais caraterísticas? Nisso, conversamos sobre escrever sobre um assunto que é um pouco polêmico, mas não irei entrar muito no escopo do tema. Os programadores devem ser simplesmente programadores ou devem fazer algo mais?

Não irei falar se fábrica de software é algo bom ou ruim. Principalmente nas fábricas existe um cargo chamado PROGRAMADOR. Em teoria, o programador é aquele profissional que lê uma especificação (normalmente definida por uma analista) e executa em linguagem de programação o que está especificado. O programador por ter "menos experiência" é um executor. Em alguns lugares, existem ferramentas cases que fazem parte do trabalho desse tipo profissional na construção de CRUD, Em outros não, mas o programador, ele apenas lê e executa. Pelo menos, isso é definido em teoria.

Um dos grandes problemas dos projetos de software tem a ver com comunicação. O desejo do cliente x expectativa x necessidade gera um problema clássico, cuja figura abaixo sintetiza de maneira perfeita o que estou tentando falar.


(Fonte: não consegui achar a fonte do autor dessa figura mas achei ela nesse link)

Então, qual seria o perfil que todos profissionais de TI deveriam ter. TI é uma ciência de natureza incerta e cuja solução envolve criatividade, conhecimento técnico, visão de negócio, dentre outras coisas. Na palestra que fiz sobre carreira nos Tour do Java Bahia ano passado, a mensagem para os estudantes é que se tornassem profissionais diferenciados (link para os slides da palestra). Um elemento básico que falamos, além de conhecimento e curiosidade, é que a pessoa, entenda o problema que ela precisa resolver. E participe do processo de decisão. Para isso, coragem é uma característica importante. Não ter medo de se expor, pois caso a sua solução não seja boa, você vai ouvir o feedback porque e vai aprender, caso seja boa, você vai evitar que o cliente final do software que você está construindo tenha menos problemas com a entrega, o que é super positivo.

Por isso, aconselhamos que as pessoas que trabalham com TI, sejam menos executoras e mais abrangentes. Mesmo que no seu crachá não esteja escrito analista, se exercite fazendo esse papel e veja se o que está especificado, está condizente com o cliente esperar receber. Para saber o que o cliente espera receber, é necessário entender o propósito do projeto.

Independente do que estiver escrito no seu crachá, dentro de seu conhecimento, seja sempre desenvolvedor e não apenas um programador que executa o que está escrito. Isso vai gerar crescimento profissional para você e com o tempo gerará ganhos para a empresa que você trabalha ou para o cliente que você atende. Nem sempre o cliente sabe o que ele quer, mas nós como analistas precisamos direcionar os mesmos para o melhor resultado possível.