Arquitetura de Software

Não Alimente Seus Paquidermes

~ Marco Mendes ~ Deixe um comentário

Com seu tamanho gigante, humor variável, vontade própria e dificuldades de serem domados, os paquidermes dominam o planeta terra.

Sim! É verdade.

Mas pare… não estou falando dos animais de quatro patas da ordem dos proboscídeos. Estou falando dos sistemas de informação monolíticos que assolam as organizações brasileiras.

Provavelmente você já deve ter visto algumas destas bestas. Elas podem ser reconhecidas pelas seguintes catacterísticas:

  • Bancos de dados com centenas de tabelas;
  • Centenas de telas e relatórios;
  • Repositórios de código com centenas de milhares de linhas de códigos
  • Linguagens arcaicas;
  • Enorme débito técnico;
  • Ausência de testes automatizados;
  • Baixo uso de práticas provadas de engenharia de software e DevOps.

Eles atendem por nomes como ERPs, MRP, CRMs, Portais e sistemas de informação com siglas que começam pela letra S. Na prática, estes produtos geram urgências em base semanal e tornam a vista dos seus gestores um inferno.

Para piorar a situação, muitos gestores e desenvolvedores continuam a alimentar estes paquidermes em base mensal. Eles constroem novos módulos nestes produtos. E devido ao seu tamanho e a ausência de testes automatizados, cada modificação tende a gerar efeitos colaterais que se manifestam em problemas que acontecem semanas ou meses depois da manutenção originalmente realizada.

A Lei dos Retornos Decrescentes dos Softwares

Na engenharia de software, quanto maior um sistema maior o custo de manter cada unidade deste sistema. Ou seja, se um sistema novo é duas vezes maior quem um sistema original base, ele provavelmente terá custado mais que duas vezes o custo do sistema base. E provavelemente o sistema novo terá uma complexidade ciclomática média maior que o sistema base e uma produtividade de manutenção muito ruim. Isso pode ser observado informalmente no repositório público de sistemas do SonarQube online. E para os mais céticos, recomendo a leitura dos artigos científicos publicados pelo brilhante cientista Capers Jones a respeito. Recomendo ainda o seu excelente livro de medição aplicada de software.

Em termos simples — Quanto maior o número de linhas, telas, funções e tabelas do seu sistema, pior será a sua densidade de defeitos e a complexidade ciclomática média. Mais medonho, mais feio e com maior chance de gerar problemas para você e o seu time no seu ambiente de produção.

Estrangule seus paquidermes… em 7 passos

Vamos lembrar que não estou falando dos animais de quatro patas com dentes de marfim ameaçados de extinção na África. Estou falando dos sistemas monolíticos gigantes e mal-humorados. E o padrão de estrangulamento (Strangler) já foi até documentado na literatura pelo profícuo autor Martin Fowler .

Aponto aqui algumas dicas para estrangular seus paquidermes:

  1. Comece a expor as funcionalidades existentes nos sistemas monolíticos legados através de APIs. Em linhas gerais, crie APIs que irão expor funcionalidades Cobol, PL-SQL, C, C# ou Java de uma forma governada. Devemos dar sobrevida a estes código, ao mesmo tempo que começamos a pavimentar um caminho paralelo. A respeito de APIs, apresentei algumas dicas de como iniciar a sua jornada nesse blog.
  2. Considere reduzir o tamanho dos seus novos sistemas. Mesmo que você tenha produtos de enorme porte para serem construídos, construa-os em módulos independentes e autônomos. Se possível, considere abordagem mais modernas de serviços como os microsserviços ou nanoserviços. Microsserviços são serviços autônomos com linhas de base de código reduzidas e que operam de forma autônoma com suas próprias bases de dados. Algumas das vantagens do uso deste estilo incluem:
  • Cada microsserviço é relativamente pequeno. Com isso o código é facilmente compreendido pelo desenvolvedor. A baixa quantidade de código não torna a IDE lenta, tornando os desenvolvedores mais produtivos. Além disso, cada serviço inicia muito mais rápido que uma grande aplicação monolítica. Isso torna os desenvolvedores mais produtivos e agiliza as implantações. A arquitetura de microsserviços facilita escalar o desenvolvimento. Pode-se organizar o esforço de desenvolvimento em vários times pequenos com o uso de métodos ágeis e práticas DevOps. Cada equipe é responsável pelo desenvolvimento e implantação de um único serviço ou um conjunto de serviços relacionados. E cada time pode desenvolver, implantar e escalar seus serviços, independente de todos os outros times.
  • Cada microsserviço pode ser implantado independentemente de outros serviços. Caso os desenvolvedores responsáveis por um serviço necessitem implantar uma modificação para um determinado serviço que não impacte a API deste serviço, não há necessidade de coordenação com outros desenvolvedores. Pode-se simplesmente implantar as modificações. A arquitetura de microsserviços torna viável a integração e a implantação contínua.
  • Além disso, cada microsserviço pode ser escalado de forma independente de outros serviços através da duplicação ou particionamento. Cada serviço pode ser implantado em um hardware mais adequado para as exigências de seus recursos. E tecnologias de contêineres como o Docker facilitam a gestão e isolamento de dependências tecnológicas.

3. Considere o uso de tecnologias mais simples e produtivas. Saem de cenas servidores de aplicação e Web pesados como IIS ou Websphere, ESBs, BPMS, o .NET Framework e até mesmo o Java EE full stack. Entram em cena tecnologias mais simples como .NET Core para C#, Spring Boot para Java, Node.JS e linguagens dinâmicas como Python e Javascript.

4. Melhore a maturidade de testes do seu time. Comece a automatizar testes funcionais e introduza suítes de testes de unidade nos seus novos produtos.

5. Comece a usar tecnologias de conteinerização para tomar contas dos seus novos produtos e dos paquidermes legados. Vagrant, Docker, Mesos, Kubernetes e o Rancher, entre outras tecnologias, são muito bem vindos neste novo jogo.

6. Faça benchmarking. Visite empresas na sua cidade ou estado que estão já usando esta abordagem. Aprenda com os seus erros e sucessos.

7. Tenha paciência. Você nao irá estrangular um paquiderme da TI em uma semana. Este processo tende a ser demorado e pode demorar meses ou anos. A Netflix, por exemplo, demorou aproximadamente 8 anos para migrar o seu extinto sistema paquidérmico para centenas de microsserviços que hoje dominam a sua operação em produção.

Não aumente mais a entropia da sua TI

Vamos lembrar que grandes sistemas tentem a aumentar a entropia na sua TI. E a entropia é danosa. Ela aumenta o passivo técnico, gera mais incidentes em produção e provoca efeitos sistêmicos graves em projetos como o tão comum padrão Firefighting.

Está declarada aberta a temporada de caça aos paquidermes da TI

O Gartner Group observa que, na média, empresas gastam 70% do seu orçamento de TI com atividades de sustentação. E os paquidermes infelizmente contribuem para este horroroso número. Sobra apenas 30% para atividades que ajudam a crescer e transformar o negócio. E isso ajuda a explicar o porque as áreas de negócio tem uma reputação tão ruim do nosso trabalho.

Considere se você quer manter a TI da sua empresa na média mundial de investimento ou avançar a maturidade com estrangulamento o abate dos paquidermes legados e a introdução de sistemas com arquiteturas de mais fácil construção e manutenção.

O Enxoval da Noiva do Node.JS

~ Marco Mendes ~ Deixe um comentário

Com o passar dos anos, a tecnologia Node.js já rivaliza com tecnologias tradicionais com como o ASP.NET, JSF, Ruby, PHP e Python em ambientes dinâmicos como startups e empresas de produtos Web. Mesmo empresas tradicionais no Brasil já tem começado a experimentar essa tecnologia bastante promissora.

Já apresentei aqui como fazer uma aplicação mínima em Node.JS, para aqueles que estão tendo o primeiro contato com essa tecnologia.

Ao mesmo tempo, algumas pessoas ainda perguntam: “É possível fazer em Node.JS uma aplicação com acesso a banco de dados com controle transacional, suporte a APIs REST, micro-serviços, com segurança forte,  tolerância a falhas e operação em cluster, entre outras preocupações técnicas corporativas?”.

A resposta, retumbante, é sim.

Para isso basta você acrescentar novos módulos ao node com o comando npm install -g <NomeModulo>. Isso é porque o Node.js vem pelado de fábrica e você deve incluir módulos conforme necessário. Essa abordagem minimalista, que permite criar ambientes Web muito leves, é um dos fatores de sucesso do Node.JS

Compilo aqui alguns módulos  que podem ajudá-lo na jornada do Node.JS e fazer aplicações cada vez melhores no mundo JavaScript.

  • ExpressJS[1] – Biblioteca para gerir requisições HTTP de forma facilitada a aplicativos móveis e Web.
  • LoopBack[2] [3] – Framework para a montagem rápida de aplicações Node. Esse framework conta com suporte da IBM e StrongLoop e tem ferramentas visuais para a geração de modelos, APIs Rest, scaffoldings e conectores com banco de dados.
  • Restify[4] – Módulo para facilitar a criação de web services REST.
  • PassportJS[5] – Biblioteca para autenticação de usuários em aplicações Node. Conta já com mais de 300 estratégias de autenticação como por exemplo OpenID, OAuth1, OAuth2 ou SAML.
  • Node-mysql[6] – Biblitoeca para acesso a aplicações MySQL com Node.
  • Node-OracleDB[7] – Driver mantido pela própria Oracle[8] para acesso aos banco de dados Oracle em aplicações Node.
  • Mssql[9] – Driver para acesso a banco de dados SQL Server em aplicações Node.
  • Mongoose[10] – Framework para manipulação do banco de dados Non-SQL MongoDB.
  • Azure[11] – Facilitador para implantação de aplicações Node em ambiente Microsoft Azure, mantido pela própria Microsoft.
  • Mocha[12] – Biblitoeca para testes de unidade para aplicações Node.
  • Pm2[13] – Gerenciamento de processo de produção para aplicações Node, com suporte a clusters, balanceamento de carga e tolerância a falhas.
  • NodeMon[14] – Biblioteca utilitária para facilitar a monitoração de mudanças no seu código fonte e recarregar automaticamente a sua aplicação Web.
  • Commander[15] – Módulo facilitador de execução de programas de linhas de comando em aplicações Node.
  • Nodemailer[16] – Biblioteca para a manipulação de emails em aplicações Node.
  • Request[17] – Biblioteca ainda mais simples que o Express para a manipulação de requisições HTTP.
  • Hapi[18] – Um outro framework HTTP para desenvolvimento de aplicações Web em Node.
  • Bluebird[19] – Biblioteca para facilitar a escrita de programas concorrentes, com suporte à primitiva de programação promise[20].
  • Async[21] – Módulo utilitário para fornecer funções de manipulação de código assíncrono em JavaScript.
  • stomp-client[22] – Módulo utilitário para clientes do protocol de fila de mensagens Stomp[23], suportado em implementações como o Apache ActiveMQ[24] e outros sistemas de filas de mensagem.
  • Numerals.JS[25] – Biblioteca utilitária para manipular e formatar números.
  • MomentJS[26] – Biblioteca utilitária para manipular datas.
  • ShouldJS[27] – Biblioteca utilitária para auxiliar a escrita de testes BDD em JavaScript.
  • Nock[28] – Biblioteca para criar mocks e simulações em testes de unidade JavaScript.

O portal do npmjs mantém uma lista  de pacotes populares JavaScript e pode ser usado como fonte de referência para acompanhar novidades da comunidade.  Para mais informações, veja aqui: https://www.npmjs.com/browse/star.

E você que já trabalha em Node.JS, que módulos Node.JS utiliza ou pretende utilizar para desenvolver aplicações Web JavaScript?  Complemente essa lista. 🙂

[1] http://expressjs.com/pt-br/

[2] http://loopback.io

[3] http://loopback.io/resources/#compare

[4] http://restify.com

[5] http://passportjs.org

[6] https://www.npmjs.com/package/node-mysql

[7] https://www.npmjs.com/package/oracledb

[8] http://www.oracle.com/technetwork/database/database-technologies/scripting-languages/node_js/index.html

[9] https://www.npmjs.com/package/mssql

[10] http://mongoosejs.com

[11] https://azure.microsoft.com/pt-br/develop/nodejs/

[12] http://mochajs.org

[13] http://pm2.keymetrics.io

[14] http://nodemon.io

[15] https://www.npmjs.com/package/commander

[16] https://www.npmjs.com/package/nodemailer

[17] https://www.npmjs.com/package/request

[18] http://hapijs.com

[19] http://bluebirdjs.com/docs/why-promises.html

[20] https://en.wikipedia.org/wiki/Futures_and_promises

[21] https://github.com/caolan/async/blob/v1.5.2/README.md

[22] https://www.npmjs.com/package/stomp-client

[23] http://stomp.github.io

[24] http://activemq.apache.org/stomp.html

[25] http://numeraljs.com/

[26] http://momentjs.com

[27] https://github.com/shouldjs/should.js

[28] https://github.com/node-nock/nock

 

 

Primeiros passos no Node.JS

~ Marco Mendes ~ 2 Comentários

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.
// Carga de modulos em Javascript. Aqui estou carregando o modulo HTTP, que dar
//suporte a requisicoes em protocolo HTTP
var http = require('http');
// Nesta linha eu crio um servidor Web, que irá ouvir requisições no porto 8080.
// Toda conexao a esse servidor será tratado por uma função criada pelo desenvolvedor.
// Esta funcao gera um cabeçalho HTTP 200 (OK) e então ecoa uma mensagem para
//o navegador que originou a requisição.
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Meu primeiro programa Node.JS!');
}).listen(8080);
// Nesta linha eu faço um log no console do servidor onde o Node.JS foi iniciado
console.log('Servidor rodando em http://localhost:8080/&#39;);
view raw AloMundo.js hosted with ❤ by GitHub


// Carga de modulos em Javascript. Aqui estou carregando o modulo HTTP, que dar
//suporte a requisicoes em protocolo HTTP
var http = require('http');
// Nesta linha eu crio um servidor Web, que irá ouvir requisições no porto 8080.
// Toda conexao a esse servidor será tratado por uma função criada pelo desenvolvedor.
// Esta funcao gera um cabeçalho HTTP 200 (OK) e então ecoa uma mensagem para
//o navegador que originou a requisição.
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Meu primeiro programa Node.JS!');
}).listen(8080);
// Nesta linha eu faço um log no console do servidor onde o Node.JS foi iniciado
console.log('Servidor rodando em http://localhost:8080/&#39;);

view raw

AloMundo.js

hosted with ❤ by GitHub

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. 
// Aplicacao minima Node.JS com MySQL
// Carrega modulos express em mysql
var express = require('express'),
mysql = require('mysql');
// Inicializa conexao com o banco de dados e servidor Web express
var connection = mysql.createConnection({
host : 'localhost',
user : 'root',
password : 'root'
});
var app = module.exports = express.createServer();
// Configura o banco de dados
connection.query('CREATE DATABASE IF NOT EXISTS test', function (err) {
if (err) throw err;
connection.query('USE test', function (err) {
if (err) throw err;
connection.query('CREATE TABLE IF NOT EXISTS users('
+ 'id INT NOT NULL AUTO_INCREMENT,'
+ 'PRIMARY KEY(id),'
+ 'name VARCHAR(30)'
+ ')', function (err) {
if (err) throw err;
});
});
});
// Configuracao da aplicacao
app.use(express.bodyParser());
// Requisicao / redireciona para o arquivo index.html
app.get('/', function(req, res) {
res.sendfile('index.html', { root: __dirname });
});
// Atualiza o banco de dados MySQL quando a rota /users for chamada.
// Ela é chamada como evento de submissao do formulario index.html
app.post('/users', function (req, res) {
connection.query('INSERT INTO users SET ?', req.body,
function (err, result) {
if (err) throw err;
res.send('Usuario adicionado ao banco de dados com ID: ' + result.insertId);
}
);
});
// Express Ouve na porta 3000
app.listen(3000);
console.log("Servidor express ouvindo no porto 3000", app.address().port, app.settings.env);
view raw AloMundoNodeMySQL.js hosted with ❤ by GitHub
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
<!doctype html>
<html>
<head>
<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script>
<script type="text/javascript">
$(document).ready(function () {
$('#user-submit').click(function () {
var payload = {
name: $('#user-name').val()
};
$.ajax({
url: "/users",
type: "POST",
contentType: "application/json",
processData: false,
data: JSON.stringify(payload),
complete: function (data) {
$('#output').html(data.responseText);
}
});
});
});
</script>
</head>
<body>
<h3>Entre o nome de um usuario que vai ser gravado no banco de dados MySQL:</h3>
<input id="user-name" type="text" />
<input id="user-submit" type="submit" />
<p id="output"></p>
</body>
</html>
view raw index.html hosted with ❤ by GitHub
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
{
"name": "AloMundoNodeMysql"
, "description": "Demonstração de como usar o Express e MySQL juntos"
, "author": "Modificado por *Seu nome*"
, "version": "0.0.1"
, "private": true
, "dependencies": {
"express": "~2.5",
"mysql": "~2.0"
}
}
view raw package.json hosted with ❤ by GitHub
 
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.

O aumento da eficiência de processos governamentais por meio da gestão por processos de negócio

~ Marco Mendes ~ 1 comentário

Tive a privilégio de ter publicado na Revista Fonte, da PRODEMGE, um artigo sobre o aumento da eficiência de processos governamentais. Disponibilizo abaixo o resumo do mesmo e uma entrada para o sítio onde o mesmo foi publicado.

Resumo

Neste artigo, discute-se o aumento da eficiência dos processos governamentais de suporte mediante a gestão por processos de negócio (Business Process Management – BPM) e apresenta os benefícios do uso de tecnologias como BPMS (Business Process Management Suite) na automação desses processos. A iniciativa do GRP Minas, Enterprise Resource Planning (ERP) governamental em desenvolvimento pela Prodemge, ilustra o empenho do governo de Minas na busca por melhoria de gestão por meio de um novo modelo de eficácia e eficiência que deve nortear a administração pública nos próximos anos.

Palavras-Chave: BPM. BPMS. Gerenciamento de processos de negócio. GRP. Eficiência.

Artigo completo aqui, nas páginas 82-91.

O design de interação e a usabilidade também são preocupações do arquiteto de software

~ Marco Mendes ~ Deixe um comentário

O design de interação é uma disciplina ainda imatura no brasil. Embora até tenhamos cursos lato-sensu na área, ela é ainda confundida injustamente com o desenho puramente estético de páginas Web, ela é muitas vezes ignorada por analistas e desenvolvedores no processo de construção de sistemas. Em muitas empresas, inclusive, é esperado que o Web Designer (que é um outro tipo de profissional) cuide de aspectos associado à usabilidade, acessibilidade e o design de interação.

O design de interação deve ser pensado como um aspecto econômico em sistemas de informação. Cito um exemplo real ocorrido em São Paulo, onde um projeto de refatoração de usabilidade foi realizado para permitir que os atendentes praticamente duplicassem a quantidade de transações de negócio efetuadas em um dia. Neste caso, não houve compras de máquinas adicionais nem refatorações de performance do sistema. Apenas o trabalho de usabilidade gerou maior assertividade na entrada de dados com redução de cliques e esforço dos usuários. Este aspecto da usabilidade, em particular, é chamado de eficiência operacional.

Arquitetos modernos devem se preocupar com aspectos de acessibilidade e usabilidade, dado que a usabilidade pode gerar trade-offs com outros requisitos técnicos como a segurança, desempenho ou escalabilidade.

Arquitetos devem capturar estes requisitos de forma quantitativa.

Exemplos incluem:

  • A acessibilidade das páginas do Web Site XPTO deve atender ao padrão WCAG no nível AA.
  • O tempo de resposta para interações em combos e lookups não deve exceder 1 segundo.
  • O sistema deve fornecer teclas de atalho e aceleradores para que as operações comuns do sistema sejam realizadas sem o uso de mouse.

Um contra-exemplo são os desejos ambíguos como “interfaces amigáveis” , naturais no vocabulário dos usuários. Requisitos objetivos e mensuráveis sempre devem ser capturados pelos arquitetos.

Após capturar os requisitos de forma quantitativa, os arquitetos podem então contar com os profissionais especializados para a implementação destes requisitos (engenheiros de usabilidade e desenvolvedores) e para os testes destes requisitos (analistas de testes).

Arquitetos são então a ponte. Eles ligam os desejos de negócio e os desejos econômicos e tornam estes desejos concretos em requisitos de usabilidades. Eles fazem a tradução destes requisitos para a linguagem dos engenheiros de usabilidade e desenvolvedores e acompanham os testes de usabilidade realizados pelos analistas de teste.

Para aprender mais sobre este assunto, arquitetos podem contar com questionários baseados em modelos com o FURPS+ ou a série ISO 25000. Para os iniciados em usabilidade, as perguntas e os testes podem ser organizadas ao longo dos seguinte temas:

  • Simplicidade. Contra-exemplos são telas que possuem campos raramente usados ou um número de grupos de campos excessivos que sobrecarregam a memória de curto prazo (STM) dos seus usuários.
  • Linguagem simples. Contra-exemplos são telas que apresentam erros de banco de dados (ORA600 ou java.lang.NullPointerException) para os seus usuários finais.
  • Minimização do uso de memória do usuário. Um contra-exemplo é um sítio de comércio eletrônico no Brasil (que não vou citar aqui por delicadeza) que requer que o usuário avance por 12 telas até que ele chegue no fim da compra.
  • Consistência. Contra-exemplo são sistemas onde existem diversas formas de fazer a mesma coisa ou que apresentam telas completamente diferentes com a mesma função. Bizarro!
  • Feedbacks. Contra-exemplo são sistemas que não fornecem retorno sobre ações do usuário. Bons exemplos são sites que mostram contextualmente  falhas na digitação de campos no local e no momento que acontecem. Bem vindo o AJAX.
  • Atalhos. Contra-exemplos são sistemas que obrigam o usuário a pegar o mouse para cada mínimo movimento necessário na tela.
  • Auxílio e documentação. Contra-exemplo são sistemas que não fornecem ajuda contextual ou ajuda on-line.
  • Prevenção de erros. Sistemas devem guiar o usuário de forma correta e evitar erros. Contra-exemplos são alguns sites bancários onde digitar um CNPJ parece ser um jogo para testar o seu estresse.

A técnica de provas de conceitos arquiteturais pode ser usada para trabalhar o tema usabilidade. Arquitetos modernos, como diz Grady Booch, devem pensar sistemas de forma holística e contribuir na sua plenitude para a construção de sistemas melhores e mais eficientes.

Don’t make me think”, Steve Krug, Don’t Make Me Think: A Common Sense Approach to Web Usability.

Como organizar uma prova de conceito arquitetural

~ Marco Mendes ~ 2 Comentários

O termo prova de conceito (POC) em arquiteturas de software e dados tem se tornado muito popular. Provas de conceito são instrumentos de mitigação de riscos técnicos, criação de arquiteturas executáveis e podem servir a vários propósitos gerenciais em um projeto. Apresentamos abaixo um modelo mental para guiar arquitetos na escolha e organização de uma prova de conceito. O nosso modelo é baseado em seis questões de análise

1. Que requisitos e cenários são candidatos a uma prova de conceito?

Observe a figura abaixo, que mostra os tipos de requisitos típicos de um sistema. Como exemplo, se considerarmos um site de comércio eletrônico veremos que os cenários de negócio ligados à venda de produtos e que fazem comunicações com sistemas de processamento de pagamento diversos são críticos para o negócio e ao mesmo tempo desafiantes tecnicamente em termos do tempo de reposta, disponibilidade, escalabilidade e vazão.

Tipos de Requisitos em projetos de software.
Tipos de Requisitos em projetos de software.

Os requisitos do quadrante 1 são aqueles que devem ser investigados pelo arquiteto e que normalmente derivam provas de conceito.

2. Quantas provas de conceito devo ter?

O número de provas de conceito é proporcional ao grau de risco de um projeto e portanto não é um número pré-determinado. Como regra geral, o número de provas de conceito deve tornar o risco técnico do projeto baixo e administrável ao longo do seu ciclo de vida.

3. O que uma prova de conceito irá explorar?

Provas de conceito normalmente exploram dois aspectos (estruturas ou comportamentos).

Provas de conceito que exploram estruturas normalmente são usadas para compararmos ou selecionarmos tecnologias, determinar viabilidade tecnológica de uma pilha tecnológica ou mesmo a descoberta de uma melhor prática técnica (ex. JEE ECB ou ASP.NET MVC). Provas de conceito que exploram comportamentos normalmente querem explorar algum caso de uso, história do usuário ou cenário de negócio potencialmente complexo em um sistema.

4. O que uma prova de conceito irá produzir?

A figura abaixo fornece tipos comuns de provas de conceito, que podem ir desde uma leitura de um artigo, passando por uma simulação simples de uma solução e até mesmo um protótipo evolutivo. Como regra geral, quanto maior o risco, mais densa tende a ser uma prova de conceito.

Tipos de provas de conceito

O conjunto dos produtos resultantes das provas de conceito de um produto é chamdo de arquitetura executável, composta por modelos, artigos, rascunhos, códigos descartávels ou mesmo códigos evolutivos.

5. Quando devo fazer as provas de conceito?

Use a regra do terço. No primeiro 1/3 de um projeto você deve ter todas as provas de conceito de um projeto finalizadas de forma a acomodar riscos e determinar a arquitetura executável do seu sistema.

6. Como encaixar as provas de conceito no processo de software da minha empresa?

  • Se você usa métodos ágeis, mescle provas de conceito ao longo dos primeiros sprints de um projeto. Se possível, crie o conceito do Sprint 0 dedicada apenas ao tema prova de conceito.
  • Se você usa o processo unificado (IBM RUP, Enterprise Unified Process, Open-UP, Essential UP ou similar), a fase de elaboração foi criada para lidar com provas de conceito.

Extraordinary claims require extraordinary evidence – Carl Sagan

Tendências de Arquitetura de Software para 2014

~ Marco Mendes ~ Deixe um comentário

2014 é o primeiro ano onde o número de dispositivos mobile irá ultrapassar o número de dispositivos tradicionais (desktops), em análise recente realizada pelo Gartner Group. Esta mudança tem sido impulsionada por fatores econômicos como a redução dos preços de celulares e tables e também por aspectos culturais como o Bring Your Own Device (BYOD), Bring Your Own Appliance (BYOA) e a Internet das Coisas.

Para quem trabalha com arquitetura, estas e outras novidades trazem novos desafios para os arquitetos. Destaco alguns destes desafios em 5 tendências de arquitetura de software.

  1. Arquiteturas Móveis Corporativas

Muitos técnicos, ao pensar em aplicações móveis, pensam que o problema está apenas localizado no lado cliente, nas aplicações que rodam Android e iOS. Em verdade, a maioria das aplicações móveis faz comunicações com servidores e portanto é crítico e complexo a correta montagem arquitetural da camada servidora para lidar com aspectos como a gerência de estado offline da aplicação, sincronização de dados cliente e dados do servidor, picos de escalabilidade e renderização em múltiplos dispositivos. Este tipo de arquétipo tem sido chamado de MADM (Mobile Application Development Platform) e é um tema cada vez mais presente na realidade das grandes empresas.

2. HTML5 como linguagem multi-dispositivo

O HTML 5 ganha força e tende a se tornar uma linguagem padrão para a renderização Web e também para a renderização iOS,  Android e Windows Phone. Esta tendência, hoje implementada por diversos frameworks Web/Mobile de mercado, tem suas motivações no alto custo da geração de aplicações nativas em diversos dispositivos e uma ausência de dominância clara do mercado de dispositivos móveis por um único fornecedor.

3. A chegada dos “Arquitetos das Nuvens“

A virtualização já e um fato estabelecido na indústria de TI Brasileira e a tendência da computação nas nuvens ganha força a cada dia. Compreender, escolher e arquitetar os diversos tipos de plataformas de nuvens tem se tornado um desafio formidável. Exemplos incluem o IAAS, PAAS, SAAS, DAAS, NAAS, XAAS, nuvens públicas, nuvens privadas, nuvens híbridas, nuvens pessoais, entre outros sabores de nuvens.

A necessidade de profissionais que consigam pensar apropriadamente o uso da computação nas nuvens é cada vez mais requisitado nas empresas de médio e grande porte do Brasil.

4. Arquiteturas Sensíveis ao Contexto

A Internet das Coisas liga pessoas, coisas, informações e lugares em um modelo único de valor aos seres humanos. Um exemplo futurístico pode ser visto no filme Minority Report (no ano 2053). Exemplos Reais do seu dia a dia em 2014 podem ser visto no uso do Waze para vencer o trânsito caótico das cidades, nas plataformas inteligentes da Akamai para otimizar o tráfego de dados sobre os principais backbones da Internet ou mesmo nos Smart Grids em modernas redes de distribuição de energia elétrica.

As arquiteturas sensíveis ao contexto, que podem ser observadas nos níveis mais avançados do modelo OSIMM (Open Group Service Integration Maturity Model), são arquiteturas que ligam hardware, dados e tecnologias através de conceitos avançados como iBPMS, SOA 2.0, BRMS, CEP e Analytics.

5. A proliferação de tecnologias para construir aplicações corporativas

De 1997 a 2010, o mercado de TI esteve relativamente fixado nas linguagens Java e C#, com alguns grupos de TI trabalhando em linguagens dinâmicas como PHP, Ruby e similares.

Nesta década, temos visto uma proliferação de tecnologias, como por exemplo Ruby on Rails, Sinatra, Node.JS, F#, Scala, Objective C, Erlang, Java para Android, entre outras. É uma nova era da diversidade tecnológica, onde os desenvolvedores ganham liberdade para escolher as tecnologias mais apropriadas à realidade da sua empresa.