<?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 Enzo Carvalho on Medium]]></title>
        <description><![CDATA[Stories by Enzo Carvalho on Medium]]></description>
        <link>https://medium.com/@enzocsantos18?source=rss-c498d1843430------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*jzcaep82qfCFVllh83589g.jpeg</url>
            <title>Stories by Enzo Carvalho on Medium</title>
            <link>https://medium.com/@enzocsantos18?source=rss-c498d1843430------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 00:02:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@enzocsantos18/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[SOLID, por que devemos usar?]]></title>
            <link>https://medium.com/orangejuicefc/solid-por-que-devemos-usar-b4c087142767?source=rss-c498d1843430------2</link>
            <guid isPermaLink="false">https://medium.com/p/b4c087142767</guid>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[poo]]></category>
            <dc:creator><![CDATA[Enzo Carvalho]]></dc:creator>
            <pubDate>Sat, 15 May 2021 00:54:20 GMT</pubDate>
            <atom:updated>2021-11-23T10:27:09.823Z</atom:updated>
            <content:encoded><![CDATA[<h3>O que é o SOLID?</h3><p>SOLID é um padrão utilizado na programação orientada a objetos, que visa melhorar a qualidade e manutenibilidade do código. O padrão foi introduzido por Robert Cecil Martin, também conhecido como “Uncle Bob” autor de grandes livros no campo da computação, Clean Code sendo o mais conhecido, em um artigo chamado <a href="https://fi.ort.edu.uy/innovaportal/file/2032/1/design_principles.pdf">“Design Principles and Design Patterns”</a> publicado em 2000, na época, ele juntou alguns conceitos que estavam surgindo no mundo da programação orientada a objetos e definiu alguns princípios fundamentais. Somente em 2004 o acrônimo SOLID foi introduzido pelo Michael Feathers, co-autor do livro Clean Code, facilitando a compreensão e a divulgação do conceito, visto que, englobava todas as diretrizes em uma única e marcante palavra.</p><h3>Conhecendo os Princípios</h3><p>O padrão é dividido em 5 princípios que formam o acrônimo SOLID, veremos a explicação de cada um deles a seguir.</p><h3>(S)ingle Responsability Principle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KUJLyJ4oQf99R_N4" /><figcaption>Photo by <a href="https://unsplash.com/@pf91_photography?utm_source=medium&amp;utm_medium=referral">Patrick</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Definição:</h3><ul><li>Uma classe ou módulo deveria ter uma, e somente uma, razão para mudar.</li></ul><p>Esse princípio diz que devemos ter classes e métodos concisos que desempenham uma única tarefa, evitando assim, o comportamento do canivete suíço, que desempenha diversas funções que não condizem com o esperado.</p><p>O objetivo desse princípio diminuir a complexidade de uma classe com a finalidade de dividir comportamentos em seus devidos lugares, diminuindo a chance de erro e dependência.</p><h3>Exemplo:</h3><p><strong>Violação do SRP</strong></p><p>A classe pessoa tem atributos como nome, data de nascimento e o endereço da pessoa, além do método buscarEnderecoPorCep(), a presença desse método na classe Pessoa não faz sentido, visto que estamos dando responsabilidade que deveria ser de uma classe chamada Endereço.</p><pre>public class Pessoa {<br>    private String nome;<br>    private LocalDate dataNascimento;<br>    private String rua;<br>    private String bairro;<br>    private int numero;<br>    private String cep;<br>    private String cidade;<br>    private String estado;</pre><pre>    public Pessoa(String nome, LocalDate dataNascimento, String cep, int numero) {<br>        this.nome = nome;<br>        this.dataNascimento = dataNascimento;<br>        this.cep = cep;<br>        this.numero = numero;</pre><pre>        buscarEnderecoPorCep();<br>    }</pre><pre>    public void buscarEnderecoPorCep(){<br>        //Simulação chamada api chamada api dos correios utilizando o campo cep<br>        this.rua = &quot;Avenida Ana Costa&quot;;<br>        this.bairro = &quot;Gonzaga&quot;;<br>        this.cidade = &quot;Santos&quot;;<br>        this.estado = &quot;São Paulo&quot;;<br>    }<br>    <br>}</pre><p><strong>Respeitando SRP</strong></p><p>Agora com as duas classes separadas tempos uma Classe pessoa, com as informações necessárias e uma classe Endereço responsável por tudo relacionado ao Endereço, tornamos o sistema mais conciso.</p><pre>public class Pessoa {<br>    private String nome;<br>    private LocalDate dataNascimento;<br>    private Endereco endereco;</pre><pre>    public Pessoa(String nome, LocalDate dataNascimento, Endereco endereco) {<br>        this.nome = nome;<br>        this.dataNascimento = dataNascimento;<br>        this.endereco = endereco;<br>    }<br>    <br>}</pre><pre>class Endereco {<br>    private String rua;<br>    private String bairro;<br>    private int numero;<br>    private String cep;<br>    private String cidade;<br>    private String estado;</pre><pre>    public Endereco(int numero, String cep) {<br>        this.numero = numero;<br>        this.cep = cep;<br>				buscarEnderecoPorCep();<br>    }</pre><pre>    public void buscarEnderecoPorCep(){<br>        //Simulação chamada api chamada api dos correios utilizando o campo cep<br>        this.rua = &quot;Avenida Ana Costa&quot;;<br>        this.bairro = &quot;Gonzaga&quot;;<br>        this.cidade = &quot;Santos&quot;;<br>        this.estado = &quot;São Paulo&quot;;<br>    }<br>}</pre><h3>(O)pen Closed Principle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*PimcKSA9f04_96G6GCkEbg.jpeg" /><figcaption>Não é necessário fazer uma cirurgia no peito para colocar um casaco</figcaption></figure><h3>Definição:</h3><ul><li>Classes deveriam ser abertas para extensão, mas fechadas para modificação.</li></ul><p>Esse princípio diz que ao adicionar novas funcionalidades devemos estender a classe original e não alterá-la, a imagem acima diz que para colocar um casaco não é necessário fazer uma cirurgia no peito, levando para o lado da programação seria: “não devemos alterar o que está funcionando, devemos apenas estender essa nova funcionalidade”.</p><p>O objetivo desse princípio é evitar a troca frequente de código nas classes e métodos que poderiam causar bugs em comportamentos, além de auxiliar na manutenção posterior dos mesmos.</p><h3>Exemplo:</h3><p><strong>Violação do OCP</strong></p><p>Essa é uma aplicação de descontos e nela existem atualmente três tipos (LIQUIDACAO, QUEIMA_ESTOQUE, DATA_ESPECIAL) com valores de desconto diferentes que são calculados pelo método calcular, método esse que tem diversos ifs de validação, caso algum tipo novo fosse adicionado seria necessário a implementação de mais um if com suas características violando o OCP.</p><pre>enum TipoDesconto {<br>    LIQUIDACAO,<br>    QUEIMA_ESTOQUE,<br>    DATA_ESPECIAL;<br>}<br>public class Desconto {<br>    public BigDecimal valor;<br>    public TipoDesconto tipoDesconto;</pre><pre>    public Desconto(BigDecimal valor, TipoDesconto tipoDesconto) {<br>        this.valor = valor;<br>        this.tipoDesconto = tipoDesconto;<br>    }</pre><pre>    public BigDecimal calcular(){<br>        if(tipoDesconto.equals(TipoDesconto.LIQUIDACAO) ){<br>            return this.valor.multiply(new BigDecimal(&quot;0.2&quot;));<br>        }</pre><pre>        if(tipoDesconto.equals(TipoDesconto.QUEIMA_ESTOQUE) ){<br>            return this.valor.multiply(new BigDecimal(&quot;0.25&quot;));<br>        }</pre><pre>        if(tipoDesconto.equals(TipoDesconto.DATA_ESPECIAL) ){<br>            return this.valor.multiply(new BigDecimal(&quot;0.15&quot;));<br>        }</pre><pre>        return BigDecimal.ZERO;<br>    }<br>}</pre><p><strong>Respeitando OCP</strong></p><p>Nessa solução adicionamos a interface TipoDesconto que contém a assinatura necessária para que uma nova classe seja considerara um Tipo de Desconto válido, as classes LiquidacaoDesconto, QueimaEstoqueDesconto e DataEspecialDesconto estão implementando esse contrato e adicionando a própria regra de negócio, a classe principal desconto não precisa ser alterada quando um novo tipo desconto for adicionado, já que ela utiliza o contrato como validador de Tipo, deixando assim o código mais desacoplado.</p><pre>interface TipoDesconto {<br>    BigDecimal calcular(BigDecimal valor);<br>}</pre><pre>public class Desconto {<br>    public BigDecimal valor;<br>    public TipoDesconto tipoDesconto;</pre><pre>    public Desconto(BigDecimal valor, TipoDesconto tipoDesconto) {<br>        this.valor = valor;<br>        this.tipoDesconto = tipoDesconto;<br>    }</pre><pre>    public BigDecimal calcular(){<br>        return  tipoDesconto.calcular(this.valor);<br>    }<br>}<br>class LiquidacaoDesconto implements TipoDesconto{<br>    @Override<br>    public BigDecimal calcular(BigDecimal valor) {<br>        return valor.multiply(new BigDecimal(&quot;0.2&quot;));<br>    }<br>}</pre><pre>class QueimaEstoqueDesconto implements TipoDesconto{<br>    @Override<br>    public BigDecimal calcular(BigDecimal valor) {<br>        return valor.multiply(new BigDecimal(&quot;0.25&quot;));<br>    }<br>}</pre><pre>class DataEspecialDesconto implements TipoDesconto{<br>    @Override<br>    public BigDecimal calcular(BigDecimal valor) {<br>        return valor.multiply(new BigDecimal(&quot;0.15&quot;));<br>    }<br>}</pre><h3>(L)iskov’s Substitution Principle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*Md1xogtGXp0zKbmE.jpg" /><figcaption>Só porque parece com um pato, faz barulho como um pato, mas precisa de baterias, isso não quer dizer que ele é um pato, sendo assim teríamos uma abstração errada</figcaption></figure><h3>Definição:</h3><ul><li>Se q(x) é uma propriedade demonstrável dos objetos x de tipo T, então q(y) deve ser verdadeiro para objetos y de tipo S, onde S é um subtipo de T.</li></ul><p>A definição dada pela Barbara Liskov é complexa e pode ser simplificada para “Classes pai podem ser substituídas por suas classes filho e as classes filho podem ser substituídas pela classe pai”, ou seja, os comportamentos da classe filho devem estar de acordo com os comportamentos da classe pai, elas devem ter o mesmo retorno e a troca entre essas classes não deve gerar erro.</p><p>Como podemos ver na imagem, só porque parece com um pato, faz barulho como um pato, mas precisa de baterias, isso não quer dizer que ele é um pato, sendo assim teríamos uma abstração errada.</p><p>O objetivo desse princípio é a utilização de classes pai e filho da mesma maneira, evitando erros.</p><h3>Exemplo:</h3><p><strong>Violação do LSP</strong></p><p>A classe Pinguim estende as características da classe Ave, porém precisa reescrever o comportamento do método voar, visto que pinguim não voa, sendo assim ela está violando o LSP.</p><pre>public class Ave {<br>    String nome;<br>    public void voar(){<br>        //Implementação voo<br>    };<br>    public void bicar() {<br>        //Implementação bicar<br>    };<br>}<br>class Canarinho extends Ave{}</pre><pre>class Pinguim extends Ave{<br>    @Override<br>    public void voar() {<br>        throw new IllegalArgumentException(&quot;Pinguins não conseguem voar&quot;);<br>    }<br>}</pre><p><strong>Respeitando LSP</strong></p><p>Foi adicionado a classe AvesQueSabemVoar que estende o comportamento de Ave e adiciona o método voar, separando assim as aves sem e com o comportamento de voar, agora os diferentes tipos de aves podem estender a Classe que mais se adequa ao seu tipo.</p><pre>public class Ave {<br>    String nome;</pre><pre>    public void bicar() {<br>        //Implementação bicar<br>    };<br>}</pre><pre>class AvesQueSabemVoar extends Ave{<br>    public void voar(){<br>        //Implementação voo<br>    };<br>}</pre><pre>class Canarinho extends AvesQueSabemVoar{}</pre><pre>class Pinguim extends Ave{}</pre><h3>(I)nterface Segregation Principle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*SMWzBHoHSjiiYUEy.jpeg" /><figcaption>Você quer que eu plugue isso aonde?</figcaption></figure><h3>Definição:</h3><ul><li>Clientes não devem ser forçados a depender de métodos que não utilizam.</li></ul><p>Uma classe não deve ser obrigada a implementar ações que não usará, seria um desperdício e poderia causar bugs, caso isso venha acontecer será necessário a divisão do contrato(interface) em outros contratos, deixando somente o que será utilizado nos casos.</p><p>O objetivo desse princípio é que classe só obedeça contratos que ela irá utilizar, evitando comportamentos fantasmas que podem gerar erros.</p><h3>Exemplo:</h3><p><strong>Violação do ISP</strong></p><p>Nesse caso as classes Carro e Moto irão implementar a interface AcoesAutomevel que possui 4 métodos: acelerar, freiar, buzinar, abrirPortaMalas.</p><p>A classe moto ao implementar a interface viola o princípio porque não deveria ter o método de abrirPortaMalas, visto que motos não possuem um.</p><pre>interface AcoesAutomovel {<br>    void acelar();<br>    void freiar();<br>    void buzinar();<br>    void abrirPortaMalas();<br>}</pre><pre>public class Carro implements AcoesAutomovel {</pre><pre>    @Override<br>    public void acelar() {<br>        //Implementação aceleração carro<br>    }</pre><pre>    @Override<br>    public void freiar() {<br>        //Implementação freio carro<br>    }</pre><pre>    @Override<br>    public void buzinar() {<br>        //Implementação buzina carro</pre><pre>    }</pre><pre>    @Override<br>    public void abrirPortaMalas() {<br>        //Abrir porta malas carro<br>    }<br>}</pre><pre>class Moto implements AcoesAutomovel{</pre><pre>    @Override<br>    public void acelar() {<br>        //Implementação aceleração moto<br>    }</pre><pre>    @Override<br>    public void freiar() {<br>        //Implementação freio moto<br>    }</pre><pre>    @Override<br>    public void buzinar() {<br>        //Implementação buzina moto</pre><pre>    }</pre><pre>    @Override<br>    public void abrirPortaMalas() {<br>        throw new IllegalArgumentException(&quot;Moto não deveria ter porta malas&quot;);<br>    }<br>}</pre><p><strong>Respeitando ISP</strong></p><p>A solução seria dividir a interface em duas: acoesAutomoveis e acoesCarros. Agora o comportamento do carro continua sendo o mesmo e moto consegue ter os métodos corretos.</p><pre>interface AcoesAutomovel {<br>    void acelar();<br>    void freiar();<br>    void buzinar();<br>}</pre><pre>interface AcoesCarro{<br>    void abrirPortaMalas();<br>}</pre><pre>public class Carro implements AcoesAutomovel, AcoesCarro {</pre><pre>    @Override<br>    public void acelar() {<br>        //Implementação aceleração carro<br>    }</pre><pre>    @Override<br>    public void freiar() {<br>        //Implementação freio carro<br>    }</pre><pre>    @Override<br>    public void buzinar() {<br>        //Implementação buzina carro</pre><pre>    }</pre><pre>    @Override<br>    public void abrirPortaMalas() {<br>        //Abrir porta malas carro<br>    }<br>}</pre><pre>class Moto implements AcoesAutomovel{</pre><pre>    @Override<br>    public void acelar() {<br>        //Implementação aceleração moto<br>    }</pre><pre>    @Override<br>    public void freiar() {<br>        //Implementação freio moto<br>    }</pre><pre>    @Override<br>    public void buzinar() {<br>        //Implementação buzina moto</pre><pre>    }<br>    <br>}</pre><h3>(D)ependency Inversion Principle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*wqx5Rs3nThmggFId.jpg" /><figcaption>Você soldaria um abajur diretamente na corrente elétrica?</figcaption></figure><h3>Definições:</h3><ul><li>Abstrações não deveriam depender em detalhes, detalhes deveriam depender de abstrações.</li><li>Módulos de Alto nível não deveriam depender de módulos de baixo nível, ambos deveriam depender de abstrações.</li></ul><p>Esse princípio diz uma classe não deve depender da implementação e sim do contrato (interface) que tem em comum com a implementação, sendo assim a implementação deve seguir o que está especificado no contrato, que nesse caso serve como um conector entre entre as partes. A imagem pergunta se soldaríamos um abajur diretamente na fiação elétrica de casa, a maioria diria que não, nesse caso usaríamos o plug que seria o contrato entre o módulo de baixo nível (energia elétrica) e alto nível(abajur)</p><p>O objetivo desse princípio é reduzir a dependência entre módulos através de um contrato (interface).</p><h3>Exemplo:</h3><p><strong>Violação do DIP</strong></p><p>A classe mensagem está sendo responsável pela lógica por traz do envio de emails e sms, violando assim o conceito DIP.</p><pre>public class Mensagem {<br>    private String conteudo;</pre><pre>    public Mensagem(String conteudo) {<br>        this.conteudo = conteudo;<br>    }</pre><pre>    public void enviarMensagem(){<br>        //Simulação envio por email<br>        System.out.println(&quot;Enviando email com a seguinte mensagem: &quot; + this.conteudo);<br>        System.out.println(&quot;Email enviado com sucesso&quot;);<br>        //Simulação envio por SMS<br>        System.out.println(&quot;Enviando sms com a seguinte mensagem: &quot; + this.conteudo);<br>        System.out.println(&quot;Sms enviado com sucesso&quot;);<br>    }<br>}</pre><p><strong>Respeitando DIP</strong></p><p>Foi criado uma interface chamada EnviadorMensagem que serve como um contrato/conector entre a classe Mensagem e os Enviadores (sms e email), dividindo assim os módulos de alto nível (classe que chama) em relação a implementação (módulos de baixo nível).</p><pre>interface EnviadorMensagem {<br>    void enviar(Mensagem mensagem);<br>}</pre><pre>public class Mensagem {<br>    private String conteudo;</pre><pre>    public Mensagem(String conteudo) {<br>        this.conteudo = conteudo;<br>    }</pre><pre>    public void enviarMensagem(EnviadorMensagem enviador){<br>        enviador.enviar(this);<br>    }</pre><pre>    public String getConteudo() {<br>        return conteudo;<br>    }<br>}</pre><pre>class EnviarPorEmail implements EnviadorMensagem{<br>    @Override<br>    public void enviar(Mensagem mensagem) {<br>        System.out.println(&quot;Enviando email com a seguinte mensagem: &quot; + mensagem.getConteudo());<br>        System.out.println(&quot;Email enviado com sucesso&quot;);<br>    }<br>}</pre><pre>class EnviarPorSMS implements EnviadorMensagem{<br>    @Override<br>    public void enviar(Mensagem mensagem) {<br>        System.out.println(&quot;Enviando sms com a seguinte mensagem: &quot; + mensagem.getConteudo());<br>        System.out.println(&quot;Sms enviado com sucesso&quot;);<br>    }<br>}</pre><h3>Por que devemos usar?</h3><p>Devemos utilizar o padrão SOLID porque ele, como dito antes, ajuda na qualidade e manutenibilidade do código, nossas classes ficam mais coesas, encapsuladas (isoladas) e sofremos menos com o acoplamento (ligação direta entre classes), gerando assim uma facilidade maior de adicionar/alterar comportamentos, diminuindo o risco de quebra em alguma funcionalidade do sistema, por esses e outros motivos, o padrão é fortemente indicado durante a construção de aplicações que utilizam a Orientação a Objetos. Muitos padrões de projeto utilizam como base o SOLID, facilitando ainda mais a utilização do conceito, que não é de fácil compreensão e demanda tempo para ser solidificado (desculpa o trocadilho) na cabeça do programador.</p><h3>Nem sempre devemos seguir a regra a risca</h3><p>A utilização do SOLID é recomendada na maior parte do tempo, mas não devemos nos prender 100% no que é dito, lembre-se, são PRINCÍPIOS e não REGRAS. Em alguns momentos, a utilização do padrão irá atrapalhar a produtividade, não fará totalmente sentido, ou não se adequará a algum padrão de projeto recomendado para situação, não devemos nos prender ao uso do SOLID, mas devemos sim sempre tê-lo como guia para seguir as melhores práticas da programação orientada a objetos.</p><h3>Próximos passos</h3><ol><li>Após o entendimento do conceito SOLID, a prática será responsável pelo aperfeiçoamento da técnica.</li><li>Aprendizado de Design Patterns, que poderão ser consultados no site <a href="https://refactoring.guru/design-patterns">refactoring guru</a>, ajudarão a aplicar alguns conceitos de SOLID, mas em alguns casos a violação de algum princípio poderá acontecer, é normal.</li></ol><h3>Referências</h3><p><a href="https://en.wikipedia.org/wiki/SOLID">https://en.wikipedia.org/wiki/SOLID</a></p><p><a href="https://cursos.alura.com.br/course/solid-orientacao-objetos-java">https://cursos.alura.com.br/course/solid-orientacao-objetos-java</a></p><p><a href="https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898">https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898</a></p><p><a href="https://imasters.com.br/back-end/principios-de-projeto-orientado-a-objetos-lsp-liskov-substitution-principle-parte-3">https://imasters.com.br/back-end/principios-de-projeto-orientado-a-objetos-lsp-liskov-substitution-principle-parte-3</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b4c087142767" width="1" height="1" alt=""><hr><p><a href="https://medium.com/orangejuicefc/solid-por-que-devemos-usar-b4c087142767">SOLID, por que devemos usar?</a> was originally published in <a href="https://medium.com/orangejuicefc">orangejuicetech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Meu primeiro App em React Native foi meu TCC]]></title>
            <link>https://enzocsantos18.medium.com/meu-primeiro-app-em-react-native-foi-meu-tcc-420c90c1ed22?source=rss-c498d1843430------2</link>
            <guid isPermaLink="false">https://medium.com/p/420c90c1ed22</guid>
            <category><![CDATA[brasil]]></category>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[programação]]></category>
            <dc:creator><![CDATA[Enzo Carvalho]]></dc:creator>
            <pubDate>Mon, 11 May 2020 00:49:45 GMT</pubDate>
            <atom:updated>2021-05-15T00:35:08.838Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*26lhfMAETGUmjlLI.png" /></figure><p>Ano passado era o ano de conclusão do meu curso técnico em informática, a escola na qual eu estudava ofericia como premiação de melhor TCC uma bolsa de 100% na melhor universidade particular da região para todos os integrantes do grupo,nós decidimos arriscar tudo para esse prêmio.</p><p>A nossa idea era fortissíma, todos os avaliadores ficaram surpresos com a qualidade, o único problema é que para que a ideia virasse realidade a gente teria que desenvolver um app. Nosso curso priorizava o desenvolvimento web e mesmo assim o conteúdo era bastante defasado, nós não sabiamos nem o que era uma API, quem dirá fazer um app que teria que literalmente falar.</p><p>No primeiro semestre de projeto, tinhamos que estrutar nossa ideia de modo que ela funcionasse, nesse mesmo período já começamos a trabalhar o banco de dados, porém somente no segundo semestre que começamos a desenvolver o app e a API, um mundo totalmente diferente dos webforms no qual estavamos acostumados, meu papel no projeto era o front-end, ou seja , o react native, eu chegava a noite em casa e ficava até a hora de dormir desenvolvendo e hoje cerca de 6 meses depois eu vejo o código, e apesar de ficar feliz pela minha evolução, fico triste porque eu poderia ter feito o projeto de um jeito mais rápido e melhor.</p><p>Durante o desenvolvimento do app houveram diversos problemas, sendo eles de organização, ou até mesmo com o próprio React Native, e infelizmente não tinhamos apoio dos professores já que eles não conheciam a tecnologia, até hoje o código tem um erro que não sei resolver… Um problema que me deixou estremamente preocupado foi a integração da biblioteca de voz, que não tinha suporte oficial para android, esse problema, caso não tivesse sido resolvido por um desenvolvedor no github, acabaria com o projeto e com a chance de a gente ganhar o premio.</p><p>Depois de meses de desenvolvimento e diversas horas criando o conteúdo do app, chegou a hora da apresentação, apesar de que todos da classe diziam que nossa ideia era a melhor e de que nosso projeto estava ótimo, acabamos perdendo para outro grupo, que por sinal tinha feito um belo trabalho também, as duas lições que tirei daquele dia é que apresentação é fundamental para um projeto e de que se eu quiser eu posso desenvolver tudo o que pedirem, mesmo que de início tenha um código ruim.</p><p>Infelizmente não entrei a fundo sobre a ideia nesse texto, mas no futuro espero escrever sobre, tomara que, dessa vez, ela esteja publicada.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=420c90c1ed22" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>