Lógica de programação: Um manual profundo e prático 🧠

E aí Programador(a), tudo bem?
Léo Scorza da OneBitCode aqui.

A dificuldade com lógica de programação é uma das principais causas de desistência na programação, eu vou te mostrar como eu superei essa fase e como você também pode fazer isso.

Para um entendimento mais profundo e prático, eu vou te guiar pela história da lógica de programação, explicando os porquês das coisas e vou te dar um caminho detalhado para dominá-la.

Também preparei uma lista de exercícios com resolução para te ajudar a praticar.

Então pega seu café ☕️ e vem nessa jornada comigo.

^{Versão em vídeo}

Para começar, o que é lógica? 🧠

A lógica, representa a arte de raciocinar, de pensar de forma estruturada e ordenada. É a espinha dorsal não só da matemática e da filosofia, mas também da programação.

A lógica remonta à Grécia Antiga, com filósofos como Aristóteles, que estabeleceu as bases do raciocínio dedutivo, um pilar essencial da lógica atual.

Dando um pouco mais de detalhe:

Aristóteles criou o conceito de silogismo, um método que consiste em deduzir uma conclusão a partir de duas premissas.

Por exemplo:

• "Todos os humanos são mortais”

• “Sócrates é humano”

• “Portanto, Sócrates é mortal."

Essa estrutura simples é a base do raciocínio lógico, ela pode parecer algo distante, mas intuitivamente fazemos isso quando criamos nossas estruturas de código.

Vamos falar sobre Álgebra Booleana

Avançando alguns séculos, encontramos George Boole, um matemático que revolucionou a lógica com seu sistema algébrico, a Álgebra Booleana.

Seu trabalho estabeleceu as bases lógicas que usamos hoje em circuitos eletrônicos e na programação.

Antes de seguirmos, vale vermos o significado da palavra Álgebra, que talvez assim como quase todo mundo, você tenha esquecido 😅.

Na programação também usamos muitos símbolos para representar a relação entre as coisas, então estamos acostumados.

Seguindo, este sistema matemático baseia-se em três operações fundamentais: AND, OR e NOT, que trabalham com valores verdadeiros e falsos, formando a base da lógica de programação.

Em detalhes:

AND: Retorna verdadeiro se todas as entradas são verdadeiras.
OR: Retorna verdadeiro se pelo menos uma das entradas é verdadeira.
NOT: Inverte o valor da entrada; se verdadeiro, torna-se falso e vice-versa (ou seja, é o tal do “!” na programação que inverte o valor de algo, exemplo, se na variável x temos o valor true, se fizermos !x teremos o valor false)

Quando criamos uma condicional como um if x > 0 && x ≤ 10 estamos usando o conceito de AND estabelecido pelo George Boole, se usarmos o || ao invés do &&, estamos usando o OR.

Um tesouro ficou esquecido por 80 anos

Claude Shannon, um engenheiro e matemático do século XX, é considerado o pai da Teoria da Informação.

Ele redescobriu a Álgebra Booleana e fez a crucial conexão entre ela e os circuitos eletrônicos.

No seu famoso trabalho de mestrado, Shannon demonstrou que os circuitos elétricos poderiam ser projetados para resolver problemas usando lógica Booleana.

Essa descoberta foi revolucionária, pois estabeleceu os fundamentos teóricos para o design de computadores digitais, unindo a matemática de Boole com a engenharia prática.

Alguns exemplos da aplicação da Álgebra Booleana:

• Transistores: Funcionam como interruptores lógicos para representar estados booleanos, formando a base dos circuitos em dispositivos digitais.

• Programação: Usa lógica booleana para controlar o fluxo dos programas e é essencial em estruturas de dados e algoritmos.

• IA: Dependente da lógica booleana para tomada de decisões, redes neurais e no tratamento de informações incertas com lógica fuzzy (que é um papo pra outro dia).

Lógica de programação, algoritmos e o "dia a dia".

Lógica de programação é a arte de aplicar lógica para formular algoritmos e solucionar problemas através da computação.

Mas o que são algoritmos?

Imagine isso como uma receita de cozinha, onde cada passo deve ser seguido em uma ordem específica para alcançar o resultado desejado.

Um algoritmo para preparar uma xícara de café poderia ser:

1. Encher o Recipiente com Água: Primeiro, encha o recipiente (cafeteira ou chaleira) com a quantidade necessária de água.

2. Aquecer a Água: Em seguida, ligue a cafeteira ou coloque a chaleira no fogão para aquecer a água até quase ferver.

3. Preparar o Café: Enquanto a água está aquecendo, coloque o pó de café no filtro da cafeteira ou em um porta-filtro, se estiver usando um método manual como o pour-over.

4. Despejar Água Quente sobre o Café: Assim que a água estiver quente, despeje-a cuidadosamente sobre o pó de café, garantindo que ele seja uniformemente saturado.

5. Esperar a Infusão: Deixe o café infundir por alguns minutos. O tempo exato pode variar dependendo do método de preparo.

6. Adicionar Açúcar (opcional): Se desejar, adicione açúcar ao café já preparado.

7. Servir: Agora o café está pronto para ser apreciado.

Cada passo é crucial e deve ser seguido na ordem correta para fazer uma boa xícara de café. Da mesma forma, os algoritmos em contextos mais técnicos, como na programação, seguem uma lógica semelhante para alcançar resultados específicos.

Um algoritmo famoso no programação é a pesquisa binária:

Ele é usado para encontrar rapidamente um elemento em uma lista ordenada.

Ele funciona dividindo repetidamente pela metade a parte da lista que pode conter o elemento, até que o elemento seja encontrado ou a sublista seja reduzida a zero.

Aqui está um pseudocódigo de exemplo:

função pesquisaBinária(lista, itemProcurado):
    início = 0
    fim = tamanho(lista) - 1

    enquanto início <= fim:
        meio = (início + fim) / 2
        chute = lista[meio]

        se chute == itemProcurado:
            return meio
        se chute > itemProcurado:
            fim = meio - 1
        senão:
            início = meio + 1

    return "Item não encontrado"

Neste pseudocódigo:

• A lista é a lista ordenada onde você está procurando o item.

• O itemProcurado é o valor que você está tentando encontrar.

• O algoritmo calcula o ponto médio da lista (meio), compara o elemento no meio com o item procurado e decide se deve continuar a busca na metade inferior ou superior da lista.

• Se o item for encontrado, retorna a posição do item na lista.

• Se o item não estiver na lista, retorna uma mensagem indicando que o item não foi encontrado.

Você conseguiu perceber os elementos da Álgebra Booleana sendo usados nesse algoritmo? Bem legal enxergar as coisas que usamos no dia a dia com uma visão mais profunda.

Qual a diferença de um algoritmo e um programa de computador?

Um algoritmo é uma sequência de passos para resolver um problema, enquanto um programa de computador é a implementação concreta de um ou mais algoritmos em uma linguagem de programação específica, executável por um computador.

Os elementos do “dia a dia” da lógica de programação.

Os seguintes conceitos são os mais importantes do seu “dia a dia” na programação:

1. Variáveis e Tipos de Dados: Variáveis são espaços na memória usados para armazenar dados. Os tipos de dados (como inteiros, ponto flutuante, caracteres, booleanos) definem a natureza dos dados que uma variável pode armazenar.

2. Operadores: São símbolos que dizem ao compilador ou interpretador para realizar operações matemáticas, lógicas ou de comparação específicas. Eles incluem operadores aritméticos (+, -, *, /), lógicos (AND, OR, NOT) e de comparação (==, !=, <, >).

3. Estruturas Condicionais: Permitem que um programa execute diferentes ações dependendo de uma condição. As mais comuns são if, else e switch. Por exemplo, if é usado para testar uma condição; se a condição for verdadeira, um bloco de código será executado.

4. Laços de Repetição (Loops): Usados para executar um bloco de código repetidamente até que uma condição específica seja atendida. Os loops comuns incluem for, while e do-while. Por exemplo, um loop for é frequentemente usado para iterar sobre uma sequência de números ou elementos de um array.

5. Funções e Procedimentos: Blocos de código que realizam uma tarefa específica e podem ser reutilizados no programa. As funções podem retornar um valor, enquanto os procedimentos não.

6. Estruturas de Dados: Maneiras de organizar e armazenar dados para que possam ser acessados e trabalhados de forma eficiente. Alguns exemplos:

   • arrays (ex: lista de números[1, 2, 3]);

   • listas encadeadas (ex: uma lista de músicas onde cada uma aponta para a próxima);

   • pilhas (ex: pratos empilhados onde o último a ser colocado é o primeiro a ser retirado);

   • filas (ex: uma fila de impressão onde o primeiro documento enviado é o primeiro a ser impresso);

   • além de árvores (ex: estrutura de diretórios de um sistema de arquivos) e;

   • grafos (ex: rede de amigos em uma mídia social).

7. Entrada e Saída de Dados: Inclui a leitura de dados (entrada) do usuário ou de uma fonte de dados e a exibição de dados (saída) para o usuário ou para outra fonte.

Então se concentre em ter uma compreensão clara de cada um desses elementos e pratique bastante até que fique natural usar cada um deles durante a criação dos seus códigos.

Caso você não tenha acesso a um treinamento que explique e exemplifique cada um deles (como fazemos nos nossos treinamentos), você encontra a explicação base deles em muitas documentações como a MDN.

Dá para desenvolver a lógica de Programação?

Desenvolver a lógica de programação é um processo gradual que envolve o entendimento de como estruturar e resolver problemas usando algoritmos.

Aqui está um passo a passo para desenvolvê-la:

1. Entenda o Problema:

   • Antes de começar a programar, é crucial compreender claramente o problema que você está tentando resolver. Isso inclui identificar as entradas, as saídas desejadas e os requisitos específicos do problema.

2. Aprenda o Básico de Algoritmos e Fluxo de Controle:

   • Estude conceitos básicos como loops (for, while), condicionais (if, else, switch), e a lógica por trás dessas estruturas.

   • Entenda como os algoritmos funcionam e como eles são usados para resolver problemas.

3. Pratique com Problemas Simples:

   • Comece com problemas de programação simples que requerem uso de condições, loops e funções básicas (você vai encontrar alguns exercícios interessantes para começar ao final dessa newsletter).

4. Aprenda sobre Estruturas de Dados:

   • Estude diferentes tipos de estruturas de dados (como arrays, listas, pilhas, filas, árvores, grafos) e entenda quando e como usá-las.

5. Desenvolva Projetos Práticos:

   • Trabalhe em projetos reais. Isso pode ser desde criar um website simples até desenvolver um jogo ou uma aplicação.

6. Estude Código de Outras Pessoas:

   • Leia e analise códigos escritos por outros. Isso pode ser feito através de repositórios no GitHub, fóruns de programação ou contribuindo para projetos de código aberto.

7. Aprenda a Depurar e Testar:

   • Pratique a localização e correção de erros (bugs) em seu código. Aprenda a escrever testes para validar a lógica e a funcionalidade do seu código.

8. Repita e Avance:

   • A repetição é chave. Continue praticando com problemas cada vez mais complexos e aprendendo novas linguagens e frameworks.

9. Busque Feedback e Colabore:

   • Interaja com outros programadores, participe de code reviews e esteja aberto a feedback para melhorar continuamente.

2 dicas para conseguir pensar mais claramente na hora de desenvolver seus algoritmos:

• Meditação: A meditação é uma técnica que te ajuda a ter mais controle sobre a sua atenção e que ao mesmo tempo te ajuda a acalmar a mente.

• Redução das distrações: Evite ficar olhando o smartphone ou abrindo outras abas no browser enquanto pensa seus algoritmos, dividir a sua energia mental vai deixar tudo mais difícil.

Se praticar é o segredo, então vamos praticar:

Eu criei uma lista com 5 exercícios para você praticar e desenvolver mais a sua lógica de programação, para acessar clique aqui: https://onebitcode.notion.site/5-exerc-cios-de-l-gica-de-programa-o-be4178ae36374880a0fa0d1b673958a8?pvs=4

Se você quer ir além e se diferenciar:

Nós temos um curso específico para te ajudar a desenvolver sua lógica de Programação, ele se chama 30 desafios de javascript.

Nele nós propomos 30 desafios, que vão desde o muito fácil até o muito difícil. Primeiro você tenta resolver sozinho(a), depois você vê nossa solução detalhada em vídeo para ver se foi pelo caminho mais otimizado.

Ao final dos 30 desafios com certeza você vai estar muito mais afiado(a) na hora de criar seus algoritmos, então vale muuuuito a pena.

Caso você queira ir mais além com a gente, ele está disponível para compra clicando aqui.

Ou você pode levar ele com desconto (direto no checkout) comprando a nossa formação completa Fullstack neste link: https://onebitcode.com/javascript (a oferta vai estar abaixo dos dados para preenchimento, de R$167 por 12x R$11,68).

Uma observação importante, se você está vendo esta newsletter antes de 25 de dezembro de 2023, estamos com um bônus de natal, levando a formação você ganha nossa livro Programador Nômade + nossa série Habilidades com 18 cursos rápidos (Vue.js, Tailwind e etc).

Conclusão

Espero que essa jornada pela história da lógica, da álgebra booleana e da criação dos computadores modernos tenha te dado mais clareza dos porquês das coisas (que são tão ingenuamente ignorados pela maioria).

Não se esqueça de aprofundar seus conhecimentos sobre algoritmos, dados primitivos e estruturas de controle e de dados, eles serão suas ferramentas na hora de criar softwares significativos.

Se esse texto te ajudou, é muito importante para mim que você me dê um feedback, assim eu vou me esforçar para trazer mais conteúdos aprofundados como este para você.

Obrigado pela presença. Grande abraço.

Léo Scorza - OneBitCode 🤘

Ps: Não se esqueça de encaminhar este email (ou o link da newsletter) para aquele(a) amigo(a) que também gosta de ir além do básico.