DEV Community: João Victor Santos

E Se... As Condicionais Fossem Mais Simples? Transformando Código com Boas Práticas

João Victor Santos — Fri, 16 Aug 2024 14:46:20 +0000

Escrever código não é apenas fazê-lo funcionar; é sobre entender como nossas escolhas de estrutura afetam a legibilidade, manutenção e eficiência do código. O uso adequado de condicionais como if-else desempenha um papel crucial nesse processo.

Importância da escolha correta

Cada if e else representa um caminho que pode levar a diferentes resultados. Embora a solução mais rápida seja tentadora, ela pode se tornar insustentável ao longo do tempo.

Um código claro e conciso melhora a legibilidade, facilita futuras modificações e promove a colaboração entre desenvolvedores. Essa clareza começa com a escolha adequada das estruturas condicionais.

A simplicidade como abordagem

Aninhar condicionais pode criar uma cascata de if-else que, embora funcione, torna-se difícil de entender. Simplificar essas estruturas com early return pode ser a melhor abordagem:

Early return é o retorno imediato de uma função quando a condição é atendida, evitando o uso de else e reduzindo a complexidade.

public String determinePermission(String accessLevel) {
    if (accessLevel.equals("Administrator")) {
        return "Full access granted";
    }
    return "Limited access granted";
}

Este exemplo demonstra como um retorno antecipado elimina a necessidade de else, tornando a intenção do código mais clara e fácil de compreender. Ao eliminar aninhamentos desnecessários, criamos um fluxo mais linear e menos propenso a erros.

Simplificando decisões

Em vez de utilizar uma série de if-else, mapear condições com lookup tables é uma maneira mais eficiente:

var vehicleTypes = map[string]string{
    "car":      "land",
    "boat":     "water",
    "airplane": "air",
}

func getTransportMedium(vehicle string) string {
    if medium, exists := vehicleTypes[vehicle]; exists {
        return medium
    }
    return "unknown medium"
}

Aqui, utilizamos um mapa para relacionar tipos de veículos com seus meios de transporte, melhorando a clareza e facilitando a manutenção e escalabilidade do código.

Organizando a complexidade

Quando as condições são numerosas, o switch-case é uma solução ideal para organizar múltiplas condições de forma clara:

function getInstrumentSound(instrument) {
    switch (instrument) {
        case "guitar":
            return "strum";
        case "drum":
            return "beat";
        case "flute":
            return "whistle";
        default:
            return "unknown sound";
    }
}

O switch-case lida com múltiplas condições de maneira elegante, tornando o código mais fácil de seguir e menos propenso a erros.

Usando estratégias a seu favor

Outro conceito importante é o short-circuit evaluation, onde as condições em uma expressão lógica são avaliadas até que o resultado seja conhecido. Isso significa priorizar condições mais prováveis, economizando tempo de execução.

Comece com a condição mais provável no OR ('||'):

if conditionLikelyTrue || otherCondition {
    // código executado se qualquer uma das condições for verdadeira
}

Ou com a menos provável no AND ('&&'):

if unlikelyCondition && otherCondition {
    // código executado somente se ambas as condições forem verdadeiras
}

Exemplo prático

Um exemplo em Kotlin:

val containerView = container.itemView as? ViewGroup ?: return

if (containerView.isEmpty()) return

Aqui, o operador Elvis (?:) permite um retorno imediato caso container.itemView não seja um ViewGroup, evitando uma verificação explícita de nulidade. A verificação containerView.isEmpty() utiliza early return, mantendo o código mais linear.

O operador Elvis em Kotlin permite que você forneça um valor padrão se a expressão for null, tornando o código mais conciso.

Boas práticas

O uso de constantes e variáveis semânticas simplifica e clarifica o código:

Utilizar constantes para operações booleanas melhora a legibilidade:

final boolean isAdult = age >= 18;
final boolean hasPermission = permissionGranted;

if (isAdult && hasPermission) {
    // código executado se a pessoa for adulta e tiver permissão
}

Crie constantes semânticas para cadeias de operações booleanas complexas:

final boolean isEligible = isAdult && hasPermission;
final boolean canProceed = isEligible && hasPaidFee;

if (canProceed) {
    // código executado se a pessoa for elegível e tiver pago a taxa
}

O operador ternário deve ser utilizado com parcimônia, apenas quando a expressão é simples e clara, pois pode comprometer a legibilidade do código:

String status = isEligible ? "Approved" : "Denied";

Utilize Guard Clauses no início da função para verificar condições e interromper a função, protegendo a execução indesejada:

if (!isValid) {
    return;
}
// Restante do código

Guard Clauses são verificações no início de uma função que permitem sair da função caso uma condição específica não seja atendida, simplificando o fluxo de controle.

Conclusão

Cada if, else ou switch que escrevemos contribui para o resultado final. Investir tempo para entender e aplicar as melhores práticas no uso de condicionais não só cria um código mais eficiente, mas também nos prepara para desafios mais complexos no futuro. A capacidade de escolher e aplicar a estrutura condicional adequada define a qualidade e sustentabilidade do nosso trabalho. Enfrentar essas escolhas com atenção e cuidado é essencial para evoluirmos como desenvolvedores.

A Arte de identificar o Problema Antes de Buscar Soluções

João Victor Santos — Sat, 20 Jul 2024 22:39:00 +0000

A minha jornada sempre foi desafiadora quando se trata de socialização, mas a resolução de problemas nunca foi um obstáculo pra mim. No entanto, essa dificuldade me trouxe uma experiência valiosa: a importância de enfrentar um problema diretamente antes de buscar ajuda.

Observei que, em ambientes que já estive de trabalho e aprendizado, a busca por soluções rápidas frequentemente reflete a falta de compreensão profunda do problema.

A Importância da Iniciativa

No meu estágio, uma das frustrações era ver a falta de iniciativa em buscar soluções antes de pedir ajuda. Embora pedir ajuda não seja um problema, eu percebia que muitos não faziam um esforço inicial para resolver por conta própria. Essa falta de tentativa própria pode ser um obstáculo para o aprendizado profundo e a compreensão real do problema.

Enfrentar o desafio diretamente ajuda a entender melhor o assunto, além de
promover um aprendizado mais sólido. E quando isso é feito por conta
própria, pode ensinar muito mais do que apenas buscar uma solução pronta.

O grande Jogo

A vida é um constante jogo entre escolhas e respostas. E a nossa trajetória é moldada atráves das respostas que temos ao tomar nossas decisões todos os dias. Não se trata apenas de responder, mas sim, de entender o que perguntar e de como ela é refletida no que precisamos resolver. Cada escolha cria um caminho, e a capacidade de buscar e interpretar respostas define o impacto dessas escolhas.

Escolher é um ato decisivo, mas o verdadeiro desafio está em obter boas respostas. Devemos fazer nossas escolhas, inicialmente, e isso vai definir a a qualidade das repostas, que virá da reflexão de nossas perguntas.

A minha perspectiva

Pular para a solução sem entender o problema, pode levar a resultados insatisfatórios e soluções que não tem as reais expectativas. Quando começamos a ter uma compreensão clara do problema, nossas soluções tendem a ser mais eficazes e direcionadas.

Conclusão

Por fim, embora o nosso dia a dia seja cheio de desafios e escolhas, o que
vai realmente nos direcionar e evoluir é a compreensão das respostas. E para criar caminhos mais significativos, devemos enfrentar os problemas,
investindo tempo e esforço para entender e resolver nossos próprios problemas. Esse processo não irá melhorar apenas suas habilidades, mas também irá definir a sua trajetória.

Desvendando Mistérios: Como Tentar Resolver Problemas Sem Pedir Ajuda

João Victor Santos — Fri, 19 Jul 2024 15:59:41 +0000

Sempre tive dificuldade em pedir ajuda, seja por achar que estou incomodando ou por pensar que o problema é simples e óbvio, e deve haver uma maneira rápida de resolvê-lo. No entanto, no desenvolvimento de software, nem sempre os problemas são simples, e os desafios fazem parte do processo de crescimento.

Saber como abordar esses problemas de forma independente antes de pedir ajuda pode melhorar suas habilidades e torná-lo um desenvolvedor mais autossuficiente. Ao longo da minha jornada de aprendizado, desenvolvi alguns passos simples para tentar resolver um problema por conta própria:

Verificar os Imports e Dependências
Um erro pode ser causado por uma dependência ausente ou import incorreto. Confirme se todos os imports e dependências estão corretamente configurados.
Limpar o Cache
Limpar o cache pode resolver problemas causados por dados armazenados. Execute os comandos apropriados para fazer a limpeza correta do seu projeto.
Verificar os Logs
Logs são uma fonte valiosa de informação. Examine os logs do sistema e da aplicação para identificar possíveis mensagens de erro.
Reiniciar a Máquina e o Servidor
Problemas temporários podem ser resolvidos reiniciando a máquina e o servidor, eliminando falhas que não são aparentes imediatamente.
Atualizar o Repositório
Garanta que você está trabalhando com a versão mais recente do código. Executar o comando git pull origin main pode trazer uma versão atualizada em que o problema já foi resolvido.
Procurar o Erro no Google e no ChatGPT
O Google é uma ferramenta poderosa para resolver problemas, e muitas vezes outros desenvolvedores já enfrentaram o mesmo problema e compartilharam suas soluções online. Ferramentas como o ChatGPT também podem trazer insights interessantes.
Buscar Implementações Similares
Analisar como outros desenvolvedores abordaram problemas semelhantes pode trazer ideias valiosas para o que você está tentando fazer.
Ler a Documentação
A documentação oficial frequentemente contém a solução para problemas comuns. Reler a documentação com atenção pode garantir que nenhuma informação importante seja perdida.

Quando Pedir Ajuda

Pedir ajuda é essencial em várias situações no desenvolvimento de software. Quando você está completamente perdido, sobrecarregado de tarefas, ou cometeu um erro sem saber como corrigi-lo, buscar orientação pode ser crucial. Além disso, se o problema exige conhecimentos que você não possui, está impactando uma entrega crítica, ou envolve múltiplas áreas de expertise, uma segunda opinião pode acelerar a resolução e minimizar riscos.

Se você está preso em um problema por muito tempo, uma nova perspectiva pode ser a chave para avançar. Pedir ajuda também é uma oportunidade de aprender com colegas mais experientes, garantindo que suas soluções sejam seguras e eficazes, especialmente quando envolvem riscos significativos.

Como Pedir Ajuda

Ao pedir ajuda, seja claro e específico ao descrever o problema, incluindo mensagens de erro, contexto e as tentativas de resolução já realizadas. Forneça o contexto necessário explicando seu objetivo final e onde está enfrentando dificuldades, e compartilhe um trecho de código ou um exemplo mínimo reproduzível para facilitar a identificação do problema.

Mostre que você tentou resolver o problema por conta própria e seja breve e direto em suas explicações, destacando as informações mais relevantes. Inclua detalhes do ambiente de desenvolvimento, como linguagem de programação e framework. Após receber ajuda, dê feedback sobre a eficácia da solução e agradeça, lembrando que a pessoa pode precisar de tempo para responder.

Por fim...

Não deixe de pedir ajuda. Essa é a minha forma de tentar resolver problemas, e, pela minha jornada ser solitária, acabei me obrigando a me tornar autossuficiente. No entanto, não sinta vergonha de pedir ajuda. Apenas se esforce, pois isso demonstra interesse e comprometimento.

Monotonia das Cores: A Revolução Silenciosa

João Victor Santos — Fri, 19 Jul 2024 02:02:40 +0000

Você já parou para pensar em como o nosso mundo está ficando mais cinza?

Recentemente, assisti a um vídeo fascinante no YouTube do Pedro Loos intitulado Por que o MUNDO está ficando menos COLORIDO, onde ele explora as mudanças nos padrões de cores ao longo do tempo e como a diminuição da diversidade de cores está afetando nossas vidas. Essa preferência crescente por tons mais suaves sempre me incomodou, por isso decidi investigar como essas tendências influenciam o desenvolvimento de software.

A Evolução das Cores no Mundo

Menos Cores ao Redor

No vídeo, Pedro Loos mostra que o mundo está, de fato, ficando menos colorido. Desde os anos 80, há uma tendência crescente de usar paletas de cores mais neutras e monótonas em objetos e espaços. Isso se deve a vários fatores, incluindo mudanças nas preferências estéticas e influências culturais. Essa mudança não apenas transforma a maneira como percebemos o mundo ao nosso redor, mas também impacta diversas indústrias, incluindo o desenvolvimento de software.

Impacto no Desenvolvimento de Software

1. Consistência e Simplicidade

Com a crescente preferência por paletas de cores mais neutras, os desenvolvedores de software estão adotando interfaces de usuário mais simples e consistentes. Isso pode ser observado em muitas aplicações modernas que utilizam esquemas de cores minimalistas. A acessibilidade é um fator importante aqui, pois cores neutras tendem a ser mais acessíveis para indivíduos com deficiências visuais, como daltonismo.

2. Redução de Sobrecarga Cognitiva

Paletas de cores simples podem ajudar a reduzir a sobrecarga cognitiva dos usuários. Quando as interfaces são menos saturadas e mais homogêneas, é mais fácil para os usuários se concentrarem nas tarefas principais sem serem distraídos por elementos visuais excessivos. Isso pode aumentar a produtividade e melhorar a experiência do usuário.

3. Desafios Criativos

Por outro lado, a tendência para menos cores pode representar um desafio para designers e desenvolvedores que buscam criar interfaces visualmente atraentes. A criatividade pode ser limitada quando as opções de cores são reduzidas, exigindo soluções inovadoras para manter a interface interessante e envolvente.

4. Padronização e Design System

O uso de paletas de cores neutras também facilita a padronização em sistemas de design. Como mencionei no meu artigo sobre Design Systems, a padronização é crucial para a consistência e escalabilidade das aplicações. Paletas de cores neutras simplificam a criação de guias de estilo e bibliotecas de componentes, tornando mais fácil manter a coesão visual.

Conclusão

A tendência de um mundo menos colorido tem impactos significativos no desenvolvimento de software. Enquanto simplifica a criação de interfaces consistentes e acessíveis, também desafia os desenvolvedores a encontrar maneiras criativas de manter o interesse visual. Adaptar-se a essas mudanças é essencial para continuar criando experiências de usuário eficientes e envolventes em um mundo que está, cada vez mais, adotando uma paleta de cores neutras.

Eu particularmente gosto do estilo minimalista, mas não há como negar o quanto isso afeta a beleza das coisas e a criatividade. Evitamos explorar o desconhecido mesmo quando a inovação é necessária, pois isso nos influencia a continuar sempre evoluindo.

"Pois a realidade sem sonho e fantasia não tem nenhum sentido..."

Todo Mundo Precisa de um Design System... Mas Ninguém Quer Mantê-lo!

João Victor Santos — Wed, 17 Jul 2024 17:57:13 +0000

Comecei a estudar sobre Design System para ajudar na documentação do projeto do estágio. E por se tratar de algo muito mais complexo do que apenas uma coleção de componentes visuais, percebi o quanto isso é escalável e pode se tornar inviável de manter.

Por ser uma documentação viva, que deve manter todas as regras, princípios e melhores práticas do design, ela sempre deve te guiar para se manter no caminho mais seguro. No entanto, apesar dos diversos benefícios, a manutenção pode ser uma tarefa árdua.

Mas Afinal, o Que é um Design System?

Na verdade, isso é bem simples. O Design System é um conjunto de convenções que devem ser utilizadas para manter uma aplicação ou marca, criando assim uma experiência coesa. Os principais elementos de um Design System são:

Guia de Estilo: Nela é mantida a paleta de cores, tipografia, espaçamentos e as principais regras visuais.

No caso de um software, ele deve manter também:

Biblioteca de Componentes: Todos os elementos de interface, como botões, ícones, formulários, etc.
Princípios de Design: Diretrizes dos elementos da marca para que a consistência seja respeitada.

E Por Que Todo Mundo Precisa de Um?

Consistência: Com um Design System, tudo segue um padrão pré-estabelecido, garantindo uma experiência unificada.
Eficiência: Com tudo definido e padronizado, não é necessário recriar elementos, acelerando o processo de desenvolvimento e reduzindo a possibilidade de erros.
Escalabilidade: À medida que o produto cresce, um design system bem mantido facilita a introdução de novos recursos e funcionalidades sem comprometer a consistência da experiência do usuário.

O Dilema da Manutenção

Manter um Design System é um desafio constante, e isso se deve a diversos motivos:

Esforço e Evolução Contínua: Para que a manutenção seja efetiva, é necessário um esforço que pode se tornar exaustivo, incluindo documentar, revisar e atualizar continuamente.
Mudanças Repentinas: Com o avanço das tendências e tecnologias, é necessário acompanhar as mudanças que se tornam cada vez mais constantes.
Recursos Limitados: A falta de recursos muitas vezes sobrecarrega designers e desenvolvedores já ocupados com outras tarefas.
Resistência Interna: Mudanças em componentes amplamente utilizados podem causar resistência devido à complexidade das modificações e ao apego dos envolvidos ao que foi criado.
Subestimação da Manutenção: Devido à complexidade, muitas vezes a equipe acaba abandonando o sistema ao longo do tempo.

Como Superar Isso?

Embora a manutenção seja um desafio a longo prazo, algumas estratégias podem tornar o processo mais gerenciável:

Responsabilidade Compartilhada: Toda a equipe deve ser responsável pela manutenção, garantindo que o Design System receba a atenção necessária. Em projetos maiores, pode ser necessária a criação de uma equipe dedicada apenas à criação e manutenção do Design System.
Automação: Utilizar ferramentas ou plugins que atualizem e documentem um Design System pode reduzir o tempo e o esforço da equipe.
Documentação Clara e Objetiva: Manter a documentação clara e acessível a todos os membros facilita a atualização e adoção do Design System.
Feedback Contínuo: Estabelecer um ciclo de feedback contínuo com a equipe de design, desenvolvimento e também com os usuários garante que o Design System evolua de acordo com as reais necessidades do produto.
Apoio da Liderança: O apoio da liderança é essencial. É necessário que eles entendam a importância da manutenção a longo prazo.

Sendo Assim, Concluímos Que

Sendo ferramentas essenciais para o desenvolvimento de marcas e criação de produtos consistentes, eficientes e escaláveis, o Design System tem se tornado cada vez mais importante. Contudo, a manutenção desse sistema é uma responsabilidade que muitos evitam devido ao esforço contínuo e aos obstáculos e desafios envolvidos. Mas, com as estratégias corretas e o apoio necessário, é possível superar e aproveitar ao máximo os benefícios que um Design System oferece.

De todo modo, manter um Design System não é uma tarefa fácil, mas vale a
pena para garantir a qualidade e consistência do produto. Afinal, o design
não é apenas uma tela bonita e responsiva, mas algo que vai além de resolver
um problema, é tornar em realidade, o que antes era apenas imaginação!

1st of 100 days?

João Victor Santos — Fri, 12 Jul 2024 04:24:55 +0000

I was bored, so I decided to start documenting my studies from here.

I began studying React, which still seems quite confusing to me. That's when I discovered Frontend Mentor, a platform with various challenges.

I admit I took on a simple yet very useful challenge. I managed to develop many functionalities and personalized it according to my preferences. I can't deny it's not perfect, but for a first project, I believe it's sufficient, isn't it?

"It's a small step for a developer, but a big dream for me."

Here was the challenge: Frontend Mentor Challenge

And here's the result: Social Link Profile

There are still a few things I'd like to adjust, such as adding a light and dark mode. So, I'm open to suggestions.

Why do I do what I do? I'm still not sure...

This is not a presentation..."

João Victor Santos — Fri, 12 Jul 2024 04:10:59 +0000

Hello, my name is João Victor! How come you've never heard of me?

I'm 25 years old and currently studying Software Engineering. I'm interning as an Android Developer, Tech Lead for the Frontend team, and Scrum Master for other teams. To be honest, the internship hasn't been fulfilling lately.

I've always been a dreamer.
Going beyond standards and rules, allowing my imagination to transcend lines and colors. I've always wanted to turn my dreams into reality, paying attention to the details that make an idea unique and special.

I enjoy writing and creating my own universe, where things flow seamlessly even when endings aren't happy. What matters is the journey. Writing reveals who I am.

It's almost impossible to destroy an idea. Once created, it gains strength, grows, and becomes a part of us. The more we understand it, the more immortal and demanding it becomes. Creating an idea is hard, but making it real is even more challenging.

I do this for myself, and I write for myself, more than anything else, because fear and loneliness have been paralyzing.

Could dreaming be just another step in this journey?