Primeiros passos no Node.JS

Conceitos – O que é o Node.JS

O Node.JS é uma plataforma leve para você construir aplicações servidoras em linguagem Javascript e pode ser comparado, em um primeiro momento de análise, a tecnologias como o Java EE Web ou ASP.NET. Ao mesmo tempo,  Node.JS é uma tecnologia minimalista. Ele é muito leve e não traz consigo servidores Web ou servidores de aplicação pesados, como o Java EE Web ou o ASP.NET. No Node.JS, você começa leve e coloca novos módulos apenas quando necessário.

O JavaScript no lado do servidor pode ser um conceito novo para todos que trabalharam exclusivamente com o JavaScript no lado do cliente, mas a idéia em sí não é tão absurda – porque não usar a mesma linguagem de programação no cliente que você usa no servidor?

Em nível detalhado, o Node.js é uma plataforma construída sobre o motor JavaScript do Google Chrome para construir aplicações de Internet rápidas e com excelente escalabilidade. O motor JavaScript V8 é o motor que a Google usa com seu navegador Chrome.  A engine JavaScript do Chrome realmente interpreta o código JavaScript e o executa. Com o V8 a Google criou um interpretador ultra-rápido  escrito em C++.

O Node.js usa um modelo de I/O direcionada a eventos assíncronos que o torna leve e eficiente, ideal para aplicações em tempo quase real com troca intensa de dados através de dispositivos distribuídos. Em termos arquiteturais, o Node é um servidor de programas e roda sobre um pequeno motor  JavaScript.

A figura abaixo representa a arquitetura minimalista do Node.JS

Pré-Requisitos para este tutorial:

  •   Node/NPM (Instalado via pacote de instalação em https://nodejs.org/en/download/)
  •  yo, gulp e bower (instalado via linha de comando via o comando: npm install -g yo gulp bower)
  • Notas: Este laboratório foi testado com o Node.JS 5.7 e 3.6 em ambiente OS/X e Windows 
Um AloMundo Node.js
Iremos usar o editor VisualStudio.Code, produto recente da Microsoft que a manipulação de projetos em Node.js, ASP.NET, C#, entre outras linguagens. Mas você pode usar qualquer outro editor, como Atom, WebStorm, entre outros.

 

1. Abra o seu editor e digite o código abaixo.

Salve o seu arquivo com o nome AloMundo.js

 

2. Abra um terminal na linha de comando e vá para o diretório onde o arquivo .JS foi salvo. Depois digite o comando: node AloMundo.js
Examine o console, que deve exibir a seguinte mensagem:
D98E13A0-0514-4FFE-8FF9-760340AE2619.png

 

3. O seu servidor Node.JS já está rodando.Abra um navegador e digite http://localhost:8080. Você deve observar a mensagem abaixo.
F1624E19-DDF2-46D7-B37D-88450F1C0A96.png

 

4. Desligue o servidor, interrompendo o programa da linha de comando. [CTRL+C no Windows]
Geração de uma Aplicação Mínima Funcional em Node.JS

 

5. Uma aplicação Node.JS tem uma estruturação mínima recomendada. 

 

6. Primeiro vamos instalar o gerador de aplicações Node.js/Express. Para isso iremos digitar na linha de comando:
npm install -g express-generator
 
Esta linha roda um utilitário chamado npm (node package manager), que instala um módulos Node.JS. Nesse caso estamos instalando um módulo HTTP mais potente chamado Express, que facilita muito o desenvolvimento de aplicações Web. A opção -g instala esse módulo globalmente.
Nota: Em ambientes Linux/MAC, talvez você precise rodar esta linha de comando em modo administrador.
(sudo npm install -g express-generator)
Depois de um tempo de download do módulo pela Internet, você deve as seguintes mensagens, que indicam uma execução bem sucedida.
53CBFACD-9BB5-45EC-B492-993FE3E1643E.png
 

 

7. Para criar uma nova aplicação basta digitar então o comando: express <NomeAplicacao>.
No nosso caso iremos digitar express AloMundoRobusto
 
Este comando irá criar uma estrutura mínima de pacotes e arquivos, similar à da figura abaixo:
9851343D-AC35-4837-B515-8D66DE21FE80.png

 

8. Nesse ponto, precisamos instalar as dependências desta aplicação gerada. Para isso entre dentro do diretório e digite npm install.
Este comando irá baixar e instalar as dependências desta aplicação.

 

9. Agora abra a pasta raiz pelo Visual Studio Code. (use a opção File->Open e escolha a pasta gerada pelo comando express)
Você deve ver a seguinte estrutura:
8B92C231-0885-4BCA-8FDE-073DAF7C954E.png

 

10. Agora iremos executar essa aplicação com o comando: npm start. 
Este comando acima simplesmente tenta chamar um script chamado start no arquivo package.json. Nesse arquivo existe um Script que dispara o comando node com o arquivo javascript chamado www. Em outras palavras, ele simplesmente chama: node www.
A000E120-1AF0-4C5A-A51E-A41CA73818FB.png
Esse arquivo irá colocar um servidor na porta 3000, que pode ser examinado no seu navegador.
563A7C28-E90E-4A46-A2C7-BDBE2F56DB4A.png

 

11. Finalmente, examine as mensagens exibidas pelo console da aplicação, para cada requisição.
 
21162216-10CC-4B13-91DA-4D649C500674.png

 

12. Finalize o servidor na linha de comando [CTRL+C]
 
Depuração da Aplicação no Visual Studio Code
 

 

13. O VS Code permite a depuração de código Node.JS. Para isso, escolha uma linha de código específica e clique do lado esquerdo da linha. Por exemplo, marque a linha 6 do código index.js, que responde a entrada do site (recurso raiz / )
 
F6419E8A-52CC-4214-81A1-1831F67A0251.png
 
Um botão vermelho irá ser marcado, que indica que o depurador está habilitado.

 

14. Em seguida, clique na botão do depurador (símbolo do inseto) e então no botão de PLAY (verde). 
Veja que assim que você chamada a URL pelo seu navegador ele irá parar a execução e exibir uma janela similar à mostrada abaixo.
364F997B-6A00-4394-A1D6-3A3C26B33CEF.png
Interaja livremente com o ambiente de depuração, similar a de ambientes tradicionais de desenvolvimento (Eclipse, Delphi ou Visual Studio).
Uma Aplicação Completa Node, com Serviços REST e Banco de Dados MySQL
15. Crie um diretório e abra esse diretório com o utilitário VS Code. 

 

16. Crie um novo arquivo chamado app.js e insira nele o seguinte código. 
Este arquivo é o ponto de entrada da aplicação e será chamado para inicializar a aplicação.
 

 

17. Crie um arquivo chamado index.html e insira o seguinte código nele
Este arquivo irá exibir um formulário para que você possa entrar o nome do usuário. Esta informação será depois gravada em banco de dados.
 

 

18. Crie um arquivo chamado package.json e insira nela o seguinte código
 
19. Atualize as dependências dessa aplicação.

 

Para isso rode o comando npm install dentro do diretório onde os arquivos foram criados.
 
20. Rode essa aplicação pela linha de comando (node app.js). Opcionalmente você pode rodá-la pelo ambiente do VS Code, conforme mostrado anteriormente nesse tutorial.

Para saber mais
Acompanhe o sítio principal do Node.js (https://nodejs.org/en/).
Alguns livros sobre o tema incluem:
E você? Já começou a trabalhar com o Node.js? Compartilhe aqui as suas experiências aqui.

Maturidade 5 em Métodos Ágeis – Em busca da Anti-Fragilidade

Neste último artigo sobre um modelo de maturidade em métodos ágeis, iremos descrever como reduzir a fragilidade organizacional.

A figura abaixo mostra um esquema com níveis de maturidade organizacional em métodos ágeis, ao longo das perspectivas de times, ritos, entregas e qualidade. O nível 1 mostra uma organização mais frágil. Os níveis intermediários e avançados mostram organizações que não são mais frágeis.

 

ModeloMaturidadeMetodosAgeisv2
Melhoria contínua em métodos ágeis [Imagem maior]

A fragilidade organizacional é aqui definida aqui como aquele tipo de organização onde os eventos negativos provocam efeitos devastadores.

Um exemplo – A Anti-Fragilidade para Times

Um exemplo de fragilidade é uma organização que tenha um time baseado no modelo comando e controle. Neste modelo, existe a figura de um gerente forte e subordinados que cumprem comandos, com baixa interação entre si. Este modelo é frágil, pois pode ser abalado por várias questões tais como:

  • Uma provável baixa capacidade do gerente de lidar com todos os problemas do dia a dia;
  • Uma baixa capacidade de aprendizado dos comandados devido a sua baixa comunicação (não é tão comum encontrar pessoas que aprendam sozinhas);
  • Uma baixíssima resiliência a qualquer evento que afete o gerente (ausências no dia a dia ou faltas ao trabalho);
  • Um provável colapso do time quando esse gerente deixa a organização.

Ao reconhecer a fragilidade em um time, uma organização pode introduzir mecanismos de resiliência. Ao fazer isso, por exemplo, com mais autonomia para as pessoas, delegação administrativa  e maior comunicação interna, estaremos avançado para um time robusto.

Definimos robustez organizacional aqui como a capacidade de resistir a eventos negativos, que ocorrem em todas organização. No exemplo acima teríamos então a figura forte de um gerente, ao mesmo tempo com mais autonomia e comunicação entre os liderados. Nesse modelo robusto, o time consegue trabalhar sem o gerente e até suportar a sua perda, pois possuem autonomia e se comunicam com frequência.

A robustez parece o objetivo desejável, mas ela não é o contrário da fragilidade. Se a fragilidade fosse um número negativo, a robustez seria o número zero. Isto é, na robustez apenas lidamos com os eventos negativos, mas não geramos oportunidades de ganhos positivos nas incertezas. Times robustos, ao invés, apenas restauram o estado inicial após um incidente negativo.

E aqui entra o conceito da anti-fragilidade. Quando uma organização avança além da robustez, ela se torna anti-frágil. A anti-fragilidade é definida aqui como a resiliência para lidar com eventos negativos e ao mesmo tempo explorar oportunisticamente os eventos negativos e positivos. A anti-fragilidade é o contrário da fragilidade, i.e., é o tipo de organismo que se torna mais forte após as adversidades.

No exemplo de times, definimos então um time anti-frágil como um time auto-organizado.

  • Em times auto-organizados, não existem “gerentes” no sentido clássico. Existem líderes facilitadores que preparam o terreno para o time atuar e fazer o seu melhor coletivamente.
  • Aqui eles organizam as suas tarefas, resolvem os seus conflitos e periodicamente discutem o que funcionou e o que precisa ser aperfeiçoado. Aquilo que não funcionou irá gerar uma agenda de melhoria, que irá fortalecer esse time.
  • Em times auto-organizados, análises de causa raiz são realizadas para lidar com a fonte dos problemas, evitando erros similares futuros e portanto os tornando mais anti-frágeis.
  • Times auto-organizados são generalistas-especialistas e portanto redundantes a absenteísmos e rotatitivades (até um certo ponto). A redundância é uma das propridades desejadas em sistemas anti-frágeis.
  • Finalmente, time auto-organizados promovem e resolvem conflitos através de uma cultura permanente de feedbacks estruturados. Isso limpa arestas, problemas de relacionamento e cria extrema confiança entre os participantes.

Frameworks gerencias modernos como o Management 3.0  ou a Holocracia tem promovido a formação de times auto-organizados (e mais anti-frágeis que os tradicionais times de mercado). O  caso Zappos, que citamos em um post anterior dessa série, é um exemplo emblemático do uso da holocracia em uma empresa que fatura mais de 1 bilhão de dólares por ano.

Um outro exemplo – A Anti-Fragilidade para a Qualidade de Produtos

Um exemplo de qualidade frágil é um time de desenvolvimento de software que entrega produtos em produção com muitos defeitos e por isso tem boa parte da sua agenda ocupada com incidentes críticos no ambiente de produção.

Ao mesmo tempo, se esse time reconhecer a fragilidade, criar uma consciência de testes e começar a trabalhar em pequenos instrumentos como refatoração, testes de unidade e TDD, essa mesma organização pode avançar do mundo da fragilidade para a robustez.

Uma organização robusta para testes e qualidade parece apropriada, mas ela simplesmente tolera até certo nível os riscos negativos que ocorrem no desenvolvimento e manutenção dos seus produtos. No exemplo de qualidade acima, ela é aquela que escreve testes e os automatiza para lidar com a imprevisibilidade ambiental, que sempre irá acontecer. (exemplo: hardwares ou banco de dados sempre falharão em algum momento). Ao mesmo tempo, a robustez não cria inovação e não usa as oportunidades positivas que também se apresentam (assim como as negativas).

Nesse mesmo exemplo de qualidade, um time pode perceber que as práticas de testes podem ser tão poderosas que podem ser usadas para:

  • provocar falhas rapidamente no ambiente com automação de testes (CI/CD) – gerar erros pequenos no começo do produto é benigno e anti-frágil;
  • trabalhar a especificação de requisitos em uma abordagem BDD (Behavior Driven Development). Com o BDD, analistas exploram narrativas de negócio na forma de teste desde o começo do desenvolvimento do produto, reduzindo assim o custo total do desenvolvimento de software e ao mesmo capturando problemas que somente seriam descobertos mais tarde no projeto;
  • realizar testes de situações anômalas, como provocar deliberamente a falha de componentes e observar o comportamento do sistema (um exemplo ótimo nesse sentido é o aplicativo CodeMonkey do NetFlix, que derruba aleatoriamente servidores em produção para descobrir e antecipar problemas. Sim, ambiente de produção!);
  • introduzir tolerância a falhas e elasticidade computacional nos seus ambientes de produção, para aproveitar as oportunidades de picos de usuários em eventos futuros incertos.

 

Da fragilidade para a robustez. E da robustez para a anti-fragilidade

A melhoria contínua é o processo contínuo que levou organizações sem maturidade a estágios mais avançados. Mesmo nas organizações mais avançadas quanto ao uso de métodos ágeis, a melhoria contínua é o instrumento que as levam a manter as suas conquistas e buscar ainda mais aprimoramentos.

A melhoria contínua é a mola mestra para sair da fragilidade e avançar para a robustez e anti-fragilidade. Ela envolve sistematizar:

  • a observação ambientel dos eventos (positivos e negativos);
  • o debate regular sobre os acontecimentos positivos e como eles podem ser mantidos no sistema;
  • o debate regular sobre os acontecimentos negativos e como eles podem ser eliminados ou mitigados através de ações de melhoria no sistema.

Se um time realiza este “ritual” periodicamente, ele avança de forma contínua e em breve começa a eliminar as suas fragilidades, uma a uma.

Se pudesse recomendar uma prática inicial para qualquer time que queira se tornar ágil, esta prática seria a retrospectiva Scrum ou o ritual Kaizen em métodos Lean.

A Toyota é um excelente exemplo de como a aplicação sistemática de pequenas melhorias, de forma contínua, pode trazer grandes resultados em longo prazo. De forma geral, a Toyota é reconhecida por produzir carros com maior qualidade, menos defeitos embutidos,  menos horas de pessoas, estoques e plantas menores no processo produtivo do que os seus concorrentes. O livro Toyota Way mostra como essa cultura gerencial fantástica foi trabalhada passo a passo.

Sobre Anti-Fragilidade

É um conceito cunhado por Nicholas Taleb e inicialmente sistematizado na história humana na filosofia estóica (Sêneca, Marcus Aurelius e Epícuro). Um artigo introdutório e interessante sobre o tema pode ser encontrado no artigo Beyond Sissy Resilience: On Becoming Antifragile, que apresenta uma bela figura metafórica sobre o conceito.

antifragile-3

 

Antifragility is beyond resilience or robustness. The resilient resists shocks and stays the same; the antifragile gets better ― Nassim Nicholas TalebAntifragile: Things That Gain from Disorder