<?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 Rosicléia Frasson on Medium]]></title>
        <description><![CDATA[Stories by Rosicléia Frasson on Medium]]></description>
        <link>https://medium.com/@rosifrasson?source=rss-4ea308de8b6c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*sfwMhkVg5pnLHPndBashJA.png</url>
            <title>Stories by Rosicléia Frasson on Medium</title>
            <link>https://medium.com/@rosifrasson?source=rss-4ea308de8b6c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 20:38:01 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rosifrasson/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[Como é ser um nômade no iFood]]></title>
            <link>https://medium.com/ifood-tech/como-%C3%A9-ser-um-n%C3%B4made-no-ifood-2f332e2b9b6c?source=rss-4ea308de8b6c------2</link>
            <guid isPermaLink="false">https://medium.com/p/2f332e2b9b6c</guid>
            <category><![CDATA[ifood]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[tech]]></category>
            <dc:creator><![CDATA[Rosicléia Frasson]]></dc:creator>
            <pubDate>Mon, 05 Jun 2023 14:48:29 GMT</pubDate>
            <atom:updated>2023-06-06T14:13:07.953Z</atom:updated>
            <content:encoded><![CDATA[<p>Por muito tempo, o crescimento na área de tecnologia esteve muito atrelado a ideia de gerenciar outras pessoas. A progressão de carreira se dava em cargos como líder de equipe, coordenador, gerente, diretor e afins.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*hrr_oKVzq6wNyVZz3A2gTA.jpeg" /></figure><p>Liderar pessoas é sem dúvidas, um papel fascinante. Mas ao mesmo tempo requer o desenvolvimento de um conjunto de habilidades diferentes. Somado a isso, existe a tendência de afastamento da área técnica. Um gestor não passa a maior parte do seu tempo em atividades diretamente relacionadas a construção de softwares.</p><p>Com o aumento da importância da tecnologia para os negócios, empresas com um certo nível de crescimento, sentiram a necessidade de ter pessoas dedicadas a resolver problemas de tecnologia, mas que tenham responsabilidade superior a de um desenvolvedor sênior.</p><p>Então se a ideia de gerir pessoas não faz seus olhos brilharem, existe a possibilidade de seguir uma outra trilha de progressão de carreira destinada ao que chamamos de contribuidores individuais. Em resumo, um contribuidor individual pode ter inúmeras responsabilidades, porém gerenciar pessoas não é uma delas.</p><p>Os nomes para esse papel são diversos: especialista, tech lead, staff engineer, principal engineer. Aqui no iFood chamamos de nômade. Esse post é dedicado a falar um pouco sobre o que é ser um nômade e quais suas principais responsabilidades.</p><h4>O que é ser um nômade?</h4><p>Para começar, é importante esclarecer o que um nômade não é. Embora estamos falando de um cargo destinado a resolver problemas técnicos, não podemos definir um nômade como um super sênior. Um nômade não produz infinitamente mais código que os outros desenvolvedores. Ele não é um conhecedor de todas as linguagens de programação, padrões arquiteturais e nem uma mina de ideias brilhantes.</p><p>No entanto, é necessário ser uma referência técnica. Precisa ter fluência com código, conhecer linguagens de programação, frameworks de mercado, mecanismos de observabilidade e troubleshooting, entendimento das diversas maneiras de disponibilizar software para os usuários finais. É fundamental ter preocupação com segurança. Também é indispensável ter conhecimento profundo e vivência de um leque de tecnologias para fazer escolhas coerentes de acordo com os problemas as serem solucionados. Enfim, é essencial que as hard skills estejam bem desenvolvidas.</p><p>Mas não pára por aí, eu costumo falar que resolver os problemas puramente técnicos é a parte fácil. Organizar pessoas para fazer acontecer é a parte difícil. Um nômade é um multiplicador de forças. Ele joga junto com o time, mas precisa fazer com que um grupo de humanos remem na mesma direção. E essa direção precisa estar conectada com a estratégia da organização. É necessário trazer outras pessoas para o jogo e fazer com que as pessoas defendam as soluções certas, afinal os problemas são resolvidos por pessoas.</p><h4>Principais responsabilidades de um nômade</h4><p>A forma de atuação de um nômade é muito diversa. Depende muito do contexto em que ele está inserido, da maturidade dos times em que atua e da necessidade do projeto em que está alocado. Mas de forma geral, é possível dividir em cinco frentes de atuação.</p><p>A primeira delas é dar direcionamento técnico. Um nômade auxilia as equipes a enxergarem uma imagem maior do que a lista de tasks, entendendo as reais necessidades da organização e orientando todos para uma solução mais eficiente. Ou seja, é responsabilidade de um nômade a condução de discussões arquiteturais, tentando encontrar brechas nas ideias para que todos os casos de uso sejam atendidos pela solução. Também é necessário auxiliar na priorização para que as coisas sejam feitas no momento certo. Um outro ponto importante, é garantir que os padrões estabelecidos pelo time de engenharia sejam seguidos.</p><p>Elevar o nível da equipe também é uma responsabilidade de um nômade. Isso pode acontecer de uma maneira mais formal, como um treinamento, um grupo de estudos, auxiliar no desenvolvimento do plano de carreira ou de forma mais informal, como um code review, um pair programming, compartilhando uma experiência ou dando um conselho.</p><p>Outra responsabilidade importante é injetar a perspectiva de engenharia em decisões importantes para o negócio. É muito importante em uma tomada de decisão que as pessoas tenham entendimento do custo, prazo, esforço, risco que é colocar uma nova funcionalidade no ar ou manter algo que já esteja em funcionamento. Também é importante colocar na mesa, coisas que muitas vezes não são prioridades a nível de negócio, como esforços relacionados a segurança, desempenho e disponibilidade.</p><p>Um nômade também trabalha muito na remoção de impedimentos. É papel dele fazer com que o time continue avançando e entregando valor. É muito comum que um nômade fique responsável por buscar respostas que estão em outros times, sejam elas relacionadas a arquitetura de solução, padronizações de segurança, definições do produto ou de UX.</p><p>E por fim, a codificação. Um nômade também coloca a mão na massa. Ás vezes um time tem um problema complexo para resolver, em outras existe a necessidade de desenvolver provas de conceito com alguma tecnologia desconhecida pelo time para entender a aderência ao problema que precisa ser resolvido. Ou ainda atuar como mais um braço do time para auxiliar nas entregas.</p><h3>Palavras finais</h3><p>Um nômade não possui nenhum subordinado, mas é uma função de liderança. Seu dia a dia está muito relacionado a resolver problemas de tecnologia, no entanto ele não resolve esses problemas sozinho: softwares são desenvolvidos por times. Ser um nômade é como ser o capitão do time. É necessário jogar com o time, mas também conduzí-lo, orientá-lo para que os melhores resultados sejam atingidos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f332e2b9b6c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ifood-tech/como-%C3%A9-ser-um-n%C3%B4made-no-ifood-2f332e2b9b6c">Como é ser um nômade no iFood</a> was originally published in <a href="https://medium.com/ifood-tech">iFood Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Histórico de transações: das escolhas arquiteturais ao processo de construção]]></title>
            <link>https://medium.com/ifood-tech/hist%C3%B3rico-de-transa%C3%A7%C3%B5es-das-escolhas-arquiteturais-ao-processo-de-constru%C3%A7%C3%A3o-71ebb0218d2a?source=rss-4ea308de8b6c------2</link>
            <guid isPermaLink="false">https://medium.com/p/71ebb0218d2a</guid>
            <dc:creator><![CDATA[Rosicléia Frasson]]></dc:creator>
            <pubDate>Thu, 16 Mar 2023 19:09:52 GMT</pubDate>
            <atom:updated>2023-03-16T19:09:52.168Z</atom:updated>
            <content:encoded><![CDATA[<p>Aqui no iFood, trabalhamos para proporcionar uma experiência incrível para todo nosso ecossistema. Sempre estamos pensando e construindo funcionalidades para que o uso dos nossos serviços seja fluido, intuitivo, confiável e que forneça autonomia e transparência das operações efetuadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*3O_I1KZwyI850kK1w3wpFg.jpeg" /></figure><p>Eu faço parte da equipe de tecnologia que cuida das transações financeiras dos pedidos e nesse artigo vou mostrar as decisões de arquitetura e design em uma nova funcionalidade que colocamos no ar recentemente: o histórico de transações.</p><figure><img alt="Fluxo Histórico de Transações" src="https://cdn-images-1.medium.com/max/1024/0*XWAUavv_ikdvIH6D" /></figure><p>O histórico de transações faz parte da área global de pagamentos e nasceu com o intuito de dar uma visibilidade maior de todas as transações financeiras efetuadas pelo cliente. Ele funciona como uma espécie de extrato e contempla os pagamentos de pedidos, gorjetas, doações, compras de iFood card, reembolsos, entre outros. A estrutura para processar e suportar essas transações já existe há algum tempo e nesse artigo vou chamar de fluxo transacional. Você pode entender melhor como funciona o fluxo transacional de um pagamento no iFood <a href="https://medium.com/ifood-tech/meios-de-pagamento-online-e-como-eles-funcionam-no-ifood-ff830990e752">aqui</a>. A ideia desse artigo é explorar a outra face que foi construída recentemente: o fluxo de consulta/visualização.</p><p>Desde o início das discussões sobre a funcionalidade, tínhamos muito claro que o fluxo transacional e o fluxo de visualização deveriam ser dissociados e independentes um do outro. Isso nos permitiria escalabilidade ajustável a demanda de cada cenário e aumento de resiliência, pois problemas no fluxo transacional não afetariam o fluxo de visualização e vice-versa. Outro ponto importante, é que essa estrutura usada para prover o histórico de transação deveria ser pensada como um motor de busca flexível para atender outras funcionalidades além da já mencionada.</p><p>Para embasar um pouco a decisão, separar as responsabilidades de escrita e leitura em infraestruturas apartadas faz parte de um padrão arquitetural chamado CQRS (Segregação de Responsabilidade de Comando e Consulta) e foi nosso ponto de partida para o design da solução.</p><p>Segregar as responsabilidades arquiteturalmente aumenta a flexibilidade na escolha das tecnologias, sendo possível escolher soluções mais indicadas para cada caso de uso. Existe a possibilidade de ajustar durabilidade e disponibilidade das informações de acordo com a necessidade. Além disso, conseguimos escalar a quantidade de pessoas trabalhando nos projetos.</p><h3><strong>E tudo começa com a escolha da estrutura de armazenamento</strong></h3><p>Transacionamos milhares de pedidos por dia e precisávamos de uma estrutura de armazenamento que oferecesse capacidade de indexação e pesquisa extremamente performática para grandes quantidades de dados. Além disso, tínhamos em mente que essa estrutura de armazenamento precisaria estar preparada para servir como motor de busca de pagamentos para outras funcionalidades além do histórico de transações, sendo necessário prover um mecanismo de busca adaptável para serviços distintos.</p><p>O escolhido para essa missão foi o OpenSearch. O OpenSearch possui uma estrutura chamada índice invertido, que torna seu mecanismo de busca imbatível em termos de velocidade. Para explicar melhor, no momento da indexação, cada palavra é listada separadamente e junto a ela, existe a identificação de todos os lugares que a mesma pode ser encontrada. No momento da busca, o OpenSearch já sabe onde um termo pode ser encontrado, ele não precisa fazer uma busca geral em todos os documentos para verificar se o termo existe, isso torna o processo de consulta em grandes quantidades de dados muito mais veloz. E o mais importante, embora o mecanismo de busca seja complexo por baixo dos panos, o processo de consulta é extremamente facilitado com uma linguagem de consulta proprietária baseada em json, onde é possível montar uma infinidade de filtros customizáveis de forma simples.</p><p>Além disso, por ser amplamente utilizado em serviços de busca, possui uma comunidade grande e engajada, o que facilita a jornada de implementação. Vale ressaltar, que sua grande popularidade fez com que SDKs para manipulação de dados fossem construídos em diversas linguagens de programação. Ademais, é um serviço conhecido por ser performático, com alta disponibilidade e consegue escalar horizontalmente. Em outras palavras, para aumentar a resiliência e poder de processamento, mais nós (servidores) podem ser adicionados ao cluster.</p><p>A título de curiosidade, o OpenSearch é um fork do ElasticSearch de código aberto, mantido pela comunidade e que está disponível como um serviço de mesmo nome na AWS. Deixar o gerenciamento a cargo da AWS nos permite focar essencialmente na construção da estrutura de armazenamento e pesquisa. Dessa forma, a AWS fica responsável pela administração do cluster, que inclui atualizações, controle de integridade e replicação dos dados.</p><h3><strong>E como os dados chegam…</strong></h3><p>Escolhida a forma de armazenamento precisaríamos construir uma ponte que transportasse os dados do fluxo transacional até o OpenSearch. Lembrando que temos estruturas apartadas e que todas as transações financeiras precisam ser replicadas para a estrutura de consulta.</p><p>Em casos como esse, usamos preferencialmente um mecanismo de transmissão assíncrona, para que o impacto no fluxo transacional seja o menor possível. Não gostaríamos que o tempo de resposta de uma operação de pagamento pudesse aumentar em virtude de uma operação de indexação no OpenSearch ou até mesmo, deixar de efetuar um pagamento por um período de downtime na estrutura responsável pela consulta.</p><p>Usamos o princípio de uma arquitetura orientada a eventos que é composta por produtores e consumidores de eventos. Neste caso, o produtor do evento é a estrutura transacional do processamento de pagamento e o consumidor a estrutura de pesquisa. Isso significa que o produtor possui a responsabilidade de postar um evento a cada tentativa de transação de pagamento ou uma mudança de estado de uma transação, como nos casos de estorno e o consumidor lê esses eventos e armazena no OpenSearch para consultas futuras. Nesse caso, temos um baixo acoplamento entre o produtor e o consumidor, onde o produtor do evento não tem conhecimento se o consumidor conseguiu detectar e consumir os eventos produzidos. Precisamos apenas ter um contrato de modelo de dados bem definido entre as duas partes, o que garante que o consumidor conseguirá processar esse evento, mesmo que isso não ocorra ao mesmo tempo que a transação é efetuada.</p><p>Levando em consideração as características apresentadas, optamos pelo uso do Apache Kafka para esse fim. O Kafka possui uma alta taxa de transferência, escalabilidade e um sistema de armazenamento configurável. Além disso, os produtores e consumidores são totalmente dissociados um do outro, isso significa que os produtores não precisam esperar pelos consumidores. Um consumidor pode processar as mensagens em real-time sempre que possível, mas nos casos de indisponibilidade nos serviços consumidores, as mensagens estarão disponíveis para serem processadas quando estes estiverem estáveis novamente.</p><p>Um outro ponto importante é que existe a possibilidade de trabalhar com o Kafka em conjunto com o Schema Registry. Com o Schema Registry são definidos schemas e serializadores conectados a clientes Kafka, efetuam o processo de serialização usando esses schemas. Isso garante que as mensagens trafegadas obedecem a um contrato previamente estabelecido entre ambas as partes: produtor e consumidor.</p><h3><strong>Já temos os dados, como exibi-los</strong></h3><p>Construir interfaces de usuário é sempre um desafio à parte. Existe a complexidade de trabalhar com duas plataformas: Android e IOS e ter a necessidade de desenvolver para dois sistemas operacionais diferentes. Todas as alterações de interface precisam ser carregadas em ambas as lojas: App Store e Play Store e carregar uma nova versão em uma das lojas é um processo que leva alguns dias, pois existe um processo de validação de ambas as empresas antes do app ser disponibilizado para download. Tudo isso contribui para que novas funcionalidades ou correções de bugs demorem um certo tempo para serem visualizadas pelo usuário final. Além disso, após a disponibilização de uma nova versão, precisamos que o usuário atualize a versão do app para ter acesso às correções ou novas funcionalidades. A atualização de 100% dos clientes pode levar meses.</p><p>Precisávamos de algo que nos permitisse ciclos de desenvolvimento mais curtos sem infringir as políticas das lojas de aplicativos e que ao mesmo tempo nos desse a possibilidade de experimentação mais rápida. A abordagem padrão não nos atenderia.</p><p>Existe uma técnica chamada server driven UI, que já é usada em outras funcionalidades dentro do iFood, onde o servidor é responsável pela montagem das estruturas visuais que compõem a interface do usuário. Essa técnica separa a renderização em um contêiner genérico no aplicativo, como uma página em branco, enquanto a estrutura e os dados de exibição são montados pelo servidor. O aplicativo sabe que irá renderizar uma tela, mas não sabe a aparência dessa tela. Nessa abordagem, o servidor é responsável por carregar os dados e também por montar a interface do usuário.</p><p>Para montar a resposta do servidor usamos uma espécie de linguagem de marcação proprietária que o app entende.Em outras palavras, ao invés do aplicativo buscar apenas os dados referentes a uma lista de transações financeiras, o aplicativo busca a visualização da lista contendo os dados, as imagens, espaçamento, alinhamento, cor e tipografia. Enfim, tudo o que é necessário para montar a página.</p><p>Isso significa que as alterações que antes precisavam ser desenvolvidas em dois sistemas operacionais, carregadas em duas lojas de aplicativos, passar pelo processo de validação das duas lojas e aguardar a atualização do usuário foi reduzido a alterações e deploy do servidor.</p><h3><strong>Construindo a visualização</strong></h3><p>Muitas coisas já tinham sido discutidas até aqui, mas ainda precisávamos definir como seriam os serviços responsáveis por fazer essa estrutura funcionar. Optamos por uma arquitetura distribuída e a construção de quatro serviços com responsabilidades bem definidas em cada um deles:</p><ul><li>Worker: Responsável por consumir as mensagens do kafka, efetuar alguns tratamentos nessas mensagens — conversão de dados, enriquecimento de informações — e salvar no OpenSearch.</li><li>Search: Responsável por efetuar as buscas no OpenSearch, montando filtros diferentes para os diversos padrões de pesquisa que possuímos.</li><li>Maitre: Conhece a estrutura da página. Dividimos a estrutura da página em cards e esse serviço é responsável por coordenar a montagem dos cards chamando o serviço responsável por essa montagem.</li><li>Cook: Responsável pela montagem dos cards. Este serviço efetua o carregamento dos dados e os formata de acordo com a visualização que deve ser exibida no app.</li></ul><p>Um fato curioso é que os nomes dos serviços são analogias ao mundo real. Maitre e cook, por exemplo, remetem ao ambiente de um restaurante, onde o maitre coordena os pedidos e o cook é responsável por preparar a comida. O nome search é auto-explicativo já que se trata de um serviço de busca. Já o worker, remete a um trabalhador por ser um serviço que fica executando em segundo plano, lendo e tratando as mensagens recebidas e salvando na base de dados.</p><p>A seguir, um desenho ilustra de forma bem simplista como ficou a distribuição e a conexão entre os serviços mencionados anteriormente.</p><figure><img alt="Fluxo de integração serviços" src="https://cdn-images-1.medium.com/max/681/0*3ioKELe4LFWF1e5M" /></figure><p>Para esclarecer melhor, search, maitre e cook estão conectados entre si via comunicação síncrona, e no momento que o usuário tenta acessar o histórico existe uma chamada ao maitre que é seguida de uma chamada ao cook, que por sua vez efetua uma chamada ao search.</p><p>Esses três serviços foram construídos em Golang. Antes de iniciarmos a construção, efetuamos alguns testes comportamentais e de carga. Para o cenário que estávamos construindo, o Go se mostrou mais aderente pelo tempo de warmup ser menor, se comparado a outras linguagens de programação. Isso garante que em picos de uso, conseguimos escalar em pouquíssimo tempo. Outro fator relevante é que o uso de recursos computacionais, como memória e CPU são extremamente otimizados para serviços construídos usando Golang.</p><p>Para o worker, optamos pelo uso do Kotlin. Já temos uma lib de mensageria desenvolvida internamente nessa linguagem e o esforço para construir o serviço seria infinitamente menor com o uso dessa lib. O uso da lib também garante padronização com os outros workers que possuímos, facilitando a manutenção do serviço.</p><h3><strong>Para finalizar</strong></h3><p>De forma bem sucinta tentei mostrar a linha de raciocínio que seguimos ao construir uma nova funcionalidade. Nem todos os detalhes foram abordados aqui, pois seriam necessárias inúmeras páginas para descrever tudo o que foi discutido e implementado até a liberação da funcionalidade para o usuário.</p><p>Por fim, gostaria de reforçar que estamos sempre antenados aos novos padrões e tecnologias que surgem no mercado e sempre buscamos utilizar o que tem mais aderência ao tipo de problema que estamos tentando resolver. Procuramos sempre prover a melhor experiência para o usuário e também para os times de desenvolvimento, construindo soluções flexíveis, escaláveis, resilientes e fáceis de manter.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71ebb0218d2a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ifood-tech/hist%C3%B3rico-de-transa%C3%A7%C3%B5es-das-escolhas-arquiteturais-ao-processo-de-constru%C3%A7%C3%A3o-71ebb0218d2a">Histórico de transações: das escolhas arquiteturais ao processo de construção</a> was originally published in <a href="https://medium.com/ifood-tech">iFood Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Java 14: Pattern Matching para instanceOf]]></title>
            <link>https://medium.com/@rosifrasson/java-14-pattern-matching-para-instanceof-489fe6236a76?source=rss-4ea308de8b6c------2</link>
            <guid isPermaLink="false">https://medium.com/p/489fe6236a76</guid>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Rosicléia Frasson]]></dc:creator>
            <pubDate>Sat, 21 Mar 2020 00:54:07 GMT</pubDate>
            <atom:updated>2020-03-21T00:54:07.556Z</atom:updated>
            <content:encoded><![CDATA[<h3>javaJava 14: Pattern Matching para instanceOf</h3><p>Um documento escrito por Gavin Bierman e Brian Goetz em setembro de 2018 já apontava um direcionamento para suportar pattern matching na linguagem Java. Inspirados por outras linguagens, algumas antigas como SNOBOL4 e Haskell e outras mais modernas como Scala e C#, os autores defendem que é chegada a hora da linguagem Java abraçar essa funcionalidade também.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/693/1*pOr5D9d6upCBBfN0tXQQnw.jpeg" /></figure><p>A JEP 305, que será liberada no Java 14, traz a implementação, como feature preview, de uma primeira versão de pattern matching para o operador instanceOf.</p><p><strong>O operador instanceOf</strong></p><p>Muito conhecido pelos desenvolvedores, o operador instanceOf é usado para saber se um objeto é de um determinado tipo. Veja o trecho de código a seguir:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a985c143f1c42902ee9497c2843b392e/href">https://medium.com/media/a985c143f1c42902ee9497c2843b392e/href</a></iframe><p>Temos um Object que foi inicializado com uma String. Precisamos descobrir o tamanho dessa String, mas não é possível usar o método lenght() com Object. Em Java é necessário fazer o cast. Com o intuito de evitar uma exceção, antes de fazer o cast, é comum fazer a verificação de tipo usando instanceOf. Se a verificação de tipo for aprovada, o cast é efetuado e o valor armazenado em uma nova variável.</p><p>Embora esse padrão seja compreendido por todos os programadores e é a forma mais direta de fazer esse tipo de conversão, convenhamos que não é tão bom quanto gostaríamos. Acompanhe os passos necessários:</p><p>- um teste: verifica se strObj é uma String;</p><p>- uma conversão: cast de strObj para String;</p><p>- declaração de uma nova varíavel: Uma String com o nome de str foi declarada para guardar o objeto convertido para ser usado posteriormente.</p><p>É intediante. Usamos a palavra chave String três vezes. Sabemos que repetição oferece oportunidade para que erros entrem despercebidos no programa. Você já deve ter se perguntado qual a necessidade de fazer cast se foi feita a verificação de tipo antes.</p><p>Bom, essa pergunta também permeava a mente dos arquitetos da Oracle responsáveis pela evolução do Java e o pattern matching está chegando para ajudar nessa questão.</p><p><strong>Pattern matching</strong></p><p>Basicamente, um pattern tem a função de testar se um valor se encaixa em uma determinada forma e pode extrair o valor quando encontrar a forma correspondente. Com pattern matching, o operador instanceOf pode extrair o valor que foi usado na verificação. Veja:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/88544dc327ab130ac91e8870c2c9937a/href">https://medium.com/media/88544dc327ab130ac91e8870c2c9937a/href</a></iframe><p>Com o uso do novo padrão, strObj é testado a fim de verificar se é uma instância de String. Se a verificação for verdadeira, é feito o cast para String e o resultado é atribuído a variável newStr.</p><p>Em outras palavras, com pattern matching, é possível adicionar uma variável depois do tipo no operador instanceOf. Se a verificação de tipo for aprovada, a variável declarada pode ser usada diretamente.</p><p>Com o uso de pattern matching em instanceOf, a quantidade de casts explícitos em programas Java deve reduzir drasticamente.</p><p><strong>Escopo da variável de instanceOf</strong></p><p>Quando usamos pattern matching com instanceOf declaramos uma nova variável após o tipo. O escopo dessa variável é limitado apenas ao lugar onde o respectivo pattern é true. Veja:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1fe6da2dd98f035a26861dfa794a5ce0/href">https://medium.com/media/1fe6da2dd98f035a26861dfa794a5ce0/href</a></iframe><p>No caso do trecho de código anterior, ao tentarmos usar a variável newInt no bloco else, um erro de compilação “cannot find symbol” será exibido. Isso acontece porque intObj foi inicializado como um Integer, portanto o pattern é true no bloco if e false no bloco else.</p><p>Podemos inverter a operação com o sinal de negação: ! , como pode ser visto no código a seguir. Neste caso, não teremos erro de compilação e podemos usar a variável newInt no bloco else já que o bloco if tem valor false.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e3602fec8cec0b679304ad2fc90da8de/href">https://medium.com/media/e3602fec8cec0b679304ad2fc90da8de/href</a></iframe><p>Vale ressaltar que a variável existe apenas dentro do bloco if/else. E apenas na declaração que for verdadeira, ou no if ou no else. Fora desse bloco não é possível utilizá-la.</p><p>Um outro cuidado que precisamos ter é não definir a variável do instanceOf com o mesmo nome de uma outra variável presente no escopo do método ou da classe. Além de causar confusão, bugs inesperados podem ocorrer.</p><p><strong>Uso dos operadores &amp;&amp; e || em conjunto com instanceOf</strong></p><p>É comum usarmos instanceOf combinado com outros operadores como &amp;&amp; e ||. Nessas combinações precisamos ter alguns cuidados. Como já mencionado, o escopo da variável criada em instanceOf existe apenas quando o pattern for verdadeiro.</p><p>No trecho de código a seguir, o uso de instanceOf em conjunto com o operador &amp;&amp; é permitido. A segunda verificação só será executada se a primeira for verdadeira. Dessa forma, o compilador já sabe que obj é uma String na segunda verificação -s.contains(“frase”)- e não apresenta erros de compilação.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e38d3b72c003f2bfa8de74f521fd0d27/href">https://medium.com/media/e38d3b72c003f2bfa8de74f521fd0d27/href</a></iframe><p>O mesmo não ocorre na junção de instanceOf com o operador ||. Sabemos que a execução de uma instrução que vem após o operador || independe do resultado da primeira instrução. Ou seja, qualquer que seja o resultado da verificação de tipo, a segunda instrução será executada. Dessa forma, o compilador não tem certeza de que se trata de uma String e ele não pode atribuir um valor para s. Sendo assim, o código a seguir, não é compilado.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4e393ec1c1a49c9ef90a70771a52a708/href">https://medium.com/media/4e393ec1c1a49c9ef90a70771a52a708/href</a></iframe><p><strong>Melhorando o método equals</strong></p><p>O operador instanceOf normalmente é usado em operações confusas. Uma delas, muito comum, que aparece em praticamente todos os softwares escritos em Java é o metodo equals.</p><p>O método equals como o próprio nome sugere, é usado para comparar a igualdade entre dois objetos. Para que dois objetos sejam considerados iguais, eles devem primeiramente ter o mesmo tipo. Essa verificação é feita usando instanceOf. Após isso, um cast é efetuado no objeto que foi passado como parâmetro, para que os atributos dos objetos sejam comparados. Veja:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2c8eb40b5bd539b8a97786e635a33dce/href">https://medium.com/media/2c8eb40b5bd539b8a97786e635a33dce/href</a></iframe><p>Com pattern matching, podemos declarar a variável person em conjunto com a verificação de tipo, reduzindo um pouco a verbosidade do método. A seguir, o mesmo método equals de Person um pouco mais compacto.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1498d3b3d86ad8708cd7ab2d82ddf024/href">https://medium.com/media/1498d3b3d86ad8708cd7ab2d82ddf024/href</a></iframe><p><strong>Considerações finais</strong></p><p>Pattern matching para instanceOf pode ser entendido como uma forma de fazer cast inteligente. O código fica mais claro e seguro. Embora pareça ter pouco impacto, como vêm sendo observado nas últimas versões do Java, o desenvolvimento e liberação de novas features está sendo feito de maneira incremental. Sendo assim, tudo indica que vem mais coisas por aí.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=489fe6236a76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Evite a tar pit]]></title>
            <link>https://medium.com/@rosifrasson/evite-a-tar-pit-3043a572ca9f?source=rss-4ea308de8b6c------2</link>
            <guid isPermaLink="false">https://medium.com/p/3043a572ca9f</guid>
            <category><![CDATA[frederick-brooks]]></category>
            <category><![CDATA[the-mythical-man-month]]></category>
            <category><![CDATA[engenharia-de-software]]></category>
            <category><![CDATA[apps]]></category>
            <dc:creator><![CDATA[Rosicléia Frasson]]></dc:creator>
            <pubDate>Tue, 03 Mar 2020 20:29:20 GMT</pubDate>
            <atom:updated>2020-03-03T20:29:20.692Z</atom:updated>
            <content:encoded><![CDATA[<p>Frederick Brooks, em seu clássico <a href="https://www.amazon.com.br/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959/ref=asc_df_0201835959/?tag=googleshopp00-20&amp;linkCode=df0&amp;hvadid=379787788238&amp;hvpos=&amp;hvnetw=g&amp;hvrand=13332602715909331581&amp;hvpone=&amp;hvptwo=&amp;hvqmt=&amp;hvdev=c&amp;hvdvcmdl=&amp;hvlocint=&amp;hvlocphy=1001710&amp;hvtargid=pla-434012227386&amp;psc=1">The Mythical Man-Month</a>, publicado há quase meio século, usou a metáfora da tar pit para comparar o processo de desenvolvimento de softwares com as poças de piche, em que grandes animais pré-históricos, como os dinossauros lutavam para sair, quase sempre sem sucesso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*AUVyZTiwmFDDbH2XYOnLdQ.jpeg" /></figure><p>Muito se estudou sobre engenharia de software nesses últimos anos, muitas teorias e metodologias de desenvolvimento surgiram… Mas ainda cometemos os mesmos erros levantados por Brooks antes de 1975.</p><p>Desenvolver um software dentro do orçamento, sem comprometer o escopo e o prazo é um desafio para a ampla maioria das empresas de desenvolvimento. Muitos projetos são cancelados após meses de desenvolvimento. Outros até são entregues com redução drástica de funcionalidades e com orçamentos e prazos estourados.</p><p>No caminho oposto, noticiários costumam publicar com frequência, matérias sobre o novo app do momento, construído por um par de jovens programadores ser negociado por bilhões de dólares.</p><p>Como desenvolvedora, quase que diariamente, recebo propostas de amigos, familiares, conhecidos e até de desconhecidos para criarmos um aplicativo nas horas vagas e ficarmos multimilionários.</p><p>O que muita gente não sabe e a mídia não expõe é que construir um programa de computador atualmente, com as ferramentas que temos disponíveis, realmente é uma tarefa possível para qualquer pessoa com um computador e um pouco de disposição. Mas transformá-lo em um produto usável não é tão simples quanto parece.</p><p>Voltando as afirmações de Brooks: um programador pode sim criar sozinho um programa importante que supere os melhores esforços de uma grande equipe. E ele consegue fazê-lo muito mais rápido do que os times em indústrias.</p><p>Você deve estar pensando: então quais são os motivos que levam grandes companhias a contratarem centenas de pessoas ao invés de terem um único desenvolvedor pica das galáxias para construir sozinho o novo produto revolucionário do universo?</p><p>A resposta é que existe uma diferença enorme entre um amontoado de linhas de código que o próprio autor executa e um produto consistente para ir para o mercado.</p><p>Apps construídos entre amigos em um final de semana são meros pedaços de código usuais apenas para as pessoas envolvidas em sua construção. Quando saem do contexto original, rapidamente sua utilidade se decompõe. Eles são apenas um protótipo. Conseguem se comportar adequadamente apenas em um conjunto específico de entradas. Não foram projetados para serem extensíveis e certamente não serão utilizados como componentes de um sistema maior.</p><p>Para transformarmos esse trecho de código em um produto usado comercialmente, é necessário que pessoas não envolvidas em sua construção consigam executá-lo. O contexto é ampliado. É necessário preocupar-se com usabilidade, segurança, performance. O app deve ser exaustivamente testado, explorando possíveis entradas e observando seus limites. É necessário algum tipo de documentação para que outros desenvolvedores consigam corrigir eventuais problemas e adicionar novas funcionalidades.</p><p>Esse trecho de código também pode ser transformado em uma biblioteca, framework ou microserviço para ser usado como parte de um sistemas maior. Mas, para que isso seja possível, interfaces precisam ser definidas e documentadas. É necessário testar sua integração com outros componentes, com a ampla gama de combinações esperadas. Preocupações com segurança e extensibilidade devem ser adicionadas.</p><p>O fato é que ter um software com o mínimo de maturidade custa muito mais caro do que desenvolver um pedaço de código com alguma funcionalidade. E por este motivo, é tão difícil construir algo palpável. No entanto, a diferença para quem vê de fora entre um produto sólido e algo que foi acabado de juntar é muito sútil. Aos olhos de um vendedor ou de um potencial cliente é a mesma coisa.</p><p>Construir uma aplicação com boa usabilidade, segura e escalável é um grande desafio. É o sonho de qualquer equipe de desenvolvimento: construir o MELHOR produto possível.</p><p>Mas não se iluda! Fazer algo com vida longa e do jeito certo demanda tempo. Aceitar isso é um grande passo.</p><p>Mesmo os apps construídos em algumas horas, passam meses e até anos sendo amadurecidos para se transformarem em um produto rentável. Na maioria das vezes, aquele código original é jogado fora. Foi só uma forma de expressar a idéia, testar a viabilidade.</p><p>Começar um software achando que será tarefa fácil mantê-lo é o mesmo que cair nos poços pré-históricos, ficar meses ou anos patinando e acabar sucumbindo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3043a572ca9f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Variáveis globais devem ser evitadas?]]></title>
            <link>https://medium.com/@rosifrasson/vari%C3%A1veis-globais-devem-ser-evitadas-e8aa948f328e?source=rss-4ea308de8b6c------2</link>
            <guid isPermaLink="false">https://medium.com/p/e8aa948f328e</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[global-variable]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[clean-code]]></category>
            <dc:creator><![CDATA[Rosicléia Frasson]]></dc:creator>
            <pubDate>Tue, 03 Mar 2020 13:28:38 GMT</pubDate>
            <atom:updated>2020-03-03T13:28:38.084Z</atom:updated>
            <content:encoded><![CDATA[<p>Em 1973, no auge de linguagens como Fortran e Cobol, um artigo intitulado “Global Variable considered harmful” escrito por W. Wulf e Mary Shaw já advertia que o uso de variáveis não locais constitui um importante fator em programas difíceis de entender. Atualmente, após quase 50 anos e o advento de muitas linguagens de programação e paradigmas de desenvolvimento, essa advertência continua válida.</p><p>Entenda como variável global uma variável que pode ser acessada e modificada em todo o software ou em grande parte dele.</p><p>Com essa definição elas parecem inofensivas. Afinal, que mal pode causar ter uma propriedade que é visível e pode ser modificada em qualquer parte do sistema? Como resposta: muitos e dos mais difíceis de encontrar, entender e corrigir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*H-KvegCluO-TrIfo-OAzCg.jpeg" /></figure><p>Talvez o principal problema e a raiz para os demais, é que o uso de variáveis globais cria um acoplamento implícito entre os módulos que as utilizam. E a palavra implícito pode ser trocada por perigoso nesse contexto, pois esses acoplamentos não são bem representados no design da aplicação.</p><p>Uma variável global pode simplesmente aparecer em um trecho de código: ela não foi definida, não está na lista de parâmetros e não existe um jeito fácil de descobrir o que está acontecendo com ela. Qualquer regra sobre seu uso pode ser quebrada ou esquecida a qualquer momento.</p><p>É possível também, que uma variável local seja declarada com o mesmo nome de uma variável global, causando mais problemas de compreensão de código, pois podemos estar usando uma variável global pensando ser local ou vice-versa.</p><p>Isso significa que se você quer saber o que uma variável global faz, você precisa procurar pela sua definição, que pode ser em qualquer lugar. Depois, você precisa encontrar todos os lugares em que o valor da mesma pode ser alterada. Se você tiver sorte, não serão muitos.</p><p>E se forem muitos? O fato é que quando uma variável global é disponibilizada, qualquer desenvolvedor, em qualquer módulo da aplicação pode fazer uso da mesma. O que inicialmente era um facilitador pode se tornar uma grande armadilha à medida que o software cresce, que a equipe muda, que refatorações são feitas.</p><p>E os testes unitários? Extremamente complexos, quando forem possíveis. É praticamente impossível saber o estado inicial de uma variável declarada globalmente quando o teste é executado. Quanto menos testável é sua aplicação, menor será a segurança no momento em que as alterações forem necessárias.</p><p>E mais… Aplicações com um número considerável de variáveis com escopo além do necessário tendem a degradar muito com o tempo. Bugs aparecem inesperadamente em lugares inimagináveis e são difíceis de diagnosticar. O esforço em refatorações aumentam consideravelmente porque é necessário rastrear o uso das variáveis globais. O reúso torna-se impraticável.</p><p>Se for inevitável, tê-las em sua aplicação, mitigue o risco. Você pode usar uma convenção de nomes que torne fácil o reconhecimento de uma variável global. Você pode ter um arquivo com todas as variáveis globais do projeto. Você pode deixar a responsabilidade de escrita centralizada em um único local e apenas a leitura acessada em toda a aplicação.</p><p>Mas, o mais importante é ter em mente que o menor escopo de algo, é sempre mais fácil de manter. Menor acoplamento, menor o risco, maior a segurança no momento das alterações. O uso de variáveis globais é defensável em casos extremamente raros. Deixe seu software simples. Evite váriaveis globais sempre que possível. Se for possível construir a sua aplicação sem elas, muito melhor.</p><h3>Referências</h3><p>W. Wulf — Global variable considered harmful</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e8aa948f328e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Monte sua estratégia com base na Pirâmide de Testes]]></title>
            <link>https://medium.com/@rosifrasson/monte-sua-estrat%C3%A9gia-com-base-na-pir%C3%A2mide-de-testes-dc11198c284a?source=rss-4ea308de8b6c------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc11198c284a</guid>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[automation-testing]]></category>
            <category><![CDATA[test]]></category>
            <category><![CDATA[teste]]></category>
            <dc:creator><![CDATA[Rosicléia Frasson]]></dc:creator>
            <pubDate>Wed, 23 May 2018 02:14:04 GMT</pubDate>
            <atom:updated>2018-05-23T02:23:35.755Z</atom:updated>
            <content:encoded><![CDATA[<p>Já é um consenso entre as empresas de software que o aumento da qualidade reduz os custos de manutenção e acelera o lead time dos produtos. Por este motivo, muitas delas estão investindo pesado em automatizar os processos de teste.</p><p>Testes automatizados são extremamente importantes para garantir que as funcionalidades do produto continuam funcionando após alguma alteração na aplicação.</p><p>É humanamente impossível retestar toda aplicação a cada mudança no código. Seria necessário um exército de testadores. E é muito provável que levariam meses para conseguir finalizar o trabalho.</p><p>É importante lembrar que a automação dos testes pode acontecer em diferentes camadas da aplicação. E uma boa estratégia de testes deve contemplar testes nas diferentes camadas em diferentes proporções.</p><p>A pirâmide de testes, foi sugerida por Mike Cohon, em seu livro Succeeding with Agile e é um excelente guia para escrever testes na medida certa, baseado na natureza do tipo de teste.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*LkiyGTPHkZI3Uy2U4HFvxA.jpeg" /><figcaption>Pirâmide de automação de testes</figcaption></figure><p>No topo da pirâmide estão os testes de interface. Os testes de interface, são testes que simulam o usuário interagindo com a aplicação.</p><p>Ao contrário, do que muitas pessoas pensam, devemos escrever o mínimo possível deles. Os testes de interface são frágeis, difíceis de manter e consomem muito tempo para serem executados.</p><p>Os testes de interface geralmente são constituídos por fluxos gigantescos e complexos. Uma pequena alteração na interface do usuário, pode quebrar muitos testes e quando isso acontece repetidas vezes, a equipe tende a desistir de corrigir os testes.</p><p>Isso não significa que não devemos automatizar essa camada da aplicação. Sim, é necessário escrever testes de interface, mas não tente escrever testes de interface para todo o produto. Foque nos fluxos principais e nos feedbacks que a interface devolve para o usuário.</p><p>No meio da pirâmide, está a camada de serviço. Os testes no nível de serviço são testes dos fluxos da aplicação sem usar a interface para a sua execução. Eles certificam se os pedaços de código estão se encaixando corretamente. Testes desse tipo são muito interessantes porque são mais rápidos de construir do que os testes de interface e mais rápidos para serem executados.</p><p>Da camada de serviço, automatize tudo o que conseguir, pois testes dessa natureza garantem que uma mudança na aplicação não impactou os fluxos das funcionalidades existentes à um custo de manutenção relativamente baixo.</p><p>Na base da pirâmide estão os testes unitários. Um teste unitário é o tipo de teste que garante que um pequeno trecho de código funciona sem a intervenção de outras partes da aplicação.</p><p>Testes unitários devem ser a fundação de uma boa estratégia de teste. Um teste unitário é muito rápido para escrever e executar. Podemos escrever muitos deles em conjunto com o código da aplicação. Além disso, eles fornecem dados precisos quando ocorre um erro, como o arquivo e a linha que o problema aconteceu.</p><p>Por serem testes fáceis, com baixa manutenção e efetivos, os testes unitários devem ser escritos para praticamente 100% da aplicação.</p><p>E os testes manuais, eles deixam de existir? Com certeza não. Mas o teste feito por um humano deve fazer o que uma máquina não consegue fazer. O teste feito por humanos é muito caro, então devemos aproveitá-los da melhor forma possível.</p><p>Os testes manuais devem ser executados de forma crítica. Um humano consegue identificar se o recurso foi desenvolvido de forma coerente para o fim que foi proposto. Além disso, testes manuais tendem revelar o que está faltando que agregaria valor na funcionalidade.</p><p>É claro que você deve adaptar essa pirâmide ao contexto do seu negócio. Ela deve servir apenas como modelo e não como uma regra que não pode ser mudada. Muitas vezes precisamos mudar as proporções de tipos de testes dependendo do produto. Mas ela é um bom guia para começar a pensar em automação.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc11198c284a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Por que desenvolvedores devem escrever testes?]]></title>
            <link>https://code.likeagirl.io/por-que-desenvolvedores-devem-escrever-testes-224448ad8098?source=rss-4ea308de8b6c------2</link>
            <guid isPermaLink="false">https://medium.com/p/224448ad8098</guid>
            <category><![CDATA[codelikeagirlbr]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Rosicléia Frasson]]></dc:creator>
            <pubDate>Sun, 13 May 2018 22:08:47 GMT</pubDate>
            <atom:updated>2018-06-03T19:59:37.277Z</atom:updated>
            <content:encoded><![CDATA[<p>Mesmo com o amadurecimento dos processos de desenvolvimento, o que presenciamos é que dia após dia, ano após ano, a grande maioria dos projetos de software tem qualidade muito mais baixa do que o esperado, custo maior que o orçado e a entrega muito após o planejado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kzZcj0-aklWfe4djD637ig.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/aA_vfQGPnnY?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Paul Esch-Laurent</a> on <a href="https://unsplash.com/search/photos/code-woman?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Parte disso se deve muito ao fato de tentarmos incorporar qualidade no processo após o início do projeto. Todos nós desenvolvedores sabemos que no começo de um projeto é muito fácil progredir rapidamente. No entanto, à medida que o código começa a crescer, fica cada vez mais difícil adicionar novas funcionalidades e fazer alterações sem quebrar o que já existe.</p><p>Equipes responsáveis pela qualidade do produto estão cada vez mais presentes nas organizações. Entretanto, é humanamente impossível para essas equipes garantir que as milhares de linhas de código sejam retestadas manualmente a cada nova funcionalidade inserida na aplicação.</p><p>Pense que a grande maioria do código que você escreve não é voltada para o usuário, o que significa que muito do seu código não está diretamente relacionado à interface da aplicação. O seu código, em grande parte, é usado por outro código.</p><p>Mesmo que esses inúmeros pedaços de código não sejam necessariamente consumidos por humanos, eles são o alicerce para a construção da interface. E adicionar qualidade nesse tipo código é o que garante o diferencial.</p><p>Mas como garantir qualidade em estruturas tão fundamentais? Testes unitários, é claro. Ter uma boa base de testes unitários é a escolha certa para garantir que essa camada de código funcione.</p><p>Um teste unitário é um teste com enfoque em um comportamento isolado de um pequeno trecho de código. Normalmente são escritos na mesma linguagem que o software está sendo desenvolvido e são feitos pelo próprio desenvolvedor.</p><p>A criação e execução de testes unitários, deve fazer parte da rotina de todo bom programador. Todo código criado deve ter, em paralelo, a criação de testes. Você deve codificar um pouco, testar um pouco e vice-versa. Isso lhe dará segurança de que o que já existia ainda funciona.</p><p>O tempo despendido na criação de um teste será compensado em qualidade e estabilidade do software, ou seja, no tempo que não será perdido procurando e consertando bugs. Além disso, à medida que o produto cresce, sua capacidade de fazer mudanças rapidamente e com confiança não será afetada.</p><p>Acho que é um consenso entre os programadores que</p><blockquote>é uma tarefa horrível trabalhar em um produto frágil, no qual as pessoas relutam em tocar, com medo de quebrar as relações misteriosas que fazem aquele código funcionar.</blockquote><p>E o que é pior: como desenvolvedor é impossível afirmar o que está funcionando e o que parou de funcionar após qualquer mudança, mesmo pequena, no código da sua aplicação.</p><p>Quando você possui testes unitários você consegue detectar de forma rápida, automática e com pouco esforço o que parou de funcionar. E o melhor de tudo é que o teste unitário consegue informar a localização exata do erro, inclusive a linha que o problema ocorre. É um belo investimento, não acham?</p><p>É óbvio que os testes unitários não substituem outras formas de automação de testes e nem o teste de uma equipe humana. No entanto, com uma boa base de testes unitários, os esforços dos outros tipos de teste são muito mais eficazes, já que quando o código vai para o controle de qualidade não está repleto de bugs no nível de unidade.</p><h4>Siga a tag <a href="https://medium.com/search/tags?q=codelikeagirlBR">codelikeagirlBR</a> para ver nossos posts! :D</h4><p>Quer escrever ou traduzir artigos em português para a Code Like A Girl? Se você já faz parte do time de escritoras(es) da Code Like A Girl basta enviar seu artigo diretamente para nossa publicação. Se você ainda não faz parte do nosso time, envie uma mensagem direta para a conta de twitter <a href="https://twitter.com/CodeLikeAGirlBr">CodeLikeAGirlBr</a> ou um email para <em>brazil@codelikeagirl.io</em>. Nós avaliaremos seu artigo e ajudaremos a refiná-lo para publicação.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=224448ad8098" width="1" height="1" alt=""><hr><p><a href="https://code.likeagirl.io/por-que-desenvolvedores-devem-escrever-testes-224448ad8098">Por que desenvolvedores devem escrever testes?</a> was originally published in <a href="https://code.likeagirl.io/">Code Like A Girl</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>