<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Hi Hi Ray on Medium]]></title>
        <description><![CDATA[Stories by Hi Hi Ray on Medium]]></description>
        <link>https://medium.com/@hihiray?source=rss-79ff9ff37f1e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*1IJ5sprqb_FkzzLDMQD1pA.jpeg</url>
            <title>Stories by Hi Hi Ray on Medium</title>
            <link>https://medium.com/@hihiray?source=rss-79ff9ff37f1e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 15:59:36 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@hihiray/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Práticas que tornarão seu código melhor]]></title>
            <link>https://medium.com/wtmrio/pr%C3%A1ticas-que-tornar%C3%A3o-seu-c%C3%B3digo-melhor-31b52d97b96b?source=rss-79ff9ff37f1e------2</link>
            <guid isPermaLink="false">https://medium.com/p/31b52d97b96b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[melhores-praticas]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Hi Hi Ray]]></dc:creator>
            <pubDate>Thu, 15 Feb 2018 11:00:52 GMT</pubDate>
            <atom:updated>2018-02-15T11:00:52.798Z</atom:updated>
            <content:encoded><![CDATA[<p>No Women Techmakers Membership recebemos dicas semanais sobre diversos assuntos, e com base no artigo <a href="https://codeaddiction.net/articles/27/5-practices-that-will-make-your-code-better">5 practices that will make your code better</a>, que foi indicado um tempo atrás, venho aqui sugerir algumas práticas.</p><ol><li><strong>Programação Defensiva:</strong></li></ol><p>Essa prática tem como objetivo aplicar um conjunto de técnicas para ter estabilidade e segurança em um software, promovendo um código que funciona em qualquer circunstância não prevista. Além da estabilidade provida, caso seja necessário aplicar alguma manutenção será muito mais simples.</p><p>O mandamento de uma boa Programação Defensiva pode ser listado da seguinte forma:</p><ul><li>Liberar os Recursos após uso: Dependendo da linguagem e da funcionalidade de um método, é necessário finalizar ele corretamente, senão ele pode consumir recursos de hardware e servidor, caso contrario, poder acabar emitindo um erro não tão esclarecido.</li><li>Mantenha um estilo de codificação uniforme, ou seja, respeite o Boilerplate (Estruturação de Arquivos e Pastas) da linguagem e do projeto, mantenha a endentação e tamanho dos espaços padronizados, e para finalizar siga o padrão de escrita do projeto ao nomear qualquer coisa (Classes, Variáveis, Arquivos, Métodos e etc.).</li><li>Valide a entrada do usuário. Se o input deve receber uma string, ele TEM que receber uma string. Essa prática ajuda a proteger a entrada do banco de dados e você sempre ter certeza o que você está recebendo daquele input.</li><li>Comente o seu código (com moderação), para explicar <em>por que</em> as coisas são feitas e não <em>como</em> são feita (se você sentir que precisa explicar <em>como</em> algo é feito, você deve considerar refatorar o código).</li><li>Controle as exceções e retorne erros mais legíveis. As vezes a linguagem pode lançar uma exceção que não pode ser capturada ou legível, por isso a importância de controlar as exceções, seja de forma genérica ou com um try catch. Não esqueça de padronizar os seus tratamentos de erros.</li><li>Certifique-se de que cada método, classe, variável e propriedade, possuam um objetivo claro e único, um nome claro com uma intenção clara (que corresponda à implementação). Ele deverá ser curto e conciso no nome e no caso de um método, deverá possuir um código sucinto e não ter nenhuma ação inesperada (isto é, não deve realizar operações imprevistas). Exemplo:</li></ul><blockquote>Função somar(x){ retorna: x - 1}</blockquote><p>No exemplo está claro que o método possui a função de somar logo ele não pode subtrair.</p><ul><li>Seu código deverá ter um contrato claro, é possível programar por contrato (<em>Design by Contract</em>), esse tipo de abordagem tem como objetivo prescrever e definir os métodos formais, interfaces e etc…</li><li>É testável? É possível realizar testes em seu código? Um código bem estruturado e definido, é possível realizar testes unitários e de integração com muita facilidade.</li><li>Utilize a modelagem de <em>Orientação a Objeto</em>, com sabedoria, pois assim você não terá vazamentos (os detalhes internos e as limitações devem ser mantidos internos), e seu código estará protegido de manipulações inesperadas por parte de outros algoritmos.</li></ul><p>2.<strong> Realize Testes:</strong></p><p>Essa prática tem como objetivo reduzir o número de erros de quando o seu código estiver em produção e torna menos arriscado mudar e refatorar o código, e também impede que regressões de versionamento se repitam. Quando feito corretamente, também pode fazer você escrever um código melhor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*B5vh8kjBoWO4PbXX.png" /><figcaption>fonte: <a href="http://www.softdesign.com.br/blog/testes-automatizados-parte-1-os-tipos-de-testes/">http://www.softdesign.com.br/blog/testes-automatizados-parte-1-os-tipos-de-testes/</a></figcaption></figure><p>Olhando a imagem acima é possível ver que existem inúmeros tipos de teste e cada um deles tem uma finalidade diferente, irei falar sobre os dois que são mais comentados:</p><ul><li><strong>Teste de Unidade (Teste Unitário)</strong>: Ele testa de maneira isolada sem considerar qualquer outra coisa a não ser se aquela unidade está tendo o comportamento correto, esse tipo de teste é muito usado para validar se o método está passando por certas entradas e se a saída é a esperada. Exemplo:</li></ul><blockquote>Função somar(x){ retorna: x + 1}</blockquote><blockquote>O teste dessa unidade seria:</blockquote><blockquote>Função_Teste somar(1){ Se retornou 2: mande um OK, senão mande um Failed}</blockquote><ul><li><strong>Teste de Integração</strong>: Ele testa a comunicação e os usos dos pacotes, ou seja, ele testa tudo que for necessário para o código funcionar bem que seja externo. Exemplo:</li></ul><blockquote>Função Busca de Coelhos no Banco de Dados(coelho){ Dou um Search no banco de Dados até achar o coelho}</blockquote><blockquote>O teste de integração seria:</blockquote><blockquote>Função_Teste Busca de Coelhos no Banco de Dados(coelho rosa) {Se consegui estabelecer uma comunicação e achei o coelho rosa: mande um OK, senão mande um Failed}</blockquote><p>A diferença entre os dois é que nos teste de unidade focamos apenas nas funções internas do nosso código, enquanto o teste de integração foca em testar a comunicação externa com a interna.</p><p>Você pode automatizar os seus testes, basta você procurar algum pacote ou ferramenta para a linguagem que você usa. Para saber mais sobre as práticas e sobre o assunto acesse: <a href="https://www.devmedia.com.br/test-driven-development-tdd-simples-e-pratico/18533">Test Driven Development: TDD simples e prático</a>.</p><p>3.<strong> Princípios S.O.L.I.D:</strong></p><p>Quando falamos desse princípio logo pensamos em como aplica-lo em Programas Orientado a Objetos. S.O.L.I.D é um acróstico para:</p><ul><li>S = Single-Responsibility Principle (Princípio de Responsabilidade Única)</li></ul><p>Esse princípio nos ensina que as classes devem ter uma responsabilidade única.</p><ul><li>O = Open/Closed Principle (Aberto para Extensão, Fechado para alteração)</li></ul><p>Nessa parte cita que as classes devem poder estender o seu comportamento sem que haja a necessidade de alterar o seu código.</p><ul><li>L = Liskov Substituition Principle (Substituição de Liskov)</li></ul><p>Esse principio nos ensina que as instâncias de um objeto deve poder ter a possibilidade de ser substituída por instâncias de seus subtipos, sem que o sistema deixe de funcionar corretamente.</p><ul><li>I = Interface Segregation Principle (Segregação de Interfaces)</li></ul><p>A segregação de Interface explica possuir várias interfaces que são especificas, são melhores do que uma única interface para uso geral.</p><ul><li>D = Dependency Inversion Principle (Inversão de Dependências)</li></ul><p>A inversão de dependência significa que as classes devem depender de abstrações e não de coisas concretas.</p><p>4.<strong> Injeção de dependência / Inversão de controle:</strong></p><p>Por estarem no mesmo tópico você leitor pode achar que são a mesma coisa, mas são coisas diferentes, a injeção de dependência é um sub-tipo da inversão de controle.</p><ul><li><strong>Injeção de Dependência (DI):</strong></li></ul><p>É uma técnica utilizada para injetar em um objeto suas dependências. Injeção de Dependências é uma forma de se obter a Inversão de Controle. Não irei descrever com mais detalhes os 3 tipos de DI, porém, elas são Injeção de Interface (Interface Injection), Injeção de Setters (Setter Injection) e Injeção de Construtor (Constructor Injection).</p><ul><li><strong>Inversão de controle (IoC):</strong></li></ul><p>Consiste em mudar o fluxo de controle do programa, ao invés do desenvolvedor determinar quando um procedimento será executado ele apenas determina qual procedimento deve ser executado para um determinado evento.</p><p>As vantagens para usar o IoC/DI são:</p><p>— Desacopla os códigos, que por sua vez aumenta a reutilização, torna mais fácil testar e permite gerenciar a instanciação de objetos em um nível mais alto. <br> — Focaliza um módulo para tarefa projetada.<br> — Ele evita efeitos colaterais ao substituir um módulo. <br> — Se possui um código testável.<br> — Promove um bom design Orientado a Objeto.</p><p>5.<strong> Imutando o seu código</strong></p><p>E nessa dica final, estamos pegando um aspecto do paradigma de programação funcional. O aspecto baseia-se em que você nunca deve ser capaz de mudar um objeto. Se um objeto precisa ser alterado, ele deve ser recriado.</p><p>Para isso que tal usarmos constantes? Ou criar um método para manipular o elemento?</p><p>Os benefícios que se pode obter é :</p><p>— Ter objetos seguros para thread (Thread Safe). <br> — Prevenção de se ter objetos com estados inválidos. <br> — A imutabilidade torna mais fácil a escrita, e lhe faz considerar o uso e a razão sobre o código. <br> — A imutabilidade torna mais fácil paralelizar o seu programa, pois não há conflitos entre objetos.<br> — As referências a objetos imutáveis ​​podem ser armazenadas em cache, pois não vão mudar.</p><p>Espero que vocês gostem e usem algumas dicas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*fO168RMmhQJRM6nOQJHwFg.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31b52d97b96b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/wtmrio/pr%C3%A1ticas-que-tornar%C3%A3o-seu-c%C3%B3digo-melhor-31b52d97b96b">Práticas que tornarão seu código melhor</a> was originally published in <a href="https://medium.com/wtmrio">wtmrio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>