<?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 Paulo Martins on Medium]]></title>
        <description><![CDATA[Stories by Paulo Martins on Medium]]></description>
        <link>https://medium.com/@paulomartins_10299?source=rss-1dfa4a33543c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*I_6-RHoepbrNz4jw5gcA1w.jpeg</url>
            <title>Stories by Paulo Martins on Medium</title>
            <link>https://medium.com/@paulomartins_10299?source=rss-1dfa4a33543c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 08:02:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@paulomartins_10299/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[Recupera dados deletados no BigQuery com viagem no tempo]]></title>
            <link>https://medium.com/@paulomartins_10299/recupera-dados-deletados-no-bigquery-com-viagem-no-tempo-402162d9b64f?source=rss-1dfa4a33543c------2</link>
            <guid isPermaLink="false">https://medium.com/p/402162d9b64f</guid>
            <category><![CDATA[gcp]]></category>
            <category><![CDATA[bigquery]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Paulo Martins]]></dc:creator>
            <pubDate>Sun, 25 Aug 2024 20:52:56 GMT</pubDate>
            <atom:updated>2024-08-25T20:59:06.284Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você alterou ou deletou dados importantes em alguma tabela do BigQuery, saiba que pode recuperar eles, desde que a função de <em>time travel </em>esteja ativa.</p><p>Caso você realmente tenha deletado a tabela, você ainda pode tentar verificar se o <em>fail-safe </em>esta ativo.</p><h3>Viagem no tempo</h3><p>Para acessar dados no passado, devemos ultilizar o comando F<em>OR SYSTEM_TIME AS OF</em> e o horario que você deseja consultar os dados antigos. No exemplo a seguir ultilizamos este comando para recuperar os dados da tabela a 1 hora atras.</p><pre>SELECT *<br>FROM `mydataset.mytable`<br> FOR SYSTEM_TIME AS OF TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR);</pre><p>Com estes dados em mãos, podemos recuperar a tabela no momento antes de algum erro ter acontecido. Entretanto, não é possivel atualizar uma tabela com os dados históricos da mesma, para isto você deve criar uma tabela temporaria seguindo os seguintes passos:</p><p>Crie uma nova tabela a partir dos dados históricos:</p><pre>CREATE TABLE `mydataset.mytable_copy`<br>SELECT *<br>FROM `mydataset.mytable`<br>  FOR SYSTEM_TIME AS OF TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR);</pre><p>Confira que a nova tabela (cópia) esta com os dados 100% corretos, então delete a tabela antiga:</p><pre>DROP TABLE `mydataset.mytable`</pre><p><strong>Observação:</strong> Lembre-se de verificar snapshots, politicas de IAM, view materiazdas, dentre outras opçãos do Google Cloud Platform que podem causar um problema antes de deletar a tabela antiga. Se achar melhor, apenas renomei a tabela antiga para `mydataset.mytable_old_bkp`</p><p>Renomei a tabela cópia como a nova tabela:</p><pre>ALTER TABLE `mydataset.mytable_copy`<br>RENAME TO `mydataset.mytable`</pre><h3>A PROVA DE FALHAS</h3><p>Caso você tenha realizado um <strong>drop table</strong> re realmente tenha excluido totalmente a tabela do seu dataset, ao tentar realizar uma viagem no tempo vai tomar o erro:</p><pre>Not found: Table myproject:mydataset.mytable was not found in location US</pre><p>Não se preocupe, ainda temos outra opção, o bigquery implementa por padrão uma politica adicional de <em>Fail-safe, </em>no qual<em> </em>snapshots temporais, são mantidos por mais 7 dias após o fim do time travel.</p><p>Sendo assim você pode restaurar sua tabela, gerando uma cópia do snapshot temporal, executando o comando abaixo no Google Shell:</p><pre>bq cp mydataset.mytable@-3600000 mydataset.mytable_restored</pre><p>Isto vai fazer a tabela deletada aparecer magicamente no seu dataset com o nome mytable_restored.</p><p>O comando segue o formato tableid@TIME, onde TIME é o número de milesegundos desde a época do UNIX.</p><p>Quando colocamos um -TIME conforme o exemplo mostrado, estou pegando a posição em milisegundos desde o momento atual.</p><p>Se usarmos TIME@0 pegaremos o snapshot mais antigo possivel daquela tabela.</p><h3>Verificar viagem no tempo esta ativa</h3><p>Você pode ativar o timetravel indo até um dataset, clicando nas opções “Editar Detalhes” -&gt; “Opções Avançadas” -&gt; “Time Travel Window”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/556/1*tmcWITHYzO9TsahC4V5qlw.png" /></figure><p>Via console GCP:</p><pre>ALTER SCHEMA myproject:mydataset SET OPTIONS (max_time_travel_hours = 48);</pre><p>Via cli:</p><pre>bq update \<br> - dataset=true - max_time_travel_hours=48 \<br>myproject:mydataset</pre><h3>Refências e mais</h3><p>Guia completo para uso do BigQuery:</p><p><a href="https://medium.com/@paulomartins_10299/bigquery-o-guia-completo-5617657f8646">https://medium.com/@paulomartins_10299/bigquery-o-guia-completo-5617657f8646</a></p><ul><li><a href="https://cloud.google.com/bigquery/docs/access-historical-data?hl=pt-br">Acessar dados históricos | BigQuery | Google Cloud</a></li><li><a href="https://cloud.google.com/bigquery/docs/access-historical-data?hl=pt-br#restore-a-table">Acessar dados históricos | BigQuery | Google Cloud</a></li><li><a href="https://cloud.google.com/bigquery/docs/time-travel#time_travel_and_row-level_access">Data retention with time travel and fail-safe | BigQuery | Google Cloud</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=402162d9b64f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reduza 80% do consumo do BigQuery usando partições — parte 2]]></title>
            <link>https://medium.com/@paulomartins_10299/reduza-80-do-consumo-do-bigquery-usando-parti%C3%A7%C3%B5es-parte-2-ad9b60cae989?source=rss-1dfa4a33543c------2</link>
            <guid isPermaLink="false">https://medium.com/p/ad9b60cae989</guid>
            <category><![CDATA[gcp]]></category>
            <category><![CDATA[bigquery]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Paulo Martins]]></dc:creator>
            <pubDate>Sat, 17 Aug 2024 18:03:51 GMT</pubDate>
            <atom:updated>2024-08-17T18:06:57.265Z</atom:updated>
            <content:encoded><![CDATA[<h3>Reduza 80% do consumo do BigQuery usando partições — parte 2</h3><p>Esta sequência de artigos visa apresentar dicas de como otimizar o desempenho e consequentemente o custo de queries do BigQuery, neste texto vamos aprender a técnica mais efetiva para reduzir a quantidade de dados processadas, o uso de partição.</p><h4>O que é partição?</h4><p>Partição é uma segmentação de dados realizada pela própia estrutura interna da engine, de forma simplificada é como se o BigQuery separasse o armazenamento de dados em estruturas menores internamente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*fbJO8xzYXHRyUWMP5YF9zg.png" /><figcaption>Tabela de Vendas vs Tabela de Vendas Particionada</figcaption></figure><h4>Como criar uma partição?</h4><p>Você pode criar uma partição a partir de dados temporarias ou dados do tipo inteiro. Para tabelas temporais, você pode usar campo DATE, DATETIME ou TIMESTAMP, podendo selecionar por intervalo de Horas, Dias, Semana, ou até mesmo Meses.</p><p>Para dar continuedade em nossos exemplos, vamos criar uma nova tabela de venda, particionada por <strong>dias</strong>, ultilizando a coluna de <strong>data venda</strong>. Para isto vamos executar o código a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/409/1*y3csJceGJLcUTaxp__ykGg.png" /></figure><h4>Como ver qual a coluna de partição da minha tabela?</h4><p>Caso você quera descobrir se uma tabela ja possui partição, ou qual a partição da sua tabela, você pode clicar sobre a tabela, ir até a aba “DETALHES” e então verificar se o “Tipo da Tabela” esta como “Particionado”. Caso a tabela não seja particionada, não sera exibida nenhuma informação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YBwblGXXpj-Ebpo5WGc8vg.png" /><figcaption>Verificando partição da tabela.</figcaption></figure><h4>Desempenho de consulta particionada Vs sem partição</h4><p>Para fazer um teste de desempenho, vamos executar a consulta para nos retornar o total de vendas de todos dias de 2024.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/1*LRJzogdHBxqguOB07Q6FNw.png" /><figcaption>Comparação query para tabelas particionadas e não particionadas.</figcaption></figure><p>Obs: Fatores como tempo de execução e quantidade de slots não são confiaveis para consultas muito pequenas no BigQuery.</p><p>Repare que a consulta reduziu o consumo de 3,81 Megabytes para 500kbytes uma <strong>redução de ~87%, </strong>mas por que isto ocorre?</p><p>No primeiro caso o banco de dados precisa processar toda a tabela para encontrar os dados que são maiores de 2024, entretanto no segundo caso, a engine por tras da consulta, consegue ultilizar apenas as particições nescessarias, conforme mostra o esquema a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/771/1*krEEooY2ZFbATXnsIlOf4Q.png" /><figcaption>Consulta BigQuery em tabela não particionada.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/771/1*bVQqDxyZrZI2Hcugtxnl_w.png" /><figcaption>Consulta BigQuery em tabela particionada.</figcaption></figure><h4>Reduza custo do storage com partições</h4><p>O uso de partição ajuda também reduzir o custo de storage, se você ficar mais de 90 dias sem realizar consulta em uma tabela, ou em uma partição especifica daquela tabela o modelo de faturamento muda de “Ativo” para “Longo Termo”, o que ocasiona uma redução de 50% do custo de storage.</p><h4>Pseudo Colunas de Partição</h4><p>Você também pode ultilizar pseudo colunas de partição que são os campos _PARTITIONTIME ou _PARTITIONDATE. Estas colunas ficam salvo o exato momento que o que os dados foram inseridos na tabela.</p><h4>Referências</h4><ul><li><a href="https://cloud.google.com/bigquery/pricing?hl=pt-br">Preços | BigQuery: Cloud Data Warehouse | Google Cloud</a></li><li><a href="https://cloud.google.com/bigquery/docs/partitioned-tables?hl=pt-br">Introdução a tabelas particionadas | BigQuery | Google Cloud</a></li></ul><p>Série Completa: <a href="https://medium.com/@paulomartins_10299/bigquery-o-guia-completo-5617657f8646">https://medium.com/@paulomartins_10299/bigquery-o-guia-completo-5617657f8646</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ad9b60cae989" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[BigQuery — O guia completo]]></title>
            <link>https://medium.com/@paulomartins_10299/bigquery-o-guia-completo-5617657f8646?source=rss-1dfa4a33543c------2</link>
            <guid isPermaLink="false">https://medium.com/p/5617657f8646</guid>
            <category><![CDATA[bigquery]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Paulo Martins]]></dc:creator>
            <pubDate>Thu, 08 Aug 2024 20:06:01 GMT</pubDate>
            <atom:updated>2024-08-25T20:53:44.515Z</atom:updated>
            <content:encoded><![CDATA[<h3>BigQuery — O guia completo</h3><p>BigQuery é o serviço de Data Warehouse da Google Cloud Platform (GCP), com ele é possivel armazenar e recuperar terabytes de dados em segundos. A maior vantagem do bigquery é ser um banco de dados sem servidor, possuindo uma grande capacidade computacional e podendo ser ultilizado com uma linguagem comum de mercado, o SQL.</p><p>Com todo este poder computacional, o bigquery pode ser ultilizado para grandes processamento analitico, treinamento e execução de modelos de inteligência artificial ou alimentar ferramentas de dataviz de bigdata, como PowerBi e Tableau.</p><p>Sendo você um usuario, disposto a aproveitar ao maximo o poder computacional do BigQuery, ou um administrador de Cloud de uma grande organização, neste texto você encontrara uma sequencia de artigos para te ajudar nesta jornada.</p><h4>Otimização:</h4><p><a href="https://medium.com/@paulomartins_10299/otimizando-bigquery-parte-1-598d8b1d4b8a">Introdução Otimizando BigQuery</a> - Introdução a boas praticas no BigQuery</p><p><a href="https://medium.com/@paulomartins_10299/reduza-80-do-consumo-do-bigquery-usando-parti%C3%A7%C3%B5es-parte-2-ad9b60cae989">Reduza 80% do consumo com partições </a>— Ferramenta mais importante de otimização do BigQuery.</p><h4>Gestão de riscos</h4><p><a href="https://medium.com/@paulomartins_10299/recupera-dados-deletados-no-bigquery-com-viagem-no-tempo-402162d9b64f">Recupere tabelas delatadas com viagem no tempo</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5617657f8646" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Otimizando Bigquery — parte 1]]></title>
            <link>https://medium.com/@paulomartins_10299/otimizando-bigquery-parte-1-598d8b1d4b8a?source=rss-1dfa4a33543c------2</link>
            <guid isPermaLink="false">https://medium.com/p/598d8b1d4b8a</guid>
            <category><![CDATA[gcp]]></category>
            <category><![CDATA[bigquery]]></category>
            <category><![CDATA[cloud]]></category>
            <dc:creator><![CDATA[Paulo Martins]]></dc:creator>
            <pubDate>Thu, 08 Aug 2024 19:42:48 GMT</pubDate>
            <atom:updated>2024-08-17T18:06:32.106Z</atom:updated>
            <content:encoded><![CDATA[<h3>Reduzindo custos do Bigquery — parte 1</h3><p>Esta sequência de artigos visa apresentar dicas de como otimizar o desempenho do BigQuery, neste texto:</p><blockquote>Não ultilize select * para explorar dados.</blockquote><blockquote>Nunca utilize select *</blockquote><blockquote>Operador LIMIT — Reduza os dados retornados na tela.</blockquote><blockquote>Sempre filtre os resultados — Operador Where.</blockquote><h4>Não utilize select * para explorar dados.</h4><p>Caso você não tenha conhecimento sobre uma tabela ou apenas queira entender seus dados, evite usar o operador SELECT *, mesmo com o operador LIMIT pode-se gerar queries com consumo alto para tabelas grandes. Em substituição, utilize a aba Preview — ou Visualização em português — do console, para entender sobre a tabela.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iX3RNiTW0ckpTqRYLttfDQ.png" /><figcaption>Visualização de uma tabela pela aba preview — BigQuery.</figcaption></figure><h4>Nunca utilize select *</h4><p>BigQuery é um banco de dados focado em bigdata, que trabalha com uma estrutura colunar, semelhante a postgree ou spark. Sendo assim, cada coluna a mais que você traz em um SELECT, aumenta o consumo total das tabelas.</p><p>Observe o comparativo de consumo de diferentes tipos de SELECT:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7XEsBBjN6j90fSKGqgOHXA.png" /><figcaption>Comparação de diferentes select no BigQuery.</figcaption></figure><p>Nossa tabela de exemplo tem 10 colunas, quando usamos um select * from em todas tabelas, temos ~63mb de dados processados.</p><p>Quando executamos o select em apenas 5 colunas colunas, nosso total de dados processados caiu para 30mb.</p><p>Mesmo em caso extremos que você precise usar 9 das 10 colunas, ainda assim você deve evitar selecionar todas. Você pode usar o operador EXCPET para dizer quais colunas não trazer de um SELECT *. Em nosso comparativo, o fato de usar except em apenas uma coluna, reduziu o total de bytes processado em ~30%.</p><h4>Operador LIMIT — Reduza os dados retornados na tela.</h4><p>O operador LIMIT reduz apenas a quantidade de dados que vai ser mostrado no retorno final do bigquery, <strong><em>mas não reduz o número de bytes processados</em></strong>. Observe o seguinte exemplo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rrZuTBWOhVrYO1WfTxEEqw.png" /><figcaption>Comparação queries com e sem o operador LIMIT.</figcaption></figure><p>Em ambos casos, como esta destacado no na linha em roxo, o número de bytes processados foi exatamente o mesmo, todo o conteúdo da tabela, 58,89 Megabytes.</p><p>A capacidade computacional utilizada (Slot) com o operador LIMIT é reduzida, isto porque sem o limitador a tabela inteira tem que ser retornada para o usuário, enquanto no primeiro caso apenas 1000 linhas foram retornadas no console.</p><h4>Sempre filtre os resultados — Operador Where.</h4><p>Sempre filtre os dados para evitar retorno gigantescos. As melhores colunas para realizar filtragem (e agrupamento) geralmente são do tipo: BOOL, INT, FLOAT ou DATE.</p><p>Entretanto existe exceções, o formato de dados tipos STRING dependendo da distribuição dos dados, pode ser mais rápido que tipo inteiro para algumas queries.</p><h4>Série Completa</h4><p><a href="https://medium.com/@paulomartins_10299/bigquery-o-guia-completo-5617657f8646">https://medium.com/@paulomartins_10299/bigquery-o-guia-completo-5617657f8646</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=598d8b1d4b8a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Uso do 5w2h para gerencimaneto de tarefas de programação.]]></title>
            <link>https://medium.com/@paulomartins_10299/uso-do-5w2h-para-gerencimaneto-de-tarefas-de-programa%C3%A7%C3%A3o-4caabcfe9c3f?source=rss-1dfa4a33543c------2</link>
            <guid isPermaLink="false">https://medium.com/p/4caabcfe9c3f</guid>
            <category><![CDATA[5w1h]]></category>
            <category><![CDATA[5w2h]]></category>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[gerenciamento-de-tarefas]]></category>
            <category><![CDATA[gerenciamento-de-projetos]]></category>
            <dc:creator><![CDATA[Paulo Martins]]></dc:creator>
            <pubDate>Wed, 06 Jul 2022 01:30:05 GMT</pubDate>
            <atom:updated>2022-07-06T12:27:41.072Z</atom:updated>
            <content:encoded><![CDATA[<p>Ultilizado em design, jornalismo, e diversas outras áreas, um método que provavelmente existe desde a grécia antiga¹, o 5w (possui variações como o 5w2h) também é um ótimo auxiliador para tomada de decisões na administração.</p><p>Este método consiste em analisar os seguintes pontos para efetuar a execução de qualquer plano:</p><p>5w:</p><ul><li>O que (What) deve ser feito?</li><li>Por que (Why) deve ser implementado?</li><li>Quem (Who) é o responsável pela ação?</li><li>Onde (Where) deve ser executado?</li><li>Quando (When) deve ser implementado?</li></ul><p>2h:</p><ul><li>Como (How) deve ser conduzido?</li><li>Quanto (How much) vai custar a implementação?</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*-5foZyQD_wwYAAUqvhhNAQ.jpeg" /><figcaption>Metodologia <a href="https://uvagpclass.wordpress.com/2017/03/30/simplifique-sua-gestao-de-processos-com-a-metodologia-5w2h/">5w2h </a>digrama.</figcaption></figure><p>Está tatica apesar de simples é um poderoso plano para executar diferentes tipos de funções. Na litetura de gestão de TI, aparece como auxilio no gerenciamento de projetos tanto em metodologia tradicional como em metodologias ageis.</p><p>O que vou propor a seguir é o uso do 5w e 1h nas tarefas de programação.</p><h3>Um exemplo prático</h3><p>Uma tarefa de programação pode ser relativamente fácil, ou difícil, talvez até a análise de complexidade dela seja um processo abstruso de se definir, mas uma boa maneira realizá-la pode ser feita através do 5w1h.</p><p>Imagine a seguinte situação: Após a definição do que ser feito na sprint semanal, uma de suas ‘tasks’ é “Adicionar função de imprimir um relatório de vendas em pdf”. Vamos analisar esta tarefa, com uma breve explicação do 5w1h.</p><h4>O que (What) deve ser feito?</h4><p>Explicação: Descrição da tarefa que sera executada.</p><p>Exemplo: Criar uma função que permita imprimir o total das vendas efetuadas em um período, definido pelo usuário, por cada vendedor.</p><h4>Por que (Why) deve ser implementado?</h4><p>Explicação: Este ponto é importante ser conhecido, pois, analisando a necessidade pedida, quem for executar a tarefa pode pensar em diferentes abordagens para resolução do problema, podendo até propor uma nova solução.</p><p>Exemplo: Os usuários do sistema precisam de um relatório para poder comparar o desempenho dos vendedores.</p><h4>Quem (Who) é o responsável pela ação?</h4><p>Explicação: Responsáveis gerais pelo processo.</p><p>Exemplo: Nome do desenvolvedor responsável pela ação, seu tech leader ou gerente.</p><h4>Onde (Where) deve ser executado?</h4><p>Explicação: Neste ponto, existe uma discussão do nível técnico a ser associado. Pode ser simplesmente “no sistema de vendas XXX”, visto que muitas empresas possuem mais de um sistema (ou vários microsserviços, api e etcs…) em seu portfólio.</p><p>Exemplo: Sistemas de vendas XXX.</p><h4>Quando (When) deve ser implementado?</h4><p>Explicação: Prazo para execução do projeto.</p><p>Exemplo: Em 2 dias.</p><h4>Como (How) deve ser conduzido?</h4><p>Nesta proposição de abordagem, este campo é de nível técnico, porém não obrigatório. Aqui deve ser preenchido quando houver possibilidade, principalmente para casos que esta tarefa é passada por um usuário que não tem familiaridade com o sistema, talvez um programador estagiário, júnior ou até mesmo em um nível mais alto, mas recém contrato.</p><h4>Não é muito trabalho?</h4><p>Normalmente já temos maioria destas informações ao criar uma tarefa, mesmo que não estejam explicitamente definidas. Para exemplo, vamos verificar um work item no Azure, da Microsoft</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*MxK_w9HdJLpUg5muwqZE6Q.png" /><figcaption>Exemplo de Work Item do Azure</figcaption></figure><p>Repare que já respondemos o que(1), quem (2) e quando(3). Talvez para este time a questão de onde já seja subentendida, mesmo assim poderia ser explicitado e faltou a questão do porquê.</p><blockquote>Conclusão</blockquote><p>Além de amplamente conhecido e usados, uma amostra de que o método é efetivo é que naturalmente já respondemos alguns desdes dados para definir uma ação.</p><p>A proposta é passar este método como um padrão, para que toda tarefa executada responda os 5w e opcionalmente o 1h. Assim é possível criar um<strong> controle de qualidade</strong> e com isto <strong>melhorar </strong>a <strong>execução dos processos</strong>, <strong>mensuração de dificuldade</strong>, e <strong>aumentar a agilidade</strong> com escopos de trabalhos bem definidos.</p><h3>Referências</h3><p><em>Septem Circumstantiae, five W’s and H or ‘six serving-men’. Alex Fedotov (em inglês). 22 de fevereiro de 2019. Consultado em 03 de julho de 2022.</em></p><p><em>¹Wikipedia contributors, </em><a href="https://en.wikipedia.org/wiki/Five_Ws"><em>“Five Ws,” Wikipedia</em></a><em>, The Free Encyclopedia,(em inglês) . Consultado em 05 de julho de 2022.</em></p><p><em>5w2h — </em><a href="https://www.sebrae.com.br/Sebrae/Portal%20Sebrae/Anexos/5W2H.pdf"><em>Plano de ação para emprededores</em></a><em>. Sebrare, Nakagawa Marcelo. Consultado em 05 de julho de 2022.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4caabcfe9c3f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Grafos — código de busca em profundidade em C.]]></title>
            <link>https://medium.com/@paulomartins_10299/grafos-c%C3%B3digo-de-busca-em-profundidade-em-c-6ba48098cdf4?source=rss-1dfa4a33543c------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ba48098cdf4</guid>
            <category><![CDATA[grafo]]></category>
            <category><![CDATA[grafo-em-c]]></category>
            <category><![CDATA[estruturadedados]]></category>
            <dc:creator><![CDATA[Paulo Martins]]></dc:creator>
            <pubDate>Tue, 05 Nov 2019 20:11:38 GMT</pubDate>
            <atom:updated>2020-10-09T15:43:25.555Z</atom:updated>
            <content:encoded><![CDATA[<h3>Grafos — código de busca em profundidade em C.</h3><p>Uma operação muito usada em grafos é a busca, neste modulo vamos ver a busca em profundidade. Como já explicado <a href="https://medium.com/@paulomartins_10299/grafos-representa%C3%A7%C3%A3o-e-implementa%C3%A7%C3%A3o-f260dd98823d">anteriormente</a> a melhor implementação de grafo para trabalhar com busca é por lista de adjacência, por isto vamos trabalhar usando esta implementação.</p><p>Este texto, tem como objetivo apenas explicar o código de implementação da busca em profundida no grafo usando a linguagem C, para fins didáticos, logo para ler, precisa-se saber como funciona a busca em profundidade.</p><h4>Caminhando pelo grafo.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*C0VsrdsvKMCOPhBEawzmLQ.png" /><figcaption>Código de implementação de grafo por lista de adjacência em C.</figcaption></figure><p>Como podemos ver a implementação de lista de adjacência não muda do que as trabalhadas anteriormente, a unica mudança no código é as lingas 16,17 e 18 em que definimos as cores. O algorítimo de busca profunda trabalha “pintando” cada aresta de uma cor para saber qual já foi visitada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vn9HAwDgTKHuIiO9UgbDCQ.png" /><figcaption>Código da função de busca em profundidade de grafo por lista de adjacência em C — função profundidade.</figcaption></figure><p>A função que a realiza a busca em profundidade tem como único parâmetro passado o grafo a qual ela vai ser trabalhada. Quando abrimos a função criamos um arranjo (vetor) de cores que vão dizer a cor de cada vértice do grafo. <strong>ATENÇÃO: </strong>Este arranjo deve ser construído de modo que a posição 0 do arrancho corresponda ao vértice zero do grafo.</p><p>Então temos um laço (linha 42) em que deixamos todas os vértices da cor branca, que é a cor que escolhemos como ainda não procurada. Logo em seguida(linha 45), temos outro laço que verifica se os vértices é de cor branca e se for começamos a visita, o que altera as cores e veremos o código a seguir.</p><p><strong>OBSERVAÇÃO:</strong> O laço da linha 45, parece percorrer todos os vértices, mas isto seria um trabalho computacional desnecessário e não faria sentido para nosso algoritmo de busca. O que ele faz é apenas percorrer os vértices brancos, para garantir que mesmo se ele visitar todos os filhos (ou seja a função visitaP sair da recursividade) e ainda não tenha acabado o grafo ele tenha outra vértice por onde recomeçar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VZ4lyo9DRyHwHNL3alGU4Q.png" /><figcaption>Código da função de busca em profundidade de grafo por lista de adjacência em C — função visita.</figcaption></figure><p>Quando chamamos a função visitaP localizamos um grafo e automaticamente marcamos ele de amarelo (linha 52). Então visitamos suas adjacências, colocando ela no arranjo v e iniciando um lanço (linha 54) a qual só vai sair depois de todas suas as adjacências(arestas) serem visitadas.</p><p>Quando entramos em uma aresta nova, caso ela seja branca, chamamos novamente a função nesta aresta, <strong>neste momento entra a recursividade. </strong>A função nova é marcada de amarela, então criasse uma arranjo com todas suas adjacências e novamente se for branca começa tudo de novo… até chegarmos na falta de adjacência, então recursivamente vai voltando.</p><p>Quando termino todos as adjacências dele, marco ele como vermelho. (linha 59)</p><h4>Realizando a busca.</h4><p>Vimos como percorrer todo o grafo, mas apenas andamos por ele, como realizar a busca? Se você sabe como andar, fica-se fácil fazer a busca: Você pode colocar um código verificando se a informação que você quer esta no local, assim que você visita ele, pode-se por exemplo colocar este if, antes da linha 52.</p><p>Lembre-se também que na linha 28 da strutct, deixamos espaços para por dados em cada vértice. Sendo assim estes dados que podem ser os pesquisados no futuro podem ir neste local. O algoritmo que dei de exemplo é geral, mas pode ser adaptado para varias situações.</p><p>Existe ainda outros tipos de buscas que vão ser exploradas. E como sempre o código completo pode ser acessado no github por este link: <a href="https://github.com/MartinsPaulo/grafosC">aqui</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ba48098cdf4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Grafos — código das operações básicas.]]></title>
            <link>https://medium.com/@paulomartins_10299/grafos-c%C3%B3digo-das-opera%C3%A7%C3%B5es-b%C3%A1sicas-e91d9a79e828?source=rss-1dfa4a33543c------2</link>
            <guid isPermaLink="false">https://medium.com/p/e91d9a79e828</guid>
            <category><![CDATA[grafo]]></category>
            <category><![CDATA[estruturadedados]]></category>
            <dc:creator><![CDATA[Paulo Martins]]></dc:creator>
            <pubDate>Sun, 27 Oct 2019 02:10:41 GMT</pubDate>
            <atom:updated>2019-10-27T16:33:52.664Z</atom:updated>
            <content:encoded><![CDATA[<h3>Grafos — código das operações básicas em C.</h3><p>Nós aprendemos no artigo passado, como se definir um grafo por lista ou matriz de adjacências. Neste artigo, vamos aprender a implementar as operações básicas no grafo criado.</p><p><em>Vale relembrar que a estrutura de grafo, já foi ensinada com ser montada no artigo passando, qual pode acessar clicando </em><a href="https://medium.com/@paulomartins_10299/grafos-representa%C3%A7%C3%A3o-e-implementa%C3%A7%C3%A3o-f260dd98823d"><em>aqui</em></a><em>.</em></p><h4>Função de criar um grafo em C</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*mFD6AsCamZwOqwVwKKZWSQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/297/1*cY9Sgrud-L-ULInEUUYuYg.png" /><figcaption>Lado direito a função em C que grafo. No lado esquerdo a representação gráfica desta função.</figcaption></figure><p>Nosso primeiro passo, depois de definirmos o escopo do grafo é cria-lo, para isto receberemos de parâmetro a variável v que representa o numero de vértices que o grafo possui.</p><p>Quando entramos na função, ela é de simples entendimento: Reservamos um espaço na memória (linha 39), dizemos que o numero de vértices é igual o da variável o informado (linha 40), deixamos o numero de arestas zerados, pois ainda não criamos nenhuma.</p><p>A parte mais não intuitiva é a linha 40. Nela aloco o arranjo contendo os v vértices na memória, note que a <strong>adj </strong>não é o arranjo em sim, mas sim um ponteiro que aponta para o arranjo.</p><p>Infelizmente os compiladores C colocam valores aleatórios na memória quando eles alocam, para não ficar estes valores(lixo), criamos um for (linha 44 a 46) em que colocamos um valor nulo em todos ponteiros, para assim ficar um grafo recém criado sem nenhum valor em nenhum ponteiro, ou seja, grafo sem nenhuma adjacência.</p><p>Link do código completo no git hub: <a href="https://github.com/MartinsPaulo/grafosC">aqui</a>.</p><h4>Adicionando arestas ao grafo</h4><figure><img alt="Função para criar arestas nos grafos em C." src="https://cdn-images-1.medium.com/max/1024/1*RiIP6oVvwH5IpFVPi1TvOw.png" /><figcaption>Função para criar arestas nos grafos em C.</figcaption></figure><p>Quando formos criar as arestas devemos começar chamando a função criaAresta, e passamos a informação de qual grafos queremos criar, o numero de vértice inicial e final que recebe a aresta além do seu peso.</p><p>Logo após validamos em teste se o grafo existe (também importante validar na criação) e se a vértice inicial e final não é numero negativo, ou é maior que o numero de vértices que o grafo possui.</p><p>Então chamamos a função criaAdj que cria adjacências:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*WdnLxRMfPDfb2p9OmYwXkg.png" /><figcaption>Efeito da função criaADJ</figcaption></figure><p>Esta função cria um nó, qual sua próxima ligação é nula e a ligação anterior não é definida, porém este nó já possui peso. Como a função retorna o ponteiro deste nó fica fácil, com o código seguinte (linha 69 e 70) fazer este valor ser grudado no inicio da sua respectiva lista de adjacência.</p><figure><img alt="Efeito final da função criaAresta." src="https://cdn-images-1.medium.com/max/374/1*-ysWNSGcKQKgHWhHqgEbJg.png" /><figcaption>Efeito final da função criaAresta.</figcaption></figure><p>Caso quisesse uma aresta não dirigida, ou ela com dupla direção, bastava rodar o código de novo trocando os valores. Lembrando claro que este é só um algorítimo geral e pode ser adaptado.</p><p>Link do código completo no git hub: <a href="https://github.com/MartinsPaulo/grafosC">aqui</a>.</p><h4>Imprimindo na tela</h4><p>Tanto para fim didático, como alguma aplicação, vamos agora ver como imprimir o grafo na tela.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ir-XdXymtGd5xkgokGbH-g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/629/1*O3Fr-oYVvX6jpDc0M_lHeQ.png" /><figcaption>Função que imprime grafo e sua saída em C.</figcaption></figure><p>A função começa imprimindo o numero de vértices e arestas do grafo. Logo em seguida ela chama um vértice, e o cabeçalho da lista de adjacência ligado a ele(linha 82). Enquanto esta lista não for nula (lina 83) ele imprime o valor da primeira adjacência no cabeçalho e seu peso(linha 84). Então a adjacência recebe o próximo valor na lista, e continua assim até imprimir todas adjacências daquele nó.</p><p>A saída mostrada a direita, vai ser a mostrada para função de chamada abaixo.</p><p>Lembrando que a ordem que as adjacências são imprimidas, depende de como o algoritmo de isenção colocava estes valores na lista. No nosso caso, cada inserção é adicionada na cabeça do da lista de adjacência, logo o ultimo valor adicionado sempre sera o primeiro.</p><h4>Inicializando o programa na classe main</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/393/1*NX07bJqSgnLEyadEZAvoqw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/629/1*O3Fr-oYVvX6jpDc0M_lHeQ.png" /><figcaption><strong>Função main, chamando as funções construídas até agora e sua saída.</strong></figcaption></figure><p>Percebe que a função principal, apenas chamara as criadas até agora, primeiro criamos um grafo (lina 94), adicionamos as arestas passando os parâmetros: gr=grafo criado, vértice inicial, vértice final, peso da aresta. E depois chamamos a função de imprimir para ver o resultado, que pode ser conferido na imagem ao lado.</p><p>Agora temos uma função completa de criação de grafos, vamos aprender fazer buscas nele no próximo artigo.</p><p>Lembrando sempre que você pode conferir o código de tudo que foi feito até aqui no git hub: por este <a href="https://github.com/MartinsPaulo/grafosC/blob/master/grafo-lista-adj-completo.c">link</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e91d9a79e828" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Grafos — representação e implementação]]></title>
            <link>https://medium.com/@paulomartins_10299/grafos-representa%C3%A7%C3%A3o-e-implementa%C3%A7%C3%A3o-f260dd98823d?source=rss-1dfa4a33543c------2</link>
            <guid isPermaLink="false">https://medium.com/p/f260dd98823d</guid>
            <category><![CDATA[estruturas-de-dados]]></category>
            <category><![CDATA[grafo]]></category>
            <category><![CDATA[estruturadedados]]></category>
            <dc:creator><![CDATA[Paulo Martins]]></dc:creator>
            <pubDate>Sat, 26 Oct 2019 19:14:02 GMT</pubDate>
            <atom:updated>2019-10-27T15:46:03.930Z</atom:updated>
            <content:encoded><![CDATA[<h3>Grafos — representação e implementação</h3><p>Para se representar um grafo temos que analisar quais de seus nós (vértices) que existem conexões, mas como ficaria esta representação nos computadores? Existem duas maneiras mais usuais de representa-los : Matriz de adjacência ou lista de adjacência.</p><h3>Matriz de adjacência</h3><p>Uma matriz de adjacência qualquer (M) terá a quantidade de vértices (n) de numero de linha e colunas, ou seja uma para cada vértice. Ocorrera diferenças para caso o grafo for ou não ponderado.</p><h4>Grafo não ponderado</h4><p>Em uma matriz M para o gráfico não ponderado, podemos completar suas linhas(i) e colunas(j) com apenas 0 e 1, pois só existe a opção de conter ou não ligações entre os vértices.</p><p>Então em uma matriz (M)de adjacência não ponderada, temos que:</p><p><em>M[i,j] = 1, se houver uma aresta saindo do vértice i e indo até o j</em></p><p><em>M[i,j] = 0, se não houver uma aresta saindo do vértice i e indo até o j</em></p><p>A imagem a seguir mostra um exemplo do caso:</p><figure><img alt="Matriz de adjacência, figura na esquerda mostra a representação de um grafo e a sua direita uma matriz o representando." src="https://cdn-images-1.medium.com/max/960/1*gny0Hz4hd90zDeCyY0s72A.png" /><figcaption>Matriz de adjacência com gráfico não ponderado.</figcaption></figure><h4>Grafo ponderado</h4><p>No caso de ponderado, usamos a mesma lógica, mas no lugar de bits (0 ou 1), usamos o valor do peso, seja eles em inteiro, reais ou outros valores.</p><p>Então em uma matriz (M)de adjacência ponderada, temos que:</p><p><em>M[i,j] = valor do peso, se houver uma aresta saindo do vértice i e indo até o j</em></p><p><em>M[i,j] = valor definido para representar não li</em>gação*<em>, se não houver uma aresta saindo do vértice i e indo até o j</em></p><p>*Note que o valor definido para representar não ligação é definido em código pelo programador, você pode usar zero como na matriz de bits, porém caso esteja trabalhando com distancia por exemplo, existe distancia zero, então talvez atrapalhe seu códio. Fique atendo na escolha!</p><p>A imagem a seguir mostra um exemplo do caso:</p><figure><img alt="Matriz de adjacência, figura na esquerda mostra a representação de um grafo e a sua direita uma matriz o representando." src="https://cdn-images-1.medium.com/max/960/1*IjSbWwPfCuUM0pm0NKO-tg.png" /><figcaption>Matriz de adjacência com gráfico ponderado.</figcaption></figure><h3>Lista de adjacência</h3><p>Consiste em uma lista qual cada elemento é um nó do grafo, logo a lista possui de tamanho o numero de vértices do grafo. Ela possui n lista ligadas, estas contem as conexões de cada arestas do vértice. Apesar da definição confusa veremos na imagem a seguir como é fácil sua visualização:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*4OPM6HrGk_vm7PT2hEQhcA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*Zh3qGRvzAc2nVvgtL1N7KA.png" /><figcaption>grafo representado usando lista de adjacências.</figcaption></figure><p>Computacionalmente, vamos representar isto como uma lista que em cada elemento (representando um vértice do grafo) existe um ponteiro para todas as arestas ligada a ela. Vamos trabalhar com uma lista de tamanho pré definido, mas caso você não saiba o tamanho do seu grafo é só mudar para uma lista encadeada. Lembrando que se seu grafo for ponderado, basta adicionar um campo de peso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*PkoqVuWVwJaCHzb6wbrsng.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*BmywGsZB87LrQZQiKeVGIw.png" /></figure><p><em>Para acessar o código completo basta clicar neste </em><a href="https://github.com/MartinsPaulo/grafosC/blob/master/grafo-lista-adj.c"><em>link.</em></a></p><p>O códio e a imagem acima mostram como implementar o grafo com a lista de adjacência, repare que salvamos o numero de vértice e arestas, pois para saber esta informação, caso não estivesse salva, seria necessário percorrer todo o arquivo.</p><p>A partir disto temos um arranjo de vértices que apontara para estrutura vértice. Cada vértice (além dos dados da vértice, que podem ser implementados) aponta para a cabeça de suas adjacências, que são uma lista contendo todas as ligações que aquele vértice possui.</p><p>A struct adjacência guarda o vértice final que ela tem ligação, o peso associado a ligação e finalmente o próximo vértice que contem ligação (na imagem representado em rosa).</p><h3>Quando usar cada representação?</h3><p>Escolher cada representação vai depender do tipo de problema que você quer modelar, mas deixaremos algumas dicas para te auxiliar na escolha.</p><p>Gráficos densos: Com muitas arestas em relações ao numero de nós. Logo as listas de adjacências seriam muito grandes, tornando inviável a sua utilização. Utilizar matriz.</p><p>Gráficos esparsos: Com muitas nós em relações ao numero de arestas. Depende de sua preferência e das operações que vão ser usadas.</p><p>Buscas: Buscas são mais rápidos com lista de adjacência, pois já existe todas as opções que o nó se conecta. Na matriz, teria que percorrer a linha toda.</p><p>Testar existência entre arestas: Mais rápido com matriz, pois é só olhar na célula (i,j) e verificar se existe ou não a ligação.</p><p>Encontrar nós que vem antes: Mais rápido com matriz, pois é só olhar a linha do nó e verificar quais fazem ligação com ele. Em uma lista teria que percorrer toda a lista.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f260dd98823d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>