Aprenda a criar diagramas simples e eficientes para projetos de software

Se você já precisou criar diagramas para representar fluxos, arquiteturas ou conceitos e achou ferramentas visuais muito trabalhosas, o PlantUML pode ser a solução. Ele permite que você crie diagramas profissionais de maneira rápida e simples, utilizando apenas texto. Neste artigo, vamos explorar o que é o PlantUML, para que ele serve, como instalar seu servidor no Docker e exemplos práticos de uso.

O PlantUML é uma ferramenta de código aberto que transforma texto em diagramas. Criado para desenvolvedores e arquitetos de software, ele suporta diversos tipos de diagramas, como:

• Diagramas de Classes
• Diagramas de Sequência
• Diagramas de Casos de Uso
• Diagramas de Componentes
• Diagramas de Atividades
• E muito mais.

A grande vantagem do PlantUML é a sua simplicidade: basta escrever o diagrama em texto utilizando uma sintaxe própria e a ferramenta gera automaticamente uma imagem visual. Isso o torna ideal para automatização e documentação de projetos em pipelines DevOps.

Para que serve?

O PlantUML é amplamente utilizado para:

• Documentação de projetos:

Crie diagramas que acompanham o código de forma simples e rápida.

• Comunicação em equipe:

Expresse ideias complexas com diagramas claros e padronizados.

• Automação em pipelines CI/CD:

Gere diagramas como parte de builds automatizados.

• Educação:

Ideal para ensinar conceitos de arquitetura, design patterns e modelagem de sistemas.

Instalando o PlantUML Server com Docker

O PlantUML Server é uma aplicação que permite gerar diagramas remotamente via HTTP. Ele é leve, rápido e ideal para integração com outras ferramentas.

Pré-requisitos

Docker instalado no seu sistema operacional.

Passos de Instalação

Faça o download da imagem oficial do PlantUML Server, conforme segue:

docker pull plantuml/plantuml-server

Inicie o container do PlantUML Server:

docker run -d -p 8080:8080 --name plantuml-docker plantuml/plantuml-server

Digite docker ps para verificar se o PlantUML-Server foi inicializado no container Docker

Acesse no navegador http://localhost:8080 irá aparecer o editor no lado esquerdo com um exemplo de diagram e no lado esquerdo o resultado como imagem, pode escolher PNG, SVG, ASCII, PDF

Exemplo de Uso do PlantUML

Diagrama de Classes

Escreva o seguinte código no editor no lado esquerdo:

@startuml
class Pessoa {
  +nome: String
  +idade: int
  +andar(): void
}

class Funcionario {
  +salario: double
  +trabalhar(): void
}

Pessoa <|-- Funcionario
@enduml

Resultado

Este código gera um diagrama mostrando a hierarquia entre as classes Pessoa e Funcionario, com Funcionario herdando de Pessoa.

Parar e iniciar o PlantUML-Server no Docker

Considerando que utilizou o nome do container de plantuml-docker, definido no comando anterior definido no argumento --name que foi plantuml-docker

docker stop plantuml-docker

docker start plantuml-docker

Recursos Adicionais

• Extensões IDE:

O PlantUML possui plugins para IntelliJ, Visual Studio Code, Eclipse e outros.

• Integração com Wikis:

Use o PlantUML com ferramentas como Confluence ou GitLab para documentar projetos.

• Suporte a Temas:

Personalize seus diagramas com temas para uma aparência mais profissional.

Considerações finais

O PlantUML é uma ferramenta poderosa para desenvolvedores que buscam eficiência na criação de diagramas. Sua abordagem baseada em texto, integração com ferramentas modernas e a possibilidade de usar um servidor Docker tornam o PlantUML uma solução flexível e produtiva. Comece a usar hoje e revolucione a forma como você cria e mantém diagramas em seus projetos.

Referências

https://plantuml.com/

Feito!

Como evitar desentendimentos entre desenvolvedores e clientes em projetos de software

Um dos maiores desafios em projetos de software é alinhar as expectativas entre desenvolvedores e clientes. Muitas vezes, um cliente explica os requisitos de forma vaga ou subjetiva, o que pode gerar interpretações diferentes. Isso resulta em situações frustrantes, como o cliente dizer: "Não foi isso que pedi." Contudo, o que realmente aconteceu é que o desenvolvedor interpretou a solicitação conforme foi apresentada, o que pode ser muito diferente da visão ideal do cliente.

Essa lacuna de entendimento pode ser evitada com uma comunicação mais clara e estruturada. A seguir, apresento algumas práticas essenciais para minimizar esses problemas, com base das minhas experiências como Analista Desenvolvedor.

1. Documente tudo

Registrar as conversas e requisitos discutidos com o cliente é fundamental. Seja em reuniões presenciais, chamadas de vídeo ou trocas de mensagens, tudo deve ser documentado:

Quais funcionalidades foram solicitadas?

Quais são as prioridades?

Quais entregáveis estão previstos?

Uma documentação clara não só serve como guia para o desenvolvimento, mas também protege o desenvolvedor de interpretações equivocadas no futuro.

2. Confirme o entendimento

Antes de iniciar o desenvolvimento, compartilhe com o cliente uma versão consolidada dos requisitos:

Utilize diagramas, wireframes ou fluxos simples para ilustrar a ideia.

Explique, em termos claros, como o sistema atenderá às solicitações.

Esse retorno ajuda a corrigir possíveis mal-entendidos antes que eles afetem o projeto.

3. Use contratos e escopo detalhado

Inclua no contrato:

Detalhes do que será entregue.

Limitações do escopo.

Como mudanças futuras serão tratadas.

Se o cliente solicitar algo fora do escopo acordado, o desenvolvedor pode se referir ao contrato e renegociar os termos de forma justa.

4. Adote ferramentas de gestão de requisitos

Ferramentas como Trello, Notion ou Google Sheets podem ajudar no acompanhamento e aprovação de tarefas. Use-as para:

Criar listas de requisitos com status (pendente, em andamento, concluído).

Associar comentários ou anexos com detalhes relevantes.

Registrar aprovações formais do cliente.

5. Mantenha comunicação constante

Agende reuniões regulares para apresentar o progresso e validar os entregáveis. Essa prática permite ao cliente acompanhar a evolução do projeto e ajustar o que for necessário antes da entrega final.

Considerações finais

A chave para evitar desentendimentos em projetos de software está na comunicação e na documentação. Como desenvolvedor, você deve assumir um papel ativo em detalhar e validar os requisitos, enquanto o cliente precisa colaborar fornecendo informações claras e específicas.

Com essas práticas, você cria um ambiente de trabalho mais eficiente, reduz frustrações e aumenta as chances de sucesso no projeto. Afinal, um projeto bem documentado é um projeto mais tranquilo para ambas as partes.

Gostou desse conteúdo? Compartilhe o link desta postagem com seus amigos desenvolvedores ou nos grupos de desenvolvedores que você participa! Sua experiência com a comunicação em projetos de software também é muito bem-vinda nos comentários.

Feito!

Compartilhando commits sem ter acesso ao repositório remoto

Em projetos colaborativos, pode surgir a necessidade de compartilhar commits com outros desenvolvedores que não têm acesso direto ao repositório remoto. Nesse caso, o Git oferece duas ferramentas: git format-patch e git am. Neste artigo, vamos explicar como essas ferramentas funcionam, como usá-las e por que elas são úteis.

O que é git format-patch?

O comando git format-patch é usado para gerar um ou mais arquivos contendo as alterações realizadas em um ou mais commits. Esses arquivos, chamados de patches, podem ser enviados para outro desenvolvedor, permitindo que ele aplique as mesmas alterações no repositório local.

Fluxo de Uso: git format-patch e git am

1. Gerar o arquivo de patch

No repositório original, você pode gerar um patch a partir de um commit específico ou de uma sequência de commits. O comando básico é:

git format-patch <hash-do-commit>

Aqui, <hash-do-commit> é o hash do commit anterior às alterações que você quer compartilhar. O Git cria arquivos .patch contendo as mudanças realizadas nos commits seguintes. Por exemplo:

0001-Adiciona-nova-feature.patch

Se houver mais de um commit após o , um arquivo será criado para cada commit.

2. Enviar o patch

Os arquivos gerados podem ser enviados para o destinatário por e-mail, mensageiros ou qualquer outro meio. Esses arquivos contêm todas as informações necessárias, como alterações de código, mensagens de commit e autoria.

3. Aplicar o patch no repositório de destino

O desenvolvedor que recebeu o patch pode aplicá-lo no repositório local usando o comando git am. É aqui que entra o redirecionamento de leitura <, indicando que o comando deve processar o arquivo fornecido.

O comando para aplicar o patch é:

git am < arquivo-gerado.patch

Isso adiciona o commit ao histórico do repositório, preservando todas as informações originais, como autoria e mensagem do commit.

Vantagens de usar git format-patch e git am

• Colaboração Offline:

Ideal quando o repositório remoto não está acessível ou quando o colaborador não tem acesso direto.

• Preservação do histórico:

Os commits aplicados mantêm mensagens, autoria e datas originais.

• Flexibilidade:

Facilita revisões e contribuições em projetos abertos.

Considerações finais

O uso de git format-patch e git am é uma maneira eficaz de compartilhar alterações sem depender de um repositório remoto. Esses comandos são especialmente úteis em projetos open source, revisões offline ou quando o acesso direto ao repositório é limitado.

Agora que você sabe como utilizá-los, experimente aplicar esses conceitos no seu fluxo de trabalho e otimize a colaboração com outros desenvolvedores.

Feito!

Ambiente Docker online e gratuito para testes de containers

O Docker revolucionou a forma como criamos, distribuímos e executamos aplicações. Mas nem sempre temos um ambiente configurado para experimentar ou aprender sobre essa tecnologia poderosa. É aqui que o Play With Docker brilha. Essa plataforma gratuita oferece um ambiente pronto para explorar o Docker, diretamente no navegador.

O Play With Docker é uma plataforma interativa que permite:

• Criar instâncias temporárias para executar containers.
• Praticar comandos do Docker em um terminal baseado em Linux.
• Testar configurações de rede entre containers.
• Experimentar tutoriais e conceitos avançados, como Docker Compose, Swarm e volumes.
• Tudo isso sem precisar instalar nada no seu computador!

Como começar

Ter uma conta no Docker Hub para logar na plataforma Play With Docker

Caso ainda não tiver uma conta no Docker Hub, crie uma gratuitamente

Após logar na plataforma Play With Docker, crie sessões, inicie uma nova sessão e comece a explorar. Você terá até 4 horas por sessão.

Pode adicionar nós, teste múltiplos containers ou crie clusters usando até 5 nós.

Principais funcionalidades

• Ambiente seguro e temporário:

Ideal para testes rápidos.

• Interface simples:

Terminal Linux no navegador. Também pode conectar no SSH da plataforma, basta copiar o endereço no campo SSH e colar no seu terminal e pronto para executar containers usando o terminal do seu computador conectado na plataforma.

Casos de Uso

• Aprendizado inicial:

Execute comandos básicos do Docker sem se preocupar com instalação.

• Testes de configuração:

Simule redes, volumes e clusters.

• Demonstrações rápidas:

Ideal para workshops e apresentações.

Limitações

Sessões são temporárias (máximo de 4 horas).

Recursos limitados em comparação com um ambiente local ou servidor dedicado.

Considerações finais

O Play With Docker é uma excelente ferramenta para quem quer aprender Docker de maneira prática e acessível. Seja para explorar novos conceitos, realizar testes rápidos ou ensinar colegas, ele elimina barreiras iniciais e torna o aprendizado muito mais fluido.

Referências

https://labs.play-with-docker.com/

Feito!

Utilizando o Faker para criar mocks de API REST

O Faker é uma aplicação de código aberto desenvolvida em Java que ajuda a separar o desenvolvimento frontend do backend, eliminando a necessidade de esperar pelo desenvolvimento da API. Este guia apresenta os passos para criar mocks de API REST usando o Faker e Docker.

Procedimentos:

1. Instalação do Docker:

Certifique-se de ter o Docker instalado em seu sistema para facilitar o uso do Faker.

Caso ainda não tenha o Docker instalado na distro Linux com base Debian, então execute no terminal:

$ sudo apt install docker.io docker-compose

2. Configuração do diretório mocks:

Crie um diretório chamado "mocks" em seu sistema. Dentro deste diretório, crie arquivos JSON para definir os mocks de API.

3. Exemplo de arquivo JSON:

Um exemplo de arquivo JSON para um mock de usuários pode ser assim:

{
  "plugins": [
    {
      "name": "list",
      "args": {
        "count": 5,
        "item": {
          "id": "#random:int:min=1&max=1000#",
          "name": "#random:name#",
          "created_at": "#timestamp#",
          "updated_at": "#timestamp#"
        }
      }
    },
    {"name": "random"},
    {"name": "timestamp"}
  ],
  "request": {
    "method": "GET",
    "path": "/v1/users"
  },
  "response": {
    "body": []
  }
}

Este exemplo define um mock para a rota "/v1/users" que retorna uma lista de 5 usuários com campos como "id", "name", "created_at" e "updated_at" gerados aleatoriamente.

4. Execução do container Docker:

Utilize o seguinte comando Docker para executar o Faker:

docker run --rm -p 3030:3030 -v /diretorio/mocks:/app/mocks dotronglong/faker:stable

Este exemplo define um mock para a rota "/v1/users" que retorna uma lista de 5 usuários com campos como "id", "name", "created_at" e "updated_at" gerados aleatoriamente.

Certifique-se de substituir "/diretorio/mocks" pelo caminho absoluto para o diretório de mocks que você criou anteriormente.

5. Acessando os mocks de API:

Após iniciar o container Docker, você pode acessar os mocks de API através do seguinte endpoint:

curl http://localhost:3030/v1/users

OU no browser http://localhost:3030/v1/users

6. Recursos adicionais:

Para mais informações e recursos sobre o Faker, consulte o repositório oficial no GitHub:

https://github.com/dotronglong/faker

7. Adicionar o Faker Mock no arquivo docker-compose.yml

No diretório, onde estão os arquivos JSON com dados de mock, crie o arquivo

docker-compose.yml, conforme abaixo:

version: '3.8'

services:
  mock_faker:
    image: dotronglong/faker:stable
    container_name: mock_faker
    ports:
      - "3030:3030"
    volumes:
      - ".:/app/mocks"
    restart: unless-stopped

Caso, tenha Faker Mock já está em execução, é necessário finalizar, com docker kill

Depois, execute docker-compose up -d

Adicione a URL do Faker Mock com o endpoint definido no arquivo JSON no Postman com o verbo HTTP (GET ou POST).

Feito!

Sua API é REST? Descubra agora

No mundo do desenvolvimento de software, o termo "API REST" tornou-se um padrão amplamente utilizado para integração entre sistemas. No entanto, nem todas as APIs que se apresentam como RESTful seguem, de fato, os princípios fundamentais do REST. Aderir a esses princípios não é apenas uma questão de semântica, mas também de garantir consistência, escalabilidade e facilidade de uso para os desenvolvedores que consomem sua API.

Neste artigo, exploraremos os elementos essenciais que definem uma API RESTful e apresentaremos um guia prático para ajudar você a verificar se sua API está verdadeiramente alinhada a esse padrão.

Descubra como estruturar endpoints, utilizar métodos HTTP corretamente e aplicar boas práticas que tornam sua API mais eficiente e aderente aos conceitos do REST.

O REST (Representational State Transfer) é um estilo arquitetural que define um conjunto de restrições para a criação de serviços web escaláveis e eficientes. Ele foi introduzido por Roy Fielding em sua tese de doutorado em 2000 e tem se tornado a base para a construção de APIs modernas. Para que uma API seja considerada RESTful, ela deve seguir seis princípios fundamentais:

1. Cliente-Servidor

A arquitetura REST é baseada na separação entre cliente e servidor, o que permite que ambos evoluam de forma independente. O cliente é responsável pela interface do usuário e pela experiência do usuário, enquanto o servidor gerencia o armazenamento e a lógica dos dados. Essa separação melhora a portabilidade do cliente e a escalabilidade do servidor.

2. Stateless (sem estado)

Cada requisição do cliente ao servidor deve conter todas as informações necessárias para que o servidor entenda e processe o pedido. O servidor não deve armazenar informações sobre o estado do cliente entre as requisições. Isso significa que cada chamada é independente, permitindo que as requisições sejam feitas em qualquer ordem.

3. Cacheável

As respostas das APIs REST devem ser rotuladas como cacheáveis ou não, permitindo que os clientes armazenem em cache as respostas para otimizar o desempenho. Isso reduz a necessidade de chamadas repetidas ao servidor para obter os mesmos dados, melhorando a eficiência da comunicação.

4. Interface uniforme

Uma interface uniforme simplifica e desacopla a arquitetura, permitindo que diferentes clientes interajam com o servidor de maneira padronizada. Isso geralmente é implementado através dos métodos HTTP padrão (GET, POST, PUT, DELETE), que definem claramente as operações permitidas em recursos específicos.

5. Sistema em camadas

A arquitetura REST pode ser composta por várias camadas hierárquicas, onde cada camada não conhece as camadas além daquela com a qual está interagindo. Isso permite que intermediários, como proxies e gateways, sejam utilizados para melhorar a segurança e a escalabilidade sem que o cliente precise conhecer a complexidade interna do servidor.

6. Código sob demanda (opcional)

Embora não seja uma exigência, as APIs REST podem permitir que o servidor envie código executável ao cliente quando necessário, estendendo a funcionalidade do cliente sem exigir atualizações constantes.

Diferença entre API REST e RESTful

REST: Conjunto de princípios arquiteturais.

RESTful: Implementação desses princípios em um sistema específico.

Exemplos de endpoints da API de Produtos

• Forma errada de endpoints

A forma incorreta de definir os endpoints para uma API de produtos pode levar a confusões e não seguir as melhores práticas do REST. Aqui estão alguns exemplos de endpoints mal estruturados:

/cadastrarProduto

/editarProduto

/atualizarProduto

/excluirProduto

Esses endpoints não representam recursos, mas sim ações específicas. Isso vai contra o princípio do REST, que enfatiza a manipulação de recursos através de URLs que representam entidades.

• Forma correta de endpoints

A seguir, apresentamos uma forma correta e mais alinhada com os princípios REST para a API de produtos:

1. Criar um Produto

POST /produtos

Sucesso: 201 Created

Erro: 422 Unprocessable Entity

O /produtos representa a coleção de produtos. O método POST é utilizado para criar um novo produto. Caso ocorre algum erro, deve retornar uma mensagem em JSON com código de status 422.

2. Listar todos os produtos

GET /produtos

Permite recuperar uma lista de todos os produtos. Caso, não tiver nenhum produto, deve retornar uma lista vazia.

3. Recuperar um produto específico

GET /produtos/1

Sucesso: 200 OK

Erro: 404 Not Found

Isso é para visualizar um produto específico pela sua identificação (ID). O número 1 representa o ID do produto ou caso o produto não existir deve retornar uma mensagem em JSON com código de status 404.

4. Atualizar um produto existente

PUT /produtos/1

Sucesso: 200 OK

Erro: 404 Not Found

O método PUT é utilizado para atualizar os dados de um produto existente, identificado pelo ID 1 ou caso o produto não existir deve retornar uma mensagem em JSON com código de status 404.

5. Excluir um Produto

DELETE /produtos/1

Sucesso: 200 OK

Erro: 404 Not Found

O método DELETE remove o produto identificado pelo ID 1 ou caso o produto não existir deve retornar uma mensagem em JSON com código de status 404.

Considerações finais

Ao projetar uma API, é fundamental seguir os princípios REST para garantir que os endpoints sejam intuitivos e representem recursos em vez de ações. Isso não apenas melhora a clareza e a usabilidade da API, mas também facilita a manutenção e a escalabilidade no futuro.

Os princípios fundamentais do REST garantem uma comunicação eficiente entre sistemas, promovendo flexibilidade, escalabilidade e interoperabilidade. A adoção dessas diretrizes no desenvolvimento de APIs tem contribuído para o crescimento das aplicações web modernas, especialmente aquelas baseadas em nuvem.

Referência

FIELDING, Roy Thomas. Architectural styles and the design of network-based software architectures. 2000. Dissertação (Doutorado em Ciência da Computação) - University of California, Irvine, 2000. Disponível em: Architectural styles and the design of network-based software architectures . Acesso em: 06/12/2024.

Feito!

Entendendo a JVM

O que é a JVM e por que ela é tão importante?

A Java Virtual Machine (JVM) é um dos pilares mais importantes da linguagem Java. Ela permite que o Java alcance seu objetivo principal de ser portável, com o famoso lema "Write Once, Run Anywhere" (Escreva uma vez, execute em qualquer lugar).

Mas o que exatamente é a JVM? Em resumo, é uma máquina virtual que interpreta e executa o bytecode Java (arquivos .class), traduzindo-o para instruções compreensíveis pelo sistema operacional e hardware subjacente.

Graças à JVM, aplicações Java podem ser executadas em diferentes plataformas sem que o código precise ser reescrito, garantindo portabilidade, segurança e eficiência.

Arquitetura da JVM: Explorando os Componentes Internos

A JVM é composta por várias partes que trabalham juntas para executar programas Java.

1. Class Loader (Carregador de Classes)

O Class Loader é responsável por carregar os arquivos .class na memória no momento da execução. Ele organiza e gerencia as classes em diferentes níveis:

• Bootstrap Class Loader:

Carrega as classes fundamentais do Java.

• Extension Class Loader:

Lida com bibliotecas adicionais.

• Application Class Loader:

Carrega as classes da aplicação.

2. Área de Memória da JVM

A memória da JVM é organizada em várias áreas, cada uma com uma função específica:

• Heap:

Onde os objetos e instâncias são armazenados.

• Stack:

Armazena frames de métodos em execução e variáveis locais.

• Method Area:

Contém metadados das classes e bytecode.

• PC Register:

Rastrea a posição atual da instrução sendo executada em cada thread.

• Native Method Stack:

Suporte para métodos escritos em linguagens nativas, como C ou C++.

3. Execution Engine (Motor de Execução)

Essa é a parte da JVM que transforma o bytecode em instruções executáveis.

• Interpretador:

Executa o bytecode linha a linha.

• JIT Compiler (Just-In-Time):

Compila o bytecode em código nativo para acelerar a execução.

4. Native Interface

Permite que o Java interaja com bibliotecas nativas do sistema, facilitando a execução de código fora da JVM.

5. Garbage Collector (Coletor de Lixo)

Um recurso essencial da JVM que gerencia automaticamente a memória, removendo objetos não utilizados e evitando problemas como vazamentos de memória (memory leaks).

Como a JVM executa o código?

O processo de execução de um programa Java na JVM segue estas etapas:

• O compilador Java (javac) converte o código-fonte (.java) em bytecode (.class).
• O Class Loader carrega o bytecode na memória da JVM.
• O Motor de Execução interpreta ou compila o bytecode para código nativo.
• O código nativo é executado pelo hardware subjacente.

Diferenciando JVM, JRE e JDK

Ao trabalhar com Java, você encontrará três termos comuns:

JVM (Java Virtual Machine): É o ambiente de execução para programas Java.

JRE (Java Runtime Environment): Inclui a JVM e bibliotecas padrão necessárias para rodar aplicações.

JDK (Java Development Kit): Inclui o JRE, ferramentas de desenvolvimento (compilador, depurador, etc.) e bibliotecas adicionais.

Benefícios da JVM

• Portabilidade:

O bytecode é independente de plataforma, e a JVM específica de cada sistema operacional cuida da execução.

• Eficiência:

O JIT Compiler otimiza o desempenho em tempo de execução.

• Segurança:

Oferece isolamento entre o código Java e o hardware real, protegendo contra execuções maliciosas.

• Multithreading:

Suporte nativo para execução simultânea de threads.

• Gerenciamento de Memória:

O Garbage Collector simplifica o desenvolvimento e reduz problemas como vazamentos de memória.

Considerações finais

A Java Virtual Machine é a espinha dorsal do Java. Sua arquitetura robusta e características inovadoras garantem que aplicações sejam executadas de forma confiável, segura e eficiente em diferentes plataformas.

Entender como a JVM funciona não é apenas importante para desenvolvedores Java, mas também para quem deseja otimizar aplicações, resolver problemas de desempenho ou explorar áreas como DevOps e segurança.

Feito!