Forem: Matheus Poda

⚙️ Arquitetura II: Não dê sorte ao azar

Matheus Poda — Mon, 14 Aug 2023 11:04:14 +0000

Olá queridos(as) devs!

Sejam bem-vindos ao segundo artigo de uma série que estou começando a publicar. Neles, vou abordar diversos temas de arquitetura, desde os fundamentos até modelos, padrões, etc.

No entanto, neste artigo, iremos discutir algo de extrema importância: as características arquiteturais.

Neste artigo, você irá aprender rapidamente:

Você considera explicitamente a arquitetura ao desenvolver um software?
O que são características estruturais?
O que é uma característica operacional?
O que é uma característica estrutural?
Pontos importantes a serem considerados no dia a dia

Vamos começar! 🔥

Não de sorte ao azar

No cotidiano, é comum desenvolvermos diversas funcionalidades, resolver problemas e entregar produtos. No entanto, muitas vezes fazemos escolhas automáticas, sem pensar muito nelas.

Com o tempo, essa abordagem pode prejudicar a qualidade do software, uma vez que negligenciamos aspectos que podem ser cruciais. Por isso, quero abordar um tópico extremamente importante na arquitetura de software: as características arquiteturais. São vários pontos que não devemos ignorar.

Tenho certeza de que, ao compreender um pouco mais sobre isso, sua abordagem ao desenvolvimento de projetos mudará completamente.

Vamos lá! 🚀

Características Arquiteturais

Ao desenvolver uma solução, sempre temos requisitos - os requisitos funcionais estão mais relacionados ao negócio e suas funcionalidades de valor, enquanto os requisitos não funcionais focam mais no sistema em si.

Com o tempo, o termo "requisito não funcional" tem sido substituído cada vez mais por "características de arquitetura". Isso envolve pensar e destacar aspectos importantes do software, que, se bem desenvolvidos, trarão maior segurança e qualidade à aplicação.

Ao considerar essas características, estamos usando uma abordagem de análise arquitetural em vez de focar apenas no domínio de negócio. Isso nos permite analisar os pontos de arquitetura do software.

Hoje em dia, não é possível listar todas as características arquiteturais que um software pode ter, mas podemos agrupá-las em três categorias: Características Operacionais, Características Estruturais e o que chamamos de cross-cutting.

Ter uma compreensão desses grupos lhe dará mais confiança ao opinar sobre uma solução e entender a visão macro e micro do software. Além disso, você deixará de apenas superficialmente considerar esses pontos em seu cotidiano e passará a ter um olhar mais crítico sobre as decisões tomadas.

Características Operacionais

Quando consideramos essas características, estamos analisando a operação do software. Isso inclui:

Disponibilidade: Quanto tempo meu projeto estará disponível (24/7)?
Confiabilidade: Segurança, autenticação, segurança em geral, etc.
Escalabilidade: Como meu sistema escala? Horizontalmente (adicionando máquinas)? Verticalmente (aumentando o poder computacional)?
Recuperação: Caso algo dê errado, tenho algum tipo de backup preparado?

Note que tudo relacionado às operações (inclusive o papel do DevOps) faz parte desse grupo.

Ter um entendimento mínimo sobre esses aspectos ao desenvolver o sistema é crucial, uma vez que todos podem afetar a forma como o sistema será operado.

Características Estruturais

Como o nome sugere, esta seção trata da estrutura do sistema. Aqui, discutimos os suportes que sustentarão nosso software. Isso inclui aspectos relacionados ao código, configuração da aplicação, instalação, etc.

Alguns exemplos de conceitos importantes nesta categoria:

Configurabilidade: Quão fácil é configurar o software e seus componentes.
Extensibilidade: Os componentes da aplicação devem estar prontos para evoluir.
Facilidade de Instalação: O software deve ser facilmente instalável e não apresentar problemas durante o deployment.
Reutilização de Componentes: Os componentes da aplicação devem ser projetados para reutilização em diferentes contextos.
Facilidade de Manutenção: Um software com boas práticas de código e baixo acoplamento será mais fácil de manter.

Características Cross-cutting

Este grupo engloba conceitos importantes para o software, mas que não se encaixam diretamente nas categorias anteriores.

Estes incluem:

Acessibilidade: O sistema deve ser acessível para os usuários.
Conformidade Legal e Privacidade: O software deve atender às leis e termos de privacidade, como a LGPD no Brasil.
Segurança: Embora possa ser considerado como parte da Confiabilidade, a segurança do projeto merece atenção extra.
Usabilidade: Compreender como o usuário interage com o software e melhorar esses aspectos.

Pontos importantes

É praticamente impossível incorporar todas as características em um software, devido ao custo e ao tempo envolvidos. Você sempre terá que definir uma lista de características mais importantes, seja em colaboração com as partes interessadas do projeto, requisitos ou conhecimento técnico sobre possíveis problemas que o software pode enfrentar.

Por exemplo:

Imagine que sua solução envolve um processo de pagamento. Você pode ter duas opções:

Se esse processo for realizado por um terceiro, não precisamos de certificações de segurança; criptografia de dados seria suficiente.
Se o processo de pagamento for feito pelo software, precisamos focar na confiabilidade e na segurança do usuário.

Toda arquitetura de software envolve trocas - você ganha algo em troca de outra coisa. Por isso, é crucial manter o objetivo da solução em mente.

A maior dica que posso dar é: Não busque a melhor arquitetura possível; escolha a menos ruim.

Ao manter esses pontos em mente, comece a observá-los nos softwares com os quais você trabalha! Tente não negligenciar esses temas enquanto desenvolve.

Me acompanhe em minhas redes sociais.

Obrigado pelo seu tempo!

Compartilhem com seus colegas de estudo/trabalho.
Me chama nas redes sociais a baixo para trocarmos uma ideia e tirar dúvidas:

Até a próxima!

⚙️ Arquitetura de Software: O início

Matheus Poda — Mon, 31 Jul 2023 11:26:59 +0000

Olá meus queridos(as) devs!

Sejam bem-vindos ao primeiro artigo de uma série de outros que vou estar começando a publicar, neles vou estar abrangendo diversos assuntos de arquitetura, desde os fundamentos, até os modelos, padrões e etc!

Mas esse aqui será o ponto de partida, nele quero falar alguns tópicos.

Você rapidamente irá aprender:

Quais são os tipos de arquitetos?;
O que é a arquitetura de software?;
Qual é o papel de um arquiteto de software?;

Vamos começar 🔥

Quais são os tipos de arquitetos?

Por incrível que pareça, dentro do mundo de TI, temos vários tipos de arquitetos, alguns próximos dos negócios, enquanto outros mais próximos do código.

Quero abordar os principais:

Quero abordar dos principais:

Arquiteto Corporativo
Arquiteto De Soluções
Arquiteto de Software
Arquiteto Tecnológico

Arquiteto Corporativo

Esse arquiteto tem como foco a área de organização e governança da empresa que desenvolverá determinado software. Seus principais papéis são:

Compreender o mercado e as inovações;
Organizar as tecnologias que a empresa utilizará na criação do software;
Definir a cultura que os times de desenvolvimento irão adotar;
Entender os custos e valores relacionados às equipes e tecnologias;
Possuir conhecimento técnico, embora seu trabalho esteja mais voltado para o negócio.

Arquiteto de Soluções

O arquiteto de soluções atua como intermediário entre os setores de negócio e software, desempenhando as seguintes funções:

Transformar os requisitos de negócio em uma solução de software;
Compreender as tecnologias já utilizadas pela empresa e determinar a necessidade de adoção de novas tecnologias para a criação do software;
Implementar tecnologias de acordo com o problema apresentado;
Ter visão do negócio e considerar suas particularidades;
Expressar a solução arquitetural por meio de desenhos e diagramas.

Arquiteto de Software

O arquiteto de software trabalha mais diretamente com as equipes de desenvolvimento e desempenha os seguintes papéis:

Compreender os recursos do time e identificar as tecnologias com as quais o time está familiarizado;
Projetar o modelo, padrão e boas práticas que o time de desenvolvimento deverá seguir;
Manter sempre a visão de que o desenho do software deve priorizar a evolução e a escalabilidade;
Garantir que o código escrito e as decisões tomadas estejam em conformidade com os padrões estabelecidos;
Auxiliar o time em uma visão macro e micro do projeto de software.

Arquiteto Tecnológico

São especialistas em uma ou mais tecnologias específicas, possuindo amplo conhecimento sobre elas e sabendo indicar a melhor escolha para resolver determinados problemas.

Por exemplo, podemos ter um Arquiteto Tecnológico especializado em Microsoft Azure, que deverá possuir amplo conhecimento das ferramentas desse serviço, a fim de orientar seu uso na solução de determinados problemas. Da mesma forma, podem existir Arquitetos Java, Arquitetos de banco de dados, entre outros.

Ilustração resumida dos tipos:

O que é arquitetura de software?

Arquitetura de software são as coisas importantes de um software. O que quer que isso seja. - Ralph Johnson

Gosto de começar a sintetizar o que é arquitetura de software, com essa frase incrível.

A definição concreta, foi estabelecida pela IEEE Standard 1471, que traz um acordo sobre o que é o conceito:

Arquitetura de software pode ser definida como a organização fundamental de um sistema, seus componentes, as relações entre eles e o ambiente que guia seu design e evolução.

Resumidamente, a arquitetura não é necessariamente um cargo, é um conhecimento que faz parte da engenharia de software.

Com este conhecimento, construímos um software que oferece soluções para o negócio, trabalhando com atributos de qualidade e preparado para a evolução.

Além disso, a arquitetura se preocupa em componentizar o software, atribuindo responsabilidades de forma clara e estabelecendo bons relacionamentos entre eles.

Quais são os papéis da arquitetura de software?

O papél de uma boa arquietura de software é:

Entender o negócio e a motivação por trás da criação de determinado software;
Com base nesse entendimento, definir os atributos de qualidade (testes, segurança, UX/UI, custo, servidor etc.);
Desenhar uma solução que seja viável para o time, levando em consideração as habilidades e competências da equipe, não se limitando apenas a selecionar o que há de melhor no mercado;
Auxiliar o time de desenvolvimento a adotar boas práticas no processo de design (SOLID, Design Patterns, paradigmas etc.);
Manter o ciclo de desenvolvimento organizado para garantir a governança e a evolução do software.

O quinto item é, em minha opinião, um dos mais importantes. Não basta criar uma arquitetura bem estruturada, com ótimas práticas para escalabilidade e resiliência, se, ao longo do tempo, tudo se tornar desorganizado e caótico. É essencial governar e defender a arquitetura selecionada.

O responsável por manter a ordem normalmente se baseia em atividades como Code Review, uso de ferramentas de automação no processo de CI/CD, entre outras.

O arquiteto de software é, idealmente, um orquestrador. Ele garante que todas as partes interessadas sejam ouvidas e suas ponderações sejam levadas em conta na formulação da arquitetura. Para isso, elabora e mantém artefatos abrangentes que facilitam o engajamento. - Elemar Jr.

Conclusão

Normalmente, confundimos arquitetura de software com um cargo, e embora ele possa ser, nunca deixará de ser um conhecimento e um conjunto de práticas. Podemos encontrar diversos cargos, como Tech Leads, desenvolvedores seniores, gerentes técnicos, entre outros, que são responsáveis por desempenhar esses papéis.

Além disso, a arquitetura de software é parte integrante da engenharia de software. Não devemos depender unicamente de uma única pessoa para tomar decisões importantes; esse processo precisa ser executado em equipe, pois é assim que podemos ter ideias melhores e refinar o melhor caminho para a entrega de um bom software.

Nos próximos artigos, vou explorar esses conceitos em detalhes e espero contar com a participação de vocês, meus caros leitores!

Me acompanhe em minhas redes sociais.

Obrigado pelo seu tempo!

Compartilhem com seus colegas de estudo/trabalho.
Me chama nas redes sociais a baixo para trocarmos uma ideia e tirar dúvidas:

Até a próxima!

Simplificando Binary Search 🔎

Matheus Poda — Thu, 29 Jun 2023 18:57:31 +0000

Nessa série de posts que escrevo, vou falar sobre algoritmos mais utilizados para determinadas tarefas.

A ideia é sempre seguir o seguinte objetivo:

Demonstrar o problema que ele soluciona;
Demonstrar como ele soluciona;
Mostrar o código;
Mostrar algo já pronto;
Finalizar com uma ou mais perguntas de entrevistas, como desafio.

No post de hoje, iremos abordar binary search.

No final vou estar deixando uma pergunta que é muito encontrada em entrevistas técnicas, não vou dar a resposta de cara, vou adicionar ela aqui após uma semana, então tente responder e deixar nos comentários.

Problema

Imagine o seguinte cenário, em uma lista de números com 11 inteiros, podemos exibir como a matriz a baixo.

Posição	Número inteiro
0	1
1	5
2	8
3	10
4	12
5	16
6	19
7	24
8	26
9	46
10	84

Precisamos criar um algoritmo que irá pesquisar pelo número inteiro e retornar sua posição, mas como podemos fazer isso?

Bom podemos aplicar uma simple search (pesquisa simples), que vai ser um looping varrendo de um a um, percorrendo cada posição da lista até encontrar o número que deseja.

Em termos de Big O, que resumidamente, seria uma função de medirmos o tempo de processamento dos nossos algoritmo (caso tenha mais interesse em saber a fundo, vou deixar um artigo excencial nas referências), ao pensar nessa solução temos O(n), que chamamos de função linear.

Significa que o tempo de execução é igual ao tamanho da estrutura de dados, no caso como temos uma matriz de 11 elementos, temos que O(11), ele irá percorrer a lista e nos entregar o resultado em até 11 passos.

Mas existe uma forma de conseguirmos diminuir este tempo, usando a binary search (pesquisa binária), para não aprofundar muito em Big O, ela é considerada O(log2 n), que significa, um ótimo tempo.

O log2 n, significa que é log na base 2.

Podemos ver pelo gráfico a baixo:

O que é a binary search?

O algoritmo funciona da seguinte forma, ele cortará ao meio uma determinada lista, verificando se o item que está no meio é o que estamos procurando, caso não seja, irá condicionar se o item é maior ou menor que o do meio, conseguindo cortar a parte maior ou menor da lista e vai repetindo o processo até encontrar a posição do item que queremos.

É importante colocar aqui um aviso importante, não é possível usar essa forma de pesquisa, caso a lista que você está usando não esteja ordenada, pois o resultado desse algoritmos, retorna a posição do item, se tivesse dois ou mais itens iguais, ele iria ignorar e retornar o primeiro que encontrar.

Voltando ao cenário da nossa lista de números inteiros, desejamos encontrar o número 24 lista, primeiro iremos encontrar o meio:

Posição	Número inteiro
0	1
1	5
2	8
3	10
4	12
5	16 (meio)
6	19
7	24
8	26
9	46
10	84

O meio é o 16, a lista está ordenada em ordem crescente, 16 é maior ou igual a 24? Não, logo é menor que 24, cortamos a fatia de números menores na lista.

Posição	Nome do Contato
6	19
7	24
8	26 (meio)
9	46
10	84

O meio é 26, novamente entra na condicional, 26 é maior ou igual a 24? Sim! Então iremos arrancar a fatia com números maiores, sobrando...

Posição	Nome do Contato
6	19
7	24

O meio agora é 1.5, mas como a posição é inteira, iremos arredondar para 1 (como normalmente as linguagens de programação fazem). Logo temos 19, esse número é maior que 24? Não, então cortamos.

Posição	Nome do Contato
7	24

Por fim sobrou nosso número! Como retorno iremos receber 7, que é a posição da lista que se encontra o número 24.

Viu como ficou mais rápido? Encontramos o valor em 3 passos, sendo que se fossemos pela simple search levariamos até 11 passos.

A fórmula para você descobrir quantos passos levaria é bem simples.

Pesquisa	Fórmula
Simple Search	n
Binary Search	log 2 n (log de base 2)

Exemplo:

Suponha que você tenha uma lista com 128 números e esteja fazendo uma pesquisa simples e binária. Qual seria o número máximo de etapas que você levaria para encontrar o número desejado?

Pesquisa simples O(n) = O(128), logo 128 passos
Pesquisa binária O(log2 n) = O(7)

Para realizar o cálculo de log, pode usar uma calculadora científica, ou usar um site como este.

O código do algoritmo

Beleza, entendemos a teoria, agora vamos colocar na prática e desenvolver um código que seja capaz de funcionar como explicado.

Irei estar utilizando Java, mas o belo dos algoritmos é que ela pode ser escrita em qualquer linguagem, dê uma olhada no repositório do Aditya Bhargava, escritor do livro Entendendo Algoritmos.

Vou estar colocando o código inteiro e vamos quebrar em etapas:


private static Integer binarySearch(int[] list, int item) {
        int baixo = 0;
        int alto = list.length - 1;

        while (baixo <= alto) {
            int meio = (baixo + alto) / 2;
            int chute = list[meio];
            if (chute == item) {
                return meio;
            }
            if (chute > item) {
                alto = meio - 1;
            } else {
                baixo = meio + 1;
            }
        }
        return null;
    }

Parte 1: Definindo o máximo e mínimo da lista

        int baixo = 0;
        int alto = list.length - 1;

Aqui praticamente estamos adotando o primeiro valor máximo e mínimo da lista, começando com 0, e como as matrizes e vetores começam com 0, nós fazemos o tamanho da lista -1 para encontrar o máximo.

Parte 2: O algoritmo


        while (baixo <= alto) {
            int meio = (baixo + alto) / 2;
            int chute = list[meio];
            if (chute == item) {
                return meio;
            }
            if (chute > item) {
                alto = meio - 1;
            } else {
                baixo = meio + 1;
            }
        }

O looping será executado até que o alto fique igual ou menor que baixo;

Definimos o valor que representa o meio.
int meio = (baixo + alto) / 2;

E o valor do chute.
int chute = list[meio];

Tendo isso em mente, vamos agora verificar a condicional que expliquei na teoria:

            if (chute == item) {
                return meio;
            }
            if (chute > item) {
                alto = meio - 1;
            } else {
                baixo = meio + 1;
            }

Se o chute for igual ao item, retornamos a posição do meio.
Se o chute for maior que o item, iremos alterar o valor do tamanho máximo da lista, para que cortemos os valores maiores que o meio.
Se o chute for menor que o item, iremos alterar o valor do tamanho mínimo da lista, para que cortemos os valores menores que o meio.

Assim no final iremos conseguir, caso exista o número na lista, encontrar sua posição, caso contrário, retorna nulo.

Código para você brincar no seu compilador


import java.util.Arrays;

public class BinarySearch {


    private static Integer binarySearch(int[] list, int item) {
        int baixo = 0;
        int alto = list.length - 1;

        while (baixo <= alto) {
            int meio = (baixo + alto) / 2;
            int chute = list[meio];
            if (chute == item) {
                return meio;
            }
            if (chute > item) {
                alto = meio - 1;
            } else {
                baixo = meio + 1;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        int[] minhaLista = {1,5,8,10,12,16,19,24,26,46,84};
        System.out.println(binarySearch(minhaLista, 24));
        System.out.println(binarySearch(minhaLista, -1));
    }
}

Simplificações do Colections do Java

Obviamente no mercado, se você precisar de uma binary search, a Colections do Java, já tem esse algoritmo pronto, basta usar da seguinte forma.


public static void main(String[] args) {
        List<Integer> listaInteiros = Arrays.asList(1,5,8,10,12,16,19,24,26,46,84);
        int[] minhaLista = {1,5,8,10,12,16,19,24,26,46,84};
        int item = 24;
        System.out.println(Collections.binarySearch(listaInteiros, item));
        System.out.println(Arrays.binarySearch(minhaLista, item));
    }

Pergunta de entrevista

Pergunta: Dado uma lista ordenado em ordem descrescente de números inteiros, escreva um código que encontre o elemento da lista, considerando o fator de tempo, como O(log2 n).

Exemplo:
INPUT: Encontre o valor 8 em {42,36,29,25,14,8,3,1}

OUTPUT: 5

Resposta da pergunta

A resposta será liberada no dia 06/07/23, a ideia é que você tente resolver e disponibilize sua ideia e código nos comentários (código pode subir no github e postar aqui, mas explique o que você pensou).

Referências

Entendendo Algoritmos: Um guia ilustrado, por Aditya Y. Bhargava;
Algoritmos, de José Augusto e Jaya Figueireido;
Cracking the Coding Interview, de Gayle Laakmann;

Links úteis

Big O;
Big O cheat sheet;

Me acompanhe em minhas redes sociais.

Obrigado pelo seu tempo!

Compartilhem com seus colegas de estudo/trabalho.
Me chama nas redes sociais a baixo para trocarmos uma ideia e tirar dúvidas:

Até a próxima!

Aprenda a medir se sua API pode ser considerada REST 🔥

Matheus Poda — Tue, 20 Jun 2023 12:54:35 +0000

Introdução

Atire a primeira pedra quem nunca entrou em uma empresa, onde sua primeira atividade é adicionar uma nova feature na tal "API REST", mas ao abrir o código do projeto você se depara com um:

POST /client/infos/update-infos

Ou pior

POST /client/infos/delete-infos

É triste mais é a realidade, existem vários sistemas que se consideram REST, mas não são.

Passando pelas leis do REST

Quando falamos que uma API é REST, significa que desenvolvemos uma aplicação de transporte de informações que utiliza HTTP, porém com regras claras criadas por Roy Fielding.
Caso você siga TODAS a risca, pode ser considerada uma API RESTful.

Fiz uma tabelinha com as leis do REST:

Caso você ainda tenha dúvida sobre elas, recomendo fortemente, ler o próprio artigo do Roy Fielding.

Medindo a maturidade de sua API

Beleza, já sabemos quais regras que devemos implementar para de fato termos uma API RESTful, mas o que você vai perceber que no dia a dia de trabalho, raramente vai encontrar tudo isso implantado.
Normalmente não vemos por conta da relação tempo x custo, por conta disso quase sempre você irá encontrar outro tipo de padrão no mercado.

Mas, como podemos medir se a API que estamos criando, ou atuando, é REST?

Para isso o desenvolvedor Leonard Richardson, criou o RMM (Richardson Maturity Model), dessa forma dividimos alguns padrões do REST em 3 níveis.

Vou explicar cada nível para vocês.

Os 3 níveis para a glória REST

Nível 0: POX

Nesse nível, consideramos que API só serve mesmo como transporte de informação, não utiliza corretamente URI, verbos HTTP, HATEOAS e status code, nem possui padrão de formato representacional (JSON, XML e etc).

Podendo ter casos, onde a mensagem de erro nos retorna código 200, e vem no corpo da resposta, o erro que pode ter ocorrido no serviço.

HTTP/1.1 200 OK
[headers]

<compraDeProutosErro>
  <produto descricao="teclado mecânico" id="0293"/>
  <cliente cpf = "xxxxxxxxxxxxx"/>
  <reason>Produto esgotado.</reason>
</compraDeProutosErro>

Nível 1: Recursos

Nesse ponto sua API já está trabalhando corretamente com URI para manipular seus recursos, mas ainda não implementa verbos HTTP, HATEOAS e status code corretamente.

Aqui já começa a ser comum de encontrar por aí, já encontrei várias dessas em alguns projetos de mercado.

Continuam utilizando os verbos GET e POST para realizar consultas e operações.

Nível 2: Verbos HTTP

Finalmente começamos a encontrar o uso correto das URI, verbos HTTP e status code. Para o padrão que encontramos, aqui existe um debate muito discutido.

Alguns programadores não consideram o nível 2 como uma API REST, já que não há o HATEOAS, já outros consideram. Com minha experiência e minha opinião, aqui coloco que sim, já considero uma API REST a partir desse ponto.

Nível 3: HATEOAS

HATEOAS, significa Hypertext As The Engine Of Application State, um nome feio e enorme, praticamente chamamos de Hypermedia Controls.

Para entender, vamos a um exemplo, imagine uma página HTML, onde temos diversos links que chamam para outros HTML. Fica vísivel qual caminho podemos adotar para vermos, por exemplo, informações de um produto, da conta e etc.

A mesma coisa vale para a API, quando realizamos uma requisição, no retorno dela, deve ter alguns endpoints para ajudar ao usuário a explorar outros recursos.

Vamos a um exemplo, imagine que quero consultar um produto:

GET /produtos/872

Como retorno HATOEAS, deveríamos ter uma resposta parecida com isso:

HTTP/1.1 200 OK

{
   "id":89,
   "nome":"Mouse ergonômico"
   "preco": 430,
   "links": {
      "fornecedor": "/fornecedores/23"
   }
}

Onde, além do retorno de uma consulta sobre um determinado produto, adicionamos um link para a URI de fornecedores, para dar um caminho e até mesmo uma ajuda para o usuário ir explorando os recursos da API.

Conclusão

É muito raro encontrarmos uma aplicação que implemente o nível 3, por isso muitos desenvolvedores consideram o nível 2 como uma API REST.

Perguntinha do artigo para refletir!

Você já trabalhou com mais APIs nível 3 ou 2?

Espero que tenha ficado claro e te ajude a medir a maturidade de suas API que virão pela frente.

Obrigado pelo seu tempo.
Compartilhem com seus colegas de estudo/trabalho.
Me acompanhem em minhas redes sociais:

Até a próxima!

Git & Github: Você sabe o que é SemVer?

Matheus Poda — Wed, 10 May 2023 14:45:46 +0000

O mal do versionamento

Você que é desenvolvedor, ou já fez algum projeto, já cansou de adicionar dependências ao seu projeto. De acordo que o projeto vai crescendo inúmeras bibliotecas/serviços vão sendo adicionados e você vai torcer com todas as forças que eles utilizem o padrão de versionamento semântico.

Você vai ficar assim se não tiver um padrão no versionamento das dependências de seu projeto:

Além disso, você a partir de agora, também irá começar a usar na construção de qualquer projeto, API e bibliotecas, pois é uma metodologia incrível que vai salvar você de inúmeros problemas e também ajudará sua API pública, caso vá ter uma, a se tornar ainda mais segura e controlada.

O que é esse padrão SemVar?

SemVar vem de Semantic Versioning, criado pelo Tom Preston-Werner, co-fundador do Github, a metodologia transforma a versão de um projeto em algo compreensível para quem está utilizando e também para quem está desenvolvendo.

Vamos a um exemplo:

Imagine uma API pública com a versão 1.3.4, ela foi construída já aplicando o versionamento semântico, significando que sua versão principal é 1, o 3 significa que foi feito adição de novas funcionalidades que não impactam quem já utiliza ela e o 4 são de ajustes e correções.

O SemVar trata as versões da seguinte forma:

MAJOR.MINOR.PATCH

MAJOR: Só é alterada quando foi feito uma mudança que tornou a versão anterior incompatível, ou seja, o básico de configuração e funcionamento anterior foi atualizado a ponto de precisar incrementar a MAJOR;
MINOR: Incrementada quando é feito uma modificação, ou adição de uma funcionalidade, que não tornou a aplicação incompatível;
PATCH: Alterada quando é corrigido algo na aplicação, seja refatoração, correção de bug, mantendo a compatibilidade.

Especificações básicas

Vou estar abordando alguma das especificações da utilização do SemVer, para mais informações, consulte a documentação oficial.

O formato deve ser X.Y.Z, inteiros e nunca negativos, não se deve colocar um 0 antes de um número, por exemplo, 01, 02 e etc;
Deve ser aumentado numericamente 1.9.0 -> 1.10.0 -> 1.11.0;
Ao iniciar o desenvolvimento, você deve colocar como MAJOR, o valor '0', esse valor significa que é instável e pode sofrer alterações que impactem a compatibilidade a qualquer momento;
Quando a aplicação se tornar pública para uso, a versão MAJOR irá para '1', se tornando 1.0.0;
Você pode ter tags em suas versões, como beta, alpha, release e etc (1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0.).

Dúvidas frequentes

Algumas dúvidas que acho relevante saber:

Quando devo lançar a versão 1.0.0?

Se seu software está sendo usado em produção, ele já deve ser provavelmente 1.0.0. Se você possui uma API estável a qual usuários passaram a depender, deve ser 1.0.0. Se você está se preocupando bastante com compatibilidade com versões anteriores, já deve ser 1.0.0.

O que eu faço se, acidentalmente, liberar uma mudança incompatível com versões anteriores como uma versão menor (minor version)?

Assim que você perceber que quebrou a especificação de versionamento semântico, conserte o problema e lance uma nova versão menor, que corrige o problema e restaura a compatibilidade. Mesmo sob esta circunstância, é inaceitável modificar versões lançadas. Se for apropriado, documente a versão ofensiva e informe seus usuários do problema de forma que eles fiquem cientes da versão em questão.

O SemVer tem um limite de tamanho para string de versão?

Não, mas use o bom senso. Uma string de versão com 255 caracteres, por exemplo, provavelmente é um exagero. Porém, sistemas específicos podem definir seus próprios limites para o tamanho da string.

Conclusão

A ideia desse tópico foi apresentar esse padrão, que é muito conhecido e usado, para que você se atente e veja se já utiliza no seu dia a dia!

Quero deixar uma pergunta para vocês responderem, para até mesmo treinar o conteúdo:

No seu dia a dia você já utiliza esse padrão? Pense e escreva um pouco sobre projetos que você atua e como é usado, ou deveria ser usado?

Obrigado pelo seu tempo.
Compartilhem com seus colegas de estudo/trabalho.
Me acompanhem em minhas redes sociais:

Até a próxima!

Git & Github: Guia básico e boas práticas de Pull Request

Matheus Poda — Tue, 09 May 2023 11:12:14 +0000

Entendendo Pull Request

De forma prática, o pull request é uma camada de segurança que podemos adicionar no repositório de nossos projetos, principalmente quando o repoistório é compartilhado com uma equipe.

Nessa camada é empacotado os commits, com os códigos novos ou alterados de uma determinada branch, acompanhada de uma descrição do que tem dentro do pacote, para que um outro desenvolvedor com maior experiência no projeto, ou até mesmo um arquiteto, realize uma análise, antes de realizar o merge entre branches.

Vamos a um exemplo:

Imagine que esteja trabalhando em uma aplicação que realiza serviços de cadastro de clientes. No momento está criado apenas a funcionalidade de cadastro cliente pessoa física (PF), mas o responsável pelo negócio do sistema, trás que vai ser preciso criar a funcionalidade para cadastro cliente pessoa jurídica (PJ).

Seguindo a ideia de boas práticas de desenvolvimento em repositórios, iremos estar criando uma branch a partir de desenvolvimento (desenv) com o nome "feature_cadastrar_cliente_pj", onde o desenvolvedor responsável irá começar a construir a solução.

Após alguns commits, ele finalizou a implementação do negócio e deseja agora subir para o ambiente de desenvolvimento, para disponibilizar a nova versão para testes, seja automáticos de e2e (end-two-end), ou para QA's da equipe testarem.

Porém, seguindo as práticas de segurança do repositório, ele precisa criar uma PullRequest, onde vai estar empacotado todos os commits, com seu código novo ou alterado, que ele realizou ao longo do processo de desenvolvimento, disponibilizando para o arquiteto do time analisar e verificar se está de acordo com as boas práticas da empresa.

Após o arquiteto realizar a code review e verificar que está tudo certo, ele irá aprovar o pull request, o que por fim irá fazer com que aconteça o merge entre as branches.

Importância de utilizar Pull Request

Agora que entendemos o que é o Pull Request, vamos tentar compreender qual a importância dele:

Ele ajuda a manter a qualidade do código, uma vez que os revisores podem detectar e corrigir erros antes do merge.
Ajudar a documentar o histórico de desenvolvimento do projeto, fornecendo um registro de todas as alterações propostas e merges no repositório.

Tendo o significado e a importância do Pull Request, precisamos dar uma rápida olhada para as boas práticas e dicas para transformar essa camada de segurança ainda mais prática e funcional.

Boas práticas

Tamanho do pull request

É comum acontecer de acumular muitos commits em uma branch, e na hora de criar um pull request ter uma enorme quantidade de código para revisar.

Isso pode gerar um enorme problema a longo prazo, de acordo com um estudo realizado pela Cisco, pode ser um código com grande chances de impacto e também pode ocorrer falha humana, já que a revisão acabará não sendo tão prática, e o processo de code review pode se tornar preguiçoso e lento.

Então tome cuidado em não demorar muito para gerar um pull request! Não espere toda a funcionalidade ser desenvolvida, dependendo da complexidade, divida em pequenas partes e vá realizando a pull requests.

Título e descrição

Assim como ao escrever um código limpo, precisamos dar nomes que façam sentido, aqui também vale. Ao criar um pull request escreva bons títulos e descrições.

Aqui uma dica brilha, é possível criar templates para os pull request, usando eles toda vez que um desenvolvedor da equipe for fazer um pull request, já é adicionado um comentário padrão onde ele pode editar rapidamente apenas as partes relacionadas a alteração dele.

Logo a frente irei estar abordando algumas ideias de template e como colocar em seu projeto.

No caso de título, existem algumas opções, que você pode seguir:

Uma descrição bem resumida da funcionalidade (ou parte dela), adicionado recurso de consulta cliente por cpf;
Adicionar uma tag relacionada a ação realizada no código do pacote, exemplo: [Correção], [Funcionalidade], [Refatoração], [Lançamento], [Ajustes] e etc;
Caso trabalhe com aplicações de gerenciamento de tarefas, como Jira, Trello e etc, podemos colocar o id da tarefa/cartão, #777 [Funcionalidade] adicionado recurso de consulta cliente por cpf.

Templates de Pull Request

Podemos criar alguns templates para deixar padronizado os comentários que os desenvolvedores irão utilizar, dessa forma poderá aumentar a produtividade tanto da criação dos pull request, como também para facilitar a vida do responsável pela code review.

Exemplos de templates:

Para bugs:

## Como reproduzir o bug?
Descrever rapidamente como ocorre o bug e qual foi a solução criada.

## Checklist
- [ ] Eu adicionei|atualizei|corrigi os testes unitários do projeto (Se aplicável);
- [ ] Sem erros ou avisos no console após minha alteração;
- [ ] Tirei prints do antes e depois da correção do problema.[adicionar a screenshot]

Para novas funcionalidades

## Resumo
Escreva um breve resumo sobre o que foi alterado no sistema.
## Checklist
- [ ] Eu adicionei|atualizei|corrigi os testes unitários do projeto (Se aplicável);
- [ ] Sem erros ou avisos no console após minha alteração;
- [ ] Tirei prints do antes e depois da correção do problema.[adicionar a screenshot]

Customizado

Não é possível dar uma fórmula de bolo, já que cada padrão depende da empresa, tipo de projeto e etc, porém, podemos encontrar um exemplo mega completo de um template de Pull Request, no site Embedded Artistry, pode utilizar de exemplo e modificar para o seu caso.

Como adicionar em seu repositório

Tutorial para GitHub: https://docs.gitlab.com/ee/user/project/description_templates.html#creating-merge-request-templates
Tutorial para GitLab: https://docs.github.com/en/github/building-a-strong-community/creating-a-pull-request-template-for-your-repository
Tutorial para Azura DevOps: https://docs.microsoft.com/en-us/azure/devops/repos/git/pull-request-templates?view=azure-devops
Tutorial para Bitbucket: https://confluence.atlassian.com/bitbucketserver/create-a-pull-request-808488431.html

Conclusão

Espero que eu tenha alcançado o objetivo de te ensinar o que é Pull Request! Ao ler e testar esse tópico, você deve ser capaz de:

Explicar o que é Pull Request;
Qual a importância;
Boas práticas;
Como usar templates e para que servem.

Obrigado pelo seu tempo.
Compartilhem com seus colegas de estudo/trabalho.
Até a próxima!

Git & Github: Começando com assinatura de commits

Matheus Poda — Thu, 04 May 2023 12:23:50 +0000

Problema de não assinar commits

Quando começamos a trabalhar com git, a primeira coisa básica, além de instalar, é começarmos uma série de comandos para dizer quem somos nós.

git config --global user.name "Matheus Poda"
git config --global user.email mpoda@example.com

Essas informações que passamos é utilizada quando realizamos commit do nosso código, dessa forma, sempre estará aparecendo seu nome e dados, para mostrar quem foi o responsável por realizar um commit no repositório.

Porém, é comum burlar esses dados que passamos, quando estamos trabalhando em projetos de larga escala com diversas equipes ou até mesmo uma equipe pequena.

Qualquer pessoa na equipe, pode alterar as configurações que vimos acima e colocar você ou outra pessoa, que não é responsável pelo commit, e realizar essa ação e isso pode acabar se tornando um problema de segurança.

Por conta dessa possível "fraude" de autor de commit, que podemos utilizar uma forma ainda mais segura de trabalhar com Git e a plataforma de repositórios (GitHub, Bitbucket e etc), essa forma é assinando digitalmente nossos commits.

Nesse breve tópico, vou estar ensinando o básico de como gerar uma assinatura e assinar commits direto no GitHub!

Instalação no Windows

O primeiro passo para começar a assinar seus commits, é de fato, criar a assinatura, que é um processo de segurança, já que é feito através de chaves (Tokens) criptografadas.

Para criar essa chave, iremos utilizar o sistema GPG (GNU PG), que praticamente é um software open-source que trás a mesma ideia do PGP (Pretty Good Privacy), que no caso é pago. Esse software nos permite criar chaves criptografadas para uso.

Nesse tópico, estarei utilizando o sistema operacional Windows, porém vou deixar mais a baixo alguns links de referência para usuários linux/mac se guiarem, normalmente o gpg nesses sistemas, já vem pré-instalado, porém no Windows é preciso instalar.

Para realizar a instalação, você deve baixar o gpg4win, nele vem outro sistema de criptografia junto, o Kleopatra, que pode ser útil no futuro.

Alguns tutoriais para instalação e teste do GPG nos sistemas linux/mac:

Criando sua chave GPG

Tendo o gpg funcional em seu terminal de preferência, vamos começar a parte de criação da chave.

O primeiro comando útil de saber é o relacionado a listar nossas chaves:

gpg --list-secret-key --keyid-form LONG

Para criarmos uma chave, usaremos o seguinte comando:

gpg --full-generate-key

Ele irá te fazer três perguntas, para o tipo de Key, recomendo utilizar o RSA e colocar 4096 bits, também irá pedir o tempo de duração da chave e por fim irá pedir seu nome e senha (IMPORTANTE: Lembre-se de colocar o mesmo nome e e-mail que seu git config).

Ele irá pedir também uma senha para você dar a chave que está criando, então não esqueça de colocar e anotar.

Adicionado sua chave ao GIT

O primeiro passo é você obter o id da chave gerada, basta usar o comando que apresentei, você irá ver algo como:

Para adicionar a assinatura que você acabou de ver pelo comando de listagem, utilizaremos o seguinte comando

git config --global user.signingkey xxxx

*xxx *-> sua chave

Além disso, precisamos deixar claro que iremos querer assinar nossos commits a partir de agora com a chave gerada:

git config --local commit.gpgsign true

Lembrando que no comando, --local apenas no diretório que você está seu commit será assinado se quiser que sempre seja, independente do repositório (o que não indico), basta colocar --global.

Adicionando chave no GitHub

Para adicionar no github, você precisará da chave pública, obteremos através do seguinte comando:
gpg --armor --export

Ele irá gerar uma sequência de caracteres gigante, você irá copiar do "--BEGIN PGP PUBLIC KEY BLOCK" até o "END PGP KEY BLOCK", incluindo esses caracteres.

Tendo eles em mãos, iremos entrar no github e ir até os settings, selecionar "SSH and GPG Keys" e iremos clicar no botão "New GPG Key", lá você deverá colar o que copiou lá no terminal.

Realizando um commit assinado

Agora com tudo configurado e já tendo uma chave vinculada ao GitHub e no seu Git, realizaremos um commit assinado.

Primeiro, vou criar um repositório para realizarmos um commit:

Vou criar um arquivo index.html, para realizar um commit:

Agora vamos realizar o commit assinado:

1- Vou estar ativando a configuração para obrigar assinatura nesse repositório:

2- Realizar o commit assinado:

git commit -S -m "First Commit!"

Colocamos o -S para dizer que é assinado, e posteriormente ele irá abrir a tela para colocar a senha que criamos quando geramos a chave.

3- Verificando no GitHub:

Como podemos ver, ao lado do commit que realizamos está com a tag 'verified', que demonstra que foi de fato assinado.

Espero que tenha sido claro e agora você irá assinar seus commits e ter um projeto ainda mais seguro!!

Se você curtiu, não esqueça de salvar esse artigo e compartilhar com o pessoal da sua equipe!

Obrigado pelo seu tempo.

Referências

Como usar Java Stream API?

Matheus Poda — Thu, 19 Jan 2023 12:02:00 +0000

Progressivamente mais, vem se tornando um requisito obrigatório criar soluções com processamento rápido, que lidam bem com paralelismo para desenvolver um backend de qualidade, confiabilidade e escalabilidade.

Por consequência um modelo “novo” (que na verdade é extremamente antigo, já que sua existência pelo que sabe originou-se em 1950 e já era usada no velho Lisp), chamado de programação funcional, vem sendo muito utilizado, por isso novas tecnologias aparecem com esse paradigma como base e outras adicionam suporte a ela (JavaScript, Python, Ruby e etc).

O Java não seria diferente, em março de 2014 foi lançada a versão 8, contando com inúmeras mudanças e o início do suporte ao arquétipo funcional, com novas construções, a adição de expressões lambda, bibliotecas para trabalhar com coleções e também data e hora.

O que é o Stream API?

Uma dessas adições foi a interface Stream, que veio para melhorar mais as operações com coleções, já que possui vários métodos.

Por exemplo:

Imagine uma lista numérica, onde você deseja imprimir no console apenas números pares, antes do Java 8, provavelmente seria utilizado o seguinte algoritmo.

Você possivelmente utilizaria o foreach para realizar a iteração, porém com essa nova Interface, podemos fazer em apenas duas linhas:

Onde usamos o método stream, para realizar a chamada da interface e usamos o método intermediário “filter()”, passando uma função lambda para filtrar por pares e por fim chamamos um método terminal, para realizar uma determinada operação, que no caso é apenas um “System.out.println”, para exibir no console.

Benefícios de seu uso

Torna seu código conciso;
Diminuição e facilitação de leitura;
Fácil de realizar manutenção;
Não precisa se preocupar com processamento em si, já que o Stream é responsável por iterar, não sua lógica;

Lembre-se: Por seguir o paradigma funcional, não se pode esquecer da imutabilidade, isto é, o Stream não irá “modificar” a coleção que está sendo utilizada. Por exemplo, se no caso de, ao invés de listar, queremos salvar na lista apenas os números pares, obrigatoriamente você terá que criar um novo objeto;

Como funciona a stream

Stream por definição no Java, é uma “sequência de elementos de uma fonte de dados que oferece suporte a diferentes tipos de operações de agregação”. Ela é uma interface para operarmos com um conjunto de elementos sequenciais de um determinado tipo.
Mas atenção, o Stream não armazena dados, serve para ser esse fluxo de operações para um resultado final.
Imagine o seguinte código de uma coleção usando Streams:

O fluxo de funcionamento de uma Stream é a seguinte:

Se inicia com o dado de origem, que normalmente será uma coleção de itens e irá passar pelo pipeline (conjunto de métodos que fazem operações básicas), por fim irá gerar um resultado através de um dado terminal (que retorna algo que não seja um Stream).
Lembre-se que os dados na stream seguem um paradigma funcional, a cada método usado na pipeline irá gerar uma nova stream.

O stream possui dois tipos de operação, operações intermediárias (sorted, filter, map e distinct) e operações terminais (forEach, average, collect e allMatch).

Vamos entender qual a responsabilidade de cada uma delas, quais métodos mais importantes fazem parte delas.

Operações Intermediárias

São os métodos usados para realizar operações que podem modificar o resultado final, aqui encontramos comparadores, ordenadores, modificadores e etc.
Para todos os exemplos, usaremos o objeto Fruta, que é a representação abstrata de uma fruta:

Sorted
Como o nome sugere, utilizamos para ordenar a stream. Com ele pode ordenar de uma forma específica utilizando, por exemplo, a interface Comparator.

Exemplo de uso:

Imagine que eu tenho um carrinho de compras de uma feira de frutas, e eu decido ordenar em ordem alfabética.
Podemos utilizar o sorted, passando a interface Comparator, com o tipo de dado que iremos ordenar, no caso por ser uma String, vai se tornar alfabético.

No console irá ficar:

Filter

O método filter é muito útil no dia a dia, quando trabalhamos com consultas, ou queremos filtrar qualquer tipo de dado.
Ele recebe como parâmetro uma interface funcional (Predicate) que define uma função onde precisamos devolver um boolean. Dessa forma iremos receber como retorno uma nova stream que foi filtrada por nosso predicate.
Exemplo de uso:

Temos um carrinho de compras de frutas e desejamos apenas frutas que começam com a letra A.

No console irá ficar:

Map

Quando necessitamos fazer algumas transformações em alguma coleção de dados, o método map é o ideal.
Assim como o filter, ele também possui como argumento uma interface funcional que é o Function.
Essa função irá pegar todos os elementos da stream como parâmetro e depois irá retornar os elementos que passaram pelo processo, em uma nova stream.

Exemplo de uso:

No meu carrinho de frutas, descobri que preciso adicionar a palavra “fruta-”, antes do nome das frutas. Podemos utilizar o map para modificar os itens:

No console irá ficar:

Distinct

A ideia é ser igual ao da linguagem SQL, retorna uma nova stream contendo elementos não repetidos, porém tem um detalhe, os itens da coleção que você está utilizando, precisam ter o método equals implementado, pois ele usa ele para realizar o algoritmo.

Exemplo de uso:

Imagine que no seu carrinho de compras, você não quer que tenha duas frutas iguais, caso o cliente esteja comprando duas, haverá uma variável de quantidade que irá computar.

Primeiro, para usarmos o distinct, adicionaremos os métodos hashcode e equals em nosso objeto Fruta:

Agora, aplicando o distinct:

No console fica:

Operações terminais

São métodos finais do fluxo Stream, usado para te retornar um resultado diferente de uma nova stream, como no caso dos intermediários (List, String, Long, Integer e etc).

Seus métodos mais importantes são:

ForEach
Assim como o foreach original do Java, ele segue a mesma ideia, nele é possível realizar um loop em todos os elementos e realizar algum tipo de processamento.
Exemplo de uso:
Até agora usei praticamente em todos os exemplos das operações intermediárias, para poder imprimir no console as frutas, praticamente essa é a ideia, ele permite receber funções lambda.
No exemplo, usei o println:

Average

É utilizado para calcularmos a média de valores de um elemento. Considerado uma operação de redução, já que ele irá retornar um único elemento.

Exemplo de uso:

Vamos adicionar mais uma propriedade no objeto Fruta, será o de “preço”:

Agora imagine o seguinte caso, no carrinho de compras, com o preço agora, queremos saber a média gasta pelo cliente ficando da seguinte forma:

No console fica:

Collect

Método que possibilita obtermos os itens da Stream que estamos mexendo e transformarmos em coleções (List, Set e Map). Normalmente colocamos como argumento o Collectors (exemplo em uma lista, “Collector.toList()”).

Exemplo de uso:

Imagine que eu queira trabalhar com apenas frutas que começam com a letra “M” e decido criar uma nova lista com elas.

No console fica:

Count
Assim como o size das coleções, esse método irá retornar quantos elementos temos em uma stream. Retornar um único valor.

Exemplo de uso:

Usando o exemplo anterior, irei querer saber ao invés da lista de frutas, apenas quantos tem:

No console fica:

AllMatch

Esse método é responsável por garantir se todos os elementos estão de acordo com uma condição. Assim como o filter, ele recebe a interface funcional Predicate, com a função, assim ele irá retornar um boolean.

Exemplo de uso:

Por exemplo, se eu utilizar ele na minha lista de frutas original, ele deve retornar false, pois, nem todas começam com a letra “M”:

No console:

Agora se filtrarmos:

No console fica:

Conclusão

O Stream do Java veio para ajudar ainda mais nós desenvolvedores, através do seu fluxo de desenvolvimento, com uma variável de origem, seguida de métodos intermediários (pipeline) que irão gerar novas versões da Stream e finalizamos com um método terminal para gerar o resultado que queremos.

Espero que tenha ficado claro o uso dessa API incrível, agora não se esqueça de aplicar em seus projetos e se tornar um desenvolvedor com um código cada vez melhor!

Como usar melhor a API Java Collection

Matheus Poda — Wed, 04 Jan 2023 12:03:00 +0000

Introdução

Como desenvolvedor Java, sempre tive uma alta demanda de estudos práticos e isso acabou me gerando diversas dúvidas ao longo da minha carreira.

Então, após finalizar minha faculdade de Engenharia da Computação, desejei voltar desde os fundamentos e estudar, me aprofundando em cada ponto da linguagem de programação Java, respondendo dúvidas comuns que ficavam em minha cabeça.

Nesse artigo irei explicar o que é o Java Collection, já dando spoiler, também irei explicar qual o motivo de usar essa API incrível do Java e quando usar cada uma das principais estruturas de dados que ela trata através de suas incríveis interfaces.

O que é a Java Collection?

É uma API Java, que fornece a nós desenvolvedores, um conjunto de classes e interfaces para armazenarmos, acessarmos e manipularmos um conjunto dinâmico de objetos (precisa ser objetos, os métodos não aceitam tipos primitivos, então caso precise de uma lista de inteiros, por exemplo, você irá utilizar Integer e não int).

Dessa forma tratamos esse conjunto de dados como uma coleção, que por sinal é o nome da interface base da API, o Collection. Essa API possui uma enorme gama de interfaces interligadas com métodos para realizar as operações já citadas.

Por que usar?

A resposta é bem simples, temos vários motivos, os mais essenciais no meu ponto de vista, são:

Reuso das Interfaces disponíveis;
Entendimento do código, já que na maioria esmagadora dos casos, implementamos o Java Collection em nossa aplicação, sendo muito mais simples e fácil de entender seu uso como sua performance, ao invés de algoritmos escritos de forma própria;
Boa qualidade, pois como havia dito, é extremamente utilizada em projetos, então foi submetida a muitos testes;

Hierarquia da API

Na API possuímos uma grande quantidade de interfaces e classes feitas para disponibilizar métodos e gerenciamento através de objetos, temos vários casos de colecionamento de objetos.

Como mostra a hierarquia abaixo:

No caso do Map, mesmo que ele não esteja na Coleção em si, ele pertence a esse pacote de utils do Java e pode ser usado da mesma forma.

Através dessas interfaces, podemos criar listas (list), conjuntos (set), mapas (map), filas (queue), Stack (pilha) e etc.

Quais são as interfaces mais comuns?

List

Visão geral sobre essa interface, que é a mais utilizada da API:

Objetos ordenados;
Pode conter elementos duplicados;
Indexado, podemos ter controle sobre o local do elemento;
Muito parecido com o Array comum, mas ele é dinâmico;
As classes mais utilizadas em implementação é o ArrayList e o LinkedList;

Em que momento utilizar essa interface:

Quando precisaremos fazer acessos aleatórios, já que ela é indexada;
Caso exista a chance de ter elementos duplicados na sua coleção;

ArrayList VS LinkedList:

ArrayList

Precisa fazer consultas mais vezes pelo índice;
Não precisa de inserções e remoções constantes.

LinkedList

Consultas frequentes pelo início e fim da coleção;
Precisa fazer inserções e remoções constantes;
Lista com um tamanho significante.

Exemplo de chamada:

ArrayList

LinkedList

Set

Visão geral sobre a interface Set:

Não permite elementos duplicados, elementos únicos;
Trabalha com representações de conjuntos matemáticos;
Não é indexada;

Utilizamos essa interface, quando precisamos montar uma coleção sem elementos duplicados:

Quando possui um sistema que cadastrará usuários únicos no sistema.
Para armazenamento de números únicos em algoritmos.

Suas implementações são:

HashSet: Elementos únicos, mas sem ordenação, consulta rápida;
TreeSet: Elementos classificados em ordem natural, consulta um pouco mais lenta que o HashSet;
LinkedHashSet: Mantém uma lista duplamente ligada através de seus itens. Seus elementos são integrados na ordem em que foram inseridos. Como por exemplo uma corrida de fórmula 1, onde temos que armazenar as colocações;

Exemplo de chamada

HashSet

TreeSet

LinkedHashSet

Map

Visão geral sobre a interface Map:

Mapeamento chave-valor;
Não pode repetir mesma chave, mas podemos ter chaves diferentes com o mesmo valor;

Utilizamos o Map quando precisamos da interação de chave-valor, como na classe Properties, ou até mesmo quando queremos montar os query params de uma chamada e precisamos passar o nome da variável e o valor dela.

Suas implementações

HashMap: Permite chaves e valores null, não possui garantia de ordenação;
TreeMap: Garantia de ordenação em ordem crescente pela chave, mas pode ser alterado, usado quando queremos nosso map ordenado;

Exemplos de chamada:

HashMap

TreeMap

Conclusão

Espero que tenha ficado claro em que momento usar cada uma das interfaces e suas implementações, é extremamente importante entender as ferramentas que temos disponíveis em nossas mãos, para criar um código de qualidade e logicamente mais efetivo.

Estarei disponibilizando uma tabela resumida sobre o assunto explicado:

Também meu repositório com exemplos dos métodos das implementações citadas. Link do git
Caso queira se aprofundar mais, nada melhor que a documentação oficial: Documentação Oracle

Obrigado por terem ficado até aqui, e lembre-se que a jornada é uma montanha, é difícil subir, mas quando se está no topo, a vista é incrível.

Até a próxima.

Referências:

https://www.digitalocean.com/community/tutorials/collections-in-java-tutorial https://www.javatpoint.com/collections-in-java https://www.devmedia.com.br/java-collections-como-utilizar-collections/18450 https://www.quora.com/What-are-the-most-important-Java-collections-to-use https://stackoverflow.com/questions/21974361/which-java-collection-should-i-use