DEV Community: Júlia Vaz

Teoria | Documentando arquitetura de software com C4 Model + Plant UML

Júlia Vaz — Thu, 28 Dec 2023 21:45:07 +0000

Prefácio
Nesse artigo, teremos contextos e explicações dos temas: Modelagem de arquitetura, C4 Model e Plant UML.

Premissa: A modelagem de arquitetura de software é um processo de concepção de sistemas em geral, envolve a criação de representações abstratas de um sistema ou aplicativo para compreender, comunicar e projetar sua estrutura e funcionamento. Facilitando assim, a comunicação entre partes interessadas como desenvolvedores, gestão e partes não técnicas. Além de contribuir para a qualidade e manutenibilidade dos sistemas de software.

C4 Model

O C4 Model é uma alternativa na construção de modelagem de arquitetura (advinda da UML), desenvolvido por Simon Brown.
Onde descreve em um conjunto de abstrações a arquitetura de software de um sistema de forma clara e eficaz, visando simplificar a comunicação e documentação.

Nota: UML (do inglês Unified Modeling Language) é a linguagem visual de modelagem que inclui diversos tipos de diagramas, como os de classe e de sequência, além de conter três tipos de pastas lógicas: diagramas, modelos e perfis. Mais detalhes

O C4 Model oferece uma estrutura hierárquica para representar a arquitetura de software em quatro níveis de abstração, cada nível fornece uma visão diferente do sistema, desde uma visão de alto nível até uma visão detalhada do código-fonte, da camada externa para interna, são eles: Context, Containers, Components e Code.

Nota: Observe na imagem onde se é contornado o objeto, para assim, seguir o "zoom" do próximo nível.

Nível 1: Context (Contexto)

A camada macro da modelagem se caracteriza pela visão do projeto de um nível mais alto e descreve o sistema como um todo. Mostra o sistemas e seus principais componentes externos e como se interagem.

Nível 2: Containers (Contêineres)

No nível de Containers, o foco está na estrutura interna, detalhando os principais subsistemas do sistema e como eles se comunicam entre si. Isso ajuda a identificar as partes fundamentais e suas interações.

Nível 3: Components (Componentes)

Entrando mais no detalhe do Container, temos a estrutura interna que identificamos como Components, são as partes funcionais do sistema que executam tarefas específicas e podem ser implementadas usando tecnologias específicas. Essa etapa fornece insights sobre a estrutura interna do sistema e como os componentes estão organizados e se relacionam uns com os outros.

Nível 4: Code (Código)

Por fim, chegamos no nível mais baixo de abstração. Neste nível é exposto o esqueleto do código-fonte real do sistema. Tendo como parte diagramas de classe, sequência e outros artefatos que mostram a estrutura e o comportamento do código-fonte.
Embora seja o nível que mais forneça informação técnica aos desenvolvedores, permitindo assim uma compreensão profunda da implementação real do sistema. Em minha opnião pessoal, se trata da camada que com o tempo se torna um peso aos mantenedores da documentação, dado sua constante mudança.

PlantUML

O PlantUML é uma ferramenta que permite criar diagramas UML (Unified Modeling Language) de forma textual, utilizando uma linguagem de marcação simples para definir elementos de diagramas, como classes, objetos, relacionamentos, etc.

Suporta a criação de diagramas em diferentes níveis de abstração, incluindo diagramas de classe, diagramas de sequência, diagramas de estado entre outros. Escrevendo código em uma sintaxe simples e legível, a ferramenta então gera automaticamente os diagramas a partir do código fornecido, além de ser altamente personalizável, permitindo ajustes na aparência e o estilo dos diagramas de acordo com suas necessidades.

O exemplo abaixo representa a camada nível 1 do C4 Model, sendo elaborada de maneira textual pelo PlantUML.

Benefícios?

O C4 Model e o PlantUML são duas ferramentas distintas que podem ser usadas em conjunto para criar diagramas arquitetônicos e representações visuais de sistemas de software. Aqui estão alguns dos prós e contras de usar essas duas ferramentas em conjunto:

Prós:

Clareza e Compreensão: O C4 Model é projetado para criar diagramas de arquitetura que são simples, claros e fáceis de entender. PlantUML, por sua vez, é uma ferramenta que pode ser usada para criar diagramas de forma textual, o que pode ajudar a manter a simplicidade e clareza dos diagramas C4.
Flexibilidade: PlantUML é altamente flexível e suporta a criação de vários tipos de diagramas, incluindo diagramas de classes, diagramas de sequência, diagramas de componentes e muito mais. Isso permite que você represente diferentes aspectos da arquitetura do sistema de forma consistente.
Controle de Versão: Como os diagramas criados com PlantUML são baseados em texto, eles podem ser facilmente armazenados em sistemas de controle de versão, como o Git, o que facilita o rastreamento de alterações e a colaboração em equipe.
Integração: PlantUML pode ser integrado em várias ferramentas de desenvolvimento, IDEs e sistemas de documentação, facilitando a inclusão de diagramas C4 em sua documentação de arquitetura.

Contras:

Curva de Aprendizado: Tanto o C4 Model quanto o PlantUML têm uma curva de aprendizado. Aprender a criar diagramas de arquitetura eficazes usando o C4 Model requer algum tempo e prática. Além disso, aprender a escrever código PlantUML também pode ser desafiador para alguns.
Limitações de Expressividade: Embora PlantUML seja flexível, ele ainda pode ter algumas limitações em termos de expressividade em comparação com ferramentas de diagramação gráfica mais avançadas. Alguns diagramas complexos podem ser difíceis de representar com precisão.
Manutenção: Como os diagramas PlantUML são baseados em texto, a manutenção de diagramas grandes e complexos pode se tornar trabalhosa, especialmente se muitas alterações forem necessárias.
Dependência de Ferramentas: Você precisa depender de ferramentas específicas para gerar os diagramas PlantUML a partir do código textual, o que pode ser uma desvantagem se sua equipe ou organização não estiver familiarizada com essas ferramentas.

Em resumo, a combinação do C4 Model e do PlantUML pode ser uma abordagem eficaz para representar a arquitetura de sistemas de software, especialmente se você valoriza a simplicidade e a clareza em seus diagramas e está disposto a investir tempo na aprendizagem e na manutenção das ferramentas. No entanto, é importante estar ciente das limitações e desafios associados a essa abordagem.

Referências

Instalação do Git e subir seu repositório para o GitHub

Júlia Vaz — Thu, 09 Jul 2020 01:13:31 +0000

Olá! nesse artigo eu irei dizer com eu faço a instalação e configuração do git/github no linux (estou usando o Ubuntu 20.04), e também como fazer com que um repositório local se torne remoto.

Espero que lhe ajude!

✨ Verificar a existência do git:

Antes de tudo, você precisa conferir se já tem o git instalado no seu computador utilizando o comando: > git --version, caso apareça "command not found" siga para a instalação.

✨ Instalação do git:

No linux utilize o comando > sudo apt install git e insira sua senha de sudo, logo após a conclusão fazer uma verificação da versão para saber se foi instalado corretamente: > git --version.

✨ Configuração de ambiente:

Utilizarei os seguintes comandos para definir o padrão de nome, email, editor de texto (opcional).
> git config --global user.name "seu nome",
> git config --global user.email "seu email,
> git config --global core.editor vscode (por exemplo).

Para visualizar todas as configurações feitas: > git config --list.

✨ Repositório local para remoto:

Utilizei o tutorial da Documentação oficial como base de estudo e prática para entender como funciona o processo, e deixei indexado para você fazer o passo-a-passo também.

Em minha visão está bem completo e didático, então essa etapa será finalizada. :D

Espero que tenha curtido!

Introdução ao MongoDB e operações de CRUD

Júlia Vaz — Tue, 07 Jul 2020 18:08:05 +0000

Estarei usando esse site como registro dos meus estudos, a intensão é totalmente fixar o conteúdo aprendido!

Primeira coisa que tem que entender sobre o MongoDB é o conceito, entender a lógica de um banco de dados não relacional.

A Documentação do MongoDB é incrível, eu consegui entender super bem por lá, precisando ver pequenas coisas por fora.

Se você é como eu, que tem o conceito de banco de dados relacional muito fixo e não entendeu de primeira a maneira na qual o não relacional funciona recomendo ver essa parte da documentação do MongoDB, Comparação com SQL.

✨ Características:

Os dados são organizados em funções;
Documento definido por um objeto, tendo o formato de campo:valor;
Não existe tabelas, sim collections;
As collections não tem contains (PK, FK), transações e também não tem as limitações das tabelas relacionais;
Composto por documentos, esses documentos são em formato JSON;
Os documentos são agrupados em collections;
O conjunto de collections formam um database;
Collection é um conjunto de dados;

✨ Fluxo de acesso

Para visualizar todos os documentos existentes.

Comando : > show databases

Para colocar em uso caso exista, senão, ele é automaticamente criado.

Comando: > use estudos

OBS.: a collection só oficialmente criada após a inserção de um registro

Para visualizar as collections.

Comando: > show collections

Para visualizar em qual documento você está.

Comando: > db

✨ Operações de CRUD

São funções que fazem as operações, como por exemplo: `insert()`, `find()`, `findOne()`, `update()` e `delete()`;

Create

> use <nome-collection>

Esse comando serve para criar o banco, mas só será oficialmente criado com a inserção do primeiro registro.

Read

Esse comando serve para visualizar os registros da sua collection (apenas os 20 primeiros).
Comando: > db.<nome-collection>.find()
Visualizar em formato JSON.
Comando: > db.<nome-collection>.find().pretty();
Ver um registro em específico.
Comando: > db.<nome-collection>.find({ <nome-campo> : <valor> })
Pode-se usar o parâmetro pretty() sempre que quiser ver em formato JSON.

Insert

Adicionar um único registro em sua collection definida:
Comando: > db.<nome-collection>.insert({ campo:valor })
Há duas opções de como adicionar vários registros em sua collection definida:

1ª opção: Usando um array para inserir os registros, logo em seguida adicionar o array no parâmetro insert:
Comando:
> addArray = [ { campo:valor}, { campo:valor}, {campo:valor}, { campo: [ {campo:valor }, {campo:valor } ] } ]
> db.<nome-collection>.insert(addArray)

2ª opção: Usar a função insertMany():
Comando: db.<nome-collection>.insertMany([ { campo:valor, campo:valor, campo:valor }, { campo:valor, campo:valor, campo:valor } ] )

Update

Importante lembrar que, a função update pode ser muito perigosa, podendo apagar registros de seu documento, então atente-se as regras de "segurança".

Atualizando um único registro em sua collection definida, usando o _id como filtro, pois é um registro único:
Comando: > db.<nome-collection>.updateOne({ _id: ObjectId("5eeed2755cda39dc20cb990c")}, {$set: {campo:valor}})
O operador $set irá sobrescrevê-lo, sendo atualizado.
Existem outras funções de update como, update(), updateMany() e upsert().

OBS.:
- Cada ObjectId() é diferente então para encontrar o seu use o comando > db.<nome-collection>.find();
- Se for atualizar um campo que não existe ele será automaticamente criado.

Delete

Seguindo a lógica das funções do update(), temos duas opções de como deletar um registro, usando deleteOne() ou deleteMany().

Para apagar todos os registros com um campo especifico: > db.<nome-collection>.deleteOne({campo:valor})

Caso queira deletar um registro em especifico não se esqueça de utilizar o ObjectId().

Fim! :D