Como Superar as Causas Comuns do Abandono da Programação.

Ao embarcarmos na jornada da codificação, inevitavelmente, algum dia você encontrará inúmeros obstáculos ao longo do caminho.

Mesmo os desenvolvedores mais habilidosos enfrentam desafios. Eu certamente enfrentei a minha cota. No entanto, para muitos aspirantes a programadores, um único obstáculo pode ser tão desanimador e frustrante que eles abandonam a aspiração de se tornar um codificador proficiente.

Dominar a codificação não é tarefa fácil: os desafios fazem parte integrante da jornada. Idealmente, a única razão pela qual um aspirante a programador pararia seria reconhecer que a codificação diverge de seus interesses. No entanto, a realidade desmente essa ideia. De fato, muitas pessoas desistem de suas buscas por codificação devido a obstáculos que podem ser superados.

Hoje, elucidarei algumas das principais razões que levam as pessoas a abandonar o aprendizado de codificação — juntamente com estratégias ou pontos de vista para superá-los. A seguir, algumas causas Principais para o Abandono da Jornada de Codificação:

1 - Impaciência

A impaciência leva muitos a desistirem da codificação. Se a paciência lhe falta, navegar pelos momentos inevitáveis de dificuldade se torna árduo.

Aprender a codificar é semelhante a uma maratona, não a uma corrida rápida. Requer tempo, diligência e determinação. Reconhecer essa realidade e adotar uma perspectiva pragmática durante a fase de aprendizado é crucial.

Se a maestria de um conceito exigir um tempo substancial, é por design — não indica qualquer deficiência cognitiva.

Para mitigar a impaciência, ajuste suas expectativas e estabeleça metas e prazos viáveis. Divida esses objetivos em etapas gerenciáveis e celebre cada avanço, independentemente de sua magnitude.

2 - Medo do Fracasso

Se você tem tendências perfeccionistas, o início de sua jornada de codificação oferece um momento oportuno para cultivar uma relação saudável com a falibilidade.

O caminho para a proficiência em codificação está repleto de erros — não há espaço para o medo do fracasso. Embora os erros possam ser exasperantes, eles representam oportunidades de aprendizado inestimáveis. Tanto novatos quanto programadores experientes cometem erros triviais, que não comprometem seu potencial para se destacar como desenvolvedores.

Na verdade, eu argumentaria que grandes desenvolvedores erram com frequência, em grande parte devido ao fato de que eles se desafiam, assumem riscos e aprendem por meio de tentativa e erro.

Para fortalecer sua resiliência e perseverança ao longo da jornada de aprendizado, desenvolva uma mentalidade de crescimento, na qual pequenos contratempos são abraçados como caminhos para o crescimento.

Na minha visão, o verdadeiro fracasso se manifesta em renunciar ao aprendizado de codificação unicamente devido a um erro cometido.

Consulte minha postagem recente, na qual explico por que a maestria em programação requer abraçar o fracasso.

3 - Síndrome do Impostor

A síndrome do impostor está mais difundida do que se imagina — afetando profissionais experientes e desenvolvedores em início de carreira.

Caracterizada por uma dúvida paralisante em relação às próprias competências e habilidades, a síndrome do impostor gera uma sensação constante de ser um fraudador, independentemente das conquistas obtidas.

Superar a síndrome do impostor requer a documentação atenta de suas realizações e o fomento de um diálogo interno positivo. Conectar-se com pessoas afins e iniciantes pode ser útil, embora seja preciso ter cautela para não fazer comparações desleais.

4 - Ausência de um Regime de Aprendizado Estruturado

Muitos aprendizes entusiásticos se veem perdidos devido à ausência de um framework de aprendizado estruturado, ficando à deriva sem um parâmetro claro de progresso incremental. Um regime de aprendizado estruturado reduz a ansiedade, promovendo uma sensação de segurança e eficácia na busca por metas de codificação.

Esse risco é particularmente relevante para autodidatas, que, ao contrário dos participantes de bootcamps ou instituições acadêmicas, assumem a responsabilidade adicional de se orientar através de diversos materiais e atividades de aprendizado. Até encontrarem recursos de aprendizado preferidos, os autodidatas podem perder um tempo considerável vasculhando tutoriais e materiais, correndo o risco de sobrecarga de informações.

Se você é um autodidata, procure cursos ou plataformas que ofereçam um currículo coerente e passo a passo — ou elabore um plano curricular estruturado para si mesmo. É crucial que o plano de aprendizado construa progressivamente sobre os conceitos anteriores. Por exemplo, não é aconselhável mergulhar em uma linguagem de programação sem uma base sólida em raciocínio lógico e resolução de problemas.

Busque recursos de aprendizado online elaborados por e especialistas reconhecidos no mercado para ensinar exatamente o que você precisa saber, na sequência ideal.

5 - Ansiedade com a Codificação

Diversos fatores podem precipitar a ansiedade com a codificação. Lidar com a ansiedade é desafiador e, sem mecanismos eficazes de enfrentamento, a rendição pode parecer inevitável.

A ansiedade com a codificação afeta muitos programadores. Suas raízes variam desde o receio sobre a vasta gama de conhecimentos até ansiedades relacionadas ao desempenho. Identificar ansiedades específicas permite abordá-las e criar estratégias de enfrentamento — sua ansiedade não é única e você não será o último a experimentá-la!

6 - Modos de Aprendizagem Desalinhados

Temos a sorte de contar com uma variedade de modalidades de aprendizado para dominar a codificação. No entanto, seja por meio de aulas, bootcamps ou cursos online, nem todos os recursos atendem igualmente aos alunos.

Muitos aprendizes abandonam a codificação devido a recursos de aprendizado inadequados para seus estilos e necessidades de aprendizagem. Um aprendiz auditivo-visual pode ter dificuldade em compreender conceitos a partir de recursos textuais, enquanto um aprendiz cinestésico pode solidificar o entendimento somente por meio de engajamento prático. Da mesma forma, o estilo de ensino de um determinado professor pode não ressoar com todos os alunos.

Se sua curva de aprendizado estiver estagnada, persevere. Avalie suas preferências de aprendizado e integre-as em sua jornada de codificação. Você pode precisar explorar recursos de aprendizado alternativos ou adotar uma abordagem mista para otimizar sua experiência de aprendizado.

Lembre-se de que a experiência prática com codificação é indispensável — sem ela, a compreensão dos conceitos permanece superficial, sem a oportunidade de aprender com os erros!

7 - Esgotamento

Às vezes, o compromisso inabalável com um objetivo leva a um esforço excessivo — semelhante a forçar um motor até seu ponto de ruptura.

Os perigos do esgotamento são palpáveis, gerando cinismo, ansiedade e desilusão em relação a um objetivo outrora valorizado — e a recuperação pode ser prolongada.

Para evitar o esgotamento, ajuste seu ritmo e abrace períodos de descanso. Aprender a codificar é uma ascensão longa e exigente — momentos de falta de fôlego são inevitáveis. No entanto, com objetivos claros e marcos alcançáveis, você alcançará o topo.

Mantendo o Curso

Se você se deparar com dificuldades no aprendizado de codificação, saiba que não está sozinho.

Muitos programadores habilidosos já consideraram desistir em algum ponto de sua jornada de aprendizado. A marca dos desenvolvedores bem-sucedidos está unicamente na perseverança.

Cada indivíduo enfrenta um conjunto único de desafios, e certamente não cobri todas as razões que levam as pessoas a abandonar o aprendizado de codificação. No entanto, entender esses obstáculos é o primeiro passo para desenvolver estratégias para superá-los.

Melhorias sobre a Segurança no PHP 8

 Principais Melhorias de Segurança no PHP 8

A versão 8 do PHP trouxe várias atualizações importantes, focadas em tornar as aplicações PHP mais seguras e robustas. Estas melhorias incluem novas funcionalidades de tipagem, um novo API de hashing de senhas e outras melhorias padrão que ajudam a proteger o código contra ataques comuns.

Tipagem Mais Forte

Union Types: Permite que uma variável possa ser de mais de um tipo, como uma string ou um inteiro, ajudando a evitar erros ao garantir que apenas os tipos de dados corretos sejam usados.

function foo(int|string $value): void {
    echo $value;
}

foo(123); // Válido
foo("Olá"); // Válido
// foo(12.5); // Inválido, gera um erro

Mixed Type: Aceita diferentes tipos de dados, proporcionando flexibilidade sem comprometer a segurança.

function bar(mixed $value): void {
    echo $value;
}

bar(123); // Válido
bar("Olá"); // Válido
bar([1, 2, 3]); // Válido

Non-capturing Catches: Permite ignorar certos erros sem a necessidade de escrever código extra, tornando o tratamento de exceções mais seguro e eficiente.

try {
    // Código que pode gerar uma exceção
} catch (SpecificException) {
    // Tratamento da exceção específica
} catch (Exception) {
    // Tratamento de outras exceções
}

API de Hashing de Senhas

Password::hash(): Gera um código seguro a partir de uma senha.

$password = "minhaSenhaSegura";
$hash = password_hash($password, PASSWORD_DEFAULT);

echo $hash; // Exibe o hash gerado
 

Password::verify(): Confirma se uma senha corresponde ao seu código seguro.

$hash = '$2y$10$saltoSAlgumasC0i8UltrasecretaM44EVy6u7';

if (password_verify('minhaSenhaSegura', $hash)) {
    echo "Senha válida!";
} else {
    echo "Senha inválida!";
}

Password::needsRehash() :

Verifica se um código seguro precisa ser atualizado.

$options = ['cost' => 12];
$hash = password_hash('minhaSenhaSegura', PASSWORD_DEFAULT, $options);

if (password_needs_rehash($hash, PASSWORD_DEFAULT, $options)) {
    $newHash = password_hash('minhaSenhaSegura', PASSWORD_DEFAULT, $options);
    // Salvar o novo hash
}

Estas funcionalidades facilitam a gestão segura de senhas, garantindo que sejam armazenadas e verificadas corretamente sem complicações adicionais.

Melhorias Padrão

Cookies Mais Privados: Os cookies agora são mais privados por padrão, aumentando a proteção dos dados do usuário.

setcookie("user", "John Doe", [
    'expires' => time() + 86400,
    'path' => '/',
    'domain' => '',
    'secure' => true,
    'httponly' => true,
    'samesite' => 'Strict', // 'Lax' ou 'None' também podem ser usados
]);

Proteção Contra Manipulação de Dados: Melhorias no envio e recebimento de dados dificultam ataques de interceptação e manipulação.

// Exemplo de uso de cabeçalhos HTTP para segurança
header("Content-Security-Policy: default-src 'self';");
header("X-Content-Type-Options: nosniff");
header("X-Frame-Options: DENY");
header("X-XSS-Protection: 1; mode=block");

Novas Ferramentas de Segurança: Introdução de ferramentas que ajudam a prevenir tipos comuns de ataques, como injeção de código e ataques de força bruta.

Impacto no Desenvolvimento

As atualizações no PHP 8 simplificam a implementação de práticas de segurança, tornando mais fácil para os desenvolvedores protegerem suas aplicações desde o início. Essas melhorias são como adicionar trancas e alarmes mais eficientes, proporcionando uma base mais segura para o desenvolvimento de aplicações web.

Perspectivas Futuras

Com o lançamento do PHP 8 e suas melhorias de segurança, espera-se que futuras versões continuem a aprimorar esses aspectos, tornando o PHP uma escolha cada vez mais segura e confiável para o desenvolvimento web.

Conclusão

As melhorias de segurança no PHP 8 representam um passo significativo para a proteção de dados e aplicações web. A adoção dessas novas funcionalidades é essencial para desenvolvedores que buscam construir sistemas seguros e resilientes contra ameaças cibernéticas.

Mudança de Cor de Fundo através de um Botão com JavaScript

Olá! Neste tutorial, veremos uma mudança na cor do texto com base na cor de fundo usando javascript. Às vezes, temos requisitos para alterar a cor do texto ou da fonte dependendo da cor de fundo e, nesse momento, se você estiver alterando a cor do texto manualmente, este post definitivamente o ajudará.

Passo 1: Estrutura Básica HTML

Crie um arquivo HTML chamado index.html e adicione a estrutura básica:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Change Background Color</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
            transition: background-color 0.5s;
        }
        button {
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
        }
    </style>
</head>
<body>
    <button id="changeColorButton">Change Background Color</button>
    <script src="script.js"></script>
</body>
</html>

Passo 2: Adicionar o JavaScript

Crie um arquivo JavaScript chamado script.js na mesma pasta do arquivo HTML e adicione o seguinte código:

document.addEventListener('DOMContentLoaded', function() {
    const button = document.getElementById('changeColorButton');
    
    button.addEventListener('click', function() {
        changeBackgroundColor();
    });
});

function changeBackgroundColor() {
    const colors = ['#FF5733', '#33FF57', '#3357FF', '#F0F', '#FF0', '#0FF'];
    const randomColor = colors[Math.floor(Math.random() * colors.length)];
    document.body.style.backgroundColor = randomColor;
}

Explicação do Código

1. HTML:

   • Um botão com o ID changeColorButton é criado.
   • O arquivo JavaScript script.js é incluído no final do corpo do documento para garantir que o DOM esteja totalmente carregado antes de o script ser executado.

2. JavaScript:

   • document.addEventListener('DOMContentLoaded', ...): Garante que o código dentro da função seja executado somente depois que todo o DOM tiver sido carregado.
   • button.addEventListener('click', ...): Adiciona um evento de clique ao botão, que chama a função changeBackgroundColor quando o botão é clicado.
   • changeBackgroundColor(): Esta função define um array de cores e escolhe uma cor aleatória do array para definir como a nova cor de fundo do corpo do documento.

Passo 3: Testar a Página

Abra o arquivo index.html no seu navegador e clique no botão para ver a cor de fundo mudar aleatoriamente.

Conclusão

Este tutorial mostrou como criar uma página web simples onde um botão pode mudar a cor de fundo usando JavaScript. Este é um exemplo básico, mas você pode expandir e modificar conforme necessário para atender às suas necessidades específicas.
Até a proxima!

Traits em PHP: Reutilização de Código Simplificada

Se você já se deparou com a necessidade de utilizar o mesmo método em várias classes diferentes, e a herança não se mostra como uma boa opção, então os Traits são a solução.

Na programação orientada a objetos, devemos estender classes que compartilham métodos e propriedades em um mesmo contexto. Seguindo esse conceito de herança, é possível ter uma classe "Animal" que é estendida por "Cachorro" e "Gato". Contudo, há situações onde precisamos compartilhar comportamentos entre classes de contextos distintos. Imagine um cenário onde temos uma classe que gerencia os logs da aplicação e possui métodos que precisam ser usados em diversas outras classes do sistema. De fato, não faria sentido definir a classe de log como pai de "Cachorro" ou "Gato", pois esses não são tipos de log, mas sim que utilizam log.

Para resolvermos esse problema, podemos utilizar os Traits, na quais permitem definir métodos e propriedades para complementar nossas classes sem a necessidade de estendê-las. Por isso, alguns autores denominam os Traits como "herança horizontal", em contraste com a herança vertical, onde há alteração no nível da hierarquia.

Vamos ver isso na prática com exemplos de código. 

Implementando Traits em PHP

Para o projeto de hoje, precisamos do PHP e Composer instalados.

Vamos começar criando o arquivo composer.json e definindo a estrutura do nosso projeto:

{
    "name": "wdev/traits",
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Agora, instale as dependências com o comando:

composer install

Crie a estrutura do projeto, incluindo o arquivo index.php na raiz do projeto:

<?php
require 'vendor/autoload.php';

// Exemplo inicial de utilização dos Traits

Exemplo de Uso de Traits

Vamos criar duas classes que compartilham métodos comuns utilizando Traits.

1. Crie a classe Cachorro:

<?php
namespace App\Animal;

class Cachorro {
    use \App\Traits\Nome;
}

2. Crie a classe Cliente::

namespace App\Pessoa;

class Cliente {
    use \App\Traits\Nome;
}

3. Defina o Trait Nome::

namespace App\Traits;

trait Nome {
    private $nome;

    public function setNome($nome) {
        $this->nome = $nome;
    }

    public function getNome() {
        return $this->nome;
    }
}

4. Atualize o index.php para usar essas classes:

<?php
require 'vendor/autoload.php';

use App\Animal\Cachorro;
use App\Pessoa\Cliente;

$cachorro = new Cachorro();
$cachorro->setNome("Rex");

$cliente = new Cliente();
$cliente->setNome("João");

echo "Nome do cachorro: " . $cachorro->getNome() . PHP_EOL;
echo "Nome do cliente: " . $cliente->getNome() . PHP_EOL;

Adicionando mais Funcionalidades com Traits

Agora, vamos criar um Trait adicional para logar informações.

1. Defina o Trait Log:

namespace App\Traits;

trait Log {
    public function gravarLog() {
        echo "Log: " . date('Y-m-d H:i:s') . " - Classe: " . get_class($this) . PHP_EOL;
        print_r(get_object_vars($this));
        echo str_repeat("-", 20) . PHP_EOL;
    }
}

2. Utilize o Trait Log nas classes Cachorro e Cliente:

namespace App\Animal;

class Cachorro {
    use \App\Traits\Nome, \App\Traits\Log;
}

namespace App\Pessoa;

class Cliente {
    use \App\Traits\Nome, \App\Traits\Log;
}

3. Atualize o index.php para usar o método gravarLog:

  
<?php
require 'vendor/autoload.php';

use App\Animal\Cachorro;
use App\Pessoa\Cliente;

$cachorro = new Cachorro();
$cachorro->setNome("Rex");
$cachorro->gravarLog();

$cliente = new Cliente();
$cliente->setNome("João");
$cliente->gravarLog();

Conclusão

Neste projeto, aprendemos a definir e utilizar Traits em PHP para compartilhar comportamentos entre classes, sem a necessidade de herança direta ou duplicação de código. Como resultado, temos um código mais limpo e de fácil manutenção.