diff --git a/categories/frameworks/index.html b/categories/frameworks/index.html
new file mode 100644
index 0000000..e1ae698
--- /dev/null
+++ b/categories/frameworks/index.html
@@ -0,0 +1,8 @@
+<!doctype html><html><head><meta charset=utf-8><meta name=viewport content="width=device-width,initial-scale=1"><meta name=author content="ZeroIdentidad"><meta name=description content="Gophers LATAM"><meta property="og:image" content="https://gophers-latam.github.io//logo.png"><title>Frameworks – Gophers LATAM</title><link rel="shortcut icon" type=image/x-icon href=/favicon.ico><link rel=stylesheet href=/css/style.min.5c43d42176932b665337e50d7340aece08d086e5c40b6f4eecff0e6abb091d0a.css><link rel=stylesheet href=/css/syntax.min.f1fef9cbbfe9d2935981821d59853e89db60d137f9117a1279371320195f1d1a.css><link href='https://fonts.googleapis.com/css2?family=Work+Sans' rel=stylesheet type=text/css><link rel=alternate type=application/rss+xml href=https://gophers-latam.github.io/categories/frameworks/index.xml title="Frameworks - Gophers LATAM"><script type=application/javascript>var doNotTrack=!1;doNotTrack||(window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)},ga.l=+new Date,ga("create","UA-192145152-1","auto"),ga("send","pageview"))</script><script async src=https://www.google-analytics.com/analytics.js></script>
+<script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-7766642915413571" crossorigin=anonymous></script></head><body><div class=container><header class="page-header app-width"><div class=header-left><a href=/><img alt="Gophers LATAM" src=/img/gopher.png style=height:90px></a></div><div class=header-center><nav><a href=/>Inicio</a>
+<a href=/biografia>Biografía</a>
+<a href=/proyectos>Proyectos</a>
+<a href=/posts>Posts</a>
+<a href=/colaboradores>Colaboradores</a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Frameworks</h2><ul><li><a href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/>Explorando Frameworks en Go: Una Guía para Principiantes</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/categories/frameworks/index.xml b/categories/frameworks/index.xml
new file mode 100644
index 0000000..f582952
--- /dev/null
+++ b/categories/frameworks/index.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Frameworks on Gophers LATAM</title><link>https://gophers-latam.github.io/categories/frameworks/</link><description>Recent content in Frameworks on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/categories/frameworks/index.xml" rel="self" type="application/rss+xml"/><item><title>Explorando Frameworks en Go: Una Guía para Principiantes</title><link>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</guid><description>&lt;figure class="post-figure">
+&lt;a href="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png">
+&lt;img src="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" width="1024" height="626" alt="go frameworks" />
+&lt;/a>
+&lt;figcaption>go frameworks&lt;/figcaption>
+&lt;/figure>
+&lt;p>Últimamente, en nuestro canal de &lt;a href="https://discord.me/gophers-latam">discord&lt;/a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.&lt;/p></description></item></channel></rss>
\ No newline at end of file
diff --git a/categories/index.html b/categories/index.html
index 9b527be..3bae7ad 100644
--- a/categories/index.html
+++ b/categories/index.html
@@ -4,5 +4,5 @@
 <a href=/proyectos>Proyectos</a>
 <a href=/posts>Posts</a>
 <a href=/colaboradores>Colaboradores</a>
-<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Categories</h2><ul><li><a href=/categories/concurrencia/>Concurrencia</a></li><li><a href=/categories/aprendizaje/>Aprendizaje</a></li><li><a href=/categories/comunidad/>Comunidad</a></li><li><a href=/categories/ide/>IDE</a></li><li><a href=/categories/golang/>golang</a></li><li><a href=/categories/programaci%C3%B3n/>programación</a></li><li><a href=/categories/seguridad/>Seguridad</a></li><li><a href=/categories/web/>Web</a></li><li><a href=/categories/experiencias/>Experiencias</a></li><li><a href=/categories/ecosistema/>Ecosistema</a></li><li><a href=/categories/tools/>Tools</a></li><li><a href=/categories/tutorial/>Tutorial</a></li><li><a href=/categories/fundamentos/>Fundamentos</a></li><li><a href=/categories/incorparados/>Incorparados</a></li><li><a href=/categories/referencia/>Referencia</a></li><li><a href=/categories/estandar/>Estandar</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Categories</h2><ul><li><a href=/categories/frameworks/>Frameworks</a></li><li><a href=/categories/principiantes/>Principiantes</a></li><li><a href=/categories/concurrencia/>Concurrencia</a></li><li><a href=/categories/aprendizaje/>Aprendizaje</a></li><li><a href=/categories/comunidad/>Comunidad</a></li><li><a href=/categories/ide/>IDE</a></li><li><a href=/categories/golang/>golang</a></li><li><a href=/categories/programaci%C3%B3n/>programación</a></li><li><a href=/categories/seguridad/>Seguridad</a></li><li><a href=/categories/web/>Web</a></li><li><a href=/categories/experiencias/>Experiencias</a></li><li><a href=/categories/ecosistema/>Ecosistema</a></li><li><a href=/categories/tools/>Tools</a></li><li><a href=/categories/tutorial/>Tutorial</a></li><li><a href=/categories/fundamentos/>Fundamentos</a></li><li><a href=/categories/incorparados/>Incorparados</a></li><li><a href=/categories/referencia/>Referencia</a></li><li><a href=/categories/estandar/>Estandar</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
 <small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/categories/index.xml b/categories/index.xml
index e196745..e57f71e 100644
--- a/categories/index.xml
+++ b/categories/index.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Categories on Gophers LATAM</title><link>https://gophers-latam.github.io/categories/</link><description>Recent content in Categories on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Tue, 06 Feb 2024 08:22:53 -0600</lastBuildDate><atom:link href="https://gophers-latam.github.io/categories/index.xml" rel="self" type="application/rss+xml"/><item><title>Concurrencia</title><link>https://gophers-latam.github.io/categories/concurrencia/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/categories/concurrencia/</guid><description/></item><item><title>Aprendizaje</title><link>https://gophers-latam.github.io/categories/aprendizaje/</link><pubDate>Sun, 21 Jan 2024 12:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/categories/aprendizaje/</guid><description/></item><item><title>Comunidad</title><link>https://gophers-latam.github.io/categories/comunidad/</link><pubDate>Sun, 21 Jan 2024 12:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/categories/comunidad/</guid><description/></item><item><title>IDE</title><link>https://gophers-latam.github.io/categories/ide/</link><pubDate>Wed, 03 Jan 2024 12:19:35 -0300</pubDate><guid>https://gophers-latam.github.io/categories/ide/</guid><description/></item><item><title>golang</title><link>https://gophers-latam.github.io/categories/golang/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/categories/golang/</guid><description/></item><item><title>programación</title><link>https://gophers-latam.github.io/categories/programaci%C3%B3n/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/categories/programaci%C3%B3n/</guid><description/></item><item><title>Seguridad</title><link>https://gophers-latam.github.io/categories/seguridad/</link><pubDate>Mon, 27 Mar 2023 00:21:15 -0300</pubDate><guid>https://gophers-latam.github.io/categories/seguridad/</guid><description/></item><item><title>Web</title><link>https://gophers-latam.github.io/categories/web/</link><pubDate>Mon, 27 Mar 2023 00:21:15 -0300</pubDate><guid>https://gophers-latam.github.io/categories/web/</guid><description/></item><item><title>Experiencias</title><link>https://gophers-latam.github.io/categories/experiencias/</link><pubDate>Mon, 01 Aug 2022 18:54:04 -0500</pubDate><guid>https://gophers-latam.github.io/categories/experiencias/</guid><description/></item><item><title>Ecosistema</title><link>https://gophers-latam.github.io/categories/ecosistema/</link><pubDate>Mon, 27 Dec 2021 11:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/categories/ecosistema/</guid><description/></item><item><title>Tools</title><link>https://gophers-latam.github.io/categories/tools/</link><pubDate>Sat, 05 Jun 2021 13:01:11 -0500</pubDate><guid>https://gophers-latam.github.io/categories/tools/</guid><description/></item><item><title>Tutorial</title><link>https://gophers-latam.github.io/categories/tutorial/</link><pubDate>Sat, 05 Jun 2021 13:01:11 -0500</pubDate><guid>https://gophers-latam.github.io/categories/tutorial/</guid><description/></item><item><title>Fundamentos</title><link>https://gophers-latam.github.io/categories/fundamentos/</link><pubDate>Wed, 05 May 2021 13:05:28 -0500</pubDate><guid>https://gophers-latam.github.io/categories/fundamentos/</guid><description/></item><item><title>Incorparados</title><link>https://gophers-latam.github.io/categories/incorparados/</link><pubDate>Wed, 05 May 2021 13:05:28 -0500</pubDate><guid>https://gophers-latam.github.io/categories/incorparados/</guid><description/></item><item><title>Referencia</title><link>https://gophers-latam.github.io/categories/referencia/</link><pubDate>Fri, 30 Apr 2021 18:02:17 -0500</pubDate><guid>https://gophers-latam.github.io/categories/referencia/</guid><description/></item><item><title>Estandar</title><link>https://gophers-latam.github.io/categories/estandar/</link><pubDate>Thu, 22 Apr 2021 23:06:22 -0500</pubDate><guid>https://gophers-latam.github.io/categories/estandar/</guid><description/></item></channel></rss>
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Categories on Gophers LATAM</title><link>https://gophers-latam.github.io/categories/</link><description>Recent content in Categories on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/categories/index.xml" rel="self" type="application/rss+xml"/><item><title>Frameworks</title><link>https://gophers-latam.github.io/categories/frameworks/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/categories/frameworks/</guid><description/></item><item><title>Principiantes</title><link>https://gophers-latam.github.io/categories/principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/categories/principiantes/</guid><description/></item><item><title>Concurrencia</title><link>https://gophers-latam.github.io/categories/concurrencia/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/categories/concurrencia/</guid><description/></item><item><title>Aprendizaje</title><link>https://gophers-latam.github.io/categories/aprendizaje/</link><pubDate>Sun, 21 Jan 2024 12:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/categories/aprendizaje/</guid><description/></item><item><title>Comunidad</title><link>https://gophers-latam.github.io/categories/comunidad/</link><pubDate>Sun, 21 Jan 2024 12:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/categories/comunidad/</guid><description/></item><item><title>IDE</title><link>https://gophers-latam.github.io/categories/ide/</link><pubDate>Wed, 03 Jan 2024 12:19:35 -0300</pubDate><guid>https://gophers-latam.github.io/categories/ide/</guid><description/></item><item><title>golang</title><link>https://gophers-latam.github.io/categories/golang/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/categories/golang/</guid><description/></item><item><title>programación</title><link>https://gophers-latam.github.io/categories/programaci%C3%B3n/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/categories/programaci%C3%B3n/</guid><description/></item><item><title>Seguridad</title><link>https://gophers-latam.github.io/categories/seguridad/</link><pubDate>Mon, 27 Mar 2023 00:21:15 -0300</pubDate><guid>https://gophers-latam.github.io/categories/seguridad/</guid><description/></item><item><title>Web</title><link>https://gophers-latam.github.io/categories/web/</link><pubDate>Mon, 27 Mar 2023 00:21:15 -0300</pubDate><guid>https://gophers-latam.github.io/categories/web/</guid><description/></item><item><title>Experiencias</title><link>https://gophers-latam.github.io/categories/experiencias/</link><pubDate>Mon, 01 Aug 2022 18:54:04 -0500</pubDate><guid>https://gophers-latam.github.io/categories/experiencias/</guid><description/></item><item><title>Ecosistema</title><link>https://gophers-latam.github.io/categories/ecosistema/</link><pubDate>Mon, 27 Dec 2021 11:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/categories/ecosistema/</guid><description/></item><item><title>Tools</title><link>https://gophers-latam.github.io/categories/tools/</link><pubDate>Sat, 05 Jun 2021 13:01:11 -0500</pubDate><guid>https://gophers-latam.github.io/categories/tools/</guid><description/></item><item><title>Tutorial</title><link>https://gophers-latam.github.io/categories/tutorial/</link><pubDate>Sat, 05 Jun 2021 13:01:11 -0500</pubDate><guid>https://gophers-latam.github.io/categories/tutorial/</guid><description/></item><item><title>Fundamentos</title><link>https://gophers-latam.github.io/categories/fundamentos/</link><pubDate>Wed, 05 May 2021 13:05:28 -0500</pubDate><guid>https://gophers-latam.github.io/categories/fundamentos/</guid><description/></item><item><title>Incorparados</title><link>https://gophers-latam.github.io/categories/incorparados/</link><pubDate>Wed, 05 May 2021 13:05:28 -0500</pubDate><guid>https://gophers-latam.github.io/categories/incorparados/</guid><description/></item><item><title>Referencia</title><link>https://gophers-latam.github.io/categories/referencia/</link><pubDate>Fri, 30 Apr 2021 18:02:17 -0500</pubDate><guid>https://gophers-latam.github.io/categories/referencia/</guid><description/></item><item><title>Estandar</title><link>https://gophers-latam.github.io/categories/estandar/</link><pubDate>Thu, 22 Apr 2021 23:06:22 -0500</pubDate><guid>https://gophers-latam.github.io/categories/estandar/</guid><description/></item></channel></rss>
\ No newline at end of file
diff --git a/categories/principiantes/index.html b/categories/principiantes/index.html
new file mode 100644
index 0000000..1be6c7e
--- /dev/null
+++ b/categories/principiantes/index.html
@@ -0,0 +1,8 @@
+<!doctype html><html><head><meta charset=utf-8><meta name=viewport content="width=device-width,initial-scale=1"><meta name=author content="ZeroIdentidad"><meta name=description content="Gophers LATAM"><meta property="og:image" content="https://gophers-latam.github.io//logo.png"><title>Principiantes – Gophers LATAM</title><link rel="shortcut icon" type=image/x-icon href=/favicon.ico><link rel=stylesheet href=/css/style.min.5c43d42176932b665337e50d7340aece08d086e5c40b6f4eecff0e6abb091d0a.css><link rel=stylesheet href=/css/syntax.min.f1fef9cbbfe9d2935981821d59853e89db60d137f9117a1279371320195f1d1a.css><link href='https://fonts.googleapis.com/css2?family=Work+Sans' rel=stylesheet type=text/css><link rel=alternate type=application/rss+xml href=https://gophers-latam.github.io/categories/principiantes/index.xml title="Principiantes - Gophers LATAM"><script type=application/javascript>var doNotTrack=!1;doNotTrack||(window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)},ga.l=+new Date,ga("create","UA-192145152-1","auto"),ga("send","pageview"))</script><script async src=https://www.google-analytics.com/analytics.js></script>
+<script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-7766642915413571" crossorigin=anonymous></script></head><body><div class=container><header class="page-header app-width"><div class=header-left><a href=/><img alt="Gophers LATAM" src=/img/gopher.png style=height:90px></a></div><div class=header-center><nav><a href=/>Inicio</a>
+<a href=/biografia>Biografía</a>
+<a href=/proyectos>Proyectos</a>
+<a href=/posts>Posts</a>
+<a href=/colaboradores>Colaboradores</a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Principiantes</h2><ul><li><a href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/>Explorando Frameworks en Go: Una Guía para Principiantes</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/categories/principiantes/index.xml b/categories/principiantes/index.xml
new file mode 100644
index 0000000..241f789
--- /dev/null
+++ b/categories/principiantes/index.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Principiantes on Gophers LATAM</title><link>https://gophers-latam.github.io/categories/principiantes/</link><description>Recent content in Principiantes on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/categories/principiantes/index.xml" rel="self" type="application/rss+xml"/><item><title>Explorando Frameworks en Go: Una Guía para Principiantes</title><link>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</guid><description>&lt;figure class="post-figure">
+&lt;a href="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png">
+&lt;img src="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" width="1024" height="626" alt="go frameworks" />
+&lt;/a>
+&lt;figcaption>go frameworks&lt;/figcaption>
+&lt;/figure>
+&lt;p>Últimamente, en nuestro canal de &lt;a href="https://discord.me/gophers-latam">discord&lt;/a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.&lt;/p></description></item></channel></rss>
\ No newline at end of file
diff --git a/index.xml b/index.xml
index 7fb0a0c..95d4813 100644
--- a/index.xml
+++ b/index.xml
@@ -1,4 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Gophers LATAM</title><link>https://gophers-latam.github.io/</link><description>Recent content on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Tue, 06 Feb 2024 08:22:53 -0600</lastBuildDate><atom:link href="https://gophers-latam.github.io/index.xml" rel="self" type="application/rss+xml"/><item><title>CodeLab. Implementemos un Worker Pool</title><link>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</guid><description>&lt;figure class="post-figure">
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Gophers LATAM</title><link>https://gophers-latam.github.io/</link><description>Recent content on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/index.xml" rel="self" type="application/rss+xml"/><item><title>Explorando Frameworks en Go: Una Guía para Principiantes</title><link>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</guid><description>&lt;figure class="post-figure">
+&lt;a href="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png">
+&lt;img src="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" width="1024" height="626" alt="go frameworks" />
+&lt;/a>
+&lt;figcaption>go frameworks&lt;/figcaption>
+&lt;/figure>
+&lt;p>Últimamente, en nuestro canal de &lt;a href="https://discord.me/gophers-latam">discord&lt;/a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.&lt;/p></description></item><item><title>CodeLab. Implementemos un Worker Pool</title><link>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</guid><description>&lt;figure class="post-figure">
 &lt;a href="https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools.png">
 &lt;img src="https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools_hu25c2df14317a6a74ebc7cc77c76ece4a_666661_1024x0_resize_box_3.png" width="1024" height="794" alt=" Mengniu Dairy production line. Gentileza de Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/" />
 &lt;/a>
diff --git a/month/index.html b/month/index.html
index 8c8e3eb..57b2318 100644
--- a/month/index.html
+++ b/month/index.html
@@ -4,5 +4,5 @@
 <a href=/proyectos>Proyectos</a>
 <a href=/posts>Posts</a>
 <a href=/colaboradores>Colaboradores</a>
-<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Month</h2><ul><li><a href=/posts/2021/04/>2021/04</a></li><li><a href=/posts/2021/05/>2021/05</a></li><li><a href=/posts/2021/06/>2021/06</a></li><li><a href=/posts/2021/08/>2021/08</a></li><li><a href=/posts/2021/12/>2021/12</a></li><li><a href=/posts/2022/08/>2022/08</a></li><li><a href=/posts/2023/03/>2023/03</a></li><li><a href=/posts/2023/10/>2023/10</a></li><li><a href=/posts/2023/12/>2023/12</a></li><li><a href=/posts/2024/01/>2024/01</a></li><li><a href=/posts/2024/02/>2024/02</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Month</h2><ul><li><a href=/posts/2021/04/>2021/04</a></li><li><a href=/posts/2021/05/>2021/05</a></li><li><a href=/posts/2021/06/>2021/06</a></li><li><a href=/posts/2021/08/>2021/08</a></li><li><a href=/posts/2021/12/>2021/12</a></li><li><a href=/posts/2022/08/>2022/08</a></li><li><a href=/posts/2023/03/>2023/03</a></li><li><a href=/posts/2023/10/>2023/10</a></li><li><a href=/posts/2023/12/>2023/12</a></li><li><a href=/posts/2024/01/>2024/01</a></li><li><a href=/posts/2024/02/>2024/02</a></li><li><a href=/posts/2024/04/>2024/04</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
 <small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/month/index.xml b/month/index.xml
index c13e33a..e660d53 100644
--- a/month/index.xml
+++ b/month/index.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Month on Gophers LATAM</title><link>https://gophers-latam.github.io/month/</link><description>Recent content in Month on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><atom:link href="https://gophers-latam.github.io/month/index.xml" rel="self" type="application/rss+xml"/><item><title>2021/04</title><link>https://gophers-latam.github.io/posts/2021/04/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/04/</guid><description/></item><item><title>2021/05</title><link>https://gophers-latam.github.io/posts/2021/05/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/05/</guid><description/></item><item><title>2021/06</title><link>https://gophers-latam.github.io/posts/2021/06/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/06/</guid><description/></item><item><title>2021/08</title><link>https://gophers-latam.github.io/posts/2021/08/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/08/</guid><description/></item><item><title>2021/12</title><link>https://gophers-latam.github.io/posts/2021/12/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/12/</guid><description/></item><item><title>2022/08</title><link>https://gophers-latam.github.io/posts/2022/08/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2022/08/</guid><description/></item><item><title>2023/03</title><link>https://gophers-latam.github.io/posts/2023/03/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2023/03/</guid><description/></item><item><title>2023/10</title><link>https://gophers-latam.github.io/posts/2023/10/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2023/10/</guid><description/></item><item><title>2023/12</title><link>https://gophers-latam.github.io/posts/2023/12/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2023/12/</guid><description/></item><item><title>2024/01</title><link>https://gophers-latam.github.io/posts/2024/01/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2024/01/</guid><description/></item><item><title>2024/02</title><link>https://gophers-latam.github.io/posts/2024/02/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/</guid><description/></item></channel></rss>
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Month on Gophers LATAM</title><link>https://gophers-latam.github.io/month/</link><description>Recent content in Month on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><atom:link href="https://gophers-latam.github.io/month/index.xml" rel="self" type="application/rss+xml"/><item><title>2021/04</title><link>https://gophers-latam.github.io/posts/2021/04/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/04/</guid><description/></item><item><title>2021/05</title><link>https://gophers-latam.github.io/posts/2021/05/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/05/</guid><description/></item><item><title>2021/06</title><link>https://gophers-latam.github.io/posts/2021/06/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/06/</guid><description/></item><item><title>2021/08</title><link>https://gophers-latam.github.io/posts/2021/08/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/08/</guid><description/></item><item><title>2021/12</title><link>https://gophers-latam.github.io/posts/2021/12/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2021/12/</guid><description/></item><item><title>2022/08</title><link>https://gophers-latam.github.io/posts/2022/08/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2022/08/</guid><description/></item><item><title>2023/03</title><link>https://gophers-latam.github.io/posts/2023/03/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2023/03/</guid><description/></item><item><title>2023/10</title><link>https://gophers-latam.github.io/posts/2023/10/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2023/10/</guid><description/></item><item><title>2023/12</title><link>https://gophers-latam.github.io/posts/2023/12/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2023/12/</guid><description/></item><item><title>2024/01</title><link>https://gophers-latam.github.io/posts/2024/01/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2024/01/</guid><description/></item><item><title>2024/02</title><link>https://gophers-latam.github.io/posts/2024/02/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/</guid><description/></item><item><title>2024/04</title><link>https://gophers-latam.github.io/posts/2024/04/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/</guid><description/></item></channel></rss>
\ No newline at end of file
diff --git a/opensource/index.html b/opensource/index.html
index e185952..ae0fd13 100644
--- a/opensource/index.html
+++ b/opensource/index.html
@@ -4,5 +4,5 @@
 <a href=/proyectos>Proyectos</a>
 <a href=/posts>Posts</a>
 <a href=/colaboradores>Colaboradores</a>
-<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Open Source</h2><p>Software Open Source compartido en GitHub por <strong>Gophers LATAM</strong>.</p><section class=oss><article><h3><a href=https://github.com/gophers-latam/go-test-mux-routes>go-test-mux-routes</a></h3><p>Ejemplos *go test* stlib http y gorilla mux routes</p></article><article><h3><a href=https://github.com/gophers-latam/fiber-simple-hexagonal-api>fiber-simple-hexagonal-api</a></h3><p>Ejemplo simple de api con fiber y arquitectura hexagonal</p></article><article><h3><a href=https://github.com/gophers-latam/fan-out-fan-in>fan-out-fan-in</a></h3><p>Fan-out / Fan-in se refiere al patrón de ejecutar múltiples funciones simultáneamente y luego realizar alguna agregación en los resultados.</p></article><article><h3><a href=https://github.com/gophers-latam/serie>serie</a></h3><p>El objetivo de este proyecto es solucionar la siguiente serie: 2, 4, 7, 28, 33, 198, ...</p></article><article><h3><a href=https://github.com/gophers-latam/awesome-latam>awesome-latam</a></h3><p>Colección de contenidos y recursos en Español para desarrolladores de Golang. Awesome oficial: https://awesome-go.com</p></article><article><h3><a href=https://github.com/gophers-latam/ejemplos>ejemplos</a></h3><p>ejemplos con soluciones posibles</p></article><article><h3><a href=https://github.com/gophers-latam/fuego-cache>fuego-cache</a></h3><p>Fuego cache es un servicio concurrente de hash pares clave-valor escrito al 100% en Golang. Un servicio de caché de alta velocidad con interfaces HTTP y TCP simple y CLI con persistencia en disco. Servicio de caché fácil de usar y fácil de implementar totalmente gratuito.</p></article><article><h3><a href=https://github.com/gophers-latam/simple-webapp>simple-webapp</a></h3><p>Simple golang webapp monolítica</p></article><article><h3><a href=https://github.com/gophers-latam/gophers-latam.github.io>gophers-latam.github.io</a></h3><p>Portafolio comunitario de Gophers LATAM.</p></article><article><h3><a href=https://github.com/gophers-latam/GoKey>GoKey</a></h3><p>Proyecto OSS sobre cache en memoria.</p></article><article><h3><a href=https://github.com/gophers-latam/subs-finder>subs-finder</a></h3><p>CLI to find movies subtitles</p></article><article><h3><a href=https://github.com/gophers-latam/cobra-pscan>cobra-pscan</a></h3><p>Cobra CLI app example</p></article><article><h3><a href=https://github.com/gophers-latam/Gorefac-mod>Gorefac-mod</a></h3><p>Una pequeña cli app para refactorizar go.mod y dependencias de archivos</p></article><article><h3><a href=https://github.com/gophers-latam/zap-ecs>zap-ecs</a></h3><p>Wrapper capa Zap logging para el estándar ECS</p></article><article><h3><a href=https://github.com/gophers-latam/darth-db>darth-db</a></h3><p>A tiny database for the Dark Side</p></article><article><h3><a href=https://github.com/gophers-latam/brancher>brancher</a></h3><p>Tool to view and select git branches! 🌿🌿</p></article><article><h3><a href=https://github.com/gophers-latam/pytago>pytago</a></h3><p>A source-to-source transpiler for Python to Go translation</p></article><article><h3><a href=https://github.com/gophers-latam/ngonx>ngonx</a></h3><p>Custom golang proxy inspired in nginx proxy, and traefik proxy</p></article><article><h3><a href=https://github.com/gophers-latam/fiber-react-sample>fiber-react-sample</a></h3><p>Golang (fiber) and React (typescript) practical project</p></article><article><h3><a href=https://github.com/gophers-latam/gopher-bot>gopher-bot</a></h3><p>First version bot for https://discord.io/gophers-latam</p></article><article><h3><a href=https://github.com/gophers-latam/go_linux>go_linux</a></h3><p></p></article><article><h3><a href=https://github.com/gophers-latam/pomodorox>pomodorox</a></h3><p>🍅 ⏰Pomodoro App</p></article><article><h3><a href=https://github.com/gophers-latam/elon-task>elon-task</a></h3><p>Golang Meetup Argentina Example</p></article><article><h3><a href=https://github.com/gophers-latam/challenges>challenges</a></h3><p></p></article><article><h3><a href=https://github.com/gophers-latam/boiler>boiler</a></h3><p>Repositorio principal para manejar plantillas</p></article><article><h3><a href=https://github.com/gophers-latam/codigo-de-conducta>codigo-de-conducta</a></h3><p>Código de conducta Gophers LATAM</p></article><article><h3><a href=https://github.com/gophers-latam/minimal>minimal</a></h3><p>Una plantilla mínima multiproposito para proyectos Go basada en la experiencia del equipo de la comunidad Gophers LATAM</p></article><article><h3><a href=https://github.com/gophers-latam/minimalchi>minimalchi</a></h3><p>Una plantilla mínima con el poderoso router chi configurado para crear apis REST</p></article><article><h3><a href=https://github.com/gophers-latam/go-tour-es>go-tour-es</a></h3><p>Traducción al español del Tour de Go</p></article><article><h3><a href=https://github.com/gophers-latam/small-template>small-template</a></h3><p>Esta plantilla propone una estructura basada en capas para un proyecto pequeño y con un propósito por definir. Es un buen inicio para comenzar un nuevo proyecto.</p></article></section></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Open Source</h2><p>Software Open Source compartido en GitHub por <strong>Gophers LATAM</strong>.</p><section class=oss><article><h3><a href=https://github.com/gophers-latam/go-test-mux-routes>go-test-mux-routes</a></h3><p>Ejemplos *go test* stlib http y gorilla mux routes</p></article><article><h3><a href=https://github.com/gophers-latam/fiber-simple-hexagonal-api>fiber-simple-hexagonal-api</a></h3><p>Ejemplo simple de api con fiber y arquitectura hexagonal</p></article><article><h3><a href=https://github.com/gophers-latam/fan-out-fan-in>fan-out-fan-in</a></h3><p>Fan-out / Fan-in se refiere al patrón de ejecutar múltiples funciones simultáneamente y luego realizar alguna agregación en los resultados.</p></article><article><h3><a href=https://github.com/gophers-latam/serie>serie</a></h3><p>El objetivo de este proyecto es solucionar la siguiente serie: 2, 4, 7, 28, 33, 198, ...</p></article><article><h3><a href=https://github.com/gophers-latam/awesome-latam>awesome-latam</a></h3><p>Colección de contenidos y recursos en Español para desarrolladores de Golang. Awesome oficial: https://awesome-go.com</p></article><article><h3><a href=https://github.com/gophers-latam/ejemplos>ejemplos</a></h3><p>ejemplos compartidos de soluciones posibles en YT Lives</p></article><article><h3><a href=https://github.com/gophers-latam/fuego-cache>fuego-cache</a></h3><p>Fuego cache es un servicio concurrente de hash pares clave-valor escrito al 100% en Golang. Un servicio de caché de alta velocidad con interfaces HTTP y TCP simple y CLI con persistencia en disco. Servicio de caché fácil de usar y fácil de implementar totalmente gratuito.</p></article><article><h3><a href=https://github.com/gophers-latam/simple-webapp>simple-webapp</a></h3><p>Simple golang webapp monolítica</p></article><article><h3><a href=https://github.com/gophers-latam/gophers-latam.github.io>gophers-latam.github.io</a></h3><p>Portafolio comunitario de Gophers LATAM.</p></article><article><h3><a href=https://github.com/gophers-latam/GoKey>GoKey</a></h3><p>Proyecto OSS sobre cache en memoria.</p></article><article><h3><a href=https://github.com/gophers-latam/subs-finder>subs-finder</a></h3><p>CLI to find movies subtitles</p></article><article><h3><a href=https://github.com/gophers-latam/cobra-pscan>cobra-pscan</a></h3><p>Cobra CLI app example</p></article><article><h3><a href=https://github.com/gophers-latam/Gorefac-mod>Gorefac-mod</a></h3><p>Una pequeña cli app para refactorizar go.mod y dependencias de archivos</p></article><article><h3><a href=https://github.com/gophers-latam/zap-ecs>zap-ecs</a></h3><p>Wrapper capa Zap logging para el estándar ECS</p></article><article><h3><a href=https://github.com/gophers-latam/darth-db>darth-db</a></h3><p>A tiny database for the Dark Side</p></article><article><h3><a href=https://github.com/gophers-latam/brancher>brancher</a></h3><p>Tool to view and select git branches! 🌿🌿</p></article><article><h3><a href=https://github.com/gophers-latam/pytago>pytago</a></h3><p>A source-to-source transpiler for Python to Go translation</p></article><article><h3><a href=https://github.com/gophers-latam/ngonx>ngonx</a></h3><p>Custom golang proxy inspired in nginx proxy, and traefik proxy</p></article><article><h3><a href=https://github.com/gophers-latam/fiber-react-sample>fiber-react-sample</a></h3><p>Golang (fiber) and React (typescript) practical project</p></article><article><h3><a href=https://github.com/gophers-latam/gopher-bot>gopher-bot</a></h3><p>First version bot for https://discord.me/gophers-latam</p></article><article><h3><a href=https://github.com/gophers-latam/go_linux>go_linux</a></h3><p></p></article><article><h3><a href=https://github.com/gophers-latam/pomodorox>pomodorox</a></h3><p>🍅 ⏰Pomodoro App</p></article><article><h3><a href=https://github.com/gophers-latam/elon-task>elon-task</a></h3><p>Golang Meetup Argentina Example</p></article><article><h3><a href=https://github.com/gophers-latam/challenges>challenges</a></h3><p></p></article><article><h3><a href=https://github.com/gophers-latam/boiler>boiler</a></h3><p>Repositorio principal para manejar plantillas</p></article><article><h3><a href=https://github.com/gophers-latam/codigo-de-conducta>codigo-de-conducta</a></h3><p>Código de conducta Gophers LATAM</p></article><article><h3><a href=https://github.com/gophers-latam/minimal>minimal</a></h3><p>Una plantilla mínima multiproposito para proyectos Go basada en la experiencia del equipo de la comunidad Gophers LATAM</p></article><article><h3><a href=https://github.com/gophers-latam/minimalchi>minimalchi</a></h3><p>Una plantilla mínima con el poderoso router chi configurado para crear apis REST</p></article><article><h3><a href=https://github.com/gophers-latam/go-tour-es>go-tour-es</a></h3><p>Traducción al español del Tour de Go</p></article><article><h3><a href=https://github.com/gophers-latam/small-template>small-template</a></h3><p>Esta plantilla propone una estructura basada en capas para un proyecto pequeño y con un propósito por definir. Es un buen inicio para comenzar un nuevo proyecto.</p></article></section></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
 <small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git "a/posts/2024/04/explorando-frameworks-en-go-una-gu\303\255a-para-principiantes/images/go-frameworks.png" "b/posts/2024/04/explorando-frameworks-en-go-una-gu\303\255a-para-principiantes/images/go-frameworks.png"
new file mode 100644
index 0000000..4f2286e
Binary files /dev/null and "b/posts/2024/04/explorando-frameworks-en-go-una-gu\303\255a-para-principiantes/images/go-frameworks.png" differ
diff --git "a/posts/2024/04/explorando-frameworks-en-go-una-gu\303\255a-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" "b/posts/2024/04/explorando-frameworks-en-go-una-gu\303\255a-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png"
new file mode 100644
index 0000000..4ee7ca1
Binary files /dev/null and "b/posts/2024/04/explorando-frameworks-en-go-una-gu\303\255a-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" differ
diff --git "a/posts/2024/04/explorando-frameworks-en-go-una-gu\303\255a-para-principiantes/index.html" "b/posts/2024/04/explorando-frameworks-en-go-una-gu\303\255a-para-principiantes/index.html"
new file mode 100644
index 0000000..377518f
--- /dev/null
+++ "b/posts/2024/04/explorando-frameworks-en-go-una-gu\303\255a-para-principiantes/index.html"
@@ -0,0 +1,25 @@
+<!doctype html><html><head><meta charset=utf-8><meta name=viewport content="width=device-width,initial-scale=1"><meta name=author content="ZeroIdentidad"><meta name=description content="Gophers LATAM"><meta property="og:image" content="https://gophers-latam.github.io//logo.png"><title>Explorando Frameworks en Go: Una Guía para Principiantes – Gophers LATAM</title><link rel="shortcut icon" type=image/x-icon href=/favicon.ico><link rel=stylesheet href=/css/style.min.5c43d42176932b665337e50d7340aece08d086e5c40b6f4eecff0e6abb091d0a.css><link rel=stylesheet href=/css/syntax.min.f1fef9cbbfe9d2935981821d59853e89db60d137f9117a1279371320195f1d1a.css><link href='https://fonts.googleapis.com/css2?family=Work+Sans' rel=stylesheet type=text/css><script type=application/javascript>var doNotTrack=!1;doNotTrack||(window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)},ga.l=+new Date,ga("create","UA-192145152-1","auto"),ga("send","pageview"))</script><script async src=https://www.google-analytics.com/analytics.js></script>
+<script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-7766642915413571" crossorigin=anonymous></script></head><body><div class=container><header class="page-header app-width"><div class=header-left><a href=/><img alt="Gophers LATAM" src=/img/gopher.png style=height:90px></a></div><div class=header-center><nav><a href=/>Inicio</a>
+<a href=/biografia>Biografía</a>
+<a href=/proyectos>Proyectos</a>
+<a href=/posts>Posts</a>
+<a href=/colaboradores>Colaboradores</a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><article class=post><header><h2>Explorando Frameworks en Go: Una Guía para Principiantes</h2><span class=tags><a class=tag href=/tags/frameworks>frameworks</a>
+<a class=tag href=/tags/golang>golang</a>
+<a class=tag href=/tags/principiantes>principiantes</a></span>
+<span class=meta><label>Por: <b>Thiago Mowszet</b></label>
+<label>Publicado <b>April 12, 2024</b></label>
+<label>Tiempo de lectura: <b>4 minutos</b>.</label></span></header><section class=body><figure class=post-figure><a href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png><img src=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png width=1024 height=626 alt="go frameworks"></a><figcaption>go frameworks</figcaption></figure><p>Últimamente, en nuestro canal de <a href=https://discord.me/gophers-latam>discord</a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.</p><h1 id=cómo-comenzar-a-escribir-aplicaciones-web-con-go>¿Cómo comenzar a escribir aplicaciones web con Go?</h1><p>No es imprescindible utilizar un framework para comenzar con Go; la biblioteca estándar proporciona todo lo necesario para desarrollar aplicaciones de manera efectiva.
+Todo lo que necesitas hacer es crear una carpeta con tu archivo principal e importar el paquete <a href=https://pkg.go.dev/net/http>net/http</a> para comenzar a desarrollar.</p><p>Las ventajas de utilizar la biblioteca estándar en lugar de un framework son las siguientes:</p><ul><li><p><em><strong>Simplicidad y Minimalismo</strong></em>: El paquete “net/http” está desarrollado siguiendo los principios de simplicidad y minimalismo, lo que significa que no hay una sobrecarga de funcionalidades o dependencias innecesarias, lo que puede resultar en código más limpio y fácil de entender.</p></li><li><p><em><strong>Rendimiento</strong></em>: La biblioteca estándar de Go está optimizada para un rendimiento óptimo.</p></li><li><p><em><strong>Flexibilidad</strong></em>: El paquete “net/http” proporciona una gran flexibilidad para construir servidores web y manejar solicitudes HTTP de manera personalizada. Esto permite adaptar la aplicación a requisitos específicos sin estar limitado por las decisiones de diseño del framework.</p></li><li><p><em><strong>Compatibilidad</strong></em>: Al basarse en la biblioteca estándar, las aplicaciones desarrolladas con el paquete “net/http” son altamente compatibles con otros paquetes y bibliotecas de Go. Esto facilita la integración con otras partes del ecosistema de Go y reduce la posibilidad de conflictos de dependencias.</p></li><li><p><em><strong>Control Total</strong></em>: Al evitar el uso de frameworks, los desarrolladores tienen un control total sobre el flujo de su aplicación. Esto significa que pueden tomar decisiones de diseño más personalizadas y adaptar la aplicación según las necesidades específicas del proyecto.</p></li></ul><h1 id=cuál-es-el-mejor-framework>¿Cuál es el mejor framework?</h1><p>En el mundo Go, no existe un &ldquo;mejor&rdquo; framework, ya que existen una variedad de ellos, cada uno con sus propias características y propósitos. La elección del framework ideal depende en gran medida de los requisitos específicos de tu proyecto, así como de tus preferencias personales y el estilo de desarrollo que te resulte más cómodo.</p><p>Algunos frameworks populares en la comunidad de Go incluyen Chi, Fiber, Gorilla, Echo y Gin, entre otros. Cada uno de estos frameworks tiene sus puntos fuertes y débiles, y la mejor opción dependerá de factores como la complejidad del proyecto, la escalabilidad requerida, la facilidad de uso y la familiaridad con el framework.</p><p>Es importante investigar y probar diferentes frameworks para determinar cuál se adapta mejor a nuestras necesidades y objetivos.</p><p>Si tenés dudas sobre cuál elegir, en el siguiente repositorio de GitHub, podrás encontrar una lista con los frameworks de Go más famosos filtrados por las estrellas obtenidas por los usuarios de dicha plataforma, también encontraras las fechas con las últimas actualizaciones y la cantidad de forks hechos: <a href=https://github.com/mingrammer/go-web-framework-stars>Go Web Frameworks por Mingrammer</a></p><p>Y si sos un apasionado de los números y las tablas te dejo 3 webs que te van a encantar, en las cuales se hacen los diferentes benchmarks de cada framework:</p><ul><li><p><a href=https://github.com/smallnest/go-web-framework-benchmark>Go Web Framework Benchmark</a> (Actualizado en el 2020, pero en el readme nos explica como podemos ejecutar uno propio)</p></li><li><p><a href=https://github.com/julienschmidt/go-http-routing-benchmark>Go Http Routing Benchmark</a> (Actualizado en el 2020, pero en el readme nos explica como podemos ejecutar uno propio)</p></li><li><p><a href=https://www.techempower.com/benchmarks/>Benchmarks</a> (Última actualización reciba: 2023-10-17)</p></li></ul><p>Las ventajas de utilizar un framework son las siguientes:</p><ul><li><p><em><strong>Productividad mejorada</strong></em>: Los frameworks suelen proporcionar herramientas y estructuras predefinidas que facilitan el desarrollo de aplicaciones. Esto puede reducir el tiempo necesario para construir y mantener el código, lo que a su vez aumenta la productividad del equipo de desarrollo.</p></li><li><p><em><strong>Abstracciones útiles</strong></em>: Los frameworks pueden ofrecer abstracciones útiles que simplifican tareas comunes, como el enrutamiento, la autenticación de usuarios, el manejo de sesiones, la validación de datos, entre otros. Esto permite a los desarrolladores centrarse en la lógica de negocio de la aplicación en lugar de reinventar la rueda para cada proyecto.</p></li><li><p><em><strong>Mejores prácticas integradas</strong></em>: Muchos frameworks promueven el uso de mejores prácticas de desarrollo, como el patrón MVC (Modelo-Vista-Controlador) o la inyección de dependencias. Esto puede resultar en un código más organizado, mantenible y escalable a medida que el proyecto crece.</p></li><li><p><em><strong>Comunidad activa</strong></em>: Los frameworks suelen tener una comunidad activa de desarrolladores que contribuyen con bibliotecas, extensiones, tutoriales y soporte en línea. Esto puede ser útil para obtener ayuda, resolver problemas y mantenerse al día con las mejores prácticas y las últimas actualizaciones.</p></li><li><p><em><strong>Documentación detallada</strong></em>: Los frameworks a menudo vienen con una documentación completa y detallada que facilita el aprendizaje y el uso de las características proporcionadas. Esto puede ser especialmente útil para los desarrolladores que son nuevos en un lenguaje o en el desarrollo web en general.</p></li></ul><h1 id=cuál-es-la-recomendación-de-la-comunidad>¿Cuál es la recomendación de la comunidad?</h1><p>En cuanto a la recomendación de un framework en particular por parte de la comunidad, no hay una preferencia unánime. Cada desarrollador tiene la libertad de elegir el framework que mejor se adapte a sus necesidades específicas. Sin embargo, es común sugerir que la biblioteca estándar de Go proporciona una base sólida y completa para la mayoría de los proyectos.</p></section><section class=related><h3>Relacionados</h3><div class=post-list><article class="box box-post"><a class=title href=/posts/2024/02/codelab.-implementemos-un-worker-pool/><h3>CodeLab. Implementemos un Worker Pool</h3></a><time class=date>February
+6
+2024</time><div class=summary-container><figure class=post-figure><a href=/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools.png><img src=/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools_hu25c2df14317a6a74ebc7cc77c76ece4a_666661_1024x0_resize_box_3.png width=1024 height=794 alt=" Mengniu Dairy production line. Gentileza de  Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/"></a><figcaption>Mengniu Dairy production line. Gentileza de Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/</figcaption></figure><p>La concurrencia es una herramienta que nos ayuda a ejecutar tareas pesadas o que bloquean el avance de un proceso, mientras otras tareas se ejecutan, mejorando el rendimiento general.</p><p>Pero ¿Podemos hacer uso de la concurrencia sin ponernos un límite?</p></div></article><article class="box box-post"><a class=title href=/posts/2021/12/ecosistema-lenguage-go/><h3>Ecosistema lenguage Go</h3></a><time class=date>December
+27
+2021</time><div class=summary-container><figure class=post-figure><a href=/posts/2021/12/ecosistema-lenguage-go/images/golang.png><img src=/posts/2021/12/ecosistema-lenguage-go/images/golang_hu57fed90b28f13fac04b0b2a1fb7dff6d_26167_1024x0_resize_box_3.png width=1024 height=346 alt="json to go"></a><figcaption>json to go</figcaption></figure><p>Go, también conocido como Golang, es un lenguaje de programación de tipado estático desarrollado por Robert Griesemer, Rob Pike y Ken Thompson en Google.</p></div></article><article class="box box-post"><a class=title href=/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/><h3>Golang: Implementación del almacenamiento en caché</h3></a><time class=date>May
+6
+2021</time><div class=summary-container><figure class=post-figure><a href=/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/images/go-cache.jpg><img src=/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/images/go-cache_huddfdaf20a9de86793c7e04ee08a1b995_15138_1024x0_resize_q75_box.jpg width=1024 height=465 alt="go cache"></a><figcaption>go cache</figcaption></figure><p>El almacenamiento en caché de datos en una aplicación web a veces es necesario para evitar solicitar datos estáticos de una base de datos o un servicio externo una y otra vez. Go no proporciona ningún paquete integrado en la librería estándar para almacenar en caché las respuestas, pero lo admite a través de paquetes externos creados por la comunidad.</p></div></article><article class="box box-post"><a class=title href=/posts/2021/04/golang-referencia-esencial-go-modules/><h3>Golang: Referencia esencial Go modules</h3></a><time class=date>April
+30
+2021</time><div class=summary-container><figure class=post-figure><a href=/posts/2021/04/golang-referencia-esencial-go-modules/images/go-modules.png><img src=/posts/2021/04/golang-referencia-esencial-go-modules/images/go-modules_hu4efca11e3cf5c24922ed10c2ec6d81f7_540656_1024x0_resize_box_3.png width=1024 height=642 alt="Go Modules"></a><figcaption>Go Modules</figcaption></figure><p>Esta es una hoja de trucos esenciales, no una referencia oficial. Con el fin de que sea conciso, se omitieron aspectos menos frecuentes, dado que este sitio desde su <a href=https://github.com/gophers-latam/gophers-latam.github.io>repositorio</a> esta abierto a cambios de contribuidores en la comunidad de <strong>Gophers LATAM</strong> cualquiera puede hacer cambios que mejoren este contenido.</p></div></article><article class="box box-post"><a class=title href=/posts/2021/04/golang-mantener-actualizado-el-sdk/><h3>Golang: Mantener actualizado el SDK</h3></a><time class=date>April
+12
+2021</time><div class=summary-container><figure class=post-figure><a href=/posts/2021/04/golang-mantener-actualizado-el-sdk/images/update-go.png><img src=/posts/2021/04/golang-mantener-actualizado-el-sdk/images/update-go_hu6b1249bbbab4c5cd87135a176f9a4910_40986_1024x0_resize_box_3.png width=1024 height=584 alt="Update Go"></a><figcaption>Update Go</figcaption></figure><p>Como ocurre con todos los lenguajes de programación, hay actualizaciones periódicas de las herramientas de desarrollo de Go. El SDK Go son binarios nativos que no dependen de un tiempo de ejecución independiente, por lo que no hay que preocuparse de que la actualización del entorno de desarrollo pueda hacer que los programas actualmente implementados fallen. Puede tenerse programas compilados con diferentes versiones de Go ejecutándose simultáneamente en la misma computadora o máquina virtual.</p></div></article></div></section><section class=comments><h3>Comentar</h3><div id=disqus_thread></div><script type=application/javascript>window.disqus_config=function(){},function(){if(["localhost","127.0.0.1"].indexOf(window.location.hostname)!=-1){document.getElementById("disqus_thread").innerHTML="Disqus comments not available by default when the website is previewed locally.";return}var t=document,e=t.createElement("script");e.async=!0,e.src="//gophers-latam.disqus.com/embed.js",e.setAttribute("data-timestamp",+new Date),(t.head||t.body).appendChild(e)}()</script><noscript>Please enable JavaScript to view the <a href=https://disqus.com/?ref_noscript>comments powered by Disqus.</a></noscript><a href=https://disqus.com class=dsq-brlink>comments powered by <span class=logo-disqus>Disqus</span></a></section></article></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/posts/2024/04/index.html b/posts/2024/04/index.html
new file mode 100644
index 0000000..7e408f5
--- /dev/null
+++ b/posts/2024/04/index.html
@@ -0,0 +1,11 @@
+<!doctype html><html><head><meta charset=utf-8><meta name=viewport content="width=device-width,initial-scale=1"><meta name=author content="ZeroIdentidad"><meta name=description content="Gophers LATAM"><meta property="og:image" content="https://gophers-latam.github.io//logo.png"><title>2024/04 – Gophers LATAM</title><link rel="shortcut icon" type=image/x-icon href=/favicon.ico><link rel=stylesheet href=/css/style.min.5c43d42176932b665337e50d7340aece08d086e5c40b6f4eecff0e6abb091d0a.css><link rel=stylesheet href=/css/syntax.min.f1fef9cbbfe9d2935981821d59853e89db60d137f9117a1279371320195f1d1a.css><link href='https://fonts.googleapis.com/css2?family=Work+Sans' rel=stylesheet type=text/css><link rel=alternate type=application/rss+xml href=https://gophers-latam.github.io/posts/2024/04/index.xml title="2024/04 - Gophers LATAM"><script type=application/javascript>var doNotTrack=!1;doNotTrack||(window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)},ga.l=+new Date,ga("create","UA-192145152-1","auto"),ga("send","pageview"))</script><script async src=https://www.google-analytics.com/analytics.js></script>
+<script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-7766642915413571" crossorigin=anonymous></script></head><body><div class=container><header class="page-header app-width"><div class=header-left><a href=/><img alt="Gophers LATAM" src=/img/gopher.png style=height:90px></a></div><div class=header-center><nav><a href=/>Inicio</a>
+<a href=/biografia>Biografía</a>
+<a href=/proyectos>Proyectos</a>
+<a href=/posts>Posts</a>
+<a href=/colaboradores>Colaboradores</a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>2024/04</h2><article class="box box-post"><a class=title href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/><h3>Explorando Frameworks en Go: Una Guía para Principiantes</h3></a><time class=date>April
+12
+2024</time><div class=summary-container><figure class=post-figure><a href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png><img src=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png width=1024 height=626 alt="go frameworks"></a><figcaption>go frameworks</figcaption></figure><p>Últimamente, en nuestro canal de <a href=https://discord.me/gophers-latam>discord</a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.</p></div></article></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/posts/2024/04/index.xml b/posts/2024/04/index.xml
new file mode 100644
index 0000000..5badc91
--- /dev/null
+++ b/posts/2024/04/index.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>2024/04 on Gophers LATAM</title><link>https://gophers-latam.github.io/posts/2024/04/</link><description>Recent content in 2024/04 on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><atom:link href="https://gophers-latam.github.io/posts/2024/04/index.xml" rel="self" type="application/rss+xml"/><item><title>Explorando Frameworks en Go: Una Guía para Principiantes</title><link>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</guid><description>&lt;figure class="post-figure">
+&lt;a href="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png">
+&lt;img src="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" width="1024" height="626" alt="go frameworks" />
+&lt;/a>
+&lt;figcaption>go frameworks&lt;/figcaption>
+&lt;/figure>
+&lt;p>Últimamente, en nuestro canal de &lt;a href="https://discord.me/gophers-latam">discord&lt;/a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.&lt;/p></description></item></channel></rss>
\ No newline at end of file
diff --git a/posts/2024/index.html b/posts/2024/index.html
index b4c59da..91d3d2b 100644
--- a/posts/2024/index.html
+++ b/posts/2024/index.html
@@ -4,7 +4,10 @@
 <a href=/proyectos>Proyectos</a>
 <a href=/posts>Posts</a>
 <a href=/colaboradores>Colaboradores</a>
-<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>2024</h2><article class="box box-post"><a class=title href=/posts/2024/02/codelab.-implementemos-un-worker-pool/><h3>CodeLab. Implementemos un Worker Pool</h3></a><time class=date>February
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>2024</h2><article class="box box-post"><a class=title href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/><h3>Explorando Frameworks en Go: Una Guía para Principiantes</h3></a><time class=date>April
+12
+2024</time><div class=summary-container><figure class=post-figure><a href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png><img src=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png width=1024 height=626 alt="go frameworks"></a><figcaption>go frameworks</figcaption></figure><p>Últimamente, en nuestro canal de <a href=https://discord.me/gophers-latam>discord</a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.</p></div></article><article class="box box-post"><a class=title href=/posts/2024/02/codelab.-implementemos-un-worker-pool/><h3>CodeLab. Implementemos un Worker Pool</h3></a><time class=date>February
 6
 2024</time><div class=summary-container><figure class=post-figure><a href=/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools.png><img src=/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools_hu25c2df14317a6a74ebc7cc77c76ece4a_666661_1024x0_resize_box_3.png width=1024 height=794 alt=" Mengniu Dairy production line. Gentileza de  Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/"></a><figcaption>Mengniu Dairy production line. Gentileza de Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/</figcaption></figure><p>La concurrencia es una herramienta que nos ayuda a ejecutar tareas pesadas o que bloquean el avance de un proceso, mientras otras tareas se ejecutan, mejorando el rendimiento general.</p><p>Pero ¿Podemos hacer uso de la concurrencia sin ponernos un límite?</p></div></article><article class="box box-post"><a class=title href=/posts/2024/01/concatenando-strings.-construyendo-sql/><h3>Concatenando strings. Construyendo SQL</h3></a><time class=date>January
 21
diff --git a/posts/2024/index.xml b/posts/2024/index.xml
index d2e8277..462eac7 100644
--- a/posts/2024/index.xml
+++ b/posts/2024/index.xml
@@ -1,4 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>2024 on Gophers LATAM</title><link>https://gophers-latam.github.io/posts/2024/</link><description>Recent content in 2024 on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Tue, 06 Feb 2024 08:22:53 -0600</lastBuildDate><atom:link href="https://gophers-latam.github.io/posts/2024/index.xml" rel="self" type="application/rss+xml"/><item><title>CodeLab. Implementemos un Worker Pool</title><link>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</guid><description>&lt;figure class="post-figure">
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>2024 on Gophers LATAM</title><link>https://gophers-latam.github.io/posts/2024/</link><description>Recent content in 2024 on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/posts/2024/index.xml" rel="self" type="application/rss+xml"/><item><title>Explorando Frameworks en Go: Una Guía para Principiantes</title><link>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</guid><description>&lt;figure class="post-figure">
+&lt;a href="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png">
+&lt;img src="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" width="1024" height="626" alt="go frameworks" />
+&lt;/a>
+&lt;figcaption>go frameworks&lt;/figcaption>
+&lt;/figure>
+&lt;p>Últimamente, en nuestro canal de &lt;a href="https://discord.me/gophers-latam">discord&lt;/a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.&lt;/p></description></item><item><title>CodeLab. Implementemos un Worker Pool</title><link>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</guid><description>&lt;figure class="post-figure">
 &lt;a href="https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools.png">
 &lt;img src="https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools_hu25c2df14317a6a74ebc7cc77c76ece4a_666661_1024x0_resize_box_3.png" width="1024" height="794" alt=" Mengniu Dairy production line. Gentileza de Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/" />
 &lt;/a>
diff --git a/posts/index.html b/posts/index.html
index 7259140..ed8f30a 100644
--- a/posts/index.html
+++ b/posts/index.html
@@ -4,7 +4,10 @@
 <a href=/proyectos>Proyectos</a>
 <a href=/posts>Posts</a>
 <a href=/colaboradores>Colaboradores</a>
-<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Posts</h2><div class=post-list><article class="box box-post"><a class=title href=/posts/2024/02/codelab.-implementemos-un-worker-pool/><h3>CodeLab. Implementemos un Worker Pool</h3></a><time class=date>February
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Posts</h2><div class=post-list><article class="box box-post"><a class=title href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/><h3>Explorando Frameworks en Go: Una Guía para Principiantes</h3></a><time class=date>April
+12
+2024</time><div class=summary-container><figure class=post-figure><a href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png><img src=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png width=1024 height=626 alt="go frameworks"></a><figcaption>go frameworks</figcaption></figure><p>Últimamente, en nuestro canal de <a href=https://discord.me/gophers-latam>discord</a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.</p></div></article><article class="box box-post"><a class=title href=/posts/2024/02/codelab.-implementemos-un-worker-pool/><h3>CodeLab. Implementemos un Worker Pool</h3></a><time class=date>February
 6
 2024</time><div class=summary-container><figure class=post-figure><a href=/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools.png><img src=/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools_hu25c2df14317a6a74ebc7cc77c76ece4a_666661_1024x0_resize_box_3.png width=1024 height=794 alt=" Mengniu Dairy production line. Gentileza de  Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/"></a><figcaption>Mengniu Dairy production line. Gentileza de Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/</figcaption></figure><p>La concurrencia es una herramienta que nos ayuda a ejecutar tareas pesadas o que bloquean el avance de un proceso, mientras otras tareas se ejecutan, mejorando el rendimiento general.</p><p>Pero ¿Podemos hacer uso de la concurrencia sin ponernos un límite?</p></div></article><article class="box box-post"><a class=title href=/posts/2024/01/concatenando-strings.-construyendo-sql/><h3>Concatenando strings. Construyendo SQL</h3></a><time class=date>January
 21
@@ -24,7 +27,5 @@
 1
 2022</time><div class=summary-container><figure class=post-figure><a href=/posts/2022/08/intro-go-mistakes-okno/images/ok-no.png><img src=/posts/2022/08/intro-go-mistakes-okno/images/ok-no_hu67b008a377f65ecd767073b64a23de40_12277_1024x0_resize_box_3.png width=1024 height=443 alt=okno></a><figcaption>okno</figcaption></figure><p>Se comparte el concepto o contexto de algunos errores basicos con su definición acompañado de ejemplo y solución.</p></div></article><article class="box box-post"><a class=title href=/posts/2021/12/ecosistema-lenguage-go/><h3>Ecosistema lenguage Go</h3></a><time class=date>December
 27
-2021</time><div class=summary-container><figure class=post-figure><a href=/posts/2021/12/ecosistema-lenguage-go/images/golang.png><img src=/posts/2021/12/ecosistema-lenguage-go/images/golang_hu57fed90b28f13fac04b0b2a1fb7dff6d_26167_1024x0_resize_box_3.png width=1024 height=346 alt="json to go"></a><figcaption>json to go</figcaption></figure><p>Go, también conocido como Golang, es un lenguaje de programación de tipado estático desarrollado por Robert Griesemer, Rob Pike y Ken Thompson en Google.</p></div></article><article class="box box-post"><a class=title href=/posts/2021/08/go-talks/><h3>Go Talks</h3></a><time class=date>August
-18
-2021</time><div class=summary-container><figure class=post-figure><a href=/posts/2021/08/go-talks/images/go-talks.png><img src=/posts/2021/08/go-talks/images/go-talks_hua2212d92c81a395131b43e35903c9f09_241848_1024x0_resize_box_3.png width=1024 height=961 alt=talks></a><figcaption>talks</figcaption></figure><p><a href=https://pkg.go.dev/golang.org/x/talks><img src=https://pkg.go.dev/badge/golang.org/x/talks.svg alt=Reference></a></p><p>Este post contiene charlas de Go que se pueden leer siguiendo los vinculos de cada título listado.</p></div></article></div><ul class="pagination pagination-default"><li class="page-item disabled"><a aria-disabled=true aria-label=First class=page-link role=button tabindex=-1><span aria-hidden=true>&#171;&#171;</span></a></li><li class="page-item disabled"><a aria-disabled=true aria-label=Previous class=page-link role=button tabindex=-1><span aria-hidden=true>&#171;</span></a></li><li class="page-item active"><a aria-current=page aria-label="Page 1" class=page-link role=button>1</a></li><li class=page-item><a href=/posts/page/2/ aria-label="Page 2" class=page-link role=button>2</a></li><li class=page-item><a href=/posts/page/2/ aria-label=Next class=page-link role=button><span aria-hidden=true>&#187;</span></a></li><li class=page-item><a href=/posts/page/2/ aria-label=Last class=page-link role=button><span aria-hidden=true>&#187;&#187;</span></a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+2021</time><div class=summary-container><figure class=post-figure><a href=/posts/2021/12/ecosistema-lenguage-go/images/golang.png><img src=/posts/2021/12/ecosistema-lenguage-go/images/golang_hu57fed90b28f13fac04b0b2a1fb7dff6d_26167_1024x0_resize_box_3.png width=1024 height=346 alt="json to go"></a><figcaption>json to go</figcaption></figure><p>Go, también conocido como Golang, es un lenguaje de programación de tipado estático desarrollado por Robert Griesemer, Rob Pike y Ken Thompson en Google.</p></div></article></div><ul class="pagination pagination-default"><li class="page-item disabled"><a aria-disabled=true aria-label=First class=page-link role=button tabindex=-1><span aria-hidden=true>&#171;&#171;</span></a></li><li class="page-item disabled"><a aria-disabled=true aria-label=Previous class=page-link role=button tabindex=-1><span aria-hidden=true>&#171;</span></a></li><li class="page-item active"><a aria-current=page aria-label="Page 1" class=page-link role=button>1</a></li><li class=page-item><a href=/posts/page/2/ aria-label="Page 2" class=page-link role=button>2</a></li><li class=page-item><a href=/posts/page/2/ aria-label=Next class=page-link role=button><span aria-hidden=true>&#187;</span></a></li><li class=page-item><a href=/posts/page/2/ aria-label=Last class=page-link role=button><span aria-hidden=true>&#187;&#187;</span></a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
 <small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/posts/index.xml b/posts/index.xml
index 8ff2684..4369af4 100644
--- a/posts/index.xml
+++ b/posts/index.xml
@@ -1,4 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Posts on Gophers LATAM</title><link>https://gophers-latam.github.io/posts/</link><description>Recent content in Posts on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Tue, 06 Feb 2024 08:22:53 -0600</lastBuildDate><atom:link href="https://gophers-latam.github.io/posts/index.xml" rel="self" type="application/rss+xml"/><item><title>CodeLab. Implementemos un Worker Pool</title><link>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</guid><description>&lt;figure class="post-figure">
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Posts on Gophers LATAM</title><link>https://gophers-latam.github.io/posts/</link><description>Recent content in Posts on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/posts/index.xml" rel="self" type="application/rss+xml"/><item><title>Explorando Frameworks en Go: Una Guía para Principiantes</title><link>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</guid><description>&lt;figure class="post-figure">
+&lt;a href="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png">
+&lt;img src="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" width="1024" height="626" alt="go frameworks" />
+&lt;/a>
+&lt;figcaption>go frameworks&lt;/figcaption>
+&lt;/figure>
+&lt;p>Últimamente, en nuestro canal de &lt;a href="https://discord.me/gophers-latam">discord&lt;/a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.&lt;/p></description></item><item><title>CodeLab. Implementemos un Worker Pool</title><link>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</guid><description>&lt;figure class="post-figure">
 &lt;a href="https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools.png">
 &lt;img src="https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools_hu25c2df14317a6a74ebc7cc77c76ece4a_666661_1024x0_resize_box_3.png" width="1024" height="794" alt=" Mengniu Dairy production line. Gentileza de Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/" />
 &lt;/a>
diff --git a/posts/page/2/index.html b/posts/page/2/index.html
index 3c0f54b..ae185e6 100644
--- a/posts/page/2/index.html
+++ b/posts/page/2/index.html
@@ -4,7 +4,9 @@
 <a href=/proyectos>Proyectos</a>
 <a href=/posts>Posts</a>
 <a href=/colaboradores>Colaboradores</a>
-<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Posts</h2><div class=post-list><article class="box box-post"><a class=title href=/posts/2021/06/conversi%C3%B3n-json-a-go/><h3>Conversión JSON a Go</h3></a><time class=date>June
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>Posts</h2><div class=post-list><article class="box box-post"><a class=title href=/posts/2021/08/go-talks/><h3>Go Talks</h3></a><time class=date>August
+18
+2021</time><div class=summary-container><figure class=post-figure><a href=/posts/2021/08/go-talks/images/go-talks.png><img src=/posts/2021/08/go-talks/images/go-talks_hua2212d92c81a395131b43e35903c9f09_241848_1024x0_resize_box_3.png width=1024 height=961 alt=talks></a><figcaption>talks</figcaption></figure><p><a href=https://pkg.go.dev/golang.org/x/talks><img src=https://pkg.go.dev/badge/golang.org/x/talks.svg alt=Reference></a></p><p>Este post contiene charlas de Go que se pueden leer siguiendo los vinculos de cada título listado.</p></div></article><article class="box box-post"><a class=title href=/posts/2021/06/conversi%C3%B3n-json-a-go/><h3>Conversión JSON a Go</h3></a><time class=date>June
 5
 2021</time><div class=summary-container><figure class=post-figure><a href=/posts/2021/06/conversi%C3%B3n-json-a-go/images/json_to_go.png><img src=/posts/2021/06/conversi%C3%B3n-json-a-go/images/json_to_go_huea8bfa3ec3570bd3e606c0b62bfa85b8_295039_1024x0_resize_box_3.png width=1024 height=768 alt="json to go"></a><figcaption>json to go</figcaption></figure><p>Uno de los formatos de datos que se encuentra con mucha frecuencia en programación, principalmente web, es JavaScript Object Notation (JSON).</p></div></article><article class="box box-post"><a class=title href=/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/><h3>Golang: Implementación del almacenamiento en caché</h3></a><time class=date>May
 6
diff --git a/search/index.json b/search/index.json
index d325f18..6593851 100644
--- a/search/index.json
+++ b/search/index.json
@@ -1 +1 @@
-{"results":[{"href":"https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/","title":"CodeLab. Implementemos un Worker Pool","body":" Mengniu Dairy production line. Gentileza de Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/ La concurrencia es una herramienta que nos ayuda a ejecutar tareas pesadas o que bloquean el avance de un proceso, mientras otras tareas se ejecutan, mejorando el rendimiento general.\nPero ¿Podemos hacer uso de la concurrencia sin ponernos un límite?\nConcurrencia es un aspecto integral del desarrollo moderno de software que permite que nuestras aplicaciones ejecuten múltiples tareas simultáneamente y nos permite usar efectivamente los recursos del sistema, especialmente en situaciones donde debemos llevar a cabo mucho computo u operaciones de entrada/salida.\nPero ¿Hay un Límite?\nImaginemos el periódo de matriculas de un colegio en donde se debe registrar el ingreso y asignar curso a cientos de alumnos. Podríamos poner un funcionario encargado para el registro de cada alumno, pero solo podríamos hacerlo hasta completar el máximo número de funcionarios disponibles\n¡Además de que todas las demás tareas de esos funcionarios quedarían en pausa hasta terminar el proceso de registro!\nWorker pool es un patrón concurrente cuya idea base es tener un número de gorutinas esperando a que se le asignen trabajos, ejecutándolos a medida que se le van asignando Como eso es poco verosímil, que tal si dejamos solo a 4 funcionarios realizando el proceso de matricula mientras que los demás se reparten las tareas habituales. De esta forma los 4 funcionarios registran alumnos concurrentemente. Junto con ello, esto nos permite que si vemos que se produce un cuello de botella, por ejemplo muchos apoderados llegan a registrar a sus pupilos al mismo tiempo, podemos reforzar con algunos funcionarios extra, y devolverlos a sus tareas habituales cuando se haya procesado el cuello de botella.\nPues bien, con esta analogía hemos descrito el funcionamiento de un worker pool, el cual es un patrón para lograr concurrencia, cuya idea base es tener un número de gorutinas, que reciben el nombre de worker, esperando a que se le asignen trabajos. Cuando un trabajo se le asigna a un worker, se ejecuta concurrentemente mientras la gorutina principal sigue ejecutando otro código.\nLa idea base de nuestra implementación es gatillar bajo demanda un número fijo de gorutinas que harán las veces de workers e iran recibiendo tareas a ejecutar a través de un canal por el cual las enviaremos Worker pool nos permite administrar el nivel de concurrencia de nuestras aplicaciones controlando el uso de recursos de procesamiento.\n¡Pero basta de teoría y ensuciemonos las manos que a eso hemos venido!\nImplementaremos un worker pool definiendo cada parte que lo constituye, junto con algunas utilidades para obtener métricas.\nLa idea base de nuestra implementación es gatillar bajo demanda un número fijo de gorutinas que harán las veces de workers e iran recibiendo tareas a ejecutar a través de un canal por el cual las enviaremos.\nDecimos que gatillaremos bajo demanda a los workers porque los iremos levantando a medida que vayan llegando tareas y no hayan workers para ejecutarlas, hasta llegar al límite definido de workers. En pocas palabras, implementaremos una lazy inicialization de los workers de nuestro pool.\nDentro de las consideraciones de diseño, haremos un fuerte uso de interfaces pues nos permiten que los elementos que componen el worker pool sean plugables y posibles de reemplazar por otros componentes que implementen la interface.\nLa belleza de esto radica en que si a Ud. se le ocurre una mejor implementación, o necesita funcionalidades extra que no están contempladas, puede construir su propia implementación de acuerdo a sus gustos o necesidades, y mientras exponga los métodos de la interface definida, su código personalizado trabajará perfectamente con el resto del worker pool.\nTareas Dentro del contexto de programación concurrente es usual llamar aquello que se procesa como tarea, que son trabajos que pueden ser ejecutados asíncrona y concurrentemente. Así que empecemos por definir la estructura de datos que nuestro worker pool será capaz de procesar.\ntype Task interface { Run() } Una interface llamada Task, exponiendo un método Run que será implementada por las tareas concretas que necesitemos procesar.\nExecutor y Spawner Comentamos que los workers deben levantarse a medida que las tareas vayan llegando, y que deben ir ejecutandolas. Podemos abstraer esas dos funcionalides en respectivas interfaces.\ntype Executor interface { // Execute ejecuta una tarea Task para un worker pool Pool Execute(Task, Pool) } La interface Executor tendrá la responsabilidad de ejecutar cada tarea\ntype Spawner interface { // Spawn engendra un nuevo worker para el worker pool // recibe como argumento: // El canal por donde se recibirán las tareas // Una función capaz de ejecutar una tarea // Una función que se ejecutará al momento de desplegar el worker // Una función que se ejecutará al momento de terminar al worker Spawn(chan Task, func(Task), func(), func()) } Spawner cuya finalidad será levantar un nuevo worker cuando sea necesario.\nPool type Pool interface { // Submit Envia una nueva tarea al worker pool Submit(Task) // WaitAll Espera a que todos los workers terminen de procesar sus tareas asignadas WaitAll() // Execute Ejecuta las tareas enviadas al worker delegando en la interface [Executor] Execute(Task) // SpawnWorker Levanta un nuevo worker delegando en la interface [Spawner] SpawnWorker() // WorkerSpawned Retorna el número de workers levantados hasta el momento WorkerSpawned() int32 // SubmittedTasks Retorna el número de tareas enviadas a los workers SubmittedTasks() int32 // AddReadyTask agrega el deltas indicado como parámetro a la cantidad // de tareas ejecutadas. Se usa en DefaultExecutor por ejemplo AddReadyTask(int32) // OnExecuteTask Lo usaremos como un hook para inyectar código que se ejecutará cuando el [Executor] ejecute cada tarea OnExecuteTask(time.Time) // CummulatedWorkTime() time.Duration` Devuelve el tiempo de trabajo hasta el momento de su invocación CummlatedWorkTime() time.Duration // AVGTime Devuelve el tiempo promedio de ejecución de tareas AVGTime() time.Duration } Definimos la última de nuestras interfaces, la interface Pool que representa al worker pool.\nCon la api de nuestro worker pool ya definida, procedemos ahora a construir una implementación concreta.\nImplementando a Executor. DefaultExecutor type DefaultExecutor struct{} func (e *DefaultExecutor) Execute(task Task, p Pool) { start := time.Now().UTC() defer p.OnExecuteTask(start) defer p.AddReadyTask(1) task.Run() } Tal como se indicó en la definición de nuestra api, el executor es responsable de gatillar la tarea recibida por el worker.\nEn esta implementación registraremos el tiempo que las tareas demoran en ejecutarse, y para invocar al método OnExecuteTask del worker pool.\nImplementando a Spawner. DefaultSpawner. type DefaultSpawner struct{} func (s *DefaultSpawner) Spawn( tasks chan Task, executor func(Task), onStart func(), onEnd func() ) { // Antes de levantar propiamente al worker, ejecutamos la función onStart // recibida como argumento. Esto nos da la oportunidad // de inyectar un hook al momento de levantar los workers onStart() // Levantamos al worker en su propia gorutina go func() { // registramos la función onEnd recibidas como argumento // para que se ejecute al terminar la gorutina defer onEnd() for task := range tasks { // Dejamos un medio para terminar al worker // recibiendo una tarea con valor nil if task == nil { return } // para cada tarea recibida, invocamos a la // función executor recibida como argumento // para que la gatille. executor(task) } }() } Implementado Pool. Deadpool Implementaremos ahora a nuestro Pool concreto, le llamaremos Deadpool por razones obvias.\nCuando definamos al constructor usaremos funciones argumentales variadicas pues nos proveen de una gran flexibilidad.\n// Definimos los posibles errores que puede gatillar la creación de un nuevo deadpool var ( ErrInvalidMaxWorkers = errors.New(\u0026#34;invalid max number of workers\u0026#34;) ErrInvalidCap = errors.New(\u0026#34;invalid capacity for tasks stream\u0026#34;) ErrInvalidExecutor = errors.New(\u0026#34;expected a valid Executor. Nil received\u0026#34;) ErrInvalidSpawner = errors.New(\u0026#34;expected a valid Spawner. Nil received\u0026#34;) ) type deadpool struct { // maxWorkers indica la cantidad máxima de workers a levantar maxWorkers int32 // cap es la capacidad de tareas para el worker pool. Se usa como // el segundo parámetro de `make` al construir el canal de tareas cap int8 // currentWorkersQTY registra la cantidad actual de workers levantados currentWorkersQTY int32 // readyTasksQTY registra la cantidad de tareas ejecutadas readyTasksQTY int32 // submittedTasksQTY registra la cantidad de tareas enviadas a los workers submittedTasksQTY int32 // registra el tiempo acumulado de proceso para las tareas ejecutadas cummulatedTime time.Duration // registra el tiempo promedio de ejecución de las tareas avgTaskTime time.Duration // executor de tipo [Executor] es un punto de montaje para un // Executor personalizado, en caso de no proveerse uno, se usará //[DefaultExecutor] executor Executor // spawner de tipo [Spawner] es un punto de montaje para un // Spawner personalizado, en caso de no proveerse uno, se usará //[DefaultSpawner] spawner Spawner // tasksStream es el canal por donde se enviaran las tareas a los workers tasksStream chan Task wg *sync.WaitGroup mu sync.Mutex } // New devuelve un puntero a un deadpool inicializado y listo para usar. func New(opts ...func(*deadpool)) (*deadpool, error) { // Instancia de deadpool con defauklts executor y spawner d := \u0026amp;deadpool{ executor: \u0026amp;DefaultExecutor{}, spawner: \u0026amp;DefaultSpawner{}, wg: \u0026amp;sync.WaitGroup{}, mu: sync.Mutex{}, } // procesamos las funciones argumentales variadicas for _, f := range opts { f(d) } if d.maxWorkers \u0026lt;= 0 { return d, ErrInvalidMaxWorkers } if d.cap \u0026lt; 0 { return d, ErrInvalidCap } // Si por cualquier causa se pasó un executor nil, terminamos con el // error correspondiente if d.executor == nil { return d, ErrInvalidExecutor } if d.spawner == nil { return d, ErrInvalidSpawner } // construimos el canal donde dejaremos caer las tareas d.tasksStream = make(chan Task, d.cap) return d, nil } func (d *deadpool) AddReadyTask(qty int32) { atomic.AddInt32(\u0026amp;d.readyTasksQTY, qty) } // Submit envía una nueva tarea parea ser procesada por algún worker func (d *deadpool) Submit(task Task) { // engendramos un nuevo worker solo si es necesario d.SpawnWorker() // enviamos la tarea por el canal d.tasksStream \u0026lt;- task // aumentamos en 1 la cantidad de tareas enviadas usando una operación atómica atomic.AddInt32(\u0026amp;d.submittedTasksQTY, 1) } // WaitAll espera porque todos los workers levantados terminen sus tareas asignadas func (d *deadpool) WaitAll() { if d.tasksStream != nil { close(d.tasksStream) } d.wg.Wait() } // Execute ejecuta la tarea delegando a la implementación de // [Executor] definida func (d *deadpool) Execute(task Task) { d.executor.Execute(task, d) } // SpawnWorker levanta un nuevo worker func (d *deadpool) SpawnWorker() { // Obtiene de una operación atómica la cantidad actual de workers levantados currentWorkersQTY := atomic.LoadInt32(\u0026amp;d.currentWorkersQTY) // si es menor a la cantidad máxima de workers indicada, procedemos a levantar un nuevo worker if currentWorkersQTY \u0026lt; atomic.LoadInt32(\u0026amp;d.maxWorkers) { // Para levantar un nuevo worker delegamos a la implementación definida // de [Spawner] d.spawner.Spawn( d.tasksStream, // canal de tareas d.Execute, // función ejecutora que al final delega al [Executer] func(workerID int32) func() { // función a invocar al iniciar el worker return func() { // en esta implementación lo usamos para d.wg.Add(1) // aumentar en 1 el contador de workers a esperar } }(currentWorkersQTY), func(workerID int32) func() { // función a invocar al terminar el worker return func() { // en esta implementación lo usamos para d.wg.Done() // disminuir en 1 el contador de workers a esperar } }(currentWorkersQTY), ) atomic.AddInt32(\u0026amp;d.currentWorkersQTY, 1) // Aumentamos en 1 la cantidad de workers levantados // con una operación atómica } } // OnExecuteTask es un hook que se provee para inyectar código antes de ejecutar una tarea. func (d *deadpool) OnExecuteTask(start time.Time) { d.mu.Lock() defer d.mu.Unlock() // En esta implementación lo usamos para guardar el tiempo // de ejecución de las tareas // para calcular el cummulated execution time y el avg execution time ellapsed := time.Since(start) d.cummulatedTime += ellapsed readies := time.Duration(atomic.LoadInt32(\u0026amp;d.readyTasksQTY)) d.avgTaskTime = d.cummulatedTime / readies // Pero ud. podría usarlo para lo que quiera! } func (d *deadpool) WorkerSpawned() int32 { return d.currentWorkersQTY } func (d *deadpool) SubmittedTasks() int32 { return d.submittedTasksQTY } func (d *deadpool) AVGTime() time.Duration { return d.avgTaskTime } func (d *deadpool) CummlatedWorkTime() time.Duration { return d.cummulatedTime } /// Funciones argumentales variadicas // WithMax indica el máximo número de workers func WithMax(max int32) func(*deadpool) { return func(d *deadpool) { d.maxWorkers = max } } // WithCap indica la capacidad del canal. Si se omite el canal de tareas no estará buffereado func WithCap(cap int8) func(*deadpool) { return func(d *deadpool) { d.cap = cap } } // WithExecutor permite explicitar el Executor a usar. Si se omite, se usa [DefaultExecutor] func WithExecutor(exe Executor) func(*deadpool) { return func(d *deadpool) { d.executor = exe } } // WithSpawner permite explicitar el [Spawner] a usar. Si se omite, se usa [DefaultSpawner] func WithSpawner(spn WorkerSpawner) func(*deadpool) { return func(d *deadpool) { d.spawner = spn } } En nuestra implementación hemos decidido usar el paquete atomic que provee primitivas de memoria de bajo nivel. La documentación de Go recomienda preferir el paquete sync o canales para sincronizar memoria, pero como lo que necesitabamos hacer era aumentar en 1 algunas variables nos decantamos por atomic.\nComo ninguna implementaciónm está terminada sin sus pruebas, construyamoslas para probar nuestro invento.\nfunc Test_deadpool_ErrsOnCreate(t *testing.T) { _, err := New(WithMax(-1)) if err == nil { t.Log(\u0026#34;ErrInvalidMaxWorkers expected\u0026#34;) t.FailNow() } _, err = New(WithCap(-1)) if err == nil { t.Log(\u0026#34;ErrInvalidCap expected\u0026#34;) t.FailNow() } _, err = New(WithExecutor(nil)) if err == nil { t.Log(\u0026#34;ErrInvalidExecutor expected\u0026#34;) t.FailNow() } _, err = New(WithSpawner(nil)) if err == nil { t.Log(\u0026#34;ErrInvalidSpawner expected\u0026#34;) t.FailNow() } } El test anterior comprueba que los posibles errores al instanciar a nuestro pool se gatillen correctamente.\nAhora implementemos un mock de una tarea para poder probar la infraestructura completa.\ntype taskTest struct { id int } func newTaskTest(id int) *taskTest { return \u0026amp;taskTest{ id: id, } } func (t *taskTest) Run() { defer func() { if os.Getenv(\u0026#34;DEBUG\u0026#34;) == \u0026#34;TRUE\u0026#34; { fmt.Printf(\u0026#34; stoping task %d\\n\u0026#34;, t.id) } }() if os.Getenv(\u0026#34;DEBUG\u0026#34;) == \u0026#34;TRUE\u0026#34; { fmt.Printf(\u0026#34; starting task %d\\n\u0026#34;, t.id) time.Sleep(10 * time.Millisecond) } } Simulamos un trabajo en nuestra implementación mock de tarea esperando durante 10 milisegundos. Además, agregamos unas comprobaciones a la variable de entorno DEBUG para poder ver logs del inicio y fin de la ejecución de las tareas mock.\nfunc Test_deadpool_Flow(t *testing.T) { // Instanciamos un nuevo deadpool con un máximo de 6 workers d, err := New(WithMax(6)) if err != nil { t.Log(err) t.FailNow() } start := time.Now().UTC() // Enviaremos al worker pool 128 de nuestras tareas mock for i := 1; i \u0026lt;= 128; i++ { func(i int) { d.Submit(newTaskTest(i)) }(i) } d.WaitAll() // estadisticas t.Logf(\u0026#34;tiempo acumulado de proceso: %v\\n\u0026#34;, d.CummlatedWorkTime()) t.Logf(\u0026#34;tiempo promedio por tarea: %v \\n\u0026#34;, d.AVGTime()) t.Logf(\u0026#34;tiempo total de proceso: %v\u0026#34;, time.Since(start)) } Y al ejecutar nuestro test con la variable de entrono DEBUG con valor TRUE podemos ver el resultado.\n$ DEBUG=TRUE go test -timeout 256s -run ^Test_deadpool_Flow$ github.com/profe-ajedrez/deadpool -v === RUN Test_deadpool_Flow starting task 1 starting task 2 starting task 3 starting task 4 ... stoping task 122 stoping task 125 stoping task 128 stoping task 127 deadpool_test.go:60: tiempo acumulado de proceso: 1.298687182s deadpool_test.go:61: tiempo promedio por tarea: 10.145993ms deadpool_test.go:62: tiempo total de proceso: 223.349239ms --- PASS: Test_deadpool_Flow (0.22s) Donde vemos que el tiempo sumado de la ejecución de todas las tareas fue 1.298687182s, pero el tiempo total de proceso solo fue de 223.349239ms, mientras que cada tarea demoro en promedio 10.145993ms que es una fracción mayor a los 10ms que le indicamos que debía esperar la tarea mock.\nComo alternativa al worker pool, según sea nuestro caso podriamos haber implementado un pipeline, que consiste en una cadena de gorutinas cada una de las cuales realiza una acción sobre un elemento hasta completarlo, y cuya analogía es una línea de producción.\nSea cual sea el patrón concurrente que elijamos, debemos ser cuidadosos de no provocar condiciones de carrera ni fugas de gorutinas, por lo que debemos hacer uso exhaustivo del flag -race al ejecutar nuestras pruebas.\nHemos implementado un worker pool funcional, pero aun no hemos respondido a la pregunta con que iniciamos este artículo ¿Hay algún límite para la concurrencia? Preferimos dejar la pregunta abierta y esperamos sus respuestas en los comentarios.\nPuede hackear el código que hemos construido en este playground, y como de costumbre, le proveemos con el repositorio donde se aloja.\nY bien, con eso llegamos al final de este codelab. Esperamos que haya sido de su agrado y como siempre le recordamos que si le gustó este artículo no dude en compartirlo o en comentarnos si considera que hay algo en lo que podamos mejorar.\n"},{"href":"https://gophers-latam.github.io/posts/2024/01/concatenando-strings.-construyendo-sql/","title":"Concatenando strings. Construyendo SQL","body":" json to go Los strings son un tipo de dato peculiar. A simple vista parecieran no esconder nada raro, pero si los comparamos con tipos de dato numéricos encontramos diferencias interesantes.\nUn string compuesto de solo un caracter, por ejemplo \u0026ldquo;A\u0026rdquo;, ocupa un byte completo para almacenarse. En un byte el número entero sin signo mas pequeño que podemos guardar es 0, siendo 255 el mas grande posible de almacenarse. O sea, un solo caracter como \u0026ldquo;A\u0026rdquo; ocupa la misma cantidad de memoria que un valor del tipo uint8.\nEntonces ¿Cuanta memoria podemos usar al concatenar una enorme cantidad de caracteres en strings de gran tamaño? Investiguémoslo con uno de los usos mas frecuentes de construcción dinámica de strings; la creación de consultas SQL.\nTerminaremos además con una bonita técnica para disminuir aun mas los direccionamientos al guardar los parámetros para la consulta SQL en un slice.\nNosotros no le creemos nada a nadie, todo lo comprobamos por nosotros mismos. Por eso acompañamos cada ejemplo con su respectivo benchmark. ¡Ud. debería hacer lo mismo ya que proveemos los benchmarks para este experimento! Construiremos una consulta sql de varias formas distintas y mediremos su eficiencia con benchmarks.\nUsaremos el siguiente struct para proveer los datos para construir el filtro:\ntype Filter struct { ID int64 // provee el id a buscar Name string // provee el nombre a buscar Lastname string Search string // provee un valor por cual buscar usando LIKE a nombres o apellidos Limit int64 Offset int64 } Usaremos la siguiente constante como base para la consulta que construiremos:\nconst qb = `SELECT id, name, last_name FROM clientes WHERE 1=1 %ATTRS% %ID% %FIRST_NAME% %LAST_NAME% %LIMIT% %OFFSET%` Y la función que construye la consulta con dicho filtro, la cual se basa en la técnica de colocar patrones en el texto y reemplazarlos al ir construyendo la consulta concatenando strings sucesivos:\nfunc QueryBuilderEvil(f Filter) (string, []any) { sql := qb var params []any if strings.TrimSpace(f.Search) != \u0026#34;\u0026#34; { sql = strings.ReplaceAll(sql, \u0026#34;%ATTRS%\u0026#34;, \u0026#34; AND ( name LIKE ? OR last_name LIKE ?)\u0026#34;) params = append(params, \u0026#34;%\u0026#34;+f.Search+\u0026#34;%\u0026#34;, \u0026#34;%\u0026#34;+f.Search+\u0026#34;%\u0026#34;) } else { sql = strings.ReplaceAll(sql, \u0026#34;%ATTRS%\u0026#34;, \u0026#34;\u0026#34;) } if f.ID \u0026gt; 0 { sql = strings.ReplaceAll(sql, \u0026#34;%ID%\u0026#34;, \u0026#34; AND id = ?\u0026#34;) params = append(params, f.ID) } else { sql = strings.ReplaceAll(sql, \u0026#34;%ID%\u0026#34;, \u0026#34;\u0026#34;) } if strings.TrimSpace(f.Name) != \u0026#34;\u0026#34; { sql = strings.ReplaceAll(sql, \u0026#34;%FIRST_NAME%\u0026#34;, \u0026#34; AND name = ?\u0026#34;) params = append(params, f.Name) } else { sql = strings.ReplaceAll(sql, \u0026#34;%FIRST_NAME%\u0026#34;, \u0026#34;\u0026#34;) } if strings.TrimSpace(f.Lastname) != \u0026#34;\u0026#34; { sql = strings.ReplaceAll(sql, \u0026#34;%LAST_NAME%\u0026#34;, \u0026#34; AND last_name = ?\u0026#34;) params = append(params, f.Lastname) } else { sql = strings.ReplaceAll(sql, \u0026#34;%LAST_NAME%\u0026#34;, \u0026#34;\u0026#34;) } if f.Limit \u0026gt; 0 { sql = strings.ReplaceAll(sql, \u0026#34;%LIMIT%\u0026#34;, \u0026#34; LIMIT ?\u0026#34;) params = append(params, f.Limit) } else { sql = strings.ReplaceAll(sql, \u0026#34;%LIMIT%\u0026#34;, \u0026#34;\u0026#34;) } if f.Offset \u0026gt; 0 { sql = strings.ReplaceAll(sql, \u0026#34;%OFFSET%\u0026#34;, \u0026#34; OFFSET ?\u0026#34;) params = append(params, f.Offset) } else { sql = strings.ReplaceAll(sql, \u0026#34;%OFFSET%\u0026#34;, \u0026#34;\u0026#34;) } return sql, params } Antes de analizar, veamos el resultado del benchmark de esta función. En mi máquina arroja estos resultados:\nfunc BenchmarkEvil(b *testing.B) { f := Filter{ Name: \u0026#34;a\u0026#34;, Lastname: \u0026#34;b\u0026#34;, Search: \u0026#34;\u0026#34;, Limit: 10, } b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { _, _ = QueryBuilderEvil(f) } } BenchmarkEvil-16 1655064\t705.8 ns/op\t720 B/op\t11 allocs/op El benchmark nos dice que se ejecutó la función 18720764 veces, durando 764 ns cada iteración, direccionado 784 bytes cada iteración, realizando 11 localizaciones al heap.\n¿Parece rápido? ¿Que puede tener esto de malo? Observe los bytes direccionados, 784. Esto, mas o menos significa que se guardaron en memoria el equivalente a 784 letras \u0026ldquo;A\u0026rdquo;.\nReunamos mas información. Usemos el flag -gcflags=\u0026quot;-m\u0026quot; para descubrir donde se producen los direccionamientos en el heap.\n./main_test.go:21:15: q escapes to heap ./main.go:89:39: \u0026#34;%\u0026#34; + f.Search + \u0026#34;%\u0026#34; escapes to heap ./main.go:89:39: \u0026#34;%\u0026#34; + f.Search + \u0026#34;%\u0026#34; escapes to heap ./main.go:89:57: \u0026#34;%\u0026#34; + f.Search + \u0026#34;%\u0026#34; escapes to heap ./main.go:89:57: \u0026#34;%\u0026#34; + f.Search + \u0026#34;%\u0026#34; escapes to heap ¡Observe además que cada concatenación con + escapa al heap! Cada una genera un direccionamiento nuevo, Lo que si leyó un artículo anterior, entenderá que puede ser susceptible de mejorar.\nPero ¿Que alternativas hay?\nConstruyendo strings de forma eficiente con strings.Builder Tratemos de mejorar nuestra implementación. Usando el mismo struct para el filtro, cambiemos la constante base de sql.\nconst q = `SELECT id, name, last_name FROM clientes WHERE 1=1` Y revisemos esta función alternativa para construir la consulta:\nb := strings.Builder{} // le indicamos una capacidad al slice que contendrá los parámetros de la query // iguala la cantidad máxima de elementos posibles de agregar al filtro params := make([]any, 0, 7) b.WriteString(q) if f.ID \u0026gt; 0 { b.WriteString(\u0026#34; AND id = ?\u0026#34;) // Agregamos el segmento del filtro sql y el parámetro posicional params = append(params, f.ID) } if strings.TrimSpace(f.Name) != \u0026#34;\u0026#34; { // Nótese el espacio extra antes del sql b.WriteString(\u0026#34; AND name = ?\u0026#34;) params = append(params, f.Name) } if strings.TrimSpace(f.Lastname) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND last_name = ?\u0026#34;) params = append(params, f.Lastname) } if strings.TrimSpace(f.Search) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND ( name LIKE ? OR last_name LIKE ?)\u0026#34;) params = append(params, fmt.Sprintf(\u0026#34;%%%s%%\u0026#34;,f.Search), fmt.Sprintf(\u0026#34;%%%s%%\u0026#34;,f.Search)) } if f.Limit \u0026gt; 0 { b.WriteString(\u0026#34; LIMIT ?\u0026#34;) params = append(params, f.Limit) } if f.Offset \u0026gt; 0 { b.WriteString(\u0026#34; OFFSET ?\u0026#34;) params = append(params, f.Offset) } return b, params Revisemos el resultado del benchmark:\nfunc BenchmarkOK(b *testing.B) { f := Filter{ Name: \u0026#34;a\u0026#34;, Lastname: \u0026#34;b\u0026#34;, Search: \u0026#34;\u0026#34;, Limit: 10, } b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { _, _ = QueryBuilderOK(f) } } BenchmarkOK-16 6253722\t234.3 ns/op\t336 B/op\t5 allocs/op ¡Vaya! hemos pasado de 705.8 ns a 234.3 ns, y de un consumo de memoria de 720 bytes disminuimos a 336 bytes ¡Bastante bien no!\nGracias al uso eficiente de strings.Builder podemos evitar concatenaciones costosas. Estas mejoras se explican porque este nuevo constructor de la consulta delega el manejo de la construcción del string a strings.Builder, cuya documentación nos explica que es un tipo de dato que permite construir strings minimizando las copias de memoria que como Ud. ya está imaginando es donde se produce la demora en ejecución y el costo.\nGracias al uso eficiente de strings.Builder podemos dejar de usar la técnica de búsqueda y reemplazo en el string que estamos construyendo y podemos evitar concatenaciones costosas.\nLlevando esto al extremo ¿Hasta que punto deberíamos llegar al pensar en evitar concatenaciones y reemplazarlas por strings.Builder?\nDepende de lo que estemos tratando de hacer. Por ejemplo, en nuestra función QueryBuilderOK Ud. podría decir que en donde se construyen los likes se esta usando fmt.Sprintf, y si acaso no sería mejor usar un builder.\n¡Comprobemoslo! Construyamos una tercera función para generar nuestra consulta sql.\nfunc QueryBuilderOKAlter(f Filter) (strings.Builder, []any) { b := strings.Builder{} params := make([]any, 0, 7) // 7 es la cantidad máxima de elementos que se pueden agregar al filtro b.WriteString(q) if f.ID \u0026gt; 0 { b.WriteString(\u0026#34; AND id = ?\u0026#34;) // Agregamos el segmento del filtro sql y el parámetro posicional params = append(params, f.ID) } if strings.TrimSpace(f.Name) != \u0026#34;\u0026#34; { // Nótese el espacio extra antes del sql b.WriteString(\u0026#34; AND name = ?\u0026#34;) params = append(params, f.Name) } if strings.TrimSpace(f.Lastname) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND last_name = ?\u0026#34;) params = append(params, f.Lastname) } if strings.TrimSpace(f.Search) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND ( name LIKE ? OR last_name LIKE ?)\u0026#34;) b2 := strings.Builder{} b2.WriteString(\u0026#34;%\u0026#34;) b2.WriteString(f.Search) b2.WriteString(\u0026#34;%\u0026#34;) params = append(params, b2.String()) b2.Reset() b2.WriteString(\u0026#34;%\u0026#34;) b2.WriteString(f.Search) b2.WriteString(\u0026#34;%\u0026#34;) params = append(params, b2.String()) } if f.Limit \u0026gt; 0 { b.WriteString(\u0026#34; LIMIT ?\u0026#34;) params = append(params, f.Limit) } if f.Offset \u0026gt; 0 { b.WriteString(\u0026#34; OFFSET ?\u0026#34;) params = append(params, f.Offset) } return b, params } Con su benchmark respectivo\nfunc BenchmarkOKAlter(b *testing.B) { f := Filter{ Name: \u0026#34;a\u0026#34;, Lastname: \u0026#34;b\u0026#34;, Search: \u0026#34;\u0026#34;, Limit: 10, } b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { _, _ = QueryBuilderOKAlter(f) } } Y ejecutemos varias veces los benchmarks para considerar pequeñas variaciones.\n# Usamos el flag -count para indicar el número de ejecuciones # de nuestros benchmarks # y el flag -benchtime para indicar el tiempo mínimo que debería durar cada bench go test -benchmem -count=16 -benchtime=2s -bench . goos: linux goarch: amd64 pkg: aa cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz BenchmarkEvil-16 3066897 744.7 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3498865 727.4 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3386638 718.1 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3180061 728.8 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3392404 741.4 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3488655 732.3 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3306530 736.1 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3028632 718.3 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3517440 710.5 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3404026 704.9 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3467962 756.4 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3440934 738.0 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3392062 711.4 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3522846 735.8 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3203848 701.6 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3502076 732.7 ns/op 720 B/op 11 allocs/op BenchmarkOK-16 11799339 228.8 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11871458 228.2 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11488488 264.0 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 12074823 236.2 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 9447732 229.9 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 10044681 204.5 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 12510486 232.0 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 10445984 256.5 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11243646 250.3 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11259970 251.3 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 9696850 247.5 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11768199 285.7 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 10200710 235.4 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 9136749 232.4 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 9717814 242.0 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 10739455 240.3 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 10271550 246.1 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8569068 237.5 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8484096 277.7 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8993108 265.8 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8013882 286.9 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8815909 240.2 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 9611652 261.0 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8601260 234.4 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 9384111 256.7 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 7744686 268.7 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8082067 289.4 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 11854416 213.5 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 10229622 286.3 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 10405981 219.1 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8921347 242.1 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 11861126 261.1 ns/op 336 B/op 5 allocs/op PASS ok aa 144.342s Si tomamos los resultados y los ordenamos desde el más rápido hasta el mas lento, vemos que no hay una gran diferencia entre las funciones OK, y que incluso QueryBuilderOK es un poco mas veloz que QueryBuilderOKAlter.\nEn el apartado de memoria ambas gastaron la misma cantidad y realizaron el mismo número de direccionamientos.\n¿Esto significa que cuando necesitemos hacer pocas concatenaciones, o cuando lo tengamos que hacer sobre strings muy pequeños no deberíamos usar strings.Builder?\n¡No lo se! Dependerá de que tan pocas concatenaciones y que tan pequeños sean los strings de su caso. Lo único que puedo recomendarle es construir su programa de forma tal que pueda realizar los benchmarks correspondientes y tomar la decisión con base a los números presentados por estos en cada situación.\nAplicando la técnica de máscaras de parámetros Ahora bien, En el caso de nuestro ejemplo hay formas de optimizar aun mas a nuestro builder que ya no pasan directamente por el manejo del string. Podemos usar la técnica de usar una máscara para determinar el tamaño exacto de los parámetros a agregar a la consulta y direccionar previamente la memoria con ese número para evitar realizar appends mientras se va construyendo la consulta, de la misma forma que evitamos concatenar gracias a strings.Builder.\nfunc QueryBuilderOKMask(f Filter) (strings.Builder, []any) { b := strings.Builder{} // tenemos una instancia de un struct con un campo booleano para // cada elemento del filtro mask := struct { ID bool Name bool Lastname bool Search bool Limit bool Offset bool }{} b.WriteString(q) // Usaremos a size para indicar cuantos elementos tendrá finalmente el slice de parámetros de la consulta size := 0 if f.ID \u0026gt; 0 { b.WriteString(\u0026#34; AND id = ?\u0026#34;) // Agregamos el segmento del filtro sql y el parámetro posicional // Si el elemento del filtro se agrega, se establece su máscara a verdadero mask.ID = true // y se aumenta en 1 el tamaño esperado para el slice de parámetros size++ } if strings.TrimSpace(f.Name) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND name = ?\u0026#34;) mask.Name = true size++ } if strings.TrimSpace(f.Lastname) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND last_name = ?\u0026#34;) mask.Lastname = true size++ } if strings.TrimSpace(f.Search) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND ( name LIKE ? OR last_name LIKE ?)\u0026#34;) mask.Search = true size += 2 } if f.Limit \u0026gt; 0 { b.WriteString(\u0026#34; LIMIT ?\u0026#34;) mask.Limit = true size++ } if f.Offset \u0026gt; 0 { b.WriteString(\u0026#34; OFFSET ?\u0026#34;) mask.Offset = true size++ } // direccionamos el slice de parámetros con la memoria exacta que necesitamos p := make([]any, size) i := 0 // y solo agregamos al slice los elementos del filtro que tengan su respectiva máscara activada if mask.ID { p[i] = f.ID i++ } if mask.Name { p[i] = f.Name i++ } if mask.Lastname { p[i] = f.Lastname i++ } if mask.Search { p[i] = fmt.Sprintf(\u0026#34;%%%s%%\u0026#34;, f.Search) i++ p[i] = fmt.Sprintf(\u0026#34;%%%s%%\u0026#34;, f.Search) i++ } if mask.Limit { p[i] = f.Limit i++ } if mask.Offset { p[i] = f.Offset } return b, p } El respectivo benchmark\nfunc BenchmarkOKMask(b *testing.B) { f := Filter{ Name: \u0026#34;a\u0026#34;, Lastname: \u0026#34;b\u0026#34;, Search: \u0026#34;\u0026#34;, Limit: 10, } b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { _, _ = QueryBuilderOKMask(f) } } El cual al ejecutarse nos arroja los siguientes resultados.\nBenchmarkOKMask-16 10261683 213.8 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12145034 230.7 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 9883455 213.3 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 10661880 212.3 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12725306 211.5 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 9966832 225.5 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 9271009 216.3 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 8934564 236.4 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12176293 249.7 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 11495956 236.9 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 10586841 224.2 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12398922 213.3 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 9481837 247.0 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 10852344 226.4 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12089485 216.7 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 10944657 201.9 ns/op 272 B/op 5 allocs/op !Vemos una mejora en el consumo de memoria y en la velocidad de ejecución!\nConcluyendo, no le crea a nada ni a nadie, compruebelo todo con benchmarks por si mismo en un ambiente lo mas parecido a sus máquinas de producción si le es posible. Detecte los cuellos de botella en su programa y aplique las medidas que su experiencia y conocimiento provean.\nDejamos a su disposición el código provisto en este artículo en este repositorio.\nY con esto despedimos este artículo, no olvide comentar si precisa hacer algún alcance y compartirlo si es que le gustó.\n"},{"href":"https://gophers-latam.github.io/posts/2024/01/desarrollo-con-go-en-neovim/","title":"Desarrollo con Go en Neovim","body":" Go con Neovim En este post vamos a ver cómo configurar desde cero Neovim y específicamente cómo personalizarlo para que nuestro desarrollo con Go sea altamente productivo.\nInstalación Lo primero que debemos de hacer es instalar Neovim.\nSi estamos en Windows, lo podemos hacer de la siguiente manera:\nwinget install Neovim.Neovim o también se puede realizar mediante gestores de paquetes externos como: Chocolatey o Scoop:\n# scoop scoop bucket add main scoop install neovim # chocolatey choco install neovim # (Podes usar `-y` para saltear automaticamente la confirmacion de mensajes). Y si estás en Linux, lo podés hacer de la siguiente manera, dependiendo de tu gestor de paquetes:\n# Arch sudo pacman -S neovim # Debian sudo apt-get install neovim # Fedora sudo dnf install -y neovim python3-neovim Para las demás distribuciones de Linux o para instalarlo de manera local, les dejo la documentación correspondiente.\nTener en cuenta que, dependiendo la distribución que se elija, será diferente la versión. Es decir, si descargamos Neovim en Ubuntu, vendrá con la versión 0.6 mientras que si se descarga en Manjaro, vendrán con la última versión estable (esto por la gestión de paquetes de cada distro).\nEs por esto que es siempre mejor descargar la última versión estable desde el código fuente, ya que nos aseguramos que nuestra versión sea la última y compatible con las últimas novedades de Neovim.\nGestión de carpetas Una vez instalado Neovim, vamos a generar nuestras carpetas.\nEn Linux, haremos lo siguiente en: ~/.config/nvim. Si nuestra carpeta no existe, la creamos.\nEn Windows, sera en: Local Disk (C:)/Users/tu-usuario/AppData/Local/nvim. Si nuestra carpeta no existe, la creamos.\nnvim/ ├── after/ │ └── plugin/ │ ├── tokyonight.lua │ └── telescope.lua ├── lua/ │ └── tu-nombre/ │ ├── init.lua │ ├── packer.lua │ ├── remap.lua │ └── set.lua ├── plugin/ │ └── packer_compiled.lua └── init.lua A continuación se explica para qué sirve cada carpeta.\nafter/plugin: Dentro de esta, creamos los .lua con el nombre del plugin que descarguemos para configurar como queramos nuestros plugins. En el arbol de referencia se ve los archivos tokyonight.lua y telescope.lua que nos sirven como ejemplo (no hace falta crear estos .lua, mas adelante se muestran ejemplos para su comprensión).\nlua/tu-nombre: Aquí, cambiaremos {tu-nombre} por tu nombre, en mi caso thiago, y dentro tendremos los archivos que nos servirán para descargar y setear nuestros atajos y configuraciones de Nvim.\nplugin: Esta carpeta no debemos generarla, contiene un archivo (packer_compiled.lua) que también se genera automáticamente como la carpeta /plugin/. En el archivo, ira toda nuestra configuración de Neovim. Es importante saber que no debemos tocar este archivo. Como información adicional, esta carpeta se generará una vez que ejecutamos el comando :PackerSync más adelante.\ninit.lua: En este archivo, haremos el llamado de la carpeta \u0026ldquo;tu-nombre\u0026rdquo;, para que al iniciar se carguen automáticamente nuestras configuraciones.\nSi bien entraremos en detalle más adelante de cada archivo y configuración, está bueno saber el set up de nuestro editor de texto.\nPacker (Gestor de plugins) Ya con nuestras carpetas generadas, vamos a instalar Packer que será nuestro gestor de plugins para Neovim.\nEs cierto que este repositorio no se mantiene desde Agosto de 2023, y que muchos usuarios de Neovim están migrando a Lazy o Pckr (el sucesor de packer), pero para este post usaremos Packer, ya que sentará las bases de nuestro conocimiento para Neovim y luego podremos realizar otro post sobre la migración a Lazy (esto debido a que quien escribe, actualmente, no migró su gestor a otro 😅).\nPara instalar packer, debemos de hacerlo de la siguiente manera:\nInstalación en Unix, Linux.\ngit clone --depth 1 https://github.com/wbthomason/packer.nvim\\ ~/.local/share/nvim/site/pack/packer/start/packer.nvim Instalación en Windows PowerShell.\ngit clone https://github.com/wbthomason/packer.nvim \u0026#34;$env:LOCALAPPDATA\\nvim-data\\site\\pack\\packer\\start\\packer.nvim\u0026#34; Una vez instalado, iremos al siguiente path: .config/nvim/lua/tu-nombre/ e ingresaremos al archivo packer.lua en donde ingresaremos el siguiente código:\nreturn require(\u0026#39;packer\u0026#39;).startup(function(use) use \u0026#39;wbthomason/packer.nvim\u0026#39; end) Una vez hecho los cambios, haremos el siguiente comando en el modo normal: :so y enter. Y luego de esto haremos: :PackerSync para instalar el nuevo paquete que agregamos (también se generará la carpeta /plugin/ y su respectivo archivo)\nY ya que estamos realizando modificaciones, iremos a nvim/lua/tu-nombre/ y agregaremos los siguientes cambios en:\nnvim/lua/tu-nombre/init.lua require(\u0026#34;tu-nombre.set\u0026#34;) require(\u0026#34;tu-nombre.remap\u0026#34;) y en nuestro init.lua de nvim/init.lua: require(\u0026#34;tu-nombre\u0026#34;) Personalización ya con nuestra configuración básica, vamos a poner bonito nuestro editor de texto, ya que por default viene vacío.\nEn: lua/tu-nombre/set.lua, vamos a setear lo básico de nuestro editor de texto:\nvim.opt.nu = true -- Muestra el número de línea actual. vim.opt.smartindent = true -- Habilita el autoindentado inteligente. vim.opt.cursorline = true -- Resalta la línea en la que se encuentra el cursor. vim.opt.clipboard:append(\u0026#34;unnamedplus\u0026#34;) -- Configura el portapapeles para usar el registro \u0026#34;unnamedplus\u0026#34; (clipboard). vim.opt.termguicolors = true -- Habilita los colores de la terminal si es posible. vim.opt.tabstop = 4 vim.opt.softtabstop = 4 vim.opt.shiftwidth = 4 vim.opt.expandtab = true Y en lua/tu-nombre/remap.lua, vamos a realizar nuestros mapeos.\nPara ejecutar un plugin que instalamos se hace de la siguiente manera: :Plugin-a-Ejecutar\nPero esto es tedioso, por lo que en este archivo .lua, podemos configurarlo para que con ciertas combinaciones se ejecute el plugin que queramos.\nlocal keymap = vim.keymap -- Creamos esta variable para no estar constantemente escribiendo vim.keymap.set({}) local opts = { noremap = true, silent = true } -- Esto se hace para que nuestro atajo sea silencioso y no afecte tu vista. vim.g.mapleader = \u0026#34; \u0026#34; -- Seteamos la tecla espacio como lider. Esto nos servira mas adelante para mapear nuestros atajos. -- Usaremos este mapeo como ejemplo keymap.set(\u0026#34;n\u0026#34;, \u0026#34;\u0026lt;leader\u0026gt;q\u0026#34;, \u0026#34;:q\u0026lt;CR\u0026gt;\u0026#34;) -- Como bien sabemos, para salir de Nvim, se hace con :q. Entonces este mapeo, lo que nos permite es salir de nvim utilizando la combinacion de teclas: \u0026lt;leader\u0026gt; + q. -- \u0026lt;leader\u0026gt; lo seteamos mas arriba (vim.g.mapleader = \u0026#34; \u0026#34;), puede ser cualquier tecla y \u0026lt;CR\u0026gt; es un enter. -- Es lo mismo que hacer :q + enter, nada mas que lo asignamos a un mapeo y ejecutaremos esta funcion de forma facil y rapida. -- Ahora salir de Nvim no sera un problema. Para poder trabajar con temas de colores, lo haremos de la siguiente manera en: nvim/lua/tu-nombre/packer.lua\nreturn require(\u0026#39;packer\u0026#39;).startup(function(use) use \u0026#39;wbthomason/packer.nvim\u0026#39; -- Gestor de paquetes. use \u0026#39;folke/tokyonight.nvim\u0026#39; -- Esquema de colores. use(\u0026#34;nvim-treesitter/nvim-treesitter\u0026#34;, { run = \u0026#34;:TSUpdate\u0026#34; }) -- Nos provee un resaltado de colores en nuestro codigo. use({ \u0026#34;nvim-lualine/lualine.nvim\u0026#34;, -- Barra de estado. requires = { \u0026#34;kyazdani42/nvim-web-devicons\u0026#34;, opt = true }, }) use({ \u0026#34;nvim-tree/nvim-tree.lua\u0026#34;, -- Arbol de archivos. requires = { \u0026#34;nvim-tree/nvim-web-devicons\u0026#34;, }, }) use(\u0026#34;fatih/vim-go\u0026#34;) -- Para el desarrollo con Go. end) Una vez que tengamos los plugins que necesitemos, haremos lo que hicimos en pasos previos\n:so y enter y luego :PackerSync para poder instarlos.\nUna vez instalados, debemos de ir a nvim/after/plugin/ y crear los archivos .lua para cada plugin que descargamos. Por ejemplo.\nnvim/after/plugin/lualine.nvim require(\u0026#39;lualine\u0026#39;).setup({ options = { theme = \u0026#34;auto\u0026#34; } }) nvim/after/plugin/nvim-treesitter.lua require(\u0026#39;nvim-treesitter.configs\u0026#39;).setup({ ensure_installed = {\u0026#34;javascript\u0026#34;, \u0026#34;lua\u0026#34;, \u0026#34;json\u0026#34;, \u0026#34;html\u0026#34;, \u0026#34;css\u0026#34;, \u0026#34;typescript\u0026#34;, \u0026#34;markdown\u0026#34;, \u0026#34;go\u0026#34;, \u0026#34;python\u0026#34;}, sync_install = false, auto_install = true, highlight = {enable = true} }) Para que no se haga muy largo este post, haremos un video en el canal de YouTube de la comunidad para que sea más fácil y visual el uso de Nvim.\nEspero que este posts les sea de utilidad para aprender. Tambien les dejo mi configuración de Nvim en donde explico qué es, porque lo uso y todos los plugins que utilizo en mi día a día.\n"},{"href":"https://gophers-latam.github.io/posts/2023/12/manejo-de-memoria-101.-memoria-virtual-stack-y-heap/","title":"Manejo de memoria 101. Memoria virtual, Stack y Heap","body":" Puzzle. imagen de dominio público gentileza piqsels. https://www.piqsels.com/en/public-domain-photo-smyfi Que Go tiene un recolector de basura integrado lo hemos escuchado muchas veces. Significa que no tenemos que preocuparnos de liberar la memoria que nuestra aplicación usa, pero ¿Deberiamos entender el ciclo de uso de memoria de nuestras aplicaciones? ¿El recolector de basura nos da derecho a olvidar y usar y abusar de ese recurso?\nY, primero que nada ¿Que diablos es la memoria de la que tanto se habla?\nRenuncia de responsabilidades. No es trivial entender la forma en que los computadores trabajan. En aras de poder difundir intentaremos simplificar lo mas posible, en ocasiones, mas alla de lo recomendado. Muchos programadores hemos llegado a Go desde lenguajes de tipado débil, donde hemos tendido a mirar recursos como la memoria como si fueran gratuitos. Nada mas lejos de la verdad, como dice el viejo dicho No hay tal cosa como un almuerzo gratis y si queremos convertirnos en programadores mínimamente competentes debemos tener al menos una idea básica sobre la forma en que se manejan dichos recursos. He ahí la razón de este artículo.\nMemoria virtual Aquellos que ya tengan la escritura de algunos programas a su haber saben que cuando declaramos una variable, lo que estamos haciendo es asignar un identificador a una dirección de memoria en la que guardaremos datos (si nunca ha declarado una variable, hagase un favor y vaya al tour de go).\nMas o menos cuando hablamos de memoria todos pensamos en una grilla homogenea, con direcciones para acceder a cada casilla comodamente.\nPues bien, esa dirección de memoria no salió del aire por generación espontanea, existe físicamente de alguna forma en alguna parte.\nEn realidad, lo que llamamos memoria es una abstracción proporcionada por el sistema operativo, la cual oculta diferentes medios de almacenamiento.\nLos registros del procesador\nLa caché del procesador\nRAM\nArchivos en disco\nEtc.\nEn terminos generales, no sabemos en cual de estos medios de almacenamiento quedará almacenada nuestra variable. Solo sabemos que le hemos pedido memoria al sistema y que este nos la presentó adecuadamente para lograr nuestro objetivo. Claro, en aras de la eficiencia hay una gran probabilidad de que nuestro dato haya quedado guardado en RAM.\nEsta abstracción a la que hicimos referencia, es lo que llamamos memoria virtual, es administrada por el sistema operativo y es un recurso el cual debe ser solicitado.\nMemoria virtual es una abstracción que provee a cada proceso la ilusión de que tiene uso exclusivo sobre la memoria principal. Bryant, R. E. \u0026amp; O’Hallaron, D. R. (2016). Computer System: A Programmer’s Perspective (Third global edition). Pearson Education Limited.\nLa organización en forma de Celdas de memoria que nos es tan familiar es propia de la memoria virtual y como se imagina para que pueda funcionar se necesita una sofisticada interacción entre el sistema operativo y el hardware. Esta interacción se basa en un mapeo, direccionamiento o traslación entre las direcciones de la memoria virtual y el medio físico donde realmente se encuentre nuestro dato.\nCuando se ejecuta un programa, este tiene una visión uniforme de la memoria, la que llamamos Espacio de direcciones virtual, y dentro de este espacio hay dos áreas bien definidas que nos son de vital importancia.\nStack y Heap Stack El Stack es una región de la memoria que es localizada para cada hilo de ejecución de nuestros programas. En el contexto de Go, decimos que cada gorutina tiene su propio Stack. Su objetivo es contener variables locales, argumentos y valores de retorno de funciones, etc.\nCuando se invoca una función, se agrega una nueva capa en el Stack y cuando la función termina, esa capa se quita a su vez del Stack.\nLlamamos Localización/Allocation al proceso de reservar memoria para almacenar nuestros datos, y Deslocalización/Deallocation al proceso de liberarla una vez que ya no la necesitamos. El Stack tiene la ventaja de que permite acceder rápidamente a la memoria, ¡claro! porque los datos más recientes están siempre en la capa superior. Además, como cuando una función termina su ejecución, su capa asociada en el Stack se quita, ¡La memoria utilizada para los datos en esa capa se ve automáticamente deslocalizada!\nEl Stack empieza con espacio pre-localizado de un tamaño fijo, si el runtime detecta que se está quedando sin espacio, localiza más y como la memoría está localizada de antemano, guardar datos en el Stack es barato y automático.\nPara que una variable sea asignada en el Stack, deben cumplirse una serie de requisitos:\nTamaño fijo, conocido en tiempo de compilación\nEl runtime de Go debe ser capaz de determinar completamente su ciclo de vida\nSu tamaño no debe superar la capacidad máxima del Stack (mas las salvaguardas del runtime)\nEl Stack es rápido, localizar y dealocalizar en el es barato. Si estas y otras condiciones no son cumplidas, la variable escapará al Heap.\nHeap El Heap es el área del espacio de direcciones virtual que el runtime de Go solicita para almacenar los datos al ejecutar nuestro programa. El Heap crece dinámicamente y su objetivo es contener los datos que necesitamos persistan mas allá del tiempo de vida de una función o que son muy grandes para ser alojados en el stack.\nEl que nuestros datos escapen al Heap es costoso porque implica una localización, lo que significa que:\n1 Se verifica que el Heap tenga suficiente capacidad para el valor que almacenaremos en el.\n2 Si el punto 1 no se cumple, se debe solicitar más memoria al sistema operativo para el Heap. Se produce una System Call solicitando el recurso. En el mundo real este paso se realiza independientemente. El runtime monitorea constantemente el Heap y algunos algoritmos implementan un una meta, un límite de memoria, que una vez alcanzado o sobrepasado produce la solicitud de mas recursos al sistema operatvo.\n3 Se localiza la memoria en el Heap (por simplicidad incluyamos en este apartado la escritura de los datos que guardaremos).\n4 Se almacena en el Stack un puntero a la dirección de memoria inicial de la localización en el Heap.\nEl Heap es flexible, pero la flexibilidad viene con un costo ¡Todo esto es bastante trabajo para guardar un monton de datos! ¡Sea parsimonioso! Si, porque localizar en el Heap, si bien proporciona muchas ventajas, tiene un costo. Es por eso que en el ecosistema de Go usted encontrará librerías que se jactan de tener cero localizaciones, es decir, estan escritas tan cuidadosamente que no guardan datos en el Heap, sólo usan el Stack.\nEscapando al Heap Revisemos el siguiente código\nmain.go\npackage main func retString() string { retVal := \u0026#34;achu\u0026#34; return retVal } Hemos definido una función que devuelve un string. Construyamos un benchmark para que la podamos analizar.\nmain_test.go\npackage main import ( \u0026#34;testing\u0026#34; ) func Benchmark_retString(b *testing.B) { var a string b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { a = retString() } b.StopTimer() b.Log(a) b.StartTimer() } Al ejecutar el benchmark veremos algo parecido al siguiente reporte\n$ go test -bench . -benchmem goos: linux goarch: amd64 pkg: exmem cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz Benchmark_retString-16 1000000000 0.3356 ns/op 0 B/op 0 allocs/op Donde el benchmark nos informa con 0 allocs/op que han ocurrido 0 localizaciones al heap.\nReunamos más información. Agreguemos al comando el flag -gcflags \u0026quot;-m -m\u0026quot; que hará que el compilador realice un análisis de escape, el cual nos informará de movimientos de datos al heap.\n$ go test -gcflags \u0026#34;-m\u0026#34; -bench . -benchmem # exmem [exmem.test] ./main.go:3:6: can inline retString ./main_test.go:13:16: inlining call to retString ./main_test.go:7:26: leaking param: b ./main_test.go:17:7: ... argument does not escape ./main_test.go:17:8: a escapes to heap # exmem.test _testmain.go:37:6: can inline init.0 _testmain.go:45:24: inlining call to testing.MainStart _testmain.go:45:42: testdeps.TestDeps{} escapes to heap _testmain.go:45:24: \u0026amp;testing.M{...} escapes to heap goos: linux goarch: amd64 pkg: exmem cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz Benchmark_retString-16 1000000000 0.3356 ns/op 0 B/op 0 allocs/op Continua reportandonos 0 localizaciones, pero ha agregado información interesante. Observe la siguiente línea en el reporte:\n./main_test.go:17:8: a escapes to heap Nos indica que la variable a escapa al Heap ¡Y nos dice el lugar exacto donde este escape ocurre!\nLa línea 17 de nuestro archivo de benchmark, precisamente donde pasamos la variable al logger.\nEsto demuestra que el escape no es producto de nuestro código pues el log de la variable está ahí solo como medio informativo y no es parte del mismo.\nConstruyamos otra función, esta vez una que devuelva un puntero a una variable local.\nfunc rePointerToString() *string { retVal := \u0026#34;achu\u0026#34; return \u0026amp;retVal } Y agreguemos el benchmark correspondiente.\nfunc Benchmark_retPointerToString(b *testing.B) { var a *string b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { a = rePointerToString() } b.StopTimer() b.Log(a) b.StartTimer() } Al ejecutar el benchmark veremos un reporte parecido a lo que sigue:\ngoos: linux goarch: amd64 pkg: exmem cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz Benchmark_retPointerToString Benchmark_retPointerToString-16 50917658\t24.86 ns/op\t16 B/op\t1 allocs/op PASS ok exmem\t1.292s ¡Una localización que reserva 16 bytes! Agreguemos un nivel más al análisis con -gcflags \u0026quot;-m\u0026quot;\n./main.go:3:6: can inline retString ./main.go:8:6: can inline rePointerToString ./main_test.go:13:16: inlining call to retString ./main_test.go:27:24: inlining call to rePointerToString ./main.go:9:2: moved to heap: retVal ./main_test.go:7:26: leaking param: b ./main_test.go:17:7: ... argument does not escape ./main_test.go:17:8: a escapes to heap ./main_test.go:21:35: leaking param: b ./main_test.go:27:24: moved to heap: retVal ./main_test.go:31:7: ... argument does not escape # exmem.test _testmain.go:39:6: can inline init.0 _testmain.go:47:24: inlining call to testing.MainStart _testmain.go:47:42: testdeps.TestDeps{} escapes to heap _testmain.go:47:24: \u0026amp;testing.M{...} escapes to heap goos: linux goarch: amd64 pkg: exmem cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz Benchmark_retPointerToString Benchmark_retPointerToString-16 49800909 25.77 ns/op 16 B/op 1 allocs/op Otra vez podemos ver varias cosas interesantes:\n./main.go:9:2: moved to heap: retVal ... ./main_test.go:17:8: a escapes to heap ... ./main_test.go:27:24: moved to heap: retVal ... En el archivo main.go, donde definimos la función rePointerToString el análisis de escape nos informa que en la línea 9, donde definimos a la variable retVal como un string, el compilador ha movido la variable al Heap ¡Cuando aún no hemos devuelto su puntero! ¡Lo hacemos recien en la línea 10! ¡Claro! el compilador ha detectado que devolveremos un puntero al valor string almacenado en la variable local, por lo que ha determinado almacenar a la variable en el Heap directamente ¡Aun antes de que se produzca el retorno del puntero!\nHablar sobre memoria y otros temas relacionados con arquitectura de computadores es apasionante, pero es para nunca terminar.\nRecapitulando, hemos dado un recorrido introductorio a vuelo de pajaro sobre la memoria revisando al Stack y al Heap, con algunos ejemplos en código. Conocimos al flag -gcflags \u0026quot;-m\u0026quot; para agregar análisis de escape a nuestros tests y benchmarks.\nSi le gustó este artículo no olvide compartirlo.\n"},{"href":"https://gophers-latam.github.io/posts/2023/12/fuga-de-gorutinas/","title":"Fuga de gorutinas","body":" Fugas. imagen de dominio público gentileza pxfuel. https://www.pxfuel.com/en/free-photo-ojgpw Sabemos que las gorutinas son una de las mas importantes primitivas que Go pone a nuestra disposición para el manejo de concurrencia. Por eso se hace necesaria una forma de prevenir fugas de gorutinas.\nSi aun no empieza a estudiar concurrencia en Go ¡Le sugerimos ver este video de la comunidad antes de leer este artículo! Una fuga o leak de gorutinas es cuando nuestra aplicación crea gorutinas sin tener el cuidado de terminarlas correctamente.\nObservemos el siguiente ejemplo. Seguramente reconocerá el problema, en este caso estamos enviando información por un canal y no tenemos a nadie que consuma dicho canal.\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;math/rand\u0026#34; \u0026#34;runtime\u0026#34; \u0026#34;time\u0026#34; ) func send() int { n := rand.Intn(1000) time.Sleep(200 * time.Millisecond) return n } func submit() int { ch := make(chan int) go func() { ch \u0026lt;- send() }() go func() { ch \u0026lt;- send() }() go func() { ch \u0026lt;- send() }() go func() { ch \u0026lt;- send() }() return \u0026lt;-ch } func submitAll() { for i := 0; i \u0026lt; 5; i++ { submit() } } func main() { submitAll() fmt.Printf(\u0026#34;número de gorutinas: %d\\n\u0026#34;, runtime.NumGoroutine()) } Si ejecutamos este programa veremos lo siguiente:\n$ go run main.go número de gorutinas: 16 Imprime número de gorutinas: 16 ¿Por que razón? Porque el contenido del loop se itera 4 veces y en cada iteración engendra 4 gorutinas en la función submit. Ingenuamente podriamos estar esperando que al salir del ámbito de la función submit las gorutinas se hubiesen cerrado ¡Pero no es así! ¡Siguen corriendo al final de su proceso como lo demuestra la impresión!\nUna fuga o leak de gorutinas es cuando nuestra aplicación crea gorutinas sin tener el cuidado de terminarlas correctamente. Ahora bien, si nuestra aplicación terminara en este punto, no habría problema alguno, pues al acabar su ejecución ya es responsabilidad del sistema operativo realizar las labores de limpieza. Pero muchas veces usamos Go para construir aplicaciones que se ejecutan continuamente sin parar y que se espera que no se detengan, como servicios, apis, etc. En este tipo de aplicaciones, un escenario como el presentado en el ejemplo es insostenible.\nGo reserva una cantidad de memoria específica inicial para que las gorutinas usen como su stack, si bien esta cantidad puede variar de versión en versión, la cantidad actual se puede revisar en el repositorio de GO\nEste stack puede ir creciendo según el proceso que se ejecute dentro de la gorutina.\nEl problema Entonces, ¿Que pasará si nuestra aplicación sufre de fuga de gorutinas y engendra 100000 de ellas durante un periódo de un año sin terminarlas correctamente?\nPues asumiendo optimistamente que el proceso que se ejecuta dentro de nuestras gorutinas fugadas devuelven correctamente la memoria, y que el stack asignado a cada una de ellas sigue teniendo un tamaño de 2kB, tendriamos para ese momento cerca de 200MB de memoria usada por la aplicación que no podrán ser recuperados por el recolector de basura ¡Porque las gorutinas todavía están ejecutandose! ¡Porque nunca nos aseguramos de terminarlas correctamente!\nSi no cuidamos de terminar correctamente las gorutinas que nuestra aplicación engendra, corremos el riesgo de enfrentar Out Of Memory Errors Si ejecutamos nuestra aplicación en algún tipo de contenedor o máquina virtual con un límite duro de memoría, esto puede llegar a ocasionar out of memory errors\n¿Que podemos hacer?\nPreviniendo fugas de gorutinas Inevitablemente debemos aprender y convertirnos en expertos en el modelo de memoria de Go y en su modelo de concurrencia. Esto es de vital importancia, pues de la misma forma que un carpintero es responsable de usar de forma segura su sierra circular, taladro y otros implementos, nosotros como programadores somos responsables de usar correctamente las herramientas de nuestro oficio.\nEn esto cae la construcción de tests y benchmarks y el uso profilactico de herramientas de perfilado como pprof asegurandonos de que las pruebas se realicen por un periodo de tiempo conveniente, pues no es lo mismo perfilar un servicio el mismo día en que lo lanzamos a correr, que dos meses después.\nOtra herramienta muy útil es goleak del equipo de Uber Go, que presenta una forma muy simple de testear que nuestras gorutinas se cierren correctamente.\nSe usa de la siguiente forma:\n1 Debemos importarla a nuestro proyecto $ go get -u go.uber.org/goleak\n2 Debemos construir un test que incluya el flujo completo de nuestras gorutinas. Usaremos el mismo ejemplo anterior\nImportamos la utilidad y nos aseguramos de invocarla usando defer para que se garantice su ejecución al final de nuestro proceso.\npackage main import ( \u0026#34;testing\u0026#34; \u0026#34;go.uber.org/goleak\u0026#34; ) func TestGorutineLeak(t *testing.T) { defer goleak.VerifyNone(t) for i := 0; i \u0026lt; 4; i++ { submitAll() } } ¡Y listo! Al ejecutar el test, si goleak detecta fugas de gorutinas, el test fallará\n$ go test ./... === RUN TestGorutineLeak /home/jacobopus/projects/go/goru/main_test.go:15: found unexpected goroutines: [Goroutine 7 in state chan send, with goru.submit.func1 on top of the stack: goru.submit.func1() /home/jacobopus/projects/go/goru/main.go:19 +0x30 created by goru.submit in goroutine 6 /home/jacobopus/projects/go/goru/main.go:19 +0x66 ] --- FAIL: TestGorutineLeak (4.46s) FAIL Puede revisar la documentación de goleak para descubrir otras formas de uso.\nNo olvide compartir este articulo si fue de su agrado.\n"},{"href":"https://gophers-latam.github.io/posts/2023/10/el-tour-de-go-ahora-en-espa%C3%B1ol/","title":"El tour de Go ahora en Español","body":" Tour de Go en Español ¡Logramos algo increíble como comunidad! La traducción del tour de Go al español. Estamos emocionados de compartir con todos ustedes el increíble logro que hemos alcanzado juntos: la completa traducción del tour de Go al español.\nEste proyecto fue un esfuerzo colaborativo en el que nuestra comunidad contribuyó con su tiempo y conocimiento para hacer que esta herramienta esté disponible para toda la comunidad hispanohablante. ¡El resultado es asombroso!\n¿Qué es El Tour de Go? 👩‍💻👨‍💻 Para aquellos que aún no lo conocen, el \u0026ldquo;Tour de Go\u0026rdquo; es una excelente introducción al lenguaje de programación Go. Proporciona ejemplos interactivos y explicaciones detalladas, lo que lo convierte en una herramienta invaluable para aprender Go.\nEl poder de la colaboración 👥 La clave de este logro fue la colaboración. Cada uno de nosotros aportó con sus habilidades y conocimientos para llevar a cabo esta traducción. Desde los que realizaron las primeras traducciones hasta aquellos que revisaron y pulieron cada detalle, cada uno de ustedes fue fundamental.\n¿Qué significa esto para la comunidad? 💡 La traducción del tour al español no solo significa que más personas tendrán acceso a esta valiosa herramienta, sino que también fortalece nuestra comunidad y nos posiciona como un grupo que puede lograr grandes cosas cuando trabajamos juntos.\n¿Qué sigue? 🛠️ Nuestro trabajo no termina aquí. Continuaremos buscando maneras de contribuir y crecer como comunidad. Si tienes ideas o proyectos en mente, ¡no dudes en compartirlas!\nUna vez más, felicitaciones a todos los que participaron en este proyecto. ¡Han demostrado el increíble poder de la comunidad de Gophers Latam!\n¡Sigamos construyendo juntos! 🚀 Tour de Go Link del repositorio: https://github.com/gophers-latam/go-tour-es\nLink profesional sobre la comunidad: https://es.linkedin.com/posts/thiago-mowszet_github-gophers-latamgo-tour-es-traducci%C3%B3n-activity-7118450478593536000-JlrR\n"},{"href":"https://gophers-latam.github.io/posts/2023/03/handlers-con-timeout/","title":"Handlers Con Timeout","body":" go handlers En algunas oportunidades, vamos a necesitar un comportamiento muy determinístico en nuestras APIs, ya sea porque el negocio así lo requiere o los clientes. Tal vez, un comportamiento que se mantenga alejado de cualquier sorpresa, puede ser el máximo de duración que le queremos dejar como ventana para que un respuesta sea entregada, en caso de excederlo, ahora si como el título lo dice, devolvemos un timeout\u0026hellip; pero, qué es un timeout?\nEn principio sabemos que contamos con 2 estados para representarlo, pero no se parecen mucho ya que están en centenas distintas, unos es 408 request timeout y el otro es 504 Gateway timeout. Si leemos un poco las especificaciones, ninguno de los dos nos calza justo para lo que queremos, el 408 nos dice que el cliente \u0026ldquo;se tardó demasiado para enviar su request\u0026rdquo;, desde la RFC dice lo siguiente:\nThe client did not produce a request within the time that the server was prepared to wait. The client MAY repeat the request without modifications at any later time.\nY para su contraparte del lado del servidor:\nThe server was acting as a gateway or proxy and did not receive a timely response from the upstream server.\nEntonces, para la responder la pregunta, concluimos que un timeout es que esperamos demasiado por algo, y no sucedió, ademas, lo consideramos un error.\nCómo hacemos nuestras funciones de Timeout? En los lenguajes de programación modernos, encontramos built-in algunas formas de manejar estos casos de uso. En Golang, por ejemplo el paquete context tiene constructores para crear uno que expire y se cancele después de cierto tiempo.\nDentro del paquete net/http también nos encontramos con muchos timeouts como por ejemplo en la struct http.Client para hacer requests y http.Server es otra que tampoco se queda afuera de tener este tipo de configuración.\nPor ahora, tenemos: context, http.Client y Server, servidores TCP y UDP, etc. Podemos resumir que siempre que haya una conexión hacia fuera (ya sea cliente o servidor) vamos a poder configurar un timeout.\nCómo nos sirven en los web handlers? Antes, debemos aclarar que es un middleware, en cualquier lenguaje, ya que es un concepto y no una implementación específica de Golang.\nEntonces, decimos que son funciones con la misma firma que un handler (o controlador web), que recibe los mismos parámetros para operar como una petición HTTP. Al ser iguales, nos permite ejecutarlo previamente de una forma sencilla y pre-ejecutar operaciones que nos ayuden a nuestro negocio. Un claro ejemplo son validaciones de token JWT, agregar request ID unicos, sumarle datos al contexto (esto si es mas estilo gopher). En nuestro caso, vamos a tener un middleware que se encargue de reemplazar el contexto, por otro que tenga un timeout, para que no tarde mas de tanto tiempo y si no, falla. Nos va a ayudar a garantizar un tiempo de respuesta de máxima, por las buenas o por las malas.\nLo llevamos a código Como middleware, podemos usar uno que ya existe y está dentro del paquete http, es http.Timeout y dentro de su firma, vamos a pasarle un http.Handler, el tiempo de espera que vamos a soportar y por último (este no me gusta mucho) un mensaje como string, donde nos quita un poco de flexibilidad, a mi entender, []byte nos daría un espectro mas amplio a la hora de retornar los valores.\nPodemos implementarlo como un wrapper general a todo el multiplexer y que todos ejecuten el middleware, este tiene como ventaja que escribimos una sola vez, pero perdemos granularidad. func main() { mux := http.NewServeMux() mux.HandleFunc(\u0026#34;/\u0026#34;, func(w http.ResponseWriter, r *http.Request) { //.... }) muxWithMiddleware := http.TimeoutHandler(mux, time.Second*5, \u0026#34;timeout!\u0026#34;) log.Fatal(http.ListenAndServe(\u0026#34;:8080\u0026#34;, muxWithMiddleware)) } Por último, tenemos otro camino, para tener un control espercífico en cada handler que expongamos. func main() { mux := http.NewServeMux() helloHandler := http.TimeoutHandler(wrapHandlerFunc(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte(\u0026#34;hello with timeout!\u0026#34;)) })), time.Second*5, \u0026#34;timeout\u0026#34;) mux.Handle(\u0026#34;/\u0026#34;, helloHandler) } func wrapHandlerFunc(handler http.Handler) http.Handler { wrapped := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set(\u0026#34;Content-Type\u0026#34;, \u0026#34;application/json\u0026#34;) handler.ServeHTTP(w, r) }) return wrapped } Conclusiones Vemos la flexibilidad que tenemos para exponer funciones en un servior web que tenemos en Golang. Siempre nos da muchas facilidades y opciones, a su vez, puede ser un poco confuso porque no sabemos bien cual usar. Como pequeño consejo, no nos fritemos la cabeza pensando y comparando, tan solo elijamos una con un análisis superficial y despues nos queda el aprendizaje.\nPara cerrar el tema técnico, estamos re-utilizando una funcion de la stdlib de Go, por lo que no es necesario que nostros pensemos esa lógica, también, muchos de los Frameworks web como Echo, Gin y Fiber (seguramente entre varios otros) ya traen sus middleware de timeout y es de una implementacion muy similar a la que acabamos de ver.\nEspero que les haya gustado la explicación! nos vemos dentro de poco y cualquier tema que quieran que tratemos lo pueden dejar en comentarios.\n"},{"href":"https://gophers-latam.github.io/posts/2022/08/intro-go-mistakes-okno/","title":"Intro Go Mistakes Okno","body":" okno Se comparte el concepto o contexto de algunos errores basicos con su definición acompañado de ejemplo y solución.\nIndice: Código y organización del proyecto Código y organización del proyecto - Sombreado de variable (shadowing) no deseado La parte de una aplicación donde un enlace de nombre es válido. En Go, un nombre de variable declarado en un bloque se puede volver a declarar en un bloque interno. Este principio, llamado sombreado de variable, es propenso a errores.\nEjemplo:\nvar client *http.Client if tracing { client, err := createClientWithTracing() if err != nil { return err } log.Println(client) } else { client, err := createDefaultClient() if err != nil { return err } log.Println(client) } 1 Declarar una variable client 2 Crear un cliente HTTP con tracing habilitado, la variable client está sombreada en este bloque 3 Crear un cliente HTTP predeterminado, la variable client también se sombrea en este bloque Como resultado, de este ejemplo, la variable externa siempre será nula.\nSolución:\nLa primera opción es usar variables temporales en los bloques internos:\nvar client *http.Client if tracing { c, err := createClientWithTracing() if err != nil { return err } client = c } else { // Same logic } 1 Crear una variable temporal c 2 Asignar esta variable temporal a client Otra opción es usar el operador de asignación (=) en los bloques internos para asignar directamente los resultados de la función a la variable. Sin embargo, requiere crear una variable de error ya que el operador de asignación solo funciona si ya se ha declarado un nombre de variable:\nvar client *http.Client var err error if tracing { client, err = createClientWithTracing() if err != nil { return err } } else { // Same logic } 1 Declarar una variable de error 2 Usar operador de asignación para asignar el *http.Client devuelto a la variable client directamente - Código anidado innecesario Un aspecto crítico de la legibilidad es el número de niveles anidados. Un código se califica como legible en función de múltiples criterios, como el nombrado, la consistencia, el formato, etc. Un código legible requerirá menos esfuerzo cognitivo para mantener un modelo mental; por lo tanto, será más fácil de leer y mantener.\nEjemplo:\nTiempo o dificultad para entender la siguiente función a detalle.\nfunc join(s1, s2 string, max int) (string, error) { if s1 == \u0026#34;\u0026#34; { return \u0026#34;\u0026#34;, errors.New(\u0026#34;s1 is empty\u0026#34;) } else { if s2 == \u0026#34;\u0026#34; { return \u0026#34;\u0026#34;, errors.New(\u0026#34;s2 is empty\u0026#34;) } else { concat, err := concatenate(s1, s2) if err != nil { return \u0026#34;\u0026#34;, err } else { if len(concat) \u0026gt; max { return concat[:max], nil } else { return concat, nil } } } } } func concatenate(s1 string, s2 string) (string, error) { // ... } Solución:\nHacer la tarea de aplicar legibilidad y consistencia sobre la misma función, implementandola de manera diferente:\nfunc join(s1, s2 string, max int) (string, error) { if s1 == \u0026#34;\u0026#34; { return \u0026#34;\u0026#34;, errors.New(\u0026#34;s1 is empty\u0026#34;) } if s2 == \u0026#34;\u0026#34; { return \u0026#34;\u0026#34;, errors.New(\u0026#34;s2 is empty\u0026#34;) } concat, err := concatenate(s1, s2) if err != nil { return \u0026#34;\u0026#34;, err } if len(concat) \u0026gt; max { return concat[:max], nil } return concat, nil } func concatenate(s1 string, s2 string) (string, error) { // ... } El resultado para requerir menos carga cognitiva. - Mal uso de las funciones init En principio init es una función que no toma argumentos y no devuelve ningún resultado (una función func()). Cuando se inicializa un paquete, se evalúan todas las declaraciones de constantes y variables del paquete. El principal problema reside cuando se ha creado un flujo de uso que se vuelve dificil de entender o seguir y por falta de entendimiento se provocan errores no manejados que se volveran dificiles de mitigar o controlar.\nEjemplo:\nOlvidar o no haber entendido el sentido o punto de entrada para ejecuion de init.\npackage main import \u0026#34;fmt\u0026#34; var a = func() int { fmt.Println(\u0026#34;var\u0026#34;) return 0 }() func init() { fmt.Println(\u0026#34;init\u0026#34;) } func main() { fmt.Println(\u0026#34;main\u0026#34;) } Salida\n1: var 2: init 3: main Ejemplo de flujo usando Redis en base de codigo personal.\nSolución:\nHay criterios en sentido idiomatico como:\nEvitar incluir funciones init en codigo que sera probado con paquete de testing.\nNo hacer que sean de ambito global a menos que sea realmente requerido.\nEvitar usar para conexiones a base de datos.\nInvestigar situaciones en las que pueden ser útiles, como definir una configuración estática. De lo contrario, y en la mayoría de los casos, manejar las inicializaciones a través de funciones personalizadas.\nEbook recomendado: 100 Go Mistakes Que trata a fondo algunos errores sobre: Tipos de datos, Estructuras de control, Strings en detalle, Funciones y métodos, Manejo de errores, Concurrencia: Fundamentos y Práctica, Librería estándar, Pruebas y Optimizaciones\n"},{"href":"https://gophers-latam.github.io/posts/2021/12/ecosistema-lenguage-go/","title":"Ecosistema lenguage Go","body":" json to go Go, también conocido como Golang, es un lenguaje de programación de tipado estático desarrollado por Robert Griesemer, Rob Pike y Ken Thompson en Google.\nGo es sintácticamente similar a C, pero viene con seguridad de memoria, recolección de basura, tipificación estructural y sincronización al estilo CSP.\nHay dos implementaciones principales:\nEl paquete de alojamiento de Google que se dirige a múltiples sistemas operativos, dispositivos móviles y WebAssembly.\ngccgo (un front) y GCC\nGo es expresivo, conciso, limpio y eficiente. Los mecanismos simultáneos facilitan la escritura de aplicaciones que aprovechan al máximo las máquinas en red de varios núcleos, mientras que el sistema más nuevo permite crear aplicaciones modulares y flexibles. Compila código máquina con bastante rapidez, pero tiene la conveniencia de la recolección de basura y el poder de reflejar el tiempo de ejecución. - Un lenguaje rápido, bien tipado y bien proporcionado que actúa como un lenguaje interpretado dinámico.\nNada hace que un programador se emocione más que descubrir un nuevo lenguaje de programación. Al examinar el estado actual del software y hardware informático, podemos ver por qué tenemos que cambiar a un nuevo lenguaje como Go. Durante la última década, la potencia de procesamiento en bruto ha aumentado ligeramente y el rendimiento de la frecuencia de la CPU se ha mantenido casi constante durante una década.\nGo, se libero cuando los procesadores de varios núcleos ya estaban disponibles. Es por eso que Go se hizo pensando en la coordinación. Sus mecanismos síncronos facilitan la escritura de aplicaciones que utilizan más sistemas multinúcleo y en red. Si bien el nuevo tipo de sistema Go hace posible construir aplicaciones modulares flexibles, en lugar de centrarse en teorías, en métodos del mundo real para construir aplicaciones de próxima generación en la nube, así como computación avanzada y computación distribuidas.\nHistórico Go es un lenguaje de programación procedimental que se lanzó en 2009 como lenguaje de programación de código abierto. Actualmente se utiliza en varios sistemas operativos de Google. El Go Compiler es compatible con Linux, Mac OS, Windows y una variedad de sistemas operativos BSD como FreeBSD. En términos de arquitectura de procesador, la arquitectura X86, la arquitectura X64, la arquitectura ARM y la arquitectura Power específica de IBM también son compatibles con Go.\nArquitectura Lingüística Go tiene muchas herramientas poderosas de análisis estático. Uno de ellos es go fmt, que diseña su código basándose en el estilo Go propuesto. Esto puede eliminar muchos comentarios en un proyecto normal y alentar a su equipo a concentrarse en el código. Lenguaje de programación desarrollado y compilado de forma nativa, que pertenece principalmente a la familia de lenguajes C en términos de sintaxis básica.\nComo C y C++, está compilado en código de máquina, por lo que no necesitamos entornos como CLR y JVM para ejecutar programas Go. Esto ayuda especialmente al compilar programas grandes. Lenguaje simple y minimalista con diseño original de Go para en lugar del clásico Thread a goroutines. En Go, el límite de tamaño de pila mínimo se elimina de 4 KB a 8 KB cuando se crea una goroutine.\nDiseño Go está influenciado por C, pero con un mayor énfasis en la simplicidad y la seguridad. Esto incluye:\nPatrones de adopción de sintaxis y entorno que son más comunes en lenguajes dinámicos: Declaración de variable corta opcional e introducción inicial por inferencia de tipo.\nEdición rápida.\nAdministración de paquetes remotos (go download) y documentación de paquetes en línea.\nEnfoques distintivos para problemas específicos.\nSincronización inicial: procesos de estilo (Gurvin), canales y expresiones selectivas.\nUn sistema de interfaz en lugar de herencia virtual e incrustación de tipo en lugar de la herencia no virtual.\nUn kit de herramientas que, de forma predeterminada, crea binarios de interfaz nativa sin dependencias externas.\nLa tendencia a preservar las propiedades del lenguaje es lo suficientemente simple como para mantener en calam la cabeza de un programador, en parte eliminando características que son comunes a lenguajes similares.\nGo es Back o Front? El código Go se puede ejecutar usando goper.js en el navegador. Pero el hecho es que la mayoría de los desarrolladores recurren a los lenguajes de programación Front y JavaScript para desarrollar su lado del cliente. Go es más preferido como lenguaje de respaldo y ofrece un alto rendimiento para el desarrollo simultáneo de aplicaciones de servidor.\nAlgunas aplicaciones populares desarrolladas en Go Algunos de los proyectos de código abierto en Go son:\nCaddy: servidor web HTTP 2 de código abierto con capacidad HTTPS automática\nCockroachDB: una base de datos SQL de código abierto, escalable y compatible\nDocker: incluye un conjunto de herramientas de implementación de Linux.\nEthereum: implementación de Go-Ethereum, máquina de bloqueo de máquina virtual, Ethereum virtual para criptomoneda Ether\nHugo: un generador de sitios estáticos\nInfluxDB: base de datos de código abierto para series de datos de alto acceso con requisitos de alto rendimiento\nInterPlanetary File System: un contenido y un protocolo de direccionamiento de medios punto a punto.\nJuju: una herramienta de evaluación de servicios de Canonical, paquetes de Ubuntu Linux.\nKubernetes: sistema de gestión de contenedores\nLightning Network: una red de bitcoins para transacciones rápidas de bitcoins.\nMattermost: un sistema de chat en equipo.\nOpenShift: una plataforma de computación en la nube proporcionada por Red Hat como servicio.\nSnappy: un administrador de paquetes para Ubuntu Touch desarrollado por Canonical.\nSyncthing: software de sincronización de archivos cliente/servidor de código abierto.\nTerraform: una herramienta de código abierto para la infraestructura multimedia en la nube proporcionada por HashiCorp.\nEmpresas y sitios notables que han utilizado GO (generalmente junto con otros lenguajes, no exclusivamente) Cacoo: para renderizar paneles de usuario y microservicios usando Go y gRPC.\nChango: una empresa de publicidad que utiliza sistemas de precios en tiempo real.\nCloud Foundry: una plataforma como servicio.\nCloudFlare: se utiliza para el proxy de codificación Delta Railgun, su servicio de DNS distribuido, así como herramientas para encriptación, registro, procesamiento de flujo y acceso a sitios SPDY.\nCoreOS: un sistema operativo basado en Linux que utiliza el repositorio Docker y el repositorio rkt.\nDropbox: que ha migrado algunos de sus componentes vitales de Python a Go.\nEthereum: una moneda digital\nGoogle: se utiliza para muchos proyectos, incluido el servidor de descargas (dl.google.com).\nHyperledger Fabric: un proyecto de código abierto único.\nMongoDB: una herramienta para administrar instancias de MongoDB\nNetflix: se utiliza para dos partes de la arquitectura de su servidor.\nNovartis: para sistema de inventario interno\nNutanix: se utiliza para una variedad de microservicios en su empresa Cloud OS.\nPlug.dj: un sitio web interactivo relacionado con la transmisión de música social en línea.\nSendGrid: un boulder, servicio de entrega de correo electrónico y servicio de gestión de transacciones.\nSoundCloud: se utiliza para \u0026ldquo;docenas de sistemas\u0026rdquo;.\nEmpalme: se utiliza para todo el backend (API y analizadores) en su plataforma de colaboración musical en línea.\nThoughtWorks: Algunas herramientas y aplicaciones para entrega continua y mensajería instantánea (CoyIM).\nTwitch.tv: para el sistema de chat basado en IRC (migración desde Python).\nUber: para manejar grandes volúmenes de consultas basadas en geovallas\nGo Features Go compila código como lenguajes de bajo nivel como C++/C. Esto significa que funciona casi tan bien como lenguajes de bajo nivel. También utiliza la recolección de basura para recolectar y eliminar objetos.\nEl gráfico siguente muestra que Go es casi tan eficiente como C++/C, mientras mantiene la sintaxis simple como Ruby, Python y otros lenguajes. Esta es una situación en la que todos ganan para los humanos y los procesadores! El alto rendimiento como C++/C y Java proporciona una sincronización altamente eficiente para codificar en términos divertidos como Python y Perl. El software optimizado puede ejecutarse en hardware más barato y lento, como los dispositivos IoT, y generalmente tiene un mayor impacto en la experiencia del usuario final. El modelo de memoria Go agrega una nueva regla para enviar y recibir canales de búfer para indicar explícitamente que un canal de búfer puede usarse como un simple spammer.\nDescripción general de las características principales del lenguaje:\nCompilación: Go genera compilaciones binarias para sus aplicaciones con todas las dependencias. No se requiere instalación de traductor o runtime.\nRecolección de basura: Para recolectar desperdicios de baja latencia, opta por una administración automática de memoria que sea eficiente y sincrónica. La gestión de la memoria es intencionadamente más fácil que C y C++. Los objetos dedicados recolectan basura de forma dinámica.\nSeguro: Go es un lenguaje de tipado estático que admite la seguridad de tipos. El compilador detecta los errores antes de la ejecución.\nSintaxis similar a C: La sintaxis Go recuerda a la familia C, pero con solo 25 palabras clave simples, es fácil de analizar sin tablas/símbolos de información de tipo y un diseño de notificación similar a Pascal.\nVarios paradigmas: Go admite varios patrones de programación, incluida la programación esencial, orientada a objetos (OOP) y la programación funcional.\nLibrería estándar: Go tiene una potente librería estándar de paquetes para respaldar el desarrollo de aplicaciones Go.\nDocumentación sencilla: GoDoc es una herramienta de análisis de código estático que genera documentos estándar simplificados directamente desde el código.\nSoporte de pruebas naturalmente: Soporte de prueba integrado en la librería estándar. Sin necesidad de dependencia adicional Si tiene un archivo llamado thing.go, escriba sus pruebas en otro archivo llamado thing_test.go y ejecute \u0026ldquo;go test\u0026rdquo;.\nGo Tools La distribución principal de Go incluye herramientas para crear, probar y analizar código:\ngo build: crea un binario usando solo sus archivos fuente.\ngo test: se utiliza para pruebas unitarias y microbenchmarks.\ngo fmt: se utiliza para formatear el código.\ngo get: se utiliza para recuperar e instalar paquetes remotos.\ngo vet: un analizador estático que busca posibles vulnerabilidades o errores en el código.\ngo run: un atajo para construir y ejecutar código directamente.\ngo doc: para mostrar documentos o enviarlos a través de HTTP\ngo rename: se utiliza para renombrar variables, funciones, etc. en tipo seguro.\ngo generate: un método estándar para llamar a un generador de código\nTambién incluye soporte de depuración y perfiles, herramientas de medición de tiempo de ejecución. El ecosistema de herramientas de terceros se ha agregado a la distribución estándar, incluido gocode, que permite completar automáticamente el código en muchos editores de texto. goimports (por un miembro del equipo de Go) que automáticamente elimina o agrega paquetes según sea necesario, y errcheck, que detecta errores de código y puede ignorarlos. Hay complementos para agregar soporte de idioma en algunos editores de texto. Hay varios IDE disponibles, incluidos LiteIDE y el \u0026ldquo;Go IDE multiplataforma\u0026rdquo; y GoLand.\nAplicaciones del lenguaje Go está diseñado específicamente como lenguaje de programación para grandes sistemas distribuidos y servidores de red altamente escalables. En este sentido, reemplaza a C++ y Java en la pila de software de Google. Muchos equipos buscan crear nuevos servidores en Go. Algunos incluso están migrando bases de código existentes. Algunas de las tecnologías de Google que utiliza a diario tienen componentes escritos en Go.\nDado que este es un lenguaje de programación relativamente nuevo, muchos preguntan para qué es adecuado.\nUn vistazo a algunos de sus beneficios:\nIdeal para el desarrollo web\nExcelente para scripts de línea de comandos\nSe puede utilizar para aplicaciones de servidor de red.\nSe puede utilizar para el desarrollo de front-end.\nLos desarrolladores disfrutan usando Go porque tiene un entorno de desarrollo completo, y aprender Go es muy fácil, incluso para desarrolladores sin experiencia. Una de las razones de esto se debe al gran ecosistema de herramientas, por lo que es muy útil para proyectos grandes y conjuntos. Esto lo convierte en una excelente opción para programar software propietario. Si se está buscando más beneficios, Go fue creado y es mantenido por Google, que tiene una de las infraestructuras de nube más importantes del mundo y puede ser a gran escala.\nData Science Es una ciencia multidisciplinaria que utiliza métodos, procesos, algoritmos y sistemas científicos para extraer conocimientos e ideas de datos estructurados y no estructurados. La ciencia de datos es el concepto de combinar estadísticas, análisis de datos, aprendizaje automático y métodos relacionados para comprender y analizar fenómenos reales con datos. Extrae técnicas y teorías que han surgido de muchos campos de las matemáticas, la estadística, la informática y la ciencia de la información. El ganador del premio Turing, Jim Gray, ve la ciencia de datos como el \u0026ldquo;cuarto modelo\u0026rdquo; de la ciencia (experimental, teórico, computacional y ahora basado en datos) y afirma que \u0026ldquo;todo lo relacionado con la ciencia está cambiando debido al impacto de la tecnología de la información\u0026rdquo;.\nEn la actualidad, a menudo se usa indistintamente con conceptos anteriores, como análisis empresarial, inteligencia empresarial, modelado de previsión y estadísticas. Si bien muchos programas académicos ahora tienen un título en ciencia de datos, no existe un consenso sobre la definición del contenido curricular apropiado. Sin embargo, muchos proyectos de ciencia de datos y Big Data no han podido lograr resultados útiles, a menudo debido a la falta de gestión y utilización de recursos.\n« Go demuestra cada vez pruebas más rápidas, codificación fácil en lenguajes de programación concurrentes altamente eficientes. Por lo general, es la próxima generación de ciencia de datos, aprendizaje automático e inteligencia artificial, porque existe un gran equilibrio entre la productividad y la retención de código. Muchos prototipos de científicos de datos, que luego son transferidos a producción por otra persona, deja que Go haga ambas cosas. »\n"},{"href":"https://gophers-latam.github.io/posts/2021/08/go-talks/","title":"Go Talks","body":" talks Este post contiene charlas de Go que se pueden leer siguiendo los vinculos de cada título listado.\n2019 playground-v3.slide: Playground v3 2017 state-of-go-may.slide\nexporting-go\nstate-of-go-aug\n2016 refactor.article: Codebase Refactoring (with help from Go)\napplicative.slide: Program your next server in Go\nasm.slide: The Design of the Go Assembler\nstate-of-go.slide: The State of Go\ntoken.slide: Stacks of Tokens\nprototype-your-design\n2015 dynamic-tools.slide: Go Dynamic Tools\ngo-for-java-programmers.slide: Go for Java Programmers\ngo4cpp.slide: Go for C++ developers\ngofmt-cn.slide: gofmt 的文化演变\ngofmt-en.slide: The Cultural Evolution of gofmt\ngogo.slide: Go in Go\ngophercon-go-on-mobile.slide: Go on Mobile\ngophercon-goevolution.slide: The Evolution of Go\ngotham-grpc.slide: gRPC Go\nhow-go-was-made.slide: How Go was made\njson.slide: JSON, interfaces, and go generate\nkeeping-up.slide: Keeping up with the Gophers\nsimplicity-is-complicated.slide: Simplicity is Complicated\nstate-of-go.slide: The State of Go\ntricks.slide: Stupid Gopher Tricks\n2014 c2go.slide: Go, from C to Go\ncamlistore.slide: - Camlistore: Android, ARM, App Engine, anywhere.\ncompiling.slide: - Go: Easy to Read, Hard to Compile\ndroidcon.slide: Go on Android\ngo1.3.slide: Toward Go 1.3\ngo4gophers.slide: Go for gophers\ngo4java.slide: Go for Javaneros (Javaïstes?)\ngocon-tokyo.slide: - Go: 90% Perfect, 100% of the time.\ngotham-context.slide: Cancelation, Context, and Plumbing\ngothamgo-android.slide: Go on Android\nhammers.slide: Gophers With Hammers\nhellogophers.slide: Hello, Gophers!\nnames.slide: What\u0026rsquo;s in a name?\norganizeio.slide: Organizing Go code\nplayground.slide: Inside the Go playground\nreadability.slide: When in Go, do as Gophers do\nresearch.slide: The Research Problems of Implementing Go\nresearch2.slide: More Research Problems of Implementing Go\nstate-of-go.slide: The State of Go\nstate-of-the-gopher.slide: The State of the Gopher (Oct)\nstatic-analysis.slide: Static analysis tools\ntaste.slide: A Taste of Go\ntesting.slide: Testing Techniques\n2013 advconc.slide: Advanced Go Concurrency Patterns\nbestpractices.slide: Twelve Go Best Practices\ndistsys.slide: Go, for Distributed Systems\ngo-sreops.slide: Go Language for Ops and Site Reliability Engineering\ngo1.1.slide: What\u0026rsquo;s new in Go 1.1\ngo4python.slide: Go for Pythonistas\nhighperf.slide: High Performance Apps with Go on App Engine\noscon-dl.slide: dl.google.com: Powered by Go\n2012 10things.slide: 10 things you (probably) don\u0026rsquo;t know about Go\nchat.slide: - Go: code that grows with grace\nconcurrency.slide: Go Concurrency Patterns\ngo-docs.slide: Go docs\ngo1.slide: The Path to Go 1\ngoforc.slide: Go for C programmers\ninsidepresent.slide: Inside the \u0026ldquo;present\u0026rdquo; tool\nsimple.slide: - Go: a simple programming environment\nsplash.slide: Go at Google\ntutorial.slide: Get started with Go\nwaza.slide: Concurrency is not Parallelism\nzen.slide: Go and the Zen of Python\n2011 lex.slide: Lexical Scanning in Go 2010 ExpressivenessOfGo-2010\ngo_talk-20100112\ngo_talk-20100121\ngo_talk-20100323\ngofrontend-gcc-summit-2010\n2009 go_talk-20091030 "},{"href":"https://gophers-latam.github.io/posts/2021/06/conversi%C3%B3n-json-a-go/","title":"Conversión JSON a Go","body":" json to go Uno de los formatos de datos que se encuentra con mucha frecuencia en programación, principalmente web, es JavaScript Object Notation (JSON).\nCuando se recibe datos en formato JSON de representación, debe convertirse a un formato que sea fácil de manipular en el programa en Go. Hay algunas herramientas en línea que permiten convertir fuente JSON directamente en estructuras Go, aunque haciendo una simple búsqueda google.com/search?q=json+to+go se ve varidad de resultados, las destacadas o pioneras son:\nJSON-to-Go - mholt.github.io/json-to-go/\nTransform - transform.tools/json-to-go\nJson2Struct - json2struct.mervine.net/\nPor último como extensión de navegador para mejor accesibilidad existe json to go para Chrome.\n"},{"href":"https://gophers-latam.github.io/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/","title":"Golang: Implementación del almacenamiento en caché","body":" go cache El almacenamiento en caché de datos en una aplicación web a veces es necesario para evitar solicitar datos estáticos de una base de datos o un servicio externo una y otra vez. Go no proporciona ningún paquete integrado en la librería estándar para almacenar en caché las respuestas, pero lo admite a través de paquetes externos creados por la comunidad.\nHay una serie de paquetes, como github.com/coocood/freecache, github.com/patrickmn/go-cache, github.com/eko/gocache y github.com/etcd-io/etcd (gRPC) que pueden ayudar a implementar el almacenamiento en caché. Por parte de la comunidad de Gophers LATAM se busca crear algo relacionado: github.com/gophers-latam/GoKey\nPara este post se estará usando github.com/patrickmn/go-cache para implementar un ejemplo de uso.\nEjemplo: Primero crear un directorio para el código fuente de prueba e inicializar un go module. [go mod init cache-example]\nLuego crear archivo .go, donde se hará un caché por medio de la librería y se completará con datos sobre el arranque del servidor, de la siguiente manera:\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;log\u0026#34; \u0026#34;net/http\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/patrickmn/go-cache\u0026#34; ) const ( CONN_PORT = \u0026#34;8080\u0026#34; ) var newCache *cache.Cache func init() { newCache = cache.New(5*time.Minute, 10*time.Minute) newCache.Set(\u0026#34;gophers\u0026#34;, \u0026#34;gophers latam\u0026#34;, cache.DefaultExpiration) } func getFromCache(w http.ResponseWriter, r *http.Request) { gophers, found := newCache.Get(\u0026#34;gophers\u0026#34;) if found { log.Print(\u0026#34;Key encontrada en caché con valor, como : \u0026#34;, gophers.(string)) fmt.Fprintf(w, \u0026#34;Hola \u0026#34;+gophers.(string)) } else { log.Print(\u0026#34;Key no encontrada en caché : \u0026#34;, \u0026#34;gophers\u0026#34;) fmt.Fprintf(w, \u0026#34;Key no encontrada en caché\u0026#34;) } } func main() { http.HandleFunc(\u0026#34;/\u0026#34;, getFromCache) err := http.ListenAndServe(\u0026#34;:\u0026#34;+CONN_PORT, nil) if err != nil { log.Fatal(\u0026#34;error al iniciar el servidor http : \u0026#34;, err) return } } Ejecutar el código. Como funciona: Una vez iniciado, el servidor HTTP comenzará a escuchar localmente en el puerto 8080. Al inicio, la clave con el nombre gophers con un valor como gophers latam se agregará a la caché.\nAl navegar por http://localhost:8080/ se leerá un valor de key de la caché y lo agregará a Hola como se muestra en la siguiente captura de pantalla:\nLog en terminal:\nSe ha especificado el tiempo de caducidad de los datos de la caché en el programa como 5 minutos, lo que significa que la clave que se ha creado en la caché al iniciar el servidor no estará allí después de 5 minutos. Por lo tanto, acceder a la misma URL nuevamente después de 5 minutos devolverá que la clave no es encontrada en la caché del servidor, de la siguiente manera:\nUsando var newCache *cache.Cache, se declara una caché privada.\nSe actualiza la función init() donde se crea un caché con 5 minutos de tiempo de vencimiento y 10 minutos de intervalo de limpieza, y se agrega un elemento a caché con una clave como gophers con su valor como gophers latam y su valor de vencimiento como 0, lo que significa que se quiere usar el tiempo de vencimiento predeterminado de la caché.\nPara usarse se define el controlador getFromCache donde se recupera el valor de una clave en caché. Si se encuentra, se escribe en respuesta HTTP, de lo contrario, se escribe el mensaje Key no encontrada en caché.\n"},{"href":"https://gophers-latam.github.io/posts/2021/05/golang-init-func/","title":"Golang: Init func","body":" init func Cada programa en Go debe tener un paquete main con una función main para ser ejecutado. Sin embargo, esto impone algunas limitaciones para determinadas soluciones, como las librerías. Imagina que importamos una librería a nuestro código.\nUna librería no está diseñada para ser ejecutada, ofrece estructuras de datos, métodos, funciones, etc. Es probable que las librerías ni siquiera tengan un paquete main. Si esta librería requiere alguna configuración inicial antes de ser invocada (inicializar variables, detectar el sistema operativo, etc.) parece imposible.\nGo define las funciones init que se ejecutan una vez por paquete. Cuando importamos un paquete, el tiempo de ejecución (runtime) de Go sigue este orden:\nInicializar los paquetes importados de forma recursiva. Inicializar y asignar valores a las variables. Ejecutar las funciones de init. Ejemplos: 1. - En el resultado para el código de ejemplo se muestra cómo la inicialización sigue el orden descrito anteriormente. La función xSetter se invoca primero, seguida de init y la función main.\npackage main import \u0026#34;fmt\u0026#34; var x = xSetter() func xSetter() int { fmt.Println(\u0026#34;xSetter\u0026#34;) return 42 } func init() { fmt.Println(\u0026#34;Init function\u0026#34;) } func main() { fmt.Println(\u0026#34;Este es el main\u0026#34;) } Salida en ejecución: La función init no tiene argumentos ni devuelve ningún valor. Un paquete puede tener varias funciones init y no se pueden invocar desde ninguna parte del código.\nGo no permite importar un paquete si no se usa dentro del código. Sin embargo, es posible que solo nos interese ejecutar las funciones init de un paquete. Esto es lo que Go llama los efectos secundarios de un paquete (side effects pkg). Por lo general, esto se hace en paquetes que realizan alguna operación de arranque o registro. La instrucción especial import _ solo llama a las funciones init de un paquete que no requiere su uso dentro del código.\n2. - Ejemplo usando import _ : importado el paquete \u0026ldquo;a\u0026rdquo; para utilizar sus efectos secundarios. Observar que este paquete tiene dos funciones init que se ejecutan antes del init del paquete de importación. [go mod init ejemplo2]\nejemplo2/main.go\npackage main import ( \u0026#34;fmt\u0026#34; _ \u0026#34;ejemplo2/a\u0026#34; ) func init() { fmt.Println(\u0026#34;Init desde mi programa\u0026#34;) } func main() { fmt.Println(\u0026#34;Mi programa\u0026#34;) } ejemplo2/a/a.go\npackage a import \u0026#34;fmt\u0026#34; func init() { fmt.Println(\u0026#34;Init 1 desde paquete a\u0026#34;) } func init() { fmt.Println(\u0026#34;Init 2 desde paquete a\u0026#34;) } Salida en ejecución: "},{"href":"https://gophers-latam.github.io/posts/2021/04/golang-referencia-esencial-go-modules/","title":"Golang: Referencia esencial Go modules","body":" Go Modules Esta es una hoja de trucos esenciales, no una referencia oficial. Con el fin de que sea conciso, se omitieron aspectos menos frecuentes, dado que este sitio desde su repositorio esta abierto a cambios de contribuidores en la comunidad de Gophers LATAM cualquiera puede hacer cambios que mejoren este contenido.\nInicio rápido Gestión de dependencias go get -d github.com/path/to/module # agregar o actualizar dep (-v log verboso) go get -d github.com/dep/two/v2@v2.1.0 # usar una versión específica go get -d github.com/dep/commit@branch # usar una rama específica go get -d -u ./... # actualizar módulos utilizados en subdirectorios go get -d github.com/dep/legacy@none # eliminar dep Comandos útiles go mod tidy # organizar y limpiar go.mod and go.sum go mod download # descargar deps en caché de módulos go mod init github.com/path/to/module # inicializar nuevo módulo go mod why -m github.com/path/to/module # por qué el módulo es una dependencia? go install github.com/path/to/bin@latest # construir e instalar binario Anatomía del go.mod // ruta de importación de Go con lugar donde se aloja el módulo module github.com/my/library go 1.16 // versión utilizada para desarrollar módulo (usar nuevas funciones de lenguaje) require ( github.com/dep/one v1.0.0 // v2 y posteriores tienen versión principal en ruta del módulo github.com/dep/two/v2 v2.3.0 // \u0026#34;pseudo-versión\u0026#34; que se refiere a un commit y no a una versión etiquetada. github.com/dep/other v0.0.0-20180523231146-b3f5c0f6e5f1 github.com/dep/legacy v2.0.0+incompatible // \u0026#34;incompatible\u0026#34; significa que el paquete aún no se ha migrado a nuevos módulos de Go ) exclude github.com/dep/legacy v1.9.2 // evitar que se use una versión de módulo específica replace github.com/dep/one =\u0026gt; github.com/fork/one // reemplazar este módulo con este otro Selección de versión mínima (MVS) Para crear un programa, Go necesita saber exactamente qué dependencias necesita y qué versión usar.\nGo utiliza MVS como una forma sencilla y predecible de decidir qué versión utilizar.\nFunciona así:\nEl módulo desde el que está ejecutando es el \u0026ldquo;módulo main\u0026rdquo;\nEncuentra todas las dependencias que necesita el módulo principal (de forma recursiva, usando los archivos go.mod de las dependencias)\nPara cada dependencia, usar la mayor versión que cualquier go.mod haya especificado explícitamente\nEjemplo: En este ejemplo, el módulo principal depende de A 1.0 y B 2.1.\nDado que B 2.1 depende de A 1.1, esta es la versión de A que se utilizará.\nDado que se usa A 1.1, también en C 1.1.\nLa lista final de dependencias es:\nA 1.1 B 2.1 C 1.1 Fuentes: Referencia oficial: https://golang.org/ref/mod\nVersión del post original: https://encore.dev/guide/go.mod\n"},{"href":"https://gophers-latam.github.io/posts/2021/04/golang-la-interfaz-vac%C3%ADa/","title":"Golang: La interfaz vacía","body":" Interface type Explicación breve sobre el tipo interfaz vacia y nula.\nSe define una interfaz vacía como interface{}, y puede contener un valor de cualquier tipo:\nvar i interface{} i = \u0026#34;hola gophers\u0026#34; fmt.Println(i) Si se necesita probar si una interfaz es de cierto tipo, se usa una aserción de tipo:\nvar i interface{} i = \u0026#34;hola gophers\u0026#34; s, ok := i.(string) if !ok { fmt.Println(\u0026#34;s is not type string\u0026#34;) } fmt.Println(s) En el ejemplo anterior, i es un tipo string, por lo que el segundo valor de retorno de la aserción de tipo es verdadero (ok) y s contiene el valor por debajo de este. Si hubiera sido de otro tipo, como un int, entonces el ok habría sido falso y s habría sido el valor cero del tipo que se estaba tratando de afirmar, es decir, 0.\nInterfaz nula Una interfaz en Go es esencialmente una tupla que contiene el tipo y el valor subyacentes. Para que una interfaz se considere nula, tanto el tipo como el valor deben ser nulos (nil). Ejemplo:\npackage main import ( \u0026#34;fmt\u0026#34; ) func main() { var i interface{} fmt.Println(i == nil) fmt.Printf(\u0026#34;%T, %v\\n\u0026#34;, i, i) var s *string fmt.Println(\u0026#34;s == nil:\u0026#34;, s == nil) i = s fmt.Println(\u0026#34;i == nil:\u0026#34;, i == nil) fmt.Printf(\u0026#34;%T, %v\\n\u0026#34;, i, i) Salida:\ntrue \u0026lt;nil\u0026gt;, \u0026lt;nil\u0026gt; s == nil: true i == nil: false *string, \u0026lt;nil\u0026gt; Observar que la variable s es nil, pero cuando se establece la interfaz i en s, se verifica si i es nil, i no se considera nil. Esto se debe a que la interfaz tiene un tipo concreto por debajo establecido y las interfaces solo son nulas cuando tanto el tipo concreto como el valor son nulos.\n"},{"href":"https://gophers-latam.github.io/search/","title":"Búsqueda","body":""},{"href":"https://gophers-latam.github.io/posts/2021/04/golang-mantener-actualizado-el-sdk/","title":"Golang: Mantener actualizado el SDK","body":" Update Go Como ocurre con todos los lenguajes de programación, hay actualizaciones periódicas de las herramientas de desarrollo de Go. El SDK Go son binarios nativos que no dependen de un tiempo de ejecución independiente, por lo que no hay que preocuparse de que la actualización del entorno de desarrollo pueda hacer que los programas actualmente implementados fallen. Puede tenerse programas compilados con diferentes versiones de Go ejecutándose simultáneamente en la misma computadora o máquina virtual.\nDesde Go 1.2, ha habido una nueva versión importante aproximadamente cada seis meses. También hay versiones menores con correcciones de errores y seguridad que se publican según sea necesario. Dados los rápidos ciclos de desarrollo y el compromiso del equipo de Go con la compatibilidad con versiones anteriores, las versiones de Go tienden a ser incrementales en lugar de expansivas. La promesa de compatibilidad de Go es una descripción detallada de cómo el equipo de Go planea evitar romper el código de Go. Dice que no habrá cambios retrógrados en el lenguaje o la librería estándar para cualquier versión de Go que comience con 1, a menos que el cambio sea necesario para un error o corrección de seguridad. Sin embargo, puede haber (y ha habido) cambios incompatibles con versiones anteriores en los indicadores o la funcionalidad de los comandos go.\nA pesar de estas garantías de compatibilidad con versiones anteriores, los errores ocurren, por lo que es natural querer asegurarse de que una nueva versión no rompa los programas personales ya hechos. Una opción es instalar un entorno Go secundario. Por ejemplo, si actualmente se está ejecutando la versión 1.15.2 y se quiere probar la versión 1.16.3, debe usarse los siguientes comandos:\ngo get golang.org/dl/go.1.16.3 go1.16.3 download Luego se puede usar el comando go1.16.3 en lugar del comando go para ver si la versión 1.16.3 funciona para los programas ya hechos anteriormente con la nueva versión de Go:\ngo1.16.3 build Una vez que se haya validado que el código funciona, puede eliminarse el entorno secundario buscando el GOROOT, eliminándolo y luego eliminando el binario del directorio $GOPATH/bin. A continuación, las indicaciones de cómo hacerlo en Mac OS, Linux y BSD respectivamente:\ngo1.16.3 env GOROOT /Users/gobook/sdk/go1.16.3 rm -rf $(go1.16.3 env GOROOT) rm $(go env GOPATH)/bin/go1.16.3 Cuando se está listo para actualizar las herramientas de desarrollo de Go instaladas en la computadora, los usuarios de Mac y Windows tienen la ruta más fácil. Aquellos que instalaron con brew o chocolatey pueden usar esas herramientas para actualizar. Aquellos que usaron los instaladores en golang.org/dl pueden descargar el último instalador, que elimina la versión anterior cuando se instala la nueva.\nLos usuarios de Linux y BSD en general deben descargar la última versión, mover la versión anterior a un directorio de respaldo, expandir la nueva versión y luego eliminar la versión anterior, algo así:\nmv /usr/local/go /usr/local/old-go tar -C /usr/local -xzf go1.16.3.linux-amd64.tar.gz rm -rf /usr/local/old-go Como nota final, igual en cada versión que sale en el canal del Discord #📰fuente-noticias se comparte automáticamente del canal de Twitter oficial como obtener la nueva versión.\n"},{"href":"https://gophers-latam.github.io/posts/2021/04/golang-resumen-reglas/","title":"Golang: Resumen reglas","body":" Go Police El lenguaje de programación Go fue creado para hacer el trabajo fácilmente.\nGo tiene conceptos similares a los lenguajes imperativos y el tipado estático.\nTambién es rápido en la compilación, rápido de ejecutar e implementar. Grande y complejo.\nEn este post, se explican conceptos básicos de Go tratando algunos conceptos o reglas importantes.\nLos principales temas tratados son los siguientes:\nEscribir comentarios. Librerías e importación. Funciones. Tipos de datos. Valores de retorno con nombre. Variables y memoria. Control de sentencias. Generar funciones. Ejecución diferida. Interfaces. Múltiples entradas. Manejo de errores. Ejecución simultánea. Escribir comentarios: Para escribir un comentario de una línea\n// comentario de una sola línea Escribir un comentario con más de una línea\n/* comentario de multi-línea */ Librerías e importación: Cada archivo de código fuente comienza con la palabra clave package. La palabra clave main se utiliza para identificar el archivo como un archivo operativo, no como una librería.\npackage main Para importar un paquete de la librería estándar, terceros o personal al archivo, usamos la instrucción import de la siguiente manera:\nimport ( \u0026#34;fmt\u0026#34; // paquete en la librería estándar \u0026#34;io/ioutil\u0026#34; // se aplican funciones de E/S m \u0026#34;math\u0026#34; // usando la letra m para acortar o hacer alias del nombre de la librería de funciones matemáticas \u0026#34;net/http\u0026#34; // web server \u0026#34;os\u0026#34; // funciones a nivel del sistema operativo, como el manejo de archivos \u0026#34;strconv\u0026#34; // conversiones de texto ) Funciones: Las funciones se definen mediante la palabra func seguida del nombre de la función.\nLa función main es privada y es la entrada al archivo ejecutable del programa (Go usa llaves ornamentadas {} para definir partes / bloques).\nfunc main() { // salida de texto en la unidad main en stdout (salida estandar) con Println de fmt (stdlib pkg) fmt.Println (\u0026#34;Hello world!\u0026#34;) // llamar a una función del paquete actual beyondHello() } Las funciones necesitan paréntesis que reciben parámetros, e incluso en ausencia de parámetros, se requieren paréntesis.\nfunc beyondHello() { // declaración de variable (la variable debe declararse antes de usarse) var x int // dar valor a la variable x = 3 // definición corta usando := incluye definición de variable, especificando su tipo y dándole valor y := 4 // una función que devuelve dos valores separados sum, prod := learnMultiple (x, y) // imprimir salida de forma sencilla y directa fmt.Println (\u0026#34;sum:\u0026#34;, sum, \u0026#34;prod:\u0026#34;, prod) learnTypes() } La definición de función puede tener múltiples coeficientes y valores de retorno. Por ejemplo, learnMultiple toma los coeficientes x, y \u0026hellip; y devuelve dos valores de sum y prod de tipo Int.\nfunc learnMultiple (x, y int) (sum, prod int) { // separar los valores devueltos con una coma regular return x + y, x * y } Tipos de datos: func learnTypes() { // las declaraciones cortas generalmente cumplen el propósito deseado // definir una variable de texto usando comillas dobles str := \u0026#34;Learn Go!\u0026#34; // definir una variable de texto con comillas simples s2 := `A \u0026#34;raw\u0026#34; string literal can include line breaks.` // definir variable tipo runa que es otro nombre para el tipo int32 que contiene unicode g := \u0026#39;Σ\u0026#39; // float f := 3.14195 // definición de número complejo (Complex) c := 3 + 4i // definir variables usando var var u uint = 7 // número natural (entero positivo) var pi float32 = 22. / 7 // un decimal de 32 bits // definición corta byte (es otro nombre para uint8) n := byte (\u0026#39;\\n\u0026#39;) // arrays tienen un tamaño fijo, y son fijos en momento de compilación // definir un array int de 4 elementos con un valor inicial de cero var a4 [4] int // definir un array de 3 elementos con valores 3, 1 y 5 a3 := [...] int {3, 1, 5} Go ofrece un tipo de datos llamado Slices. Los Slices entendibles como \u0026ldquo;rebanadas\u0026rdquo;, \u0026ldquo;porciones\u0026rdquo;, \u0026ldquo;segmentos\u0026rdquo; tienen un tamaño dinámico. Las matrices (array) y los segmentos (slice) tienen ventajas, pero los casos de uso de los segmentos son más comunes. La siguiente instrucción define un segmento de tipo int\n// observar la diferencia entre el array y la declaración del slice, donde cuando // el slice está definido no hay un número que determine su tamaño s3: = [] int {4, 5, 9} // definir un tipo int con cuatro elementos con valores cero s4: = make ([] int, 4) // solo definir, y no hay selección var d2 [] [] float64 // método para convertir el tipo de texto en slice bs: = [] byte (\u0026#34;a slice\u0026#34;) Por la naturaleza de los slice dinámicos, es posible agregar nuevos elementos usando la función append incorporada. Primero se pasa el slice al que queremos agregar y luego los elementos que queremos agregar.\ns := [] int {1, 2, 3} s = append (s, 4, 5, 6) // se imprimirá un slice con el siguiente contenido [1 2 3 4 5 6] fmt.Println (s) Para agregar un slice a otro slice, pasamos los dos slices en la función en lugar de pasar elementos individuales, y siguiendo el segundo slice con tres puntos.\ns = append (s, [] int {7, 8, 9} ...) // se imprimirá un slice con el siguiente contenido [1 2 3 4 5 6 7 8 9] fmt.Println (s) La siguiente instrucción define las variables p y q como punteros en dos variables de tipo int que contienen dos valores devueltos por la función learnMemory:\np, q := learnMemory() // tema de reglas por ver Cuando un asterisco precede a un cursor, significa el valor de la variable a la que se refiere el cursor, como en el siguiente ejemplo los valores de las dos variables devueltas por la función learnMemory:\nfmt.Println (*p, *q) Los mapas (maps) en Go son arrays dinámicos y modificables que son similares al tipo de diccionario o hash en otros lenguajes.\n// aquí un mapa cuya clave es tipo texto y los valores de los elementos numéricos. m: = map [string] int {\u0026#34;three\u0026#34;: 3, \u0026#34;four\u0026#34;: 4} m [\u0026#34;one\u0026#34;] = 1 Las variables no utilizadas son errores. El subrayado, guion bajo, operador blanco o Blank Identifier de la siguiente manera hace usar la variable pero ignora valores al mismo tiempo:\n_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs Valores de retorno con nombre: A diferencia de otros lenguajes, las funciones pueden tener valores de retorno con nombre. Donde el nombre se devuelve al valor de la función en la línea de la definición de la función, esta característica permite regresar fácilmente desde cualquier punto de la función además del uso de la palabra return solo sin mencionar nada después:\nfunc learnNamedReturns (x, y int) (z int) { z = x * y // aquí implícitamente significa devolver el valor de la variable z return } Nota: El lenguaje Go se basa en gran medida en la recolección de basura. Go tiene indicadores pero no cálculos (puede confundir un cursor vacío, pero no puede aumentar el cursor). Tener cuidado con valores de retorno de nil pointer reference.\nVariables y memoria: Las variables p y q a continuación son indicadores del tipo int y representan valores de retorno en la función. Cuando se define, los cursores están vacíos; sin embargo, el uso de la función incorporada new hace que el valor de la variable numérica p se refiera a cero, y por lo tanto ocupa espacio en la memoria; es decir, p ya no está vacío.\nfunc learnMemory() (p, q* int) { p = new(int) // definir un slice de 20 elementos como una sola unidad en la memoria. s := make([] int, 20) // dar valor a un elemento s[3] = 7 // definir una nueva variable local a nivel de función r := -2 // devolver dos valores de la función, que son direcciones de memoria // para las variables s y r, respectivamente. return \u0026amp;s[3], \u0026amp;r } func expensiveComputation() float64 { return m.Exp (10) } Control de sentencias Las sentencias condicionales requieren corchetes ornamentados y no requieren paréntesis.\nfunc learnFlowControl() { if true {fmt.Println (\u0026#34;told ya\u0026#34; ) } if false { // Rusters. } else { // Gophers. } Usar la instrucción switch si se necesita escribir más de una secuencia condicional.\nx := 42.0 switch x { case 0: case 1: case 42: case 43: default: } Como sentencia condicional, la cláusula for no toma paréntesis. Las variables definidas en la cláusula for son visibles a nivel de la sentencia.\nfor x: = 0; x \u0026lt;3; x ++ { fmt.Println (\u0026#34;iteration\u0026#34;, x) } La instrucción for es la única instrucción de iteración en el lenguaje Go y tiene otra formas, de la siguiente manera:\n// repetición infinita for { // break para detener la repetición break // continue para ir a la siguiente iteración continue } Se puede utilizar el range para pasar elementos de array, slice, text string, map, channel.\nEl range de canal (channel) devuelve un valor, y dos valores cuando se usa en slice, array, text string, o map.\n// ejemplo: for key, value := range map [string] int {\u0026#34;one\u0026#34;: 1, \u0026#34;two\u0026#34;: 2, \u0026#34;three\u0026#34;: 3} { // imprimir el valor de cada elemento del mapa fmt.Printf (\u0026#34;key =% s, value =% d \\n\u0026#34;, key, value) } Usar el guión bajo (_) contra valor de retorno en la clave si solo se desea el valor, de la siguiente manera:\nfor _, name: = range [] string {\u0026#34;Bob\u0026#34;, \u0026#34;Bill\u0026#34;, \u0026#34;Joe\u0026#34;} { fmt.Printf (\u0026#34;Hello,% s \\n\u0026#34;, name) } Se puede usar la declaración corta con la sentencia condicional para que se defina una variable y luego se verifique en la sentencia de condición.\nPor ejemplo se define una variable y, se le da un valor y luego se coloca la condición de la sentencia para que estén separadas por un punto y coma.\nif y := expensiveComputation(); y \u0026gt; x { x = y } Se puede definir funciones anónimas falsas directamente en el código.\nxBig := func() bool { // x:= 42 que fue declarada antes donde de menciona la sentencia switch return x \u0026gt; 10000 } x = 99999 // la función xBig ahora devuelve el valor verdadero fmt.Println (\u0026#34;xBig:\u0026#34;, xBig()) x = 1.3e3 // Después de modificar el valor de x a 1.3e3 que es igual a 1300 (es decir, mayor que 1000) // la función xBig devuelve falso fmt.Println (\u0026#34;xBig:\u0026#34;, xBig()) Además de lo anterior, es posible definir función fantasma y llamarla en la misma línea y pasarla a otra función siempre que se llame directamente y el tipo de resultado sea consistente con lo esperado en el parámetro de la función.\nfmt.Println (\u0026#34;Add + double two numbers:\u0026#34;, func (a, b int) int { return (a + b) * 2 } (10, 2)) goto love love: learnFunctionFactory() // Una función que devuelve una función learnDefer() // Dormir learnInterfaces() // Trabajar con interfaces } Generar funciones Se puede tratar las funciones como objetos separados. Por ejemplo, crear una función y el valor de retorno es otra.\nfunc learnFunctionFactory() { Los dos métodos siguientes para imprimir la oración son iguales, pero el segundo método es más claro, más legible y común.\nfmt.Println(sentenceFactory (\u0026#34;summer\u0026#34;) (\u0026#34;A beautiful\u0026#34;, \u0026#34;day!\u0026#34;)) d: = sentenceFactory (\u0026#34;summer\u0026#34;) fmt.Println(d (\u0026#34;A beautiful\u0026#34;, \u0026#34;day!\u0026#34;)) fmt.Println(d (\u0026#34;A lazy\u0026#34;, \u0026#34;afternoon!\u0026#34;)) } Los decoradores se encuentran en algunos lenguajes de programación y en el mismo concepto en Go para que poder pasar datos a funciones.\nfunc sentenceFactory(mystring string) func(before, after string) string { return func(before, after string) string { return fmt.Sprintf (\u0026#34;%s %s %s\u0026#34;, before, mystring, after) } } Ejecución diferida Se puede usar la función defer en funciones para realizar una acción antes de devolver el valor o resolver la funcion, y si se escribe más de una, el orden en ejecución de estas acciones es la contraria, como en learnDefer:\nfunc learnDefer() (ok bool) { // instrucciones diferidas se ejecutan antes de que la función devuelva el resultado. defer fmt.Println (\u0026#34;deferred statements execute in reverse (LIFO) order.\u0026#34;) defer fmt.Println (\u0026#34;\\nThis line is being printed first because\u0026#34;) // defer se utiliza normalmente para cerrar un archivo después de abrirlo. return true } Interfaces Como ejemplo se define una función llamada Stringer que contiene una función llamada String; luego se define una estructura de dos dígitos de tipo int nombrados x y y.\ntype Stringer interface { String() string } type pair struct { x, y int } Aquí se define la función String como un pair, convirtiéndose en un pair para la implementación de la interfaz Stringer. La variable p a continuación se llama receptor (receiver). Observar cómo se accede a los campos de estructura de pair utilizando el nombre de la estructura seguido de un punto y luego el nombre del campo.\nfunc(p pair) String() string { return fmt.Sprintf (\u0026#34;(%d, %d)\u0026#34;, p.x, p.y) } Los puntos y comas se utilizan para crear un elemento de estructura (struct). Se usa la definición corta en el siguiente ejemplo para crear una variable llamada p y especificar su tipo en la estructura de pair.\nfunc learnInterfaces() { p := pair{3, 4} // llamar función String de pair fmt.Println(p.String()) // definir una variable como i del tipo Stringer interface previamente definida var i Stringer // esta igualdad es correcta, porque se aplica pair de Stringer i = p // se llama función String de la variable i de tipo Stringer y se obtiene // el mismo resultado que antes fmt.Println(i.String()) // al pasar las variables anteriores directamente a las funciones de impresión y salida fmt, // estas funciones llaman a la función String para imprimir la representación de la variable. */ // Las siguientes dos líneas dan el mismo resultado de impresión fmt.Println(p) fmt.Println(i) learnVariadicParams (\u0026#34;great\u0026#34;, \u0026#34;learning\u0026#34;, \u0026#34;here!\u0026#34;) } Múltiples entradas Es posible pasar variedad de variables a funciones sin un número definido de parámetros.\nfunc learnVariadicParams (myStrings... interface{}) { // la siguiente iteración recorre los elementos de entrada de datos de la función. for _, param: = range myStrings { fmt.Println(\u0026#34;param:\u0026#34;, param) } // se pasa la entrada de la función variadica como parámetro de otra función (para Sprintln) fmt.Println (\u0026#34;params:\u0026#34;, fmt.Sprintln(myStrings...)) learnErrorHandling() } Manejo de errores La palabra clave \u0026ldquo;ok\u0026rdquo; se utiliza para determinar si una sentencia es correcta. Si ocurre un error, se puede usar una variable err para conocer más detalles sobre el error.\nfunc learnErrorHandling() { m := map [int] string{3: \u0026#34;three\u0026#34;, 4: \u0026#34;four\u0026#34;} if x, ok := m[1]; !ok { // ok aquí será falso porque el número 1 no está en el mapa m fmt.Println(\u0026#34;no one there\u0026#34;) } else { // x será el valor en el mapa fmt.Print(x) } // aqui se intenta convertir valor de texto a número que resultará en un error, // se imprimen los detalles del error si err no es nil */ if _, err := strconv.Atoi(\u0026#34;non-int\u0026#34;); err != nil { fmt.Println(err) } learnConcurrency() } Ejecución simultánea Usando una función anterior para hacer una suma numérica a algunos números en conjunto. Se usa make para crear una variable sin especificar un valor para ella.\nfunc learnConcurrency() { // se crea una variable de tipo canal llamada c c := make(chan int) // creando tres funciones Go concurrentes. Los números se incrementarán simultáneamente // (en paralelo si el dispositivo está configurado para hacerlo). // todas las transmisiones irán al mismo canal // \u0026#34;go\u0026#34; aquí significa iniciar una nueva función go inc(0, c) go inc(10, c) go inc(-805, c) // luego hacer tres lecturas desde el mismo canal e imprimir los resultados. // no hay un orden de acceso de lectura desde el canal, y // también cuando el canal aparece a la derecha de la operación // \u0026lt;- significa que esta leyendo y recibiendo del canal fmt.Println(\u0026lt;-c, \u0026lt;-c, \u0026lt;-c) // nuevo canal con texto cs := make(chan string) // canal contiene canales de texto ccs := make(chan chan string) // enviar valor 84 al canal c go func() {c \u0026lt;- 84}() // enviar palabra al canal cs go func() {cs \u0026lt;- \u0026#34;wordy\u0026#34;}() // instrucción select es similar a la instrucción switch, // pero en cada caso contiene un proceso para un canal que // está listo para comunicarse. select { // valor recibido del canal se puede guardar en una variable case i := \u0026lt;-c: fmt.Printf(\u0026#34;it\u0026#39;s a %T\u0026#34;, i) case \u0026lt;-cs: fmt.Println(\u0026#34;it\u0026#39;s a string\u0026#34;) // canal vacío pero listo para comunicarse case \u0026lt;-ccs: fmt.Println(\u0026#34;didn\u0026#39;t happen.\u0026#34;) } } "},{"href":"https://gophers-latam.github.io/opensource/","title":"Open Source","body":"Software Open Source compartido en GitHub por Gophers LATAM.\n"},{"href":"https://gophers-latam.github.io/contacto/","title":"Contacto","body":"Medios de contacto con Gophers LATAM.\n"},{"href":"https://gophers-latam.github.io/colaboradores/","title":"Colaboradores","body":"Miembros públicos en github.com/gophers-latam\n"},{"href":"https://gophers-latam.github.io/biografia/","title":"Biografía","body":"Gophers LATAM es un esfuerzo conjunto por hacer una comunidad de programadores Golang en Español-Latino.\nLos inicios son desde el canal de YouTube de Tomás Lingotti, luego se adopto la idea del Discord el cual ha sido impulsado desde el mismo canal y en otros canales de YouTube, tales como el de Golandia. Compartido en otros medios como Facebook, Twitter y Linkedin. Y con apoyo desde los inicios de zeroidentidad.\nOtra forma en la que se ha adoptado hacer presencia es en Github.\n\u0026ndash; Todo lo mencionado surgió desde octubre del 2020.\n"},{"href":"https://gophers-latam.github.io/proyectos/awesomelatam/","title":"Awesome Latam","body":"Colección de contenidos y recursos principalmente en Español para desarrolladores de Golang\n"},{"href":"https://gophers-latam.github.io/proyectos/go-tour/","title":"Go Tour","body":"Para aquellos que aún no lo conocen, el \u0026lsquo;Tour de Go\u0026rsquo; representa una introducción excepcional al lenguaje de programación Go. Ofrece ejemplos interactivos y explicaciones detalladas, convirtiéndose en una herramienta invaluable para aquellos que desean aprender Go.\nComo comunidad, hemos realizado la traducción del sitio, permitiendo que cualquier persona de habla hispana tenga acceso a esta valiosa herramienta de aprendizaje.\nEstatus: Pendiente de aprobación por el sitio oficial de Go (https://go-review.googlesource.com/c/website/+/545855).\n"},{"href":"https://gophers-latam.github.io/proyectos/gokey/","title":"GoKey","body":"GoKey es un cache en memoria. El principal aspecto es guardar, leer y borrar entradas dentro del ciclo de vida de la goroutine main. Es decir, si deja de correr, los datos se pierden.\nEstatus: ETAPA 1 - libreria cliente\n"},{"href":"https://gophers-latam.github.io/proyectos/gopherbot/","title":"Gopher-Bot","body":"Bot de discord como mascota y utilidad de comandos en server discord.me/gophers-latam.\nEl bot se encuentra inactivo debido a que kintohub ya dejo de dar servicio. "}]}
\ No newline at end of file
+{"results":[{"href":"https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/","title":"Explorando Frameworks en Go: Una Guía para Principiantes","body":" go frameworks Últimamente, en nuestro canal de discord, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje. En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.\n¿Cómo comenzar a escribir aplicaciones web con Go? No es imprescindible utilizar un framework para comenzar con Go; la biblioteca estándar proporciona todo lo necesario para desarrollar aplicaciones de manera efectiva. Todo lo que necesitas hacer es crear una carpeta con tu archivo principal e importar el paquete net/http para comenzar a desarrollar.\nLas ventajas de utilizar la biblioteca estándar en lugar de un framework son las siguientes:\nSimplicidad y Minimalismo: El paquete “net/http” está desarrollado siguiendo los principios de simplicidad y minimalismo, lo que significa que no hay una sobrecarga de funcionalidades o dependencias innecesarias, lo que puede resultar en código más limpio y fácil de entender.\nRendimiento: La biblioteca estándar de Go está optimizada para un rendimiento óptimo.\nFlexibilidad: El paquete “net/http” proporciona una gran flexibilidad para construir servidores web y manejar solicitudes HTTP de manera personalizada. Esto permite adaptar la aplicación a requisitos específicos sin estar limitado por las decisiones de diseño del framework.\nCompatibilidad: Al basarse en la biblioteca estándar, las aplicaciones desarrolladas con el paquete “net/http” son altamente compatibles con otros paquetes y bibliotecas de Go. Esto facilita la integración con otras partes del ecosistema de Go y reduce la posibilidad de conflictos de dependencias.\nControl Total: Al evitar el uso de frameworks, los desarrolladores tienen un control total sobre el flujo de su aplicación. Esto significa que pueden tomar decisiones de diseño más personalizadas y adaptar la aplicación según las necesidades específicas del proyecto.\n¿Cuál es el mejor framework? En el mundo Go, no existe un \u0026ldquo;mejor\u0026rdquo; framework, ya que existen una variedad de ellos, cada uno con sus propias características y propósitos. La elección del framework ideal depende en gran medida de los requisitos específicos de tu proyecto, así como de tus preferencias personales y el estilo de desarrollo que te resulte más cómodo.\nAlgunos frameworks populares en la comunidad de Go incluyen Chi, Fiber, Gorilla, Echo y Gin, entre otros. Cada uno de estos frameworks tiene sus puntos fuertes y débiles, y la mejor opción dependerá de factores como la complejidad del proyecto, la escalabilidad requerida, la facilidad de uso y la familiaridad con el framework.\nEs importante investigar y probar diferentes frameworks para determinar cuál se adapta mejor a nuestras necesidades y objetivos.\nSi tenés dudas sobre cuál elegir, en el siguiente repositorio de GitHub, podrás encontrar una lista con los frameworks de Go más famosos filtrados por las estrellas obtenidas por los usuarios de dicha plataforma, también encontraras las fechas con las últimas actualizaciones y la cantidad de forks hechos: Go Web Frameworks por Mingrammer\nY si sos un apasionado de los números y las tablas te dejo 3 webs que te van a encantar, en las cuales se hacen los diferentes benchmarks de cada framework:\nGo Web Framework Benchmark (Actualizado en el 2020, pero en el readme nos explica como podemos ejecutar uno propio)\nGo Http Routing Benchmark (Actualizado en el 2020, pero en el readme nos explica como podemos ejecutar uno propio)\nBenchmarks (Última actualización reciba: 2023-10-17)\nLas ventajas de utilizar un framework son las siguientes:\nProductividad mejorada: Los frameworks suelen proporcionar herramientas y estructuras predefinidas que facilitan el desarrollo de aplicaciones. Esto puede reducir el tiempo necesario para construir y mantener el código, lo que a su vez aumenta la productividad del equipo de desarrollo.\nAbstracciones útiles: Los frameworks pueden ofrecer abstracciones útiles que simplifican tareas comunes, como el enrutamiento, la autenticación de usuarios, el manejo de sesiones, la validación de datos, entre otros. Esto permite a los desarrolladores centrarse en la lógica de negocio de la aplicación en lugar de reinventar la rueda para cada proyecto.\nMejores prácticas integradas: Muchos frameworks promueven el uso de mejores prácticas de desarrollo, como el patrón MVC (Modelo-Vista-Controlador) o la inyección de dependencias. Esto puede resultar en un código más organizado, mantenible y escalable a medida que el proyecto crece.\nComunidad activa: Los frameworks suelen tener una comunidad activa de desarrolladores que contribuyen con bibliotecas, extensiones, tutoriales y soporte en línea. Esto puede ser útil para obtener ayuda, resolver problemas y mantenerse al día con las mejores prácticas y las últimas actualizaciones.\nDocumentación detallada: Los frameworks a menudo vienen con una documentación completa y detallada que facilita el aprendizaje y el uso de las características proporcionadas. Esto puede ser especialmente útil para los desarrolladores que son nuevos en un lenguaje o en el desarrollo web en general.\n¿Cuál es la recomendación de la comunidad? En cuanto a la recomendación de un framework en particular por parte de la comunidad, no hay una preferencia unánime. Cada desarrollador tiene la libertad de elegir el framework que mejor se adapte a sus necesidades específicas. Sin embargo, es común sugerir que la biblioteca estándar de Go proporciona una base sólida y completa para la mayoría de los proyectos.\n"},{"href":"https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/","title":"CodeLab. Implementemos un Worker Pool","body":" Mengniu Dairy production line. Gentileza de Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/ La concurrencia es una herramienta que nos ayuda a ejecutar tareas pesadas o que bloquean el avance de un proceso, mientras otras tareas se ejecutan, mejorando el rendimiento general.\nPero ¿Podemos hacer uso de la concurrencia sin ponernos un límite?\nConcurrencia es un aspecto integral del desarrollo moderno de software que permite que nuestras aplicaciones ejecuten múltiples tareas simultáneamente y nos permite usar efectivamente los recursos del sistema, especialmente en situaciones donde debemos llevar a cabo mucho computo u operaciones de entrada/salida.\nPero ¿Hay un Límite?\nImaginemos el periódo de matriculas de un colegio en donde se debe registrar el ingreso y asignar curso a cientos de alumnos. Podríamos poner un funcionario encargado para el registro de cada alumno, pero solo podríamos hacerlo hasta completar el máximo número de funcionarios disponibles\n¡Además de que todas las demás tareas de esos funcionarios quedarían en pausa hasta terminar el proceso de registro!\nWorker pool es un patrón concurrente cuya idea base es tener un número de gorutinas esperando a que se le asignen trabajos, ejecutándolos a medida que se le van asignando Como eso es poco verosímil, que tal si dejamos solo a 4 funcionarios realizando el proceso de matricula mientras que los demás se reparten las tareas habituales. De esta forma los 4 funcionarios registran alumnos concurrentemente. Junto con ello, esto nos permite que si vemos que se produce un cuello de botella, por ejemplo muchos apoderados llegan a registrar a sus pupilos al mismo tiempo, podemos reforzar con algunos funcionarios extra, y devolverlos a sus tareas habituales cuando se haya procesado el cuello de botella.\nPues bien, con esta analogía hemos descrito el funcionamiento de un worker pool, el cual es un patrón para lograr concurrencia, cuya idea base es tener un número de gorutinas, que reciben el nombre de worker, esperando a que se le asignen trabajos. Cuando un trabajo se le asigna a un worker, se ejecuta concurrentemente mientras la gorutina principal sigue ejecutando otro código.\nLa idea base de nuestra implementación es gatillar bajo demanda un número fijo de gorutinas que harán las veces de workers e iran recibiendo tareas a ejecutar a través de un canal por el cual las enviaremos Worker pool nos permite administrar el nivel de concurrencia de nuestras aplicaciones controlando el uso de recursos de procesamiento.\n¡Pero basta de teoría y ensuciemonos las manos que a eso hemos venido!\nImplementaremos un worker pool definiendo cada parte que lo constituye, junto con algunas utilidades para obtener métricas.\nLa idea base de nuestra implementación es gatillar bajo demanda un número fijo de gorutinas que harán las veces de workers e iran recibiendo tareas a ejecutar a través de un canal por el cual las enviaremos.\nDecimos que gatillaremos bajo demanda a los workers porque los iremos levantando a medida que vayan llegando tareas y no hayan workers para ejecutarlas, hasta llegar al límite definido de workers. En pocas palabras, implementaremos una lazy inicialization de los workers de nuestro pool.\nDentro de las consideraciones de diseño, haremos un fuerte uso de interfaces pues nos permiten que los elementos que componen el worker pool sean plugables y posibles de reemplazar por otros componentes que implementen la interface.\nLa belleza de esto radica en que si a Ud. se le ocurre una mejor implementación, o necesita funcionalidades extra que no están contempladas, puede construir su propia implementación de acuerdo a sus gustos o necesidades, y mientras exponga los métodos de la interface definida, su código personalizado trabajará perfectamente con el resto del worker pool.\nTareas Dentro del contexto de programación concurrente es usual llamar aquello que se procesa como tarea, que son trabajos que pueden ser ejecutados asíncrona y concurrentemente. Así que empecemos por definir la estructura de datos que nuestro worker pool será capaz de procesar.\ntype Task interface { Run() } Una interface llamada Task, exponiendo un método Run que será implementada por las tareas concretas que necesitemos procesar.\nExecutor y Spawner Comentamos que los workers deben levantarse a medida que las tareas vayan llegando, y que deben ir ejecutandolas. Podemos abstraer esas dos funcionalides en respectivas interfaces.\ntype Executor interface { // Execute ejecuta una tarea Task para un worker pool Pool Execute(Task, Pool) } La interface Executor tendrá la responsabilidad de ejecutar cada tarea\ntype Spawner interface { // Spawn engendra un nuevo worker para el worker pool // recibe como argumento: // El canal por donde se recibirán las tareas // Una función capaz de ejecutar una tarea // Una función que se ejecutará al momento de desplegar el worker // Una función que se ejecutará al momento de terminar al worker Spawn(chan Task, func(Task), func(), func()) } Spawner cuya finalidad será levantar un nuevo worker cuando sea necesario.\nPool type Pool interface { // Submit Envia una nueva tarea al worker pool Submit(Task) // WaitAll Espera a que todos los workers terminen de procesar sus tareas asignadas WaitAll() // Execute Ejecuta las tareas enviadas al worker delegando en la interface [Executor] Execute(Task) // SpawnWorker Levanta un nuevo worker delegando en la interface [Spawner] SpawnWorker() // WorkerSpawned Retorna el número de workers levantados hasta el momento WorkerSpawned() int32 // SubmittedTasks Retorna el número de tareas enviadas a los workers SubmittedTasks() int32 // AddReadyTask agrega el deltas indicado como parámetro a la cantidad // de tareas ejecutadas. Se usa en DefaultExecutor por ejemplo AddReadyTask(int32) // OnExecuteTask Lo usaremos como un hook para inyectar código que se ejecutará cuando el [Executor] ejecute cada tarea OnExecuteTask(time.Time) // CummulatedWorkTime() time.Duration` Devuelve el tiempo de trabajo hasta el momento de su invocación CummlatedWorkTime() time.Duration // AVGTime Devuelve el tiempo promedio de ejecución de tareas AVGTime() time.Duration } Definimos la última de nuestras interfaces, la interface Pool que representa al worker pool.\nCon la api de nuestro worker pool ya definida, procedemos ahora a construir una implementación concreta.\nImplementando a Executor. DefaultExecutor type DefaultExecutor struct{} func (e *DefaultExecutor) Execute(task Task, p Pool) { start := time.Now().UTC() defer p.OnExecuteTask(start) defer p.AddReadyTask(1) task.Run() } Tal como se indicó en la definición de nuestra api, el executor es responsable de gatillar la tarea recibida por el worker.\nEn esta implementación registraremos el tiempo que las tareas demoran en ejecutarse, y para invocar al método OnExecuteTask del worker pool.\nImplementando a Spawner. DefaultSpawner. type DefaultSpawner struct{} func (s *DefaultSpawner) Spawn( tasks chan Task, executor func(Task), onStart func(), onEnd func() ) { // Antes de levantar propiamente al worker, ejecutamos la función onStart // recibida como argumento. Esto nos da la oportunidad // de inyectar un hook al momento de levantar los workers onStart() // Levantamos al worker en su propia gorutina go func() { // registramos la función onEnd recibidas como argumento // para que se ejecute al terminar la gorutina defer onEnd() for task := range tasks { // Dejamos un medio para terminar al worker // recibiendo una tarea con valor nil if task == nil { return } // para cada tarea recibida, invocamos a la // función executor recibida como argumento // para que la gatille. executor(task) } }() } Implementado Pool. Deadpool Implementaremos ahora a nuestro Pool concreto, le llamaremos Deadpool por razones obvias.\nCuando definamos al constructor usaremos funciones argumentales variadicas pues nos proveen de una gran flexibilidad.\n// Definimos los posibles errores que puede gatillar la creación de un nuevo deadpool var ( ErrInvalidMaxWorkers = errors.New(\u0026#34;invalid max number of workers\u0026#34;) ErrInvalidCap = errors.New(\u0026#34;invalid capacity for tasks stream\u0026#34;) ErrInvalidExecutor = errors.New(\u0026#34;expected a valid Executor. Nil received\u0026#34;) ErrInvalidSpawner = errors.New(\u0026#34;expected a valid Spawner. Nil received\u0026#34;) ) type deadpool struct { // maxWorkers indica la cantidad máxima de workers a levantar maxWorkers int32 // cap es la capacidad de tareas para el worker pool. Se usa como // el segundo parámetro de `make` al construir el canal de tareas cap int8 // currentWorkersQTY registra la cantidad actual de workers levantados currentWorkersQTY int32 // readyTasksQTY registra la cantidad de tareas ejecutadas readyTasksQTY int32 // submittedTasksQTY registra la cantidad de tareas enviadas a los workers submittedTasksQTY int32 // registra el tiempo acumulado de proceso para las tareas ejecutadas cummulatedTime time.Duration // registra el tiempo promedio de ejecución de las tareas avgTaskTime time.Duration // executor de tipo [Executor] es un punto de montaje para un // Executor personalizado, en caso de no proveerse uno, se usará //[DefaultExecutor] executor Executor // spawner de tipo [Spawner] es un punto de montaje para un // Spawner personalizado, en caso de no proveerse uno, se usará //[DefaultSpawner] spawner Spawner // tasksStream es el canal por donde se enviaran las tareas a los workers tasksStream chan Task wg *sync.WaitGroup mu sync.Mutex } // New devuelve un puntero a un deadpool inicializado y listo para usar. func New(opts ...func(*deadpool)) (*deadpool, error) { // Instancia de deadpool con defauklts executor y spawner d := \u0026amp;deadpool{ executor: \u0026amp;DefaultExecutor{}, spawner: \u0026amp;DefaultSpawner{}, wg: \u0026amp;sync.WaitGroup{}, mu: sync.Mutex{}, } // procesamos las funciones argumentales variadicas for _, f := range opts { f(d) } if d.maxWorkers \u0026lt;= 0 { return d, ErrInvalidMaxWorkers } if d.cap \u0026lt; 0 { return d, ErrInvalidCap } // Si por cualquier causa se pasó un executor nil, terminamos con el // error correspondiente if d.executor == nil { return d, ErrInvalidExecutor } if d.spawner == nil { return d, ErrInvalidSpawner } // construimos el canal donde dejaremos caer las tareas d.tasksStream = make(chan Task, d.cap) return d, nil } func (d *deadpool) AddReadyTask(qty int32) { atomic.AddInt32(\u0026amp;d.readyTasksQTY, qty) } // Submit envía una nueva tarea parea ser procesada por algún worker func (d *deadpool) Submit(task Task) { // engendramos un nuevo worker solo si es necesario d.SpawnWorker() // enviamos la tarea por el canal d.tasksStream \u0026lt;- task // aumentamos en 1 la cantidad de tareas enviadas usando una operación atómica atomic.AddInt32(\u0026amp;d.submittedTasksQTY, 1) } // WaitAll espera porque todos los workers levantados terminen sus tareas asignadas func (d *deadpool) WaitAll() { if d.tasksStream != nil { close(d.tasksStream) } d.wg.Wait() } // Execute ejecuta la tarea delegando a la implementación de // [Executor] definida func (d *deadpool) Execute(task Task) { d.executor.Execute(task, d) } // SpawnWorker levanta un nuevo worker func (d *deadpool) SpawnWorker() { // Obtiene de una operación atómica la cantidad actual de workers levantados currentWorkersQTY := atomic.LoadInt32(\u0026amp;d.currentWorkersQTY) // si es menor a la cantidad máxima de workers indicada, procedemos a levantar un nuevo worker if currentWorkersQTY \u0026lt; atomic.LoadInt32(\u0026amp;d.maxWorkers) { // Para levantar un nuevo worker delegamos a la implementación definida // de [Spawner] d.spawner.Spawn( d.tasksStream, // canal de tareas d.Execute, // función ejecutora que al final delega al [Executer] func(workerID int32) func() { // función a invocar al iniciar el worker return func() { // en esta implementación lo usamos para d.wg.Add(1) // aumentar en 1 el contador de workers a esperar } }(currentWorkersQTY), func(workerID int32) func() { // función a invocar al terminar el worker return func() { // en esta implementación lo usamos para d.wg.Done() // disminuir en 1 el contador de workers a esperar } }(currentWorkersQTY), ) atomic.AddInt32(\u0026amp;d.currentWorkersQTY, 1) // Aumentamos en 1 la cantidad de workers levantados // con una operación atómica } } // OnExecuteTask es un hook que se provee para inyectar código antes de ejecutar una tarea. func (d *deadpool) OnExecuteTask(start time.Time) { d.mu.Lock() defer d.mu.Unlock() // En esta implementación lo usamos para guardar el tiempo // de ejecución de las tareas // para calcular el cummulated execution time y el avg execution time ellapsed := time.Since(start) d.cummulatedTime += ellapsed readies := time.Duration(atomic.LoadInt32(\u0026amp;d.readyTasksQTY)) d.avgTaskTime = d.cummulatedTime / readies // Pero ud. podría usarlo para lo que quiera! } func (d *deadpool) WorkerSpawned() int32 { return d.currentWorkersQTY } func (d *deadpool) SubmittedTasks() int32 { return d.submittedTasksQTY } func (d *deadpool) AVGTime() time.Duration { return d.avgTaskTime } func (d *deadpool) CummlatedWorkTime() time.Duration { return d.cummulatedTime } /// Funciones argumentales variadicas // WithMax indica el máximo número de workers func WithMax(max int32) func(*deadpool) { return func(d *deadpool) { d.maxWorkers = max } } // WithCap indica la capacidad del canal. Si se omite el canal de tareas no estará buffereado func WithCap(cap int8) func(*deadpool) { return func(d *deadpool) { d.cap = cap } } // WithExecutor permite explicitar el Executor a usar. Si se omite, se usa [DefaultExecutor] func WithExecutor(exe Executor) func(*deadpool) { return func(d *deadpool) { d.executor = exe } } // WithSpawner permite explicitar el [Spawner] a usar. Si se omite, se usa [DefaultSpawner] func WithSpawner(spn WorkerSpawner) func(*deadpool) { return func(d *deadpool) { d.spawner = spn } } En nuestra implementación hemos decidido usar el paquete atomic que provee primitivas de memoria de bajo nivel. La documentación de Go recomienda preferir el paquete sync o canales para sincronizar memoria, pero como lo que necesitabamos hacer era aumentar en 1 algunas variables nos decantamos por atomic.\nComo ninguna implementaciónm está terminada sin sus pruebas, construyamoslas para probar nuestro invento.\nfunc Test_deadpool_ErrsOnCreate(t *testing.T) { _, err := New(WithMax(-1)) if err == nil { t.Log(\u0026#34;ErrInvalidMaxWorkers expected\u0026#34;) t.FailNow() } _, err = New(WithCap(-1)) if err == nil { t.Log(\u0026#34;ErrInvalidCap expected\u0026#34;) t.FailNow() } _, err = New(WithExecutor(nil)) if err == nil { t.Log(\u0026#34;ErrInvalidExecutor expected\u0026#34;) t.FailNow() } _, err = New(WithSpawner(nil)) if err == nil { t.Log(\u0026#34;ErrInvalidSpawner expected\u0026#34;) t.FailNow() } } El test anterior comprueba que los posibles errores al instanciar a nuestro pool se gatillen correctamente.\nAhora implementemos un mock de una tarea para poder probar la infraestructura completa.\ntype taskTest struct { id int } func newTaskTest(id int) *taskTest { return \u0026amp;taskTest{ id: id, } } func (t *taskTest) Run() { defer func() { if os.Getenv(\u0026#34;DEBUG\u0026#34;) == \u0026#34;TRUE\u0026#34; { fmt.Printf(\u0026#34; stoping task %d\\n\u0026#34;, t.id) } }() if os.Getenv(\u0026#34;DEBUG\u0026#34;) == \u0026#34;TRUE\u0026#34; { fmt.Printf(\u0026#34; starting task %d\\n\u0026#34;, t.id) time.Sleep(10 * time.Millisecond) } } Simulamos un trabajo en nuestra implementación mock de tarea esperando durante 10 milisegundos. Además, agregamos unas comprobaciones a la variable de entorno DEBUG para poder ver logs del inicio y fin de la ejecución de las tareas mock.\nfunc Test_deadpool_Flow(t *testing.T) { // Instanciamos un nuevo deadpool con un máximo de 6 workers d, err := New(WithMax(6)) if err != nil { t.Log(err) t.FailNow() } start := time.Now().UTC() // Enviaremos al worker pool 128 de nuestras tareas mock for i := 1; i \u0026lt;= 128; i++ { func(i int) { d.Submit(newTaskTest(i)) }(i) } d.WaitAll() // estadisticas t.Logf(\u0026#34;tiempo acumulado de proceso: %v\\n\u0026#34;, d.CummlatedWorkTime()) t.Logf(\u0026#34;tiempo promedio por tarea: %v \\n\u0026#34;, d.AVGTime()) t.Logf(\u0026#34;tiempo total de proceso: %v\u0026#34;, time.Since(start)) } Y al ejecutar nuestro test con la variable de entrono DEBUG con valor TRUE podemos ver el resultado.\n$ DEBUG=TRUE go test -timeout 256s -run ^Test_deadpool_Flow$ github.com/profe-ajedrez/deadpool -v === RUN Test_deadpool_Flow starting task 1 starting task 2 starting task 3 starting task 4 ... stoping task 122 stoping task 125 stoping task 128 stoping task 127 deadpool_test.go:60: tiempo acumulado de proceso: 1.298687182s deadpool_test.go:61: tiempo promedio por tarea: 10.145993ms deadpool_test.go:62: tiempo total de proceso: 223.349239ms --- PASS: Test_deadpool_Flow (0.22s) Donde vemos que el tiempo sumado de la ejecución de todas las tareas fue 1.298687182s, pero el tiempo total de proceso solo fue de 223.349239ms, mientras que cada tarea demoro en promedio 10.145993ms que es una fracción mayor a los 10ms que le indicamos que debía esperar la tarea mock.\nComo alternativa al worker pool, según sea nuestro caso podriamos haber implementado un pipeline, que consiste en una cadena de gorutinas cada una de las cuales realiza una acción sobre un elemento hasta completarlo, y cuya analogía es una línea de producción.\nSea cual sea el patrón concurrente que elijamos, debemos ser cuidadosos de no provocar condiciones de carrera ni fugas de gorutinas, por lo que debemos hacer uso exhaustivo del flag -race al ejecutar nuestras pruebas.\nHemos implementado un worker pool funcional, pero aun no hemos respondido a la pregunta con que iniciamos este artículo ¿Hay algún límite para la concurrencia? Preferimos dejar la pregunta abierta y esperamos sus respuestas en los comentarios.\nPuede hackear el código que hemos construido en este playground, y como de costumbre, le proveemos con el repositorio donde se aloja.\nY bien, con eso llegamos al final de este codelab. Esperamos que haya sido de su agrado y como siempre le recordamos que si le gustó este artículo no dude en compartirlo o en comentarnos si considera que hay algo en lo que podamos mejorar.\n"},{"href":"https://gophers-latam.github.io/posts/2024/01/concatenando-strings.-construyendo-sql/","title":"Concatenando strings. Construyendo SQL","body":" json to go Los strings son un tipo de dato peculiar. A simple vista parecieran no esconder nada raro, pero si los comparamos con tipos de dato numéricos encontramos diferencias interesantes.\nUn string compuesto de solo un caracter, por ejemplo \u0026ldquo;A\u0026rdquo;, ocupa un byte completo para almacenarse. En un byte el número entero sin signo mas pequeño que podemos guardar es 0, siendo 255 el mas grande posible de almacenarse. O sea, un solo caracter como \u0026ldquo;A\u0026rdquo; ocupa la misma cantidad de memoria que un valor del tipo uint8.\nEntonces ¿Cuanta memoria podemos usar al concatenar una enorme cantidad de caracteres en strings de gran tamaño? Investiguémoslo con uno de los usos mas frecuentes de construcción dinámica de strings; la creación de consultas SQL.\nTerminaremos además con una bonita técnica para disminuir aun mas los direccionamientos al guardar los parámetros para la consulta SQL en un slice.\nNosotros no le creemos nada a nadie, todo lo comprobamos por nosotros mismos. Por eso acompañamos cada ejemplo con su respectivo benchmark. ¡Ud. debería hacer lo mismo ya que proveemos los benchmarks para este experimento! Construiremos una consulta sql de varias formas distintas y mediremos su eficiencia con benchmarks.\nUsaremos el siguiente struct para proveer los datos para construir el filtro:\ntype Filter struct { ID int64 // provee el id a buscar Name string // provee el nombre a buscar Lastname string Search string // provee un valor por cual buscar usando LIKE a nombres o apellidos Limit int64 Offset int64 } Usaremos la siguiente constante como base para la consulta que construiremos:\nconst qb = `SELECT id, name, last_name FROM clientes WHERE 1=1 %ATTRS% %ID% %FIRST_NAME% %LAST_NAME% %LIMIT% %OFFSET%` Y la función que construye la consulta con dicho filtro, la cual se basa en la técnica de colocar patrones en el texto y reemplazarlos al ir construyendo la consulta concatenando strings sucesivos:\nfunc QueryBuilderEvil(f Filter) (string, []any) { sql := qb var params []any if strings.TrimSpace(f.Search) != \u0026#34;\u0026#34; { sql = strings.ReplaceAll(sql, \u0026#34;%ATTRS%\u0026#34;, \u0026#34; AND ( name LIKE ? OR last_name LIKE ?)\u0026#34;) params = append(params, \u0026#34;%\u0026#34;+f.Search+\u0026#34;%\u0026#34;, \u0026#34;%\u0026#34;+f.Search+\u0026#34;%\u0026#34;) } else { sql = strings.ReplaceAll(sql, \u0026#34;%ATTRS%\u0026#34;, \u0026#34;\u0026#34;) } if f.ID \u0026gt; 0 { sql = strings.ReplaceAll(sql, \u0026#34;%ID%\u0026#34;, \u0026#34; AND id = ?\u0026#34;) params = append(params, f.ID) } else { sql = strings.ReplaceAll(sql, \u0026#34;%ID%\u0026#34;, \u0026#34;\u0026#34;) } if strings.TrimSpace(f.Name) != \u0026#34;\u0026#34; { sql = strings.ReplaceAll(sql, \u0026#34;%FIRST_NAME%\u0026#34;, \u0026#34; AND name = ?\u0026#34;) params = append(params, f.Name) } else { sql = strings.ReplaceAll(sql, \u0026#34;%FIRST_NAME%\u0026#34;, \u0026#34;\u0026#34;) } if strings.TrimSpace(f.Lastname) != \u0026#34;\u0026#34; { sql = strings.ReplaceAll(sql, \u0026#34;%LAST_NAME%\u0026#34;, \u0026#34; AND last_name = ?\u0026#34;) params = append(params, f.Lastname) } else { sql = strings.ReplaceAll(sql, \u0026#34;%LAST_NAME%\u0026#34;, \u0026#34;\u0026#34;) } if f.Limit \u0026gt; 0 { sql = strings.ReplaceAll(sql, \u0026#34;%LIMIT%\u0026#34;, \u0026#34; LIMIT ?\u0026#34;) params = append(params, f.Limit) } else { sql = strings.ReplaceAll(sql, \u0026#34;%LIMIT%\u0026#34;, \u0026#34;\u0026#34;) } if f.Offset \u0026gt; 0 { sql = strings.ReplaceAll(sql, \u0026#34;%OFFSET%\u0026#34;, \u0026#34; OFFSET ?\u0026#34;) params = append(params, f.Offset) } else { sql = strings.ReplaceAll(sql, \u0026#34;%OFFSET%\u0026#34;, \u0026#34;\u0026#34;) } return sql, params } Antes de analizar, veamos el resultado del benchmark de esta función. En mi máquina arroja estos resultados:\nfunc BenchmarkEvil(b *testing.B) { f := Filter{ Name: \u0026#34;a\u0026#34;, Lastname: \u0026#34;b\u0026#34;, Search: \u0026#34;\u0026#34;, Limit: 10, } b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { _, _ = QueryBuilderEvil(f) } } BenchmarkEvil-16 1655064\t705.8 ns/op\t720 B/op\t11 allocs/op El benchmark nos dice que se ejecutó la función 18720764 veces, durando 764 ns cada iteración, direccionado 784 bytes cada iteración, realizando 11 localizaciones al heap.\n¿Parece rápido? ¿Que puede tener esto de malo? Observe los bytes direccionados, 784. Esto, mas o menos significa que se guardaron en memoria el equivalente a 784 letras \u0026ldquo;A\u0026rdquo;.\nReunamos mas información. Usemos el flag -gcflags=\u0026quot;-m\u0026quot; para descubrir donde se producen los direccionamientos en el heap.\n./main_test.go:21:15: q escapes to heap ./main.go:89:39: \u0026#34;%\u0026#34; + f.Search + \u0026#34;%\u0026#34; escapes to heap ./main.go:89:39: \u0026#34;%\u0026#34; + f.Search + \u0026#34;%\u0026#34; escapes to heap ./main.go:89:57: \u0026#34;%\u0026#34; + f.Search + \u0026#34;%\u0026#34; escapes to heap ./main.go:89:57: \u0026#34;%\u0026#34; + f.Search + \u0026#34;%\u0026#34; escapes to heap ¡Observe además que cada concatenación con + escapa al heap! Cada una genera un direccionamiento nuevo, Lo que si leyó un artículo anterior, entenderá que puede ser susceptible de mejorar.\nPero ¿Que alternativas hay?\nConstruyendo strings de forma eficiente con strings.Builder Tratemos de mejorar nuestra implementación. Usando el mismo struct para el filtro, cambiemos la constante base de sql.\nconst q = `SELECT id, name, last_name FROM clientes WHERE 1=1` Y revisemos esta función alternativa para construir la consulta:\nb := strings.Builder{} // le indicamos una capacidad al slice que contendrá los parámetros de la query // iguala la cantidad máxima de elementos posibles de agregar al filtro params := make([]any, 0, 7) b.WriteString(q) if f.ID \u0026gt; 0 { b.WriteString(\u0026#34; AND id = ?\u0026#34;) // Agregamos el segmento del filtro sql y el parámetro posicional params = append(params, f.ID) } if strings.TrimSpace(f.Name) != \u0026#34;\u0026#34; { // Nótese el espacio extra antes del sql b.WriteString(\u0026#34; AND name = ?\u0026#34;) params = append(params, f.Name) } if strings.TrimSpace(f.Lastname) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND last_name = ?\u0026#34;) params = append(params, f.Lastname) } if strings.TrimSpace(f.Search) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND ( name LIKE ? OR last_name LIKE ?)\u0026#34;) params = append(params, fmt.Sprintf(\u0026#34;%%%s%%\u0026#34;,f.Search), fmt.Sprintf(\u0026#34;%%%s%%\u0026#34;,f.Search)) } if f.Limit \u0026gt; 0 { b.WriteString(\u0026#34; LIMIT ?\u0026#34;) params = append(params, f.Limit) } if f.Offset \u0026gt; 0 { b.WriteString(\u0026#34; OFFSET ?\u0026#34;) params = append(params, f.Offset) } return b, params Revisemos el resultado del benchmark:\nfunc BenchmarkOK(b *testing.B) { f := Filter{ Name: \u0026#34;a\u0026#34;, Lastname: \u0026#34;b\u0026#34;, Search: \u0026#34;\u0026#34;, Limit: 10, } b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { _, _ = QueryBuilderOK(f) } } BenchmarkOK-16 6253722\t234.3 ns/op\t336 B/op\t5 allocs/op ¡Vaya! hemos pasado de 705.8 ns a 234.3 ns, y de un consumo de memoria de 720 bytes disminuimos a 336 bytes ¡Bastante bien no!\nGracias al uso eficiente de strings.Builder podemos evitar concatenaciones costosas. Estas mejoras se explican porque este nuevo constructor de la consulta delega el manejo de la construcción del string a strings.Builder, cuya documentación nos explica que es un tipo de dato que permite construir strings minimizando las copias de memoria que como Ud. ya está imaginando es donde se produce la demora en ejecución y el costo.\nGracias al uso eficiente de strings.Builder podemos dejar de usar la técnica de búsqueda y reemplazo en el string que estamos construyendo y podemos evitar concatenaciones costosas.\nLlevando esto al extremo ¿Hasta que punto deberíamos llegar al pensar en evitar concatenaciones y reemplazarlas por strings.Builder?\nDepende de lo que estemos tratando de hacer. Por ejemplo, en nuestra función QueryBuilderOK Ud. podría decir que en donde se construyen los likes se esta usando fmt.Sprintf, y si acaso no sería mejor usar un builder.\n¡Comprobemoslo! Construyamos una tercera función para generar nuestra consulta sql.\nfunc QueryBuilderOKAlter(f Filter) (strings.Builder, []any) { b := strings.Builder{} params := make([]any, 0, 7) // 7 es la cantidad máxima de elementos que se pueden agregar al filtro b.WriteString(q) if f.ID \u0026gt; 0 { b.WriteString(\u0026#34; AND id = ?\u0026#34;) // Agregamos el segmento del filtro sql y el parámetro posicional params = append(params, f.ID) } if strings.TrimSpace(f.Name) != \u0026#34;\u0026#34; { // Nótese el espacio extra antes del sql b.WriteString(\u0026#34; AND name = ?\u0026#34;) params = append(params, f.Name) } if strings.TrimSpace(f.Lastname) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND last_name = ?\u0026#34;) params = append(params, f.Lastname) } if strings.TrimSpace(f.Search) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND ( name LIKE ? OR last_name LIKE ?)\u0026#34;) b2 := strings.Builder{} b2.WriteString(\u0026#34;%\u0026#34;) b2.WriteString(f.Search) b2.WriteString(\u0026#34;%\u0026#34;) params = append(params, b2.String()) b2.Reset() b2.WriteString(\u0026#34;%\u0026#34;) b2.WriteString(f.Search) b2.WriteString(\u0026#34;%\u0026#34;) params = append(params, b2.String()) } if f.Limit \u0026gt; 0 { b.WriteString(\u0026#34; LIMIT ?\u0026#34;) params = append(params, f.Limit) } if f.Offset \u0026gt; 0 { b.WriteString(\u0026#34; OFFSET ?\u0026#34;) params = append(params, f.Offset) } return b, params } Con su benchmark respectivo\nfunc BenchmarkOKAlter(b *testing.B) { f := Filter{ Name: \u0026#34;a\u0026#34;, Lastname: \u0026#34;b\u0026#34;, Search: \u0026#34;\u0026#34;, Limit: 10, } b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { _, _ = QueryBuilderOKAlter(f) } } Y ejecutemos varias veces los benchmarks para considerar pequeñas variaciones.\n# Usamos el flag -count para indicar el número de ejecuciones # de nuestros benchmarks # y el flag -benchtime para indicar el tiempo mínimo que debería durar cada bench go test -benchmem -count=16 -benchtime=2s -bench . goos: linux goarch: amd64 pkg: aa cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz BenchmarkEvil-16 3066897 744.7 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3498865 727.4 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3386638 718.1 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3180061 728.8 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3392404 741.4 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3488655 732.3 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3306530 736.1 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3028632 718.3 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3517440 710.5 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3404026 704.9 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3467962 756.4 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3440934 738.0 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3392062 711.4 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3522846 735.8 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3203848 701.6 ns/op 720 B/op 11 allocs/op BenchmarkEvil-16 3502076 732.7 ns/op 720 B/op 11 allocs/op BenchmarkOK-16 11799339 228.8 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11871458 228.2 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11488488 264.0 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 12074823 236.2 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 9447732 229.9 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 10044681 204.5 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 12510486 232.0 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 10445984 256.5 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11243646 250.3 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11259970 251.3 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 9696850 247.5 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 11768199 285.7 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 10200710 235.4 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 9136749 232.4 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 9717814 242.0 ns/op 336 B/op 5 allocs/op BenchmarkOK-16 10739455 240.3 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 10271550 246.1 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8569068 237.5 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8484096 277.7 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8993108 265.8 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8013882 286.9 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8815909 240.2 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 9611652 261.0 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8601260 234.4 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 9384111 256.7 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 7744686 268.7 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8082067 289.4 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 11854416 213.5 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 10229622 286.3 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 10405981 219.1 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 8921347 242.1 ns/op 336 B/op 5 allocs/op BenchmarkOKAlter-16 11861126 261.1 ns/op 336 B/op 5 allocs/op PASS ok aa 144.342s Si tomamos los resultados y los ordenamos desde el más rápido hasta el mas lento, vemos que no hay una gran diferencia entre las funciones OK, y que incluso QueryBuilderOK es un poco mas veloz que QueryBuilderOKAlter.\nEn el apartado de memoria ambas gastaron la misma cantidad y realizaron el mismo número de direccionamientos.\n¿Esto significa que cuando necesitemos hacer pocas concatenaciones, o cuando lo tengamos que hacer sobre strings muy pequeños no deberíamos usar strings.Builder?\n¡No lo se! Dependerá de que tan pocas concatenaciones y que tan pequeños sean los strings de su caso. Lo único que puedo recomendarle es construir su programa de forma tal que pueda realizar los benchmarks correspondientes y tomar la decisión con base a los números presentados por estos en cada situación.\nAplicando la técnica de máscaras de parámetros Ahora bien, En el caso de nuestro ejemplo hay formas de optimizar aun mas a nuestro builder que ya no pasan directamente por el manejo del string. Podemos usar la técnica de usar una máscara para determinar el tamaño exacto de los parámetros a agregar a la consulta y direccionar previamente la memoria con ese número para evitar realizar appends mientras se va construyendo la consulta, de la misma forma que evitamos concatenar gracias a strings.Builder.\nfunc QueryBuilderOKMask(f Filter) (strings.Builder, []any) { b := strings.Builder{} // tenemos una instancia de un struct con un campo booleano para // cada elemento del filtro mask := struct { ID bool Name bool Lastname bool Search bool Limit bool Offset bool }{} b.WriteString(q) // Usaremos a size para indicar cuantos elementos tendrá finalmente el slice de parámetros de la consulta size := 0 if f.ID \u0026gt; 0 { b.WriteString(\u0026#34; AND id = ?\u0026#34;) // Agregamos el segmento del filtro sql y el parámetro posicional // Si el elemento del filtro se agrega, se establece su máscara a verdadero mask.ID = true // y se aumenta en 1 el tamaño esperado para el slice de parámetros size++ } if strings.TrimSpace(f.Name) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND name = ?\u0026#34;) mask.Name = true size++ } if strings.TrimSpace(f.Lastname) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND last_name = ?\u0026#34;) mask.Lastname = true size++ } if strings.TrimSpace(f.Search) != \u0026#34;\u0026#34; { b.WriteString(\u0026#34; AND ( name LIKE ? OR last_name LIKE ?)\u0026#34;) mask.Search = true size += 2 } if f.Limit \u0026gt; 0 { b.WriteString(\u0026#34; LIMIT ?\u0026#34;) mask.Limit = true size++ } if f.Offset \u0026gt; 0 { b.WriteString(\u0026#34; OFFSET ?\u0026#34;) mask.Offset = true size++ } // direccionamos el slice de parámetros con la memoria exacta que necesitamos p := make([]any, size) i := 0 // y solo agregamos al slice los elementos del filtro que tengan su respectiva máscara activada if mask.ID { p[i] = f.ID i++ } if mask.Name { p[i] = f.Name i++ } if mask.Lastname { p[i] = f.Lastname i++ } if mask.Search { p[i] = fmt.Sprintf(\u0026#34;%%%s%%\u0026#34;, f.Search) i++ p[i] = fmt.Sprintf(\u0026#34;%%%s%%\u0026#34;, f.Search) i++ } if mask.Limit { p[i] = f.Limit i++ } if mask.Offset { p[i] = f.Offset } return b, p } El respectivo benchmark\nfunc BenchmarkOKMask(b *testing.B) { f := Filter{ Name: \u0026#34;a\u0026#34;, Lastname: \u0026#34;b\u0026#34;, Search: \u0026#34;\u0026#34;, Limit: 10, } b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { _, _ = QueryBuilderOKMask(f) } } El cual al ejecutarse nos arroja los siguientes resultados.\nBenchmarkOKMask-16 10261683 213.8 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12145034 230.7 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 9883455 213.3 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 10661880 212.3 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12725306 211.5 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 9966832 225.5 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 9271009 216.3 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 8934564 236.4 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12176293 249.7 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 11495956 236.9 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 10586841 224.2 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12398922 213.3 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 9481837 247.0 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 10852344 226.4 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 12089485 216.7 ns/op 272 B/op 5 allocs/op BenchmarkOKMask-16 10944657 201.9 ns/op 272 B/op 5 allocs/op !Vemos una mejora en el consumo de memoria y en la velocidad de ejecución!\nConcluyendo, no le crea a nada ni a nadie, compruebelo todo con benchmarks por si mismo en un ambiente lo mas parecido a sus máquinas de producción si le es posible. Detecte los cuellos de botella en su programa y aplique las medidas que su experiencia y conocimiento provean.\nDejamos a su disposición el código provisto en este artículo en este repositorio.\nY con esto despedimos este artículo, no olvide comentar si precisa hacer algún alcance y compartirlo si es que le gustó.\n"},{"href":"https://gophers-latam.github.io/posts/2024/01/desarrollo-con-go-en-neovim/","title":"Desarrollo con Go en Neovim","body":" Go con Neovim En este post vamos a ver cómo configurar desde cero Neovim y específicamente cómo personalizarlo para que nuestro desarrollo con Go sea altamente productivo.\nInstalación Lo primero que debemos de hacer es instalar Neovim.\nSi estamos en Windows, lo podemos hacer de la siguiente manera:\nwinget install Neovim.Neovim o también se puede realizar mediante gestores de paquetes externos como: Chocolatey o Scoop:\n# scoop scoop bucket add main scoop install neovim # chocolatey choco install neovim # (Podes usar `-y` para saltear automaticamente la confirmacion de mensajes). Y si estás en Linux, lo podés hacer de la siguiente manera, dependiendo de tu gestor de paquetes:\n# Arch sudo pacman -S neovim # Debian sudo apt-get install neovim # Fedora sudo dnf install -y neovim python3-neovim Para las demás distribuciones de Linux o para instalarlo de manera local, les dejo la documentación correspondiente.\nTener en cuenta que, dependiendo la distribución que se elija, será diferente la versión. Es decir, si descargamos Neovim en Ubuntu, vendrá con la versión 0.6 mientras que si se descarga en Manjaro, vendrán con la última versión estable (esto por la gestión de paquetes de cada distro).\nEs por esto que es siempre mejor descargar la última versión estable desde el código fuente, ya que nos aseguramos que nuestra versión sea la última y compatible con las últimas novedades de Neovim.\nGestión de carpetas Una vez instalado Neovim, vamos a generar nuestras carpetas.\nEn Linux, haremos lo siguiente en: ~/.config/nvim. Si nuestra carpeta no existe, la creamos.\nEn Windows, sera en: Local Disk (C:)/Users/tu-usuario/AppData/Local/nvim. Si nuestra carpeta no existe, la creamos.\nnvim/ ├── after/ │ └── plugin/ │ ├── tokyonight.lua │ └── telescope.lua ├── lua/ │ └── tu-nombre/ │ ├── init.lua │ ├── packer.lua │ ├── remap.lua │ └── set.lua ├── plugin/ │ └── packer_compiled.lua └── init.lua A continuación se explica para qué sirve cada carpeta.\nafter/plugin: Dentro de esta, creamos los .lua con el nombre del plugin que descarguemos para configurar como queramos nuestros plugins. En el arbol de referencia se ve los archivos tokyonight.lua y telescope.lua que nos sirven como ejemplo (no hace falta crear estos .lua, mas adelante se muestran ejemplos para su comprensión).\nlua/tu-nombre: Aquí, cambiaremos {tu-nombre} por tu nombre, en mi caso thiago, y dentro tendremos los archivos que nos servirán para descargar y setear nuestros atajos y configuraciones de Nvim.\nplugin: Esta carpeta no debemos generarla, contiene un archivo (packer_compiled.lua) que también se genera automáticamente como la carpeta /plugin/. En el archivo, ira toda nuestra configuración de Neovim. Es importante saber que no debemos tocar este archivo. Como información adicional, esta carpeta se generará una vez que ejecutamos el comando :PackerSync más adelante.\ninit.lua: En este archivo, haremos el llamado de la carpeta \u0026ldquo;tu-nombre\u0026rdquo;, para que al iniciar se carguen automáticamente nuestras configuraciones.\nSi bien entraremos en detalle más adelante de cada archivo y configuración, está bueno saber el set up de nuestro editor de texto.\nPacker (Gestor de plugins) Ya con nuestras carpetas generadas, vamos a instalar Packer que será nuestro gestor de plugins para Neovim.\nEs cierto que este repositorio no se mantiene desde Agosto de 2023, y que muchos usuarios de Neovim están migrando a Lazy o Pckr (el sucesor de packer), pero para este post usaremos Packer, ya que sentará las bases de nuestro conocimiento para Neovim y luego podremos realizar otro post sobre la migración a Lazy (esto debido a que quien escribe, actualmente, no migró su gestor a otro 😅).\nPara instalar packer, debemos de hacerlo de la siguiente manera:\nInstalación en Unix, Linux.\ngit clone --depth 1 https://github.com/wbthomason/packer.nvim\\ ~/.local/share/nvim/site/pack/packer/start/packer.nvim Instalación en Windows PowerShell.\ngit clone https://github.com/wbthomason/packer.nvim \u0026#34;$env:LOCALAPPDATA\\nvim-data\\site\\pack\\packer\\start\\packer.nvim\u0026#34; Una vez instalado, iremos al siguiente path: .config/nvim/lua/tu-nombre/ e ingresaremos al archivo packer.lua en donde ingresaremos el siguiente código:\nreturn require(\u0026#39;packer\u0026#39;).startup(function(use) use \u0026#39;wbthomason/packer.nvim\u0026#39; end) Una vez hecho los cambios, haremos el siguiente comando en el modo normal: :so y enter. Y luego de esto haremos: :PackerSync para instalar el nuevo paquete que agregamos (también se generará la carpeta /plugin/ y su respectivo archivo)\nY ya que estamos realizando modificaciones, iremos a nvim/lua/tu-nombre/ y agregaremos los siguientes cambios en:\nnvim/lua/tu-nombre/init.lua require(\u0026#34;tu-nombre.set\u0026#34;) require(\u0026#34;tu-nombre.remap\u0026#34;) y en nuestro init.lua de nvim/init.lua: require(\u0026#34;tu-nombre\u0026#34;) Personalización ya con nuestra configuración básica, vamos a poner bonito nuestro editor de texto, ya que por default viene vacío.\nEn: lua/tu-nombre/set.lua, vamos a setear lo básico de nuestro editor de texto:\nvim.opt.nu = true -- Muestra el número de línea actual. vim.opt.smartindent = true -- Habilita el autoindentado inteligente. vim.opt.cursorline = true -- Resalta la línea en la que se encuentra el cursor. vim.opt.clipboard:append(\u0026#34;unnamedplus\u0026#34;) -- Configura el portapapeles para usar el registro \u0026#34;unnamedplus\u0026#34; (clipboard). vim.opt.termguicolors = true -- Habilita los colores de la terminal si es posible. vim.opt.tabstop = 4 vim.opt.softtabstop = 4 vim.opt.shiftwidth = 4 vim.opt.expandtab = true Y en lua/tu-nombre/remap.lua, vamos a realizar nuestros mapeos.\nPara ejecutar un plugin que instalamos se hace de la siguiente manera: :Plugin-a-Ejecutar\nPero esto es tedioso, por lo que en este archivo .lua, podemos configurarlo para que con ciertas combinaciones se ejecute el plugin que queramos.\nlocal keymap = vim.keymap -- Creamos esta variable para no estar constantemente escribiendo vim.keymap.set({}) local opts = { noremap = true, silent = true } -- Esto se hace para que nuestro atajo sea silencioso y no afecte tu vista. vim.g.mapleader = \u0026#34; \u0026#34; -- Seteamos la tecla espacio como lider. Esto nos servira mas adelante para mapear nuestros atajos. -- Usaremos este mapeo como ejemplo keymap.set(\u0026#34;n\u0026#34;, \u0026#34;\u0026lt;leader\u0026gt;q\u0026#34;, \u0026#34;:q\u0026lt;CR\u0026gt;\u0026#34;) -- Como bien sabemos, para salir de Nvim, se hace con :q. Entonces este mapeo, lo que nos permite es salir de nvim utilizando la combinacion de teclas: \u0026lt;leader\u0026gt; + q. -- \u0026lt;leader\u0026gt; lo seteamos mas arriba (vim.g.mapleader = \u0026#34; \u0026#34;), puede ser cualquier tecla y \u0026lt;CR\u0026gt; es un enter. -- Es lo mismo que hacer :q + enter, nada mas que lo asignamos a un mapeo y ejecutaremos esta funcion de forma facil y rapida. -- Ahora salir de Nvim no sera un problema. Para poder trabajar con temas de colores, lo haremos de la siguiente manera en: nvim/lua/tu-nombre/packer.lua\nreturn require(\u0026#39;packer\u0026#39;).startup(function(use) use \u0026#39;wbthomason/packer.nvim\u0026#39; -- Gestor de paquetes. use \u0026#39;folke/tokyonight.nvim\u0026#39; -- Esquema de colores. use(\u0026#34;nvim-treesitter/nvim-treesitter\u0026#34;, { run = \u0026#34;:TSUpdate\u0026#34; }) -- Nos provee un resaltado de colores en nuestro codigo. use({ \u0026#34;nvim-lualine/lualine.nvim\u0026#34;, -- Barra de estado. requires = { \u0026#34;kyazdani42/nvim-web-devicons\u0026#34;, opt = true }, }) use({ \u0026#34;nvim-tree/nvim-tree.lua\u0026#34;, -- Arbol de archivos. requires = { \u0026#34;nvim-tree/nvim-web-devicons\u0026#34;, }, }) use(\u0026#34;fatih/vim-go\u0026#34;) -- Para el desarrollo con Go. end) Una vez que tengamos los plugins que necesitemos, haremos lo que hicimos en pasos previos\n:so y enter y luego :PackerSync para poder instarlos.\nUna vez instalados, debemos de ir a nvim/after/plugin/ y crear los archivos .lua para cada plugin que descargamos. Por ejemplo.\nnvim/after/plugin/lualine.nvim require(\u0026#39;lualine\u0026#39;).setup({ options = { theme = \u0026#34;auto\u0026#34; } }) nvim/after/plugin/nvim-treesitter.lua require(\u0026#39;nvim-treesitter.configs\u0026#39;).setup({ ensure_installed = {\u0026#34;javascript\u0026#34;, \u0026#34;lua\u0026#34;, \u0026#34;json\u0026#34;, \u0026#34;html\u0026#34;, \u0026#34;css\u0026#34;, \u0026#34;typescript\u0026#34;, \u0026#34;markdown\u0026#34;, \u0026#34;go\u0026#34;, \u0026#34;python\u0026#34;}, sync_install = false, auto_install = true, highlight = {enable = true} }) Para que no se haga muy largo este post, haremos un video en el canal de YouTube de la comunidad para que sea más fácil y visual el uso de Nvim.\nEspero que este posts les sea de utilidad para aprender. Tambien les dejo mi configuración de Nvim en donde explico qué es, porque lo uso y todos los plugins que utilizo en mi día a día.\n"},{"href":"https://gophers-latam.github.io/posts/2023/12/manejo-de-memoria-101.-memoria-virtual-stack-y-heap/","title":"Manejo de memoria 101. Memoria virtual, Stack y Heap","body":" Puzzle. imagen de dominio público gentileza piqsels. https://www.piqsels.com/en/public-domain-photo-smyfi Que Go tiene un recolector de basura integrado lo hemos escuchado muchas veces. Significa que no tenemos que preocuparnos de liberar la memoria que nuestra aplicación usa, pero ¿Deberiamos entender el ciclo de uso de memoria de nuestras aplicaciones? ¿El recolector de basura nos da derecho a olvidar y usar y abusar de ese recurso?\nY, primero que nada ¿Que diablos es la memoria de la que tanto se habla?\nRenuncia de responsabilidades. No es trivial entender la forma en que los computadores trabajan. En aras de poder difundir intentaremos simplificar lo mas posible, en ocasiones, mas alla de lo recomendado. Muchos programadores hemos llegado a Go desde lenguajes de tipado débil, donde hemos tendido a mirar recursos como la memoria como si fueran gratuitos. Nada mas lejos de la verdad, como dice el viejo dicho No hay tal cosa como un almuerzo gratis y si queremos convertirnos en programadores mínimamente competentes debemos tener al menos una idea básica sobre la forma en que se manejan dichos recursos. He ahí la razón de este artículo.\nMemoria virtual Aquellos que ya tengan la escritura de algunos programas a su haber saben que cuando declaramos una variable, lo que estamos haciendo es asignar un identificador a una dirección de memoria en la que guardaremos datos (si nunca ha declarado una variable, hagase un favor y vaya al tour de go).\nMas o menos cuando hablamos de memoria todos pensamos en una grilla homogenea, con direcciones para acceder a cada casilla comodamente.\nPues bien, esa dirección de memoria no salió del aire por generación espontanea, existe físicamente de alguna forma en alguna parte.\nEn realidad, lo que llamamos memoria es una abstracción proporcionada por el sistema operativo, la cual oculta diferentes medios de almacenamiento.\nLos registros del procesador\nLa caché del procesador\nRAM\nArchivos en disco\nEtc.\nEn terminos generales, no sabemos en cual de estos medios de almacenamiento quedará almacenada nuestra variable. Solo sabemos que le hemos pedido memoria al sistema y que este nos la presentó adecuadamente para lograr nuestro objetivo. Claro, en aras de la eficiencia hay una gran probabilidad de que nuestro dato haya quedado guardado en RAM.\nEsta abstracción a la que hicimos referencia, es lo que llamamos memoria virtual, es administrada por el sistema operativo y es un recurso el cual debe ser solicitado.\nMemoria virtual es una abstracción que provee a cada proceso la ilusión de que tiene uso exclusivo sobre la memoria principal. Bryant, R. E. \u0026amp; O’Hallaron, D. R. (2016). Computer System: A Programmer’s Perspective (Third global edition). Pearson Education Limited.\nLa organización en forma de Celdas de memoria que nos es tan familiar es propia de la memoria virtual y como se imagina para que pueda funcionar se necesita una sofisticada interacción entre el sistema operativo y el hardware. Esta interacción se basa en un mapeo, direccionamiento o traslación entre las direcciones de la memoria virtual y el medio físico donde realmente se encuentre nuestro dato.\nCuando se ejecuta un programa, este tiene una visión uniforme de la memoria, la que llamamos Espacio de direcciones virtual, y dentro de este espacio hay dos áreas bien definidas que nos son de vital importancia.\nStack y Heap Stack El Stack es una región de la memoria que es localizada para cada hilo de ejecución de nuestros programas. En el contexto de Go, decimos que cada gorutina tiene su propio Stack. Su objetivo es contener variables locales, argumentos y valores de retorno de funciones, etc.\nCuando se invoca una función, se agrega una nueva capa en el Stack y cuando la función termina, esa capa se quita a su vez del Stack.\nLlamamos Localización/Allocation al proceso de reservar memoria para almacenar nuestros datos, y Deslocalización/Deallocation al proceso de liberarla una vez que ya no la necesitamos. El Stack tiene la ventaja de que permite acceder rápidamente a la memoria, ¡claro! porque los datos más recientes están siempre en la capa superior. Además, como cuando una función termina su ejecución, su capa asociada en el Stack se quita, ¡La memoria utilizada para los datos en esa capa se ve automáticamente deslocalizada!\nEl Stack empieza con espacio pre-localizado de un tamaño fijo, si el runtime detecta que se está quedando sin espacio, localiza más y como la memoría está localizada de antemano, guardar datos en el Stack es barato y automático.\nPara que una variable sea asignada en el Stack, deben cumplirse una serie de requisitos:\nTamaño fijo, conocido en tiempo de compilación\nEl runtime de Go debe ser capaz de determinar completamente su ciclo de vida\nSu tamaño no debe superar la capacidad máxima del Stack (mas las salvaguardas del runtime)\nEl Stack es rápido, localizar y dealocalizar en el es barato. Si estas y otras condiciones no son cumplidas, la variable escapará al Heap.\nHeap El Heap es el área del espacio de direcciones virtual que el runtime de Go solicita para almacenar los datos al ejecutar nuestro programa. El Heap crece dinámicamente y su objetivo es contener los datos que necesitamos persistan mas allá del tiempo de vida de una función o que son muy grandes para ser alojados en el stack.\nEl que nuestros datos escapen al Heap es costoso porque implica una localización, lo que significa que:\n1 Se verifica que el Heap tenga suficiente capacidad para el valor que almacenaremos en el.\n2 Si el punto 1 no se cumple, se debe solicitar más memoria al sistema operativo para el Heap. Se produce una System Call solicitando el recurso. En el mundo real este paso se realiza independientemente. El runtime monitorea constantemente el Heap y algunos algoritmos implementan un una meta, un límite de memoria, que una vez alcanzado o sobrepasado produce la solicitud de mas recursos al sistema operatvo.\n3 Se localiza la memoria en el Heap (por simplicidad incluyamos en este apartado la escritura de los datos que guardaremos).\n4 Se almacena en el Stack un puntero a la dirección de memoria inicial de la localización en el Heap.\nEl Heap es flexible, pero la flexibilidad viene con un costo ¡Todo esto es bastante trabajo para guardar un monton de datos! ¡Sea parsimonioso! Si, porque localizar en el Heap, si bien proporciona muchas ventajas, tiene un costo. Es por eso que en el ecosistema de Go usted encontrará librerías que se jactan de tener cero localizaciones, es decir, estan escritas tan cuidadosamente que no guardan datos en el Heap, sólo usan el Stack.\nEscapando al Heap Revisemos el siguiente código\nmain.go\npackage main func retString() string { retVal := \u0026#34;achu\u0026#34; return retVal } Hemos definido una función que devuelve un string. Construyamos un benchmark para que la podamos analizar.\nmain_test.go\npackage main import ( \u0026#34;testing\u0026#34; ) func Benchmark_retString(b *testing.B) { var a string b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { a = retString() } b.StopTimer() b.Log(a) b.StartTimer() } Al ejecutar el benchmark veremos algo parecido al siguiente reporte\n$ go test -bench . -benchmem goos: linux goarch: amd64 pkg: exmem cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz Benchmark_retString-16 1000000000 0.3356 ns/op 0 B/op 0 allocs/op Donde el benchmark nos informa con 0 allocs/op que han ocurrido 0 localizaciones al heap.\nReunamos más información. Agreguemos al comando el flag -gcflags \u0026quot;-m -m\u0026quot; que hará que el compilador realice un análisis de escape, el cual nos informará de movimientos de datos al heap.\n$ go test -gcflags \u0026#34;-m\u0026#34; -bench . -benchmem # exmem [exmem.test] ./main.go:3:6: can inline retString ./main_test.go:13:16: inlining call to retString ./main_test.go:7:26: leaking param: b ./main_test.go:17:7: ... argument does not escape ./main_test.go:17:8: a escapes to heap # exmem.test _testmain.go:37:6: can inline init.0 _testmain.go:45:24: inlining call to testing.MainStart _testmain.go:45:42: testdeps.TestDeps{} escapes to heap _testmain.go:45:24: \u0026amp;testing.M{...} escapes to heap goos: linux goarch: amd64 pkg: exmem cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz Benchmark_retString-16 1000000000 0.3356 ns/op 0 B/op 0 allocs/op Continua reportandonos 0 localizaciones, pero ha agregado información interesante. Observe la siguiente línea en el reporte:\n./main_test.go:17:8: a escapes to heap Nos indica que la variable a escapa al Heap ¡Y nos dice el lugar exacto donde este escape ocurre!\nLa línea 17 de nuestro archivo de benchmark, precisamente donde pasamos la variable al logger.\nEsto demuestra que el escape no es producto de nuestro código pues el log de la variable está ahí solo como medio informativo y no es parte del mismo.\nConstruyamos otra función, esta vez una que devuelva un puntero a una variable local.\nfunc rePointerToString() *string { retVal := \u0026#34;achu\u0026#34; return \u0026amp;retVal } Y agreguemos el benchmark correspondiente.\nfunc Benchmark_retPointerToString(b *testing.B) { var a *string b.ResetTimer() for i := 0; i \u0026lt;= b.N; i++ { a = rePointerToString() } b.StopTimer() b.Log(a) b.StartTimer() } Al ejecutar el benchmark veremos un reporte parecido a lo que sigue:\ngoos: linux goarch: amd64 pkg: exmem cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz Benchmark_retPointerToString Benchmark_retPointerToString-16 50917658\t24.86 ns/op\t16 B/op\t1 allocs/op PASS ok exmem\t1.292s ¡Una localización que reserva 16 bytes! Agreguemos un nivel más al análisis con -gcflags \u0026quot;-m\u0026quot;\n./main.go:3:6: can inline retString ./main.go:8:6: can inline rePointerToString ./main_test.go:13:16: inlining call to retString ./main_test.go:27:24: inlining call to rePointerToString ./main.go:9:2: moved to heap: retVal ./main_test.go:7:26: leaking param: b ./main_test.go:17:7: ... argument does not escape ./main_test.go:17:8: a escapes to heap ./main_test.go:21:35: leaking param: b ./main_test.go:27:24: moved to heap: retVal ./main_test.go:31:7: ... argument does not escape # exmem.test _testmain.go:39:6: can inline init.0 _testmain.go:47:24: inlining call to testing.MainStart _testmain.go:47:42: testdeps.TestDeps{} escapes to heap _testmain.go:47:24: \u0026amp;testing.M{...} escapes to heap goos: linux goarch: amd64 pkg: exmem cpu: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz Benchmark_retPointerToString Benchmark_retPointerToString-16 49800909 25.77 ns/op 16 B/op 1 allocs/op Otra vez podemos ver varias cosas interesantes:\n./main.go:9:2: moved to heap: retVal ... ./main_test.go:17:8: a escapes to heap ... ./main_test.go:27:24: moved to heap: retVal ... En el archivo main.go, donde definimos la función rePointerToString el análisis de escape nos informa que en la línea 9, donde definimos a la variable retVal como un string, el compilador ha movido la variable al Heap ¡Cuando aún no hemos devuelto su puntero! ¡Lo hacemos recien en la línea 10! ¡Claro! el compilador ha detectado que devolveremos un puntero al valor string almacenado en la variable local, por lo que ha determinado almacenar a la variable en el Heap directamente ¡Aun antes de que se produzca el retorno del puntero!\nHablar sobre memoria y otros temas relacionados con arquitectura de computadores es apasionante, pero es para nunca terminar.\nRecapitulando, hemos dado un recorrido introductorio a vuelo de pajaro sobre la memoria revisando al Stack y al Heap, con algunos ejemplos en código. Conocimos al flag -gcflags \u0026quot;-m\u0026quot; para agregar análisis de escape a nuestros tests y benchmarks.\nSi le gustó este artículo no olvide compartirlo.\n"},{"href":"https://gophers-latam.github.io/posts/2023/12/fuga-de-gorutinas/","title":"Fuga de gorutinas","body":" Fugas. imagen de dominio público gentileza pxfuel. https://www.pxfuel.com/en/free-photo-ojgpw Sabemos que las gorutinas son una de las mas importantes primitivas que Go pone a nuestra disposición para el manejo de concurrencia. Por eso se hace necesaria una forma de prevenir fugas de gorutinas.\nSi aun no empieza a estudiar concurrencia en Go ¡Le sugerimos ver este video de la comunidad antes de leer este artículo! Una fuga o leak de gorutinas es cuando nuestra aplicación crea gorutinas sin tener el cuidado de terminarlas correctamente.\nObservemos el siguiente ejemplo. Seguramente reconocerá el problema, en este caso estamos enviando información por un canal y no tenemos a nadie que consuma dicho canal.\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;math/rand\u0026#34; \u0026#34;runtime\u0026#34; \u0026#34;time\u0026#34; ) func send() int { n := rand.Intn(1000) time.Sleep(200 * time.Millisecond) return n } func submit() int { ch := make(chan int) go func() { ch \u0026lt;- send() }() go func() { ch \u0026lt;- send() }() go func() { ch \u0026lt;- send() }() go func() { ch \u0026lt;- send() }() return \u0026lt;-ch } func submitAll() { for i := 0; i \u0026lt; 5; i++ { submit() } } func main() { submitAll() fmt.Printf(\u0026#34;número de gorutinas: %d\\n\u0026#34;, runtime.NumGoroutine()) } Si ejecutamos este programa veremos lo siguiente:\n$ go run main.go número de gorutinas: 16 Imprime número de gorutinas: 16 ¿Por que razón? Porque el contenido del loop se itera 4 veces y en cada iteración engendra 4 gorutinas en la función submit. Ingenuamente podriamos estar esperando que al salir del ámbito de la función submit las gorutinas se hubiesen cerrado ¡Pero no es así! ¡Siguen corriendo al final de su proceso como lo demuestra la impresión!\nUna fuga o leak de gorutinas es cuando nuestra aplicación crea gorutinas sin tener el cuidado de terminarlas correctamente. Ahora bien, si nuestra aplicación terminara en este punto, no habría problema alguno, pues al acabar su ejecución ya es responsabilidad del sistema operativo realizar las labores de limpieza. Pero muchas veces usamos Go para construir aplicaciones que se ejecutan continuamente sin parar y que se espera que no se detengan, como servicios, apis, etc. En este tipo de aplicaciones, un escenario como el presentado en el ejemplo es insostenible.\nGo reserva una cantidad de memoria específica inicial para que las gorutinas usen como su stack, si bien esta cantidad puede variar de versión en versión, la cantidad actual se puede revisar en el repositorio de GO\nEste stack puede ir creciendo según el proceso que se ejecute dentro de la gorutina.\nEl problema Entonces, ¿Que pasará si nuestra aplicación sufre de fuga de gorutinas y engendra 100000 de ellas durante un periódo de un año sin terminarlas correctamente?\nPues asumiendo optimistamente que el proceso que se ejecuta dentro de nuestras gorutinas fugadas devuelven correctamente la memoria, y que el stack asignado a cada una de ellas sigue teniendo un tamaño de 2kB, tendriamos para ese momento cerca de 200MB de memoria usada por la aplicación que no podrán ser recuperados por el recolector de basura ¡Porque las gorutinas todavía están ejecutandose! ¡Porque nunca nos aseguramos de terminarlas correctamente!\nSi no cuidamos de terminar correctamente las gorutinas que nuestra aplicación engendra, corremos el riesgo de enfrentar Out Of Memory Errors Si ejecutamos nuestra aplicación en algún tipo de contenedor o máquina virtual con un límite duro de memoría, esto puede llegar a ocasionar out of memory errors\n¿Que podemos hacer?\nPreviniendo fugas de gorutinas Inevitablemente debemos aprender y convertirnos en expertos en el modelo de memoria de Go y en su modelo de concurrencia. Esto es de vital importancia, pues de la misma forma que un carpintero es responsable de usar de forma segura su sierra circular, taladro y otros implementos, nosotros como programadores somos responsables de usar correctamente las herramientas de nuestro oficio.\nEn esto cae la construcción de tests y benchmarks y el uso profilactico de herramientas de perfilado como pprof asegurandonos de que las pruebas se realicen por un periodo de tiempo conveniente, pues no es lo mismo perfilar un servicio el mismo día en que lo lanzamos a correr, que dos meses después.\nOtra herramienta muy útil es goleak del equipo de Uber Go, que presenta una forma muy simple de testear que nuestras gorutinas se cierren correctamente.\nSe usa de la siguiente forma:\n1 Debemos importarla a nuestro proyecto $ go get -u go.uber.org/goleak\n2 Debemos construir un test que incluya el flujo completo de nuestras gorutinas. Usaremos el mismo ejemplo anterior\nImportamos la utilidad y nos aseguramos de invocarla usando defer para que se garantice su ejecución al final de nuestro proceso.\npackage main import ( \u0026#34;testing\u0026#34; \u0026#34;go.uber.org/goleak\u0026#34; ) func TestGorutineLeak(t *testing.T) { defer goleak.VerifyNone(t) for i := 0; i \u0026lt; 4; i++ { submitAll() } } ¡Y listo! Al ejecutar el test, si goleak detecta fugas de gorutinas, el test fallará\n$ go test ./... === RUN TestGorutineLeak /home/jacobopus/projects/go/goru/main_test.go:15: found unexpected goroutines: [Goroutine 7 in state chan send, with goru.submit.func1 on top of the stack: goru.submit.func1() /home/jacobopus/projects/go/goru/main.go:19 +0x30 created by goru.submit in goroutine 6 /home/jacobopus/projects/go/goru/main.go:19 +0x66 ] --- FAIL: TestGorutineLeak (4.46s) FAIL Puede revisar la documentación de goleak para descubrir otras formas de uso.\nNo olvide compartir este articulo si fue de su agrado.\n"},{"href":"https://gophers-latam.github.io/posts/2023/10/el-tour-de-go-ahora-en-espa%C3%B1ol/","title":"El tour de Go ahora en Español","body":" Tour de Go en Español ¡Logramos algo increíble como comunidad! La traducción del tour de Go al español. Estamos emocionados de compartir con todos ustedes el increíble logro que hemos alcanzado juntos: la completa traducción del tour de Go al español.\nEste proyecto fue un esfuerzo colaborativo en el que nuestra comunidad contribuyó con su tiempo y conocimiento para hacer que esta herramienta esté disponible para toda la comunidad hispanohablante. ¡El resultado es asombroso!\n¿Qué es El Tour de Go? 👩‍💻👨‍💻 Para aquellos que aún no lo conocen, el \u0026ldquo;Tour de Go\u0026rdquo; es una excelente introducción al lenguaje de programación Go. Proporciona ejemplos interactivos y explicaciones detalladas, lo que lo convierte en una herramienta invaluable para aprender Go.\nEl poder de la colaboración 👥 La clave de este logro fue la colaboración. Cada uno de nosotros aportó con sus habilidades y conocimientos para llevar a cabo esta traducción. Desde los que realizaron las primeras traducciones hasta aquellos que revisaron y pulieron cada detalle, cada uno de ustedes fue fundamental.\n¿Qué significa esto para la comunidad? 💡 La traducción del tour al español no solo significa que más personas tendrán acceso a esta valiosa herramienta, sino que también fortalece nuestra comunidad y nos posiciona como un grupo que puede lograr grandes cosas cuando trabajamos juntos.\n¿Qué sigue? 🛠️ Nuestro trabajo no termina aquí. Continuaremos buscando maneras de contribuir y crecer como comunidad. Si tienes ideas o proyectos en mente, ¡no dudes en compartirlas!\nUna vez más, felicitaciones a todos los que participaron en este proyecto. ¡Han demostrado el increíble poder de la comunidad de Gophers Latam!\n¡Sigamos construyendo juntos! 🚀 Tour de Go Link del repositorio: https://github.com/gophers-latam/go-tour-es\nLink profesional sobre la comunidad: https://es.linkedin.com/posts/thiago-mowszet_github-gophers-latamgo-tour-es-traducci%C3%B3n-activity-7118450478593536000-JlrR\n"},{"href":"https://gophers-latam.github.io/posts/2023/03/handlers-con-timeout/","title":"Handlers Con Timeout","body":" go handlers En algunas oportunidades, vamos a necesitar un comportamiento muy determinístico en nuestras APIs, ya sea porque el negocio así lo requiere o los clientes. Tal vez, un comportamiento que se mantenga alejado de cualquier sorpresa, puede ser el máximo de duración que le queremos dejar como ventana para que un respuesta sea entregada, en caso de excederlo, ahora si como el título lo dice, devolvemos un timeout\u0026hellip; pero, qué es un timeout?\nEn principio sabemos que contamos con 2 estados para representarlo, pero no se parecen mucho ya que están en centenas distintas, unos es 408 request timeout y el otro es 504 Gateway timeout. Si leemos un poco las especificaciones, ninguno de los dos nos calza justo para lo que queremos, el 408 nos dice que el cliente \u0026ldquo;se tardó demasiado para enviar su request\u0026rdquo;, desde la RFC dice lo siguiente:\nThe client did not produce a request within the time that the server was prepared to wait. The client MAY repeat the request without modifications at any later time.\nY para su contraparte del lado del servidor:\nThe server was acting as a gateway or proxy and did not receive a timely response from the upstream server.\nEntonces, para la responder la pregunta, concluimos que un timeout es que esperamos demasiado por algo, y no sucedió, ademas, lo consideramos un error.\nCómo hacemos nuestras funciones de Timeout? En los lenguajes de programación modernos, encontramos built-in algunas formas de manejar estos casos de uso. En Golang, por ejemplo el paquete context tiene constructores para crear uno que expire y se cancele después de cierto tiempo.\nDentro del paquete net/http también nos encontramos con muchos timeouts como por ejemplo en la struct http.Client para hacer requests y http.Server es otra que tampoco se queda afuera de tener este tipo de configuración.\nPor ahora, tenemos: context, http.Client y Server, servidores TCP y UDP, etc. Podemos resumir que siempre que haya una conexión hacia fuera (ya sea cliente o servidor) vamos a poder configurar un timeout.\nCómo nos sirven en los web handlers? Antes, debemos aclarar que es un middleware, en cualquier lenguaje, ya que es un concepto y no una implementación específica de Golang.\nEntonces, decimos que son funciones con la misma firma que un handler (o controlador web), que recibe los mismos parámetros para operar como una petición HTTP. Al ser iguales, nos permite ejecutarlo previamente de una forma sencilla y pre-ejecutar operaciones que nos ayuden a nuestro negocio. Un claro ejemplo son validaciones de token JWT, agregar request ID unicos, sumarle datos al contexto (esto si es mas estilo gopher). En nuestro caso, vamos a tener un middleware que se encargue de reemplazar el contexto, por otro que tenga un timeout, para que no tarde mas de tanto tiempo y si no, falla. Nos va a ayudar a garantizar un tiempo de respuesta de máxima, por las buenas o por las malas.\nLo llevamos a código Como middleware, podemos usar uno que ya existe y está dentro del paquete http, es http.Timeout y dentro de su firma, vamos a pasarle un http.Handler, el tiempo de espera que vamos a soportar y por último (este no me gusta mucho) un mensaje como string, donde nos quita un poco de flexibilidad, a mi entender, []byte nos daría un espectro mas amplio a la hora de retornar los valores.\nPodemos implementarlo como un wrapper general a todo el multiplexer y que todos ejecuten el middleware, este tiene como ventaja que escribimos una sola vez, pero perdemos granularidad. func main() { mux := http.NewServeMux() mux.HandleFunc(\u0026#34;/\u0026#34;, func(w http.ResponseWriter, r *http.Request) { //.... }) muxWithMiddleware := http.TimeoutHandler(mux, time.Second*5, \u0026#34;timeout!\u0026#34;) log.Fatal(http.ListenAndServe(\u0026#34;:8080\u0026#34;, muxWithMiddleware)) } Por último, tenemos otro camino, para tener un control espercífico en cada handler que expongamos. func main() { mux := http.NewServeMux() helloHandler := http.TimeoutHandler(wrapHandlerFunc(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte(\u0026#34;hello with timeout!\u0026#34;)) })), time.Second*5, \u0026#34;timeout\u0026#34;) mux.Handle(\u0026#34;/\u0026#34;, helloHandler) } func wrapHandlerFunc(handler http.Handler) http.Handler { wrapped := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set(\u0026#34;Content-Type\u0026#34;, \u0026#34;application/json\u0026#34;) handler.ServeHTTP(w, r) }) return wrapped } Conclusiones Vemos la flexibilidad que tenemos para exponer funciones en un servior web que tenemos en Golang. Siempre nos da muchas facilidades y opciones, a su vez, puede ser un poco confuso porque no sabemos bien cual usar. Como pequeño consejo, no nos fritemos la cabeza pensando y comparando, tan solo elijamos una con un análisis superficial y despues nos queda el aprendizaje.\nPara cerrar el tema técnico, estamos re-utilizando una funcion de la stdlib de Go, por lo que no es necesario que nostros pensemos esa lógica, también, muchos de los Frameworks web como Echo, Gin y Fiber (seguramente entre varios otros) ya traen sus middleware de timeout y es de una implementacion muy similar a la que acabamos de ver.\nEspero que les haya gustado la explicación! nos vemos dentro de poco y cualquier tema que quieran que tratemos lo pueden dejar en comentarios.\n"},{"href":"https://gophers-latam.github.io/posts/2022/08/intro-go-mistakes-okno/","title":"Intro Go Mistakes Okno","body":" okno Se comparte el concepto o contexto de algunos errores basicos con su definición acompañado de ejemplo y solución.\nIndice: Código y organización del proyecto Código y organización del proyecto - Sombreado de variable (shadowing) no deseado La parte de una aplicación donde un enlace de nombre es válido. En Go, un nombre de variable declarado en un bloque se puede volver a declarar en un bloque interno. Este principio, llamado sombreado de variable, es propenso a errores.\nEjemplo:\nvar client *http.Client if tracing { client, err := createClientWithTracing() if err != nil { return err } log.Println(client) } else { client, err := createDefaultClient() if err != nil { return err } log.Println(client) } 1 Declarar una variable client 2 Crear un cliente HTTP con tracing habilitado, la variable client está sombreada en este bloque 3 Crear un cliente HTTP predeterminado, la variable client también se sombrea en este bloque Como resultado, de este ejemplo, la variable externa siempre será nula.\nSolución:\nLa primera opción es usar variables temporales en los bloques internos:\nvar client *http.Client if tracing { c, err := createClientWithTracing() if err != nil { return err } client = c } else { // Same logic } 1 Crear una variable temporal c 2 Asignar esta variable temporal a client Otra opción es usar el operador de asignación (=) en los bloques internos para asignar directamente los resultados de la función a la variable. Sin embargo, requiere crear una variable de error ya que el operador de asignación solo funciona si ya se ha declarado un nombre de variable:\nvar client *http.Client var err error if tracing { client, err = createClientWithTracing() if err != nil { return err } } else { // Same logic } 1 Declarar una variable de error 2 Usar operador de asignación para asignar el *http.Client devuelto a la variable client directamente - Código anidado innecesario Un aspecto crítico de la legibilidad es el número de niveles anidados. Un código se califica como legible en función de múltiples criterios, como el nombrado, la consistencia, el formato, etc. Un código legible requerirá menos esfuerzo cognitivo para mantener un modelo mental; por lo tanto, será más fácil de leer y mantener.\nEjemplo:\nTiempo o dificultad para entender la siguiente función a detalle.\nfunc join(s1, s2 string, max int) (string, error) { if s1 == \u0026#34;\u0026#34; { return \u0026#34;\u0026#34;, errors.New(\u0026#34;s1 is empty\u0026#34;) } else { if s2 == \u0026#34;\u0026#34; { return \u0026#34;\u0026#34;, errors.New(\u0026#34;s2 is empty\u0026#34;) } else { concat, err := concatenate(s1, s2) if err != nil { return \u0026#34;\u0026#34;, err } else { if len(concat) \u0026gt; max { return concat[:max], nil } else { return concat, nil } } } } } func concatenate(s1 string, s2 string) (string, error) { // ... } Solución:\nHacer la tarea de aplicar legibilidad y consistencia sobre la misma función, implementandola de manera diferente:\nfunc join(s1, s2 string, max int) (string, error) { if s1 == \u0026#34;\u0026#34; { return \u0026#34;\u0026#34;, errors.New(\u0026#34;s1 is empty\u0026#34;) } if s2 == \u0026#34;\u0026#34; { return \u0026#34;\u0026#34;, errors.New(\u0026#34;s2 is empty\u0026#34;) } concat, err := concatenate(s1, s2) if err != nil { return \u0026#34;\u0026#34;, err } if len(concat) \u0026gt; max { return concat[:max], nil } return concat, nil } func concatenate(s1 string, s2 string) (string, error) { // ... } El resultado para requerir menos carga cognitiva. - Mal uso de las funciones init En principio init es una función que no toma argumentos y no devuelve ningún resultado (una función func()). Cuando se inicializa un paquete, se evalúan todas las declaraciones de constantes y variables del paquete. El principal problema reside cuando se ha creado un flujo de uso que se vuelve dificil de entender o seguir y por falta de entendimiento se provocan errores no manejados que se volveran dificiles de mitigar o controlar.\nEjemplo:\nOlvidar o no haber entendido el sentido o punto de entrada para ejecuion de init.\npackage main import \u0026#34;fmt\u0026#34; var a = func() int { fmt.Println(\u0026#34;var\u0026#34;) return 0 }() func init() { fmt.Println(\u0026#34;init\u0026#34;) } func main() { fmt.Println(\u0026#34;main\u0026#34;) } Salida\n1: var 2: init 3: main Ejemplo de flujo usando Redis en base de codigo personal.\nSolución:\nHay criterios en sentido idiomatico como:\nEvitar incluir funciones init en codigo que sera probado con paquete de testing.\nNo hacer que sean de ambito global a menos que sea realmente requerido.\nEvitar usar para conexiones a base de datos.\nInvestigar situaciones en las que pueden ser útiles, como definir una configuración estática. De lo contrario, y en la mayoría de los casos, manejar las inicializaciones a través de funciones personalizadas.\nEbook recomendado: 100 Go Mistakes Que trata a fondo algunos errores sobre: Tipos de datos, Estructuras de control, Strings en detalle, Funciones y métodos, Manejo de errores, Concurrencia: Fundamentos y Práctica, Librería estándar, Pruebas y Optimizaciones\n"},{"href":"https://gophers-latam.github.io/posts/2021/12/ecosistema-lenguage-go/","title":"Ecosistema lenguage Go","body":" json to go Go, también conocido como Golang, es un lenguaje de programación de tipado estático desarrollado por Robert Griesemer, Rob Pike y Ken Thompson en Google.\nGo es sintácticamente similar a C, pero viene con seguridad de memoria, recolección de basura, tipificación estructural y sincronización al estilo CSP.\nHay dos implementaciones principales:\nEl paquete de alojamiento de Google que se dirige a múltiples sistemas operativos, dispositivos móviles y WebAssembly.\ngccgo (un front) y GCC\nGo es expresivo, conciso, limpio y eficiente. Los mecanismos simultáneos facilitan la escritura de aplicaciones que aprovechan al máximo las máquinas en red de varios núcleos, mientras que el sistema más nuevo permite crear aplicaciones modulares y flexibles. Compila código máquina con bastante rapidez, pero tiene la conveniencia de la recolección de basura y el poder de reflejar el tiempo de ejecución. - Un lenguaje rápido, bien tipado y bien proporcionado que actúa como un lenguaje interpretado dinámico.\nNada hace que un programador se emocione más que descubrir un nuevo lenguaje de programación. Al examinar el estado actual del software y hardware informático, podemos ver por qué tenemos que cambiar a un nuevo lenguaje como Go. Durante la última década, la potencia de procesamiento en bruto ha aumentado ligeramente y el rendimiento de la frecuencia de la CPU se ha mantenido casi constante durante una década.\nGo, se libero cuando los procesadores de varios núcleos ya estaban disponibles. Es por eso que Go se hizo pensando en la coordinación. Sus mecanismos síncronos facilitan la escritura de aplicaciones que utilizan más sistemas multinúcleo y en red. Si bien el nuevo tipo de sistema Go hace posible construir aplicaciones modulares flexibles, en lugar de centrarse en teorías, en métodos del mundo real para construir aplicaciones de próxima generación en la nube, así como computación avanzada y computación distribuidas.\nHistórico Go es un lenguaje de programación procedimental que se lanzó en 2009 como lenguaje de programación de código abierto. Actualmente se utiliza en varios sistemas operativos de Google. El Go Compiler es compatible con Linux, Mac OS, Windows y una variedad de sistemas operativos BSD como FreeBSD. En términos de arquitectura de procesador, la arquitectura X86, la arquitectura X64, la arquitectura ARM y la arquitectura Power específica de IBM también son compatibles con Go.\nArquitectura Lingüística Go tiene muchas herramientas poderosas de análisis estático. Uno de ellos es go fmt, que diseña su código basándose en el estilo Go propuesto. Esto puede eliminar muchos comentarios en un proyecto normal y alentar a su equipo a concentrarse en el código. Lenguaje de programación desarrollado y compilado de forma nativa, que pertenece principalmente a la familia de lenguajes C en términos de sintaxis básica.\nComo C y C++, está compilado en código de máquina, por lo que no necesitamos entornos como CLR y JVM para ejecutar programas Go. Esto ayuda especialmente al compilar programas grandes. Lenguaje simple y minimalista con diseño original de Go para en lugar del clásico Thread a goroutines. En Go, el límite de tamaño de pila mínimo se elimina de 4 KB a 8 KB cuando se crea una goroutine.\nDiseño Go está influenciado por C, pero con un mayor énfasis en la simplicidad y la seguridad. Esto incluye:\nPatrones de adopción de sintaxis y entorno que son más comunes en lenguajes dinámicos: Declaración de variable corta opcional e introducción inicial por inferencia de tipo.\nEdición rápida.\nAdministración de paquetes remotos (go download) y documentación de paquetes en línea.\nEnfoques distintivos para problemas específicos.\nSincronización inicial: procesos de estilo (Gurvin), canales y expresiones selectivas.\nUn sistema de interfaz en lugar de herencia virtual e incrustación de tipo en lugar de la herencia no virtual.\nUn kit de herramientas que, de forma predeterminada, crea binarios de interfaz nativa sin dependencias externas.\nLa tendencia a preservar las propiedades del lenguaje es lo suficientemente simple como para mantener en calam la cabeza de un programador, en parte eliminando características que son comunes a lenguajes similares.\nGo es Back o Front? El código Go se puede ejecutar usando goper.js en el navegador. Pero el hecho es que la mayoría de los desarrolladores recurren a los lenguajes de programación Front y JavaScript para desarrollar su lado del cliente. Go es más preferido como lenguaje de respaldo y ofrece un alto rendimiento para el desarrollo simultáneo de aplicaciones de servidor.\nAlgunas aplicaciones populares desarrolladas en Go Algunos de los proyectos de código abierto en Go son:\nCaddy: servidor web HTTP 2 de código abierto con capacidad HTTPS automática\nCockroachDB: una base de datos SQL de código abierto, escalable y compatible\nDocker: incluye un conjunto de herramientas de implementación de Linux.\nEthereum: implementación de Go-Ethereum, máquina de bloqueo de máquina virtual, Ethereum virtual para criptomoneda Ether\nHugo: un generador de sitios estáticos\nInfluxDB: base de datos de código abierto para series de datos de alto acceso con requisitos de alto rendimiento\nInterPlanetary File System: un contenido y un protocolo de direccionamiento de medios punto a punto.\nJuju: una herramienta de evaluación de servicios de Canonical, paquetes de Ubuntu Linux.\nKubernetes: sistema de gestión de contenedores\nLightning Network: una red de bitcoins para transacciones rápidas de bitcoins.\nMattermost: un sistema de chat en equipo.\nOpenShift: una plataforma de computación en la nube proporcionada por Red Hat como servicio.\nSnappy: un administrador de paquetes para Ubuntu Touch desarrollado por Canonical.\nSyncthing: software de sincronización de archivos cliente/servidor de código abierto.\nTerraform: una herramienta de código abierto para la infraestructura multimedia en la nube proporcionada por HashiCorp.\nEmpresas y sitios notables que han utilizado GO (generalmente junto con otros lenguajes, no exclusivamente) Cacoo: para renderizar paneles de usuario y microservicios usando Go y gRPC.\nChango: una empresa de publicidad que utiliza sistemas de precios en tiempo real.\nCloud Foundry: una plataforma como servicio.\nCloudFlare: se utiliza para el proxy de codificación Delta Railgun, su servicio de DNS distribuido, así como herramientas para encriptación, registro, procesamiento de flujo y acceso a sitios SPDY.\nCoreOS: un sistema operativo basado en Linux que utiliza el repositorio Docker y el repositorio rkt.\nDropbox: que ha migrado algunos de sus componentes vitales de Python a Go.\nEthereum: una moneda digital\nGoogle: se utiliza para muchos proyectos, incluido el servidor de descargas (dl.google.com).\nHyperledger Fabric: un proyecto de código abierto único.\nMongoDB: una herramienta para administrar instancias de MongoDB\nNetflix: se utiliza para dos partes de la arquitectura de su servidor.\nNovartis: para sistema de inventario interno\nNutanix: se utiliza para una variedad de microservicios en su empresa Cloud OS.\nPlug.dj: un sitio web interactivo relacionado con la transmisión de música social en línea.\nSendGrid: un boulder, servicio de entrega de correo electrónico y servicio de gestión de transacciones.\nSoundCloud: se utiliza para \u0026ldquo;docenas de sistemas\u0026rdquo;.\nEmpalme: se utiliza para todo el backend (API y analizadores) en su plataforma de colaboración musical en línea.\nThoughtWorks: Algunas herramientas y aplicaciones para entrega continua y mensajería instantánea (CoyIM).\nTwitch.tv: para el sistema de chat basado en IRC (migración desde Python).\nUber: para manejar grandes volúmenes de consultas basadas en geovallas\nGo Features Go compila código como lenguajes de bajo nivel como C++/C. Esto significa que funciona casi tan bien como lenguajes de bajo nivel. También utiliza la recolección de basura para recolectar y eliminar objetos.\nEl gráfico siguente muestra que Go es casi tan eficiente como C++/C, mientras mantiene la sintaxis simple como Ruby, Python y otros lenguajes. Esta es una situación en la que todos ganan para los humanos y los procesadores! El alto rendimiento como C++/C y Java proporciona una sincronización altamente eficiente para codificar en términos divertidos como Python y Perl. El software optimizado puede ejecutarse en hardware más barato y lento, como los dispositivos IoT, y generalmente tiene un mayor impacto en la experiencia del usuario final. El modelo de memoria Go agrega una nueva regla para enviar y recibir canales de búfer para indicar explícitamente que un canal de búfer puede usarse como un simple spammer.\nDescripción general de las características principales del lenguaje:\nCompilación: Go genera compilaciones binarias para sus aplicaciones con todas las dependencias. No se requiere instalación de traductor o runtime.\nRecolección de basura: Para recolectar desperdicios de baja latencia, opta por una administración automática de memoria que sea eficiente y sincrónica. La gestión de la memoria es intencionadamente más fácil que C y C++. Los objetos dedicados recolectan basura de forma dinámica.\nSeguro: Go es un lenguaje de tipado estático que admite la seguridad de tipos. El compilador detecta los errores antes de la ejecución.\nSintaxis similar a C: La sintaxis Go recuerda a la familia C, pero con solo 25 palabras clave simples, es fácil de analizar sin tablas/símbolos de información de tipo y un diseño de notificación similar a Pascal.\nVarios paradigmas: Go admite varios patrones de programación, incluida la programación esencial, orientada a objetos (OOP) y la programación funcional.\nLibrería estándar: Go tiene una potente librería estándar de paquetes para respaldar el desarrollo de aplicaciones Go.\nDocumentación sencilla: GoDoc es una herramienta de análisis de código estático que genera documentos estándar simplificados directamente desde el código.\nSoporte de pruebas naturalmente: Soporte de prueba integrado en la librería estándar. Sin necesidad de dependencia adicional Si tiene un archivo llamado thing.go, escriba sus pruebas en otro archivo llamado thing_test.go y ejecute \u0026ldquo;go test\u0026rdquo;.\nGo Tools La distribución principal de Go incluye herramientas para crear, probar y analizar código:\ngo build: crea un binario usando solo sus archivos fuente.\ngo test: se utiliza para pruebas unitarias y microbenchmarks.\ngo fmt: se utiliza para formatear el código.\ngo get: se utiliza para recuperar e instalar paquetes remotos.\ngo vet: un analizador estático que busca posibles vulnerabilidades o errores en el código.\ngo run: un atajo para construir y ejecutar código directamente.\ngo doc: para mostrar documentos o enviarlos a través de HTTP\ngo rename: se utiliza para renombrar variables, funciones, etc. en tipo seguro.\ngo generate: un método estándar para llamar a un generador de código\nTambién incluye soporte de depuración y perfiles, herramientas de medición de tiempo de ejecución. El ecosistema de herramientas de terceros se ha agregado a la distribución estándar, incluido gocode, que permite completar automáticamente el código en muchos editores de texto. goimports (por un miembro del equipo de Go) que automáticamente elimina o agrega paquetes según sea necesario, y errcheck, que detecta errores de código y puede ignorarlos. Hay complementos para agregar soporte de idioma en algunos editores de texto. Hay varios IDE disponibles, incluidos LiteIDE y el \u0026ldquo;Go IDE multiplataforma\u0026rdquo; y GoLand.\nAplicaciones del lenguaje Go está diseñado específicamente como lenguaje de programación para grandes sistemas distribuidos y servidores de red altamente escalables. En este sentido, reemplaza a C++ y Java en la pila de software de Google. Muchos equipos buscan crear nuevos servidores en Go. Algunos incluso están migrando bases de código existentes. Algunas de las tecnologías de Google que utiliza a diario tienen componentes escritos en Go.\nDado que este es un lenguaje de programación relativamente nuevo, muchos preguntan para qué es adecuado.\nUn vistazo a algunos de sus beneficios:\nIdeal para el desarrollo web\nExcelente para scripts de línea de comandos\nSe puede utilizar para aplicaciones de servidor de red.\nSe puede utilizar para el desarrollo de front-end.\nLos desarrolladores disfrutan usando Go porque tiene un entorno de desarrollo completo, y aprender Go es muy fácil, incluso para desarrolladores sin experiencia. Una de las razones de esto se debe al gran ecosistema de herramientas, por lo que es muy útil para proyectos grandes y conjuntos. Esto lo convierte en una excelente opción para programar software propietario. Si se está buscando más beneficios, Go fue creado y es mantenido por Google, que tiene una de las infraestructuras de nube más importantes del mundo y puede ser a gran escala.\nData Science Es una ciencia multidisciplinaria que utiliza métodos, procesos, algoritmos y sistemas científicos para extraer conocimientos e ideas de datos estructurados y no estructurados. La ciencia de datos es el concepto de combinar estadísticas, análisis de datos, aprendizaje automático y métodos relacionados para comprender y analizar fenómenos reales con datos. Extrae técnicas y teorías que han surgido de muchos campos de las matemáticas, la estadística, la informática y la ciencia de la información. El ganador del premio Turing, Jim Gray, ve la ciencia de datos como el \u0026ldquo;cuarto modelo\u0026rdquo; de la ciencia (experimental, teórico, computacional y ahora basado en datos) y afirma que \u0026ldquo;todo lo relacionado con la ciencia está cambiando debido al impacto de la tecnología de la información\u0026rdquo;.\nEn la actualidad, a menudo se usa indistintamente con conceptos anteriores, como análisis empresarial, inteligencia empresarial, modelado de previsión y estadísticas. Si bien muchos programas académicos ahora tienen un título en ciencia de datos, no existe un consenso sobre la definición del contenido curricular apropiado. Sin embargo, muchos proyectos de ciencia de datos y Big Data no han podido lograr resultados útiles, a menudo debido a la falta de gestión y utilización de recursos.\n« Go demuestra cada vez pruebas más rápidas, codificación fácil en lenguajes de programación concurrentes altamente eficientes. Por lo general, es la próxima generación de ciencia de datos, aprendizaje automático e inteligencia artificial, porque existe un gran equilibrio entre la productividad y la retención de código. Muchos prototipos de científicos de datos, que luego son transferidos a producción por otra persona, deja que Go haga ambas cosas. »\n"},{"href":"https://gophers-latam.github.io/posts/2021/08/go-talks/","title":"Go Talks","body":" talks Este post contiene charlas de Go que se pueden leer siguiendo los vinculos de cada título listado.\n2019 playground-v3.slide: Playground v3 2017 state-of-go-may.slide\nexporting-go\nstate-of-go-aug\n2016 refactor.article: Codebase Refactoring (with help from Go)\napplicative.slide: Program your next server in Go\nasm.slide: The Design of the Go Assembler\nstate-of-go.slide: The State of Go\ntoken.slide: Stacks of Tokens\nprototype-your-design\n2015 dynamic-tools.slide: Go Dynamic Tools\ngo-for-java-programmers.slide: Go for Java Programmers\ngo4cpp.slide: Go for C++ developers\ngofmt-cn.slide: gofmt 的文化演变\ngofmt-en.slide: The Cultural Evolution of gofmt\ngogo.slide: Go in Go\ngophercon-go-on-mobile.slide: Go on Mobile\ngophercon-goevolution.slide: The Evolution of Go\ngotham-grpc.slide: gRPC Go\nhow-go-was-made.slide: How Go was made\njson.slide: JSON, interfaces, and go generate\nkeeping-up.slide: Keeping up with the Gophers\nsimplicity-is-complicated.slide: Simplicity is Complicated\nstate-of-go.slide: The State of Go\ntricks.slide: Stupid Gopher Tricks\n2014 c2go.slide: Go, from C to Go\ncamlistore.slide: - Camlistore: Android, ARM, App Engine, anywhere.\ncompiling.slide: - Go: Easy to Read, Hard to Compile\ndroidcon.slide: Go on Android\ngo1.3.slide: Toward Go 1.3\ngo4gophers.slide: Go for gophers\ngo4java.slide: Go for Javaneros (Javaïstes?)\ngocon-tokyo.slide: - Go: 90% Perfect, 100% of the time.\ngotham-context.slide: Cancelation, Context, and Plumbing\ngothamgo-android.slide: Go on Android\nhammers.slide: Gophers With Hammers\nhellogophers.slide: Hello, Gophers!\nnames.slide: What\u0026rsquo;s in a name?\norganizeio.slide: Organizing Go code\nplayground.slide: Inside the Go playground\nreadability.slide: When in Go, do as Gophers do\nresearch.slide: The Research Problems of Implementing Go\nresearch2.slide: More Research Problems of Implementing Go\nstate-of-go.slide: The State of Go\nstate-of-the-gopher.slide: The State of the Gopher (Oct)\nstatic-analysis.slide: Static analysis tools\ntaste.slide: A Taste of Go\ntesting.slide: Testing Techniques\n2013 advconc.slide: Advanced Go Concurrency Patterns\nbestpractices.slide: Twelve Go Best Practices\ndistsys.slide: Go, for Distributed Systems\ngo-sreops.slide: Go Language for Ops and Site Reliability Engineering\ngo1.1.slide: What\u0026rsquo;s new in Go 1.1\ngo4python.slide: Go for Pythonistas\nhighperf.slide: High Performance Apps with Go on App Engine\noscon-dl.slide: dl.google.com: Powered by Go\n2012 10things.slide: 10 things you (probably) don\u0026rsquo;t know about Go\nchat.slide: - Go: code that grows with grace\nconcurrency.slide: Go Concurrency Patterns\ngo-docs.slide: Go docs\ngo1.slide: The Path to Go 1\ngoforc.slide: Go for C programmers\ninsidepresent.slide: Inside the \u0026ldquo;present\u0026rdquo; tool\nsimple.slide: - Go: a simple programming environment\nsplash.slide: Go at Google\ntutorial.slide: Get started with Go\nwaza.slide: Concurrency is not Parallelism\nzen.slide: Go and the Zen of Python\n2011 lex.slide: Lexical Scanning in Go 2010 ExpressivenessOfGo-2010\ngo_talk-20100112\ngo_talk-20100121\ngo_talk-20100323\ngofrontend-gcc-summit-2010\n2009 go_talk-20091030 "},{"href":"https://gophers-latam.github.io/posts/2021/06/conversi%C3%B3n-json-a-go/","title":"Conversión JSON a Go","body":" json to go Uno de los formatos de datos que se encuentra con mucha frecuencia en programación, principalmente web, es JavaScript Object Notation (JSON).\nCuando se recibe datos en formato JSON de representación, debe convertirse a un formato que sea fácil de manipular en el programa en Go. Hay algunas herramientas en línea que permiten convertir fuente JSON directamente en estructuras Go, aunque haciendo una simple búsqueda google.com/search?q=json+to+go se ve varidad de resultados, las destacadas o pioneras son:\nJSON-to-Go - mholt.github.io/json-to-go/\nTransform - transform.tools/json-to-go\nJson2Struct - json2struct.mervine.net/\nPor último como extensión de navegador para mejor accesibilidad existe json to go para Chrome.\n"},{"href":"https://gophers-latam.github.io/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/","title":"Golang: Implementación del almacenamiento en caché","body":" go cache El almacenamiento en caché de datos en una aplicación web a veces es necesario para evitar solicitar datos estáticos de una base de datos o un servicio externo una y otra vez. Go no proporciona ningún paquete integrado en la librería estándar para almacenar en caché las respuestas, pero lo admite a través de paquetes externos creados por la comunidad.\nHay una serie de paquetes, como github.com/coocood/freecache, github.com/patrickmn/go-cache, github.com/eko/gocache y github.com/etcd-io/etcd (gRPC) que pueden ayudar a implementar el almacenamiento en caché. Por parte de la comunidad de Gophers LATAM se busca crear algo relacionado: github.com/gophers-latam/GoKey\nPara este post se estará usando github.com/patrickmn/go-cache para implementar un ejemplo de uso.\nEjemplo: Primero crear un directorio para el código fuente de prueba e inicializar un go module. [go mod init cache-example]\nLuego crear archivo .go, donde se hará un caché por medio de la librería y se completará con datos sobre el arranque del servidor, de la siguiente manera:\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;log\u0026#34; \u0026#34;net/http\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/patrickmn/go-cache\u0026#34; ) const ( CONN_PORT = \u0026#34;8080\u0026#34; ) var newCache *cache.Cache func init() { newCache = cache.New(5*time.Minute, 10*time.Minute) newCache.Set(\u0026#34;gophers\u0026#34;, \u0026#34;gophers latam\u0026#34;, cache.DefaultExpiration) } func getFromCache(w http.ResponseWriter, r *http.Request) { gophers, found := newCache.Get(\u0026#34;gophers\u0026#34;) if found { log.Print(\u0026#34;Key encontrada en caché con valor, como : \u0026#34;, gophers.(string)) fmt.Fprintf(w, \u0026#34;Hola \u0026#34;+gophers.(string)) } else { log.Print(\u0026#34;Key no encontrada en caché : \u0026#34;, \u0026#34;gophers\u0026#34;) fmt.Fprintf(w, \u0026#34;Key no encontrada en caché\u0026#34;) } } func main() { http.HandleFunc(\u0026#34;/\u0026#34;, getFromCache) err := http.ListenAndServe(\u0026#34;:\u0026#34;+CONN_PORT, nil) if err != nil { log.Fatal(\u0026#34;error al iniciar el servidor http : \u0026#34;, err) return } } Ejecutar el código. Como funciona: Una vez iniciado, el servidor HTTP comenzará a escuchar localmente en el puerto 8080. Al inicio, la clave con el nombre gophers con un valor como gophers latam se agregará a la caché.\nAl navegar por http://localhost:8080/ se leerá un valor de key de la caché y lo agregará a Hola como se muestra en la siguiente captura de pantalla:\nLog en terminal:\nSe ha especificado el tiempo de caducidad de los datos de la caché en el programa como 5 minutos, lo que significa que la clave que se ha creado en la caché al iniciar el servidor no estará allí después de 5 minutos. Por lo tanto, acceder a la misma URL nuevamente después de 5 minutos devolverá que la clave no es encontrada en la caché del servidor, de la siguiente manera:\nUsando var newCache *cache.Cache, se declara una caché privada.\nSe actualiza la función init() donde se crea un caché con 5 minutos de tiempo de vencimiento y 10 minutos de intervalo de limpieza, y se agrega un elemento a caché con una clave como gophers con su valor como gophers latam y su valor de vencimiento como 0, lo que significa que se quiere usar el tiempo de vencimiento predeterminado de la caché.\nPara usarse se define el controlador getFromCache donde se recupera el valor de una clave en caché. Si se encuentra, se escribe en respuesta HTTP, de lo contrario, se escribe el mensaje Key no encontrada en caché.\n"},{"href":"https://gophers-latam.github.io/posts/2021/05/golang-init-func/","title":"Golang: Init func","body":" init func Cada programa en Go debe tener un paquete main con una función main para ser ejecutado. Sin embargo, esto impone algunas limitaciones para determinadas soluciones, como las librerías. Imagina que importamos una librería a nuestro código.\nUna librería no está diseñada para ser ejecutada, ofrece estructuras de datos, métodos, funciones, etc. Es probable que las librerías ni siquiera tengan un paquete main. Si esta librería requiere alguna configuración inicial antes de ser invocada (inicializar variables, detectar el sistema operativo, etc.) parece imposible.\nGo define las funciones init que se ejecutan una vez por paquete. Cuando importamos un paquete, el tiempo de ejecución (runtime) de Go sigue este orden:\nInicializar los paquetes importados de forma recursiva. Inicializar y asignar valores a las variables. Ejecutar las funciones de init. Ejemplos: 1. - En el resultado para el código de ejemplo se muestra cómo la inicialización sigue el orden descrito anteriormente. La función xSetter se invoca primero, seguida de init y la función main.\npackage main import \u0026#34;fmt\u0026#34; var x = xSetter() func xSetter() int { fmt.Println(\u0026#34;xSetter\u0026#34;) return 42 } func init() { fmt.Println(\u0026#34;Init function\u0026#34;) } func main() { fmt.Println(\u0026#34;Este es el main\u0026#34;) } Salida en ejecución: La función init no tiene argumentos ni devuelve ningún valor. Un paquete puede tener varias funciones init y no se pueden invocar desde ninguna parte del código.\nGo no permite importar un paquete si no se usa dentro del código. Sin embargo, es posible que solo nos interese ejecutar las funciones init de un paquete. Esto es lo que Go llama los efectos secundarios de un paquete (side effects pkg). Por lo general, esto se hace en paquetes que realizan alguna operación de arranque o registro. La instrucción especial import _ solo llama a las funciones init de un paquete que no requiere su uso dentro del código.\n2. - Ejemplo usando import _ : importado el paquete \u0026ldquo;a\u0026rdquo; para utilizar sus efectos secundarios. Observar que este paquete tiene dos funciones init que se ejecutan antes del init del paquete de importación. [go mod init ejemplo2]\nejemplo2/main.go\npackage main import ( \u0026#34;fmt\u0026#34; _ \u0026#34;ejemplo2/a\u0026#34; ) func init() { fmt.Println(\u0026#34;Init desde mi programa\u0026#34;) } func main() { fmt.Println(\u0026#34;Mi programa\u0026#34;) } ejemplo2/a/a.go\npackage a import \u0026#34;fmt\u0026#34; func init() { fmt.Println(\u0026#34;Init 1 desde paquete a\u0026#34;) } func init() { fmt.Println(\u0026#34;Init 2 desde paquete a\u0026#34;) } Salida en ejecución: "},{"href":"https://gophers-latam.github.io/posts/2021/04/golang-referencia-esencial-go-modules/","title":"Golang: Referencia esencial Go modules","body":" Go Modules Esta es una hoja de trucos esenciales, no una referencia oficial. Con el fin de que sea conciso, se omitieron aspectos menos frecuentes, dado que este sitio desde su repositorio esta abierto a cambios de contribuidores en la comunidad de Gophers LATAM cualquiera puede hacer cambios que mejoren este contenido.\nInicio rápido Gestión de dependencias go get -d github.com/path/to/module # agregar o actualizar dep (-v log verboso) go get -d github.com/dep/two/v2@v2.1.0 # usar una versión específica go get -d github.com/dep/commit@branch # usar una rama específica go get -d -u ./... # actualizar módulos utilizados en subdirectorios go get -d github.com/dep/legacy@none # eliminar dep Comandos útiles go mod tidy # organizar y limpiar go.mod and go.sum go mod download # descargar deps en caché de módulos go mod init github.com/path/to/module # inicializar nuevo módulo go mod why -m github.com/path/to/module # por qué el módulo es una dependencia? go install github.com/path/to/bin@latest # construir e instalar binario Anatomía del go.mod // ruta de importación de Go con lugar donde se aloja el módulo module github.com/my/library go 1.16 // versión utilizada para desarrollar módulo (usar nuevas funciones de lenguaje) require ( github.com/dep/one v1.0.0 // v2 y posteriores tienen versión principal en ruta del módulo github.com/dep/two/v2 v2.3.0 // \u0026#34;pseudo-versión\u0026#34; que se refiere a un commit y no a una versión etiquetada. github.com/dep/other v0.0.0-20180523231146-b3f5c0f6e5f1 github.com/dep/legacy v2.0.0+incompatible // \u0026#34;incompatible\u0026#34; significa que el paquete aún no se ha migrado a nuevos módulos de Go ) exclude github.com/dep/legacy v1.9.2 // evitar que se use una versión de módulo específica replace github.com/dep/one =\u0026gt; github.com/fork/one // reemplazar este módulo con este otro Selección de versión mínima (MVS) Para crear un programa, Go necesita saber exactamente qué dependencias necesita y qué versión usar.\nGo utiliza MVS como una forma sencilla y predecible de decidir qué versión utilizar.\nFunciona así:\nEl módulo desde el que está ejecutando es el \u0026ldquo;módulo main\u0026rdquo;\nEncuentra todas las dependencias que necesita el módulo principal (de forma recursiva, usando los archivos go.mod de las dependencias)\nPara cada dependencia, usar la mayor versión que cualquier go.mod haya especificado explícitamente\nEjemplo: En este ejemplo, el módulo principal depende de A 1.0 y B 2.1.\nDado que B 2.1 depende de A 1.1, esta es la versión de A que se utilizará.\nDado que se usa A 1.1, también en C 1.1.\nLa lista final de dependencias es:\nA 1.1 B 2.1 C 1.1 Fuentes: Referencia oficial: https://golang.org/ref/mod\nVersión del post original: https://encore.dev/guide/go.mod\n"},{"href":"https://gophers-latam.github.io/posts/2021/04/golang-la-interfaz-vac%C3%ADa/","title":"Golang: La interfaz vacía","body":" Interface type Explicación breve sobre el tipo interfaz vacia y nula.\nSe define una interfaz vacía como interface{}, y puede contener un valor de cualquier tipo:\nvar i interface{} i = \u0026#34;hola gophers\u0026#34; fmt.Println(i) Si se necesita probar si una interfaz es de cierto tipo, se usa una aserción de tipo:\nvar i interface{} i = \u0026#34;hola gophers\u0026#34; s, ok := i.(string) if !ok { fmt.Println(\u0026#34;s is not type string\u0026#34;) } fmt.Println(s) En el ejemplo anterior, i es un tipo string, por lo que el segundo valor de retorno de la aserción de tipo es verdadero (ok) y s contiene el valor por debajo de este. Si hubiera sido de otro tipo, como un int, entonces el ok habría sido falso y s habría sido el valor cero del tipo que se estaba tratando de afirmar, es decir, 0.\nInterfaz nula Una interfaz en Go es esencialmente una tupla que contiene el tipo y el valor subyacentes. Para que una interfaz se considere nula, tanto el tipo como el valor deben ser nulos (nil). Ejemplo:\npackage main import ( \u0026#34;fmt\u0026#34; ) func main() { var i interface{} fmt.Println(i == nil) fmt.Printf(\u0026#34;%T, %v\\n\u0026#34;, i, i) var s *string fmt.Println(\u0026#34;s == nil:\u0026#34;, s == nil) i = s fmt.Println(\u0026#34;i == nil:\u0026#34;, i == nil) fmt.Printf(\u0026#34;%T, %v\\n\u0026#34;, i, i) Salida:\ntrue \u0026lt;nil\u0026gt;, \u0026lt;nil\u0026gt; s == nil: true i == nil: false *string, \u0026lt;nil\u0026gt; Observar que la variable s es nil, pero cuando se establece la interfaz i en s, se verifica si i es nil, i no se considera nil. Esto se debe a que la interfaz tiene un tipo concreto por debajo establecido y las interfaces solo son nulas cuando tanto el tipo concreto como el valor son nulos.\n"},{"href":"https://gophers-latam.github.io/search/","title":"Búsqueda","body":""},{"href":"https://gophers-latam.github.io/posts/2021/04/golang-mantener-actualizado-el-sdk/","title":"Golang: Mantener actualizado el SDK","body":" Update Go Como ocurre con todos los lenguajes de programación, hay actualizaciones periódicas de las herramientas de desarrollo de Go. El SDK Go son binarios nativos que no dependen de un tiempo de ejecución independiente, por lo que no hay que preocuparse de que la actualización del entorno de desarrollo pueda hacer que los programas actualmente implementados fallen. Puede tenerse programas compilados con diferentes versiones de Go ejecutándose simultáneamente en la misma computadora o máquina virtual.\nDesde Go 1.2, ha habido una nueva versión importante aproximadamente cada seis meses. También hay versiones menores con correcciones de errores y seguridad que se publican según sea necesario. Dados los rápidos ciclos de desarrollo y el compromiso del equipo de Go con la compatibilidad con versiones anteriores, las versiones de Go tienden a ser incrementales en lugar de expansivas. La promesa de compatibilidad de Go es una descripción detallada de cómo el equipo de Go planea evitar romper el código de Go. Dice que no habrá cambios retrógrados en el lenguaje o la librería estándar para cualquier versión de Go que comience con 1, a menos que el cambio sea necesario para un error o corrección de seguridad. Sin embargo, puede haber (y ha habido) cambios incompatibles con versiones anteriores en los indicadores o la funcionalidad de los comandos go.\nA pesar de estas garantías de compatibilidad con versiones anteriores, los errores ocurren, por lo que es natural querer asegurarse de que una nueva versión no rompa los programas personales ya hechos. Una opción es instalar un entorno Go secundario. Por ejemplo, si actualmente se está ejecutando la versión 1.15.2 y se quiere probar la versión 1.16.3, debe usarse los siguientes comandos:\ngo get golang.org/dl/go.1.16.3 go1.16.3 download Luego se puede usar el comando go1.16.3 en lugar del comando go para ver si la versión 1.16.3 funciona para los programas ya hechos anteriormente con la nueva versión de Go:\ngo1.16.3 build Una vez que se haya validado que el código funciona, puede eliminarse el entorno secundario buscando el GOROOT, eliminándolo y luego eliminando el binario del directorio $GOPATH/bin. A continuación, las indicaciones de cómo hacerlo en Mac OS, Linux y BSD respectivamente:\ngo1.16.3 env GOROOT /Users/gobook/sdk/go1.16.3 rm -rf $(go1.16.3 env GOROOT) rm $(go env GOPATH)/bin/go1.16.3 Cuando se está listo para actualizar las herramientas de desarrollo de Go instaladas en la computadora, los usuarios de Mac y Windows tienen la ruta más fácil. Aquellos que instalaron con brew o chocolatey pueden usar esas herramientas para actualizar. Aquellos que usaron los instaladores en golang.org/dl pueden descargar el último instalador, que elimina la versión anterior cuando se instala la nueva.\nLos usuarios de Linux y BSD en general deben descargar la última versión, mover la versión anterior a un directorio de respaldo, expandir la nueva versión y luego eliminar la versión anterior, algo así:\nmv /usr/local/go /usr/local/old-go tar -C /usr/local -xzf go1.16.3.linux-amd64.tar.gz rm -rf /usr/local/old-go Como nota final, igual en cada versión que sale en el canal del Discord #📰fuente-noticias se comparte automáticamente del canal de Twitter oficial como obtener la nueva versión.\n"},{"href":"https://gophers-latam.github.io/posts/2021/04/golang-resumen-reglas/","title":"Golang: Resumen reglas","body":" Go Police El lenguaje de programación Go fue creado para hacer el trabajo fácilmente.\nGo tiene conceptos similares a los lenguajes imperativos y el tipado estático.\nTambién es rápido en la compilación, rápido de ejecutar e implementar. Grande y complejo.\nEn este post, se explican conceptos básicos de Go tratando algunos conceptos o reglas importantes.\nLos principales temas tratados son los siguientes:\nEscribir comentarios. Librerías e importación. Funciones. Tipos de datos. Valores de retorno con nombre. Variables y memoria. Control de sentencias. Generar funciones. Ejecución diferida. Interfaces. Múltiples entradas. Manejo de errores. Ejecución simultánea. Escribir comentarios: Para escribir un comentario de una línea\n// comentario de una sola línea Escribir un comentario con más de una línea\n/* comentario de multi-línea */ Librerías e importación: Cada archivo de código fuente comienza con la palabra clave package. La palabra clave main se utiliza para identificar el archivo como un archivo operativo, no como una librería.\npackage main Para importar un paquete de la librería estándar, terceros o personal al archivo, usamos la instrucción import de la siguiente manera:\nimport ( \u0026#34;fmt\u0026#34; // paquete en la librería estándar \u0026#34;io/ioutil\u0026#34; // se aplican funciones de E/S m \u0026#34;math\u0026#34; // usando la letra m para acortar o hacer alias del nombre de la librería de funciones matemáticas \u0026#34;net/http\u0026#34; // web server \u0026#34;os\u0026#34; // funciones a nivel del sistema operativo, como el manejo de archivos \u0026#34;strconv\u0026#34; // conversiones de texto ) Funciones: Las funciones se definen mediante la palabra func seguida del nombre de la función.\nLa función main es privada y es la entrada al archivo ejecutable del programa (Go usa llaves ornamentadas {} para definir partes / bloques).\nfunc main() { // salida de texto en la unidad main en stdout (salida estandar) con Println de fmt (stdlib pkg) fmt.Println (\u0026#34;Hello world!\u0026#34;) // llamar a una función del paquete actual beyondHello() } Las funciones necesitan paréntesis que reciben parámetros, e incluso en ausencia de parámetros, se requieren paréntesis.\nfunc beyondHello() { // declaración de variable (la variable debe declararse antes de usarse) var x int // dar valor a la variable x = 3 // definición corta usando := incluye definición de variable, especificando su tipo y dándole valor y := 4 // una función que devuelve dos valores separados sum, prod := learnMultiple (x, y) // imprimir salida de forma sencilla y directa fmt.Println (\u0026#34;sum:\u0026#34;, sum, \u0026#34;prod:\u0026#34;, prod) learnTypes() } La definición de función puede tener múltiples coeficientes y valores de retorno. Por ejemplo, learnMultiple toma los coeficientes x, y \u0026hellip; y devuelve dos valores de sum y prod de tipo Int.\nfunc learnMultiple (x, y int) (sum, prod int) { // separar los valores devueltos con una coma regular return x + y, x * y } Tipos de datos: func learnTypes() { // las declaraciones cortas generalmente cumplen el propósito deseado // definir una variable de texto usando comillas dobles str := \u0026#34;Learn Go!\u0026#34; // definir una variable de texto con comillas simples s2 := `A \u0026#34;raw\u0026#34; string literal can include line breaks.` // definir variable tipo runa que es otro nombre para el tipo int32 que contiene unicode g := \u0026#39;Σ\u0026#39; // float f := 3.14195 // definición de número complejo (Complex) c := 3 + 4i // definir variables usando var var u uint = 7 // número natural (entero positivo) var pi float32 = 22. / 7 // un decimal de 32 bits // definición corta byte (es otro nombre para uint8) n := byte (\u0026#39;\\n\u0026#39;) // arrays tienen un tamaño fijo, y son fijos en momento de compilación // definir un array int de 4 elementos con un valor inicial de cero var a4 [4] int // definir un array de 3 elementos con valores 3, 1 y 5 a3 := [...] int {3, 1, 5} Go ofrece un tipo de datos llamado Slices. Los Slices entendibles como \u0026ldquo;rebanadas\u0026rdquo;, \u0026ldquo;porciones\u0026rdquo;, \u0026ldquo;segmentos\u0026rdquo; tienen un tamaño dinámico. Las matrices (array) y los segmentos (slice) tienen ventajas, pero los casos de uso de los segmentos son más comunes. La siguiente instrucción define un segmento de tipo int\n// observar la diferencia entre el array y la declaración del slice, donde cuando // el slice está definido no hay un número que determine su tamaño s3: = [] int {4, 5, 9} // definir un tipo int con cuatro elementos con valores cero s4: = make ([] int, 4) // solo definir, y no hay selección var d2 [] [] float64 // método para convertir el tipo de texto en slice bs: = [] byte (\u0026#34;a slice\u0026#34;) Por la naturaleza de los slice dinámicos, es posible agregar nuevos elementos usando la función append incorporada. Primero se pasa el slice al que queremos agregar y luego los elementos que queremos agregar.\ns := [] int {1, 2, 3} s = append (s, 4, 5, 6) // se imprimirá un slice con el siguiente contenido [1 2 3 4 5 6] fmt.Println (s) Para agregar un slice a otro slice, pasamos los dos slices en la función en lugar de pasar elementos individuales, y siguiendo el segundo slice con tres puntos.\ns = append (s, [] int {7, 8, 9} ...) // se imprimirá un slice con el siguiente contenido [1 2 3 4 5 6 7 8 9] fmt.Println (s) La siguiente instrucción define las variables p y q como punteros en dos variables de tipo int que contienen dos valores devueltos por la función learnMemory:\np, q := learnMemory() // tema de reglas por ver Cuando un asterisco precede a un cursor, significa el valor de la variable a la que se refiere el cursor, como en el siguiente ejemplo los valores de las dos variables devueltas por la función learnMemory:\nfmt.Println (*p, *q) Los mapas (maps) en Go son arrays dinámicos y modificables que son similares al tipo de diccionario o hash en otros lenguajes.\n// aquí un mapa cuya clave es tipo texto y los valores de los elementos numéricos. m: = map [string] int {\u0026#34;three\u0026#34;: 3, \u0026#34;four\u0026#34;: 4} m [\u0026#34;one\u0026#34;] = 1 Las variables no utilizadas son errores. El subrayado, guion bajo, operador blanco o Blank Identifier de la siguiente manera hace usar la variable pero ignora valores al mismo tiempo:\n_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs Valores de retorno con nombre: A diferencia de otros lenguajes, las funciones pueden tener valores de retorno con nombre. Donde el nombre se devuelve al valor de la función en la línea de la definición de la función, esta característica permite regresar fácilmente desde cualquier punto de la función además del uso de la palabra return solo sin mencionar nada después:\nfunc learnNamedReturns (x, y int) (z int) { z = x * y // aquí implícitamente significa devolver el valor de la variable z return } Nota: El lenguaje Go se basa en gran medida en la recolección de basura. Go tiene indicadores pero no cálculos (puede confundir un cursor vacío, pero no puede aumentar el cursor). Tener cuidado con valores de retorno de nil pointer reference.\nVariables y memoria: Las variables p y q a continuación son indicadores del tipo int y representan valores de retorno en la función. Cuando se define, los cursores están vacíos; sin embargo, el uso de la función incorporada new hace que el valor de la variable numérica p se refiera a cero, y por lo tanto ocupa espacio en la memoria; es decir, p ya no está vacío.\nfunc learnMemory() (p, q* int) { p = new(int) // definir un slice de 20 elementos como una sola unidad en la memoria. s := make([] int, 20) // dar valor a un elemento s[3] = 7 // definir una nueva variable local a nivel de función r := -2 // devolver dos valores de la función, que son direcciones de memoria // para las variables s y r, respectivamente. return \u0026amp;s[3], \u0026amp;r } func expensiveComputation() float64 { return m.Exp (10) } Control de sentencias Las sentencias condicionales requieren corchetes ornamentados y no requieren paréntesis.\nfunc learnFlowControl() { if true {fmt.Println (\u0026#34;told ya\u0026#34; ) } if false { // Rusters. } else { // Gophers. } Usar la instrucción switch si se necesita escribir más de una secuencia condicional.\nx := 42.0 switch x { case 0: case 1: case 42: case 43: default: } Como sentencia condicional, la cláusula for no toma paréntesis. Las variables definidas en la cláusula for son visibles a nivel de la sentencia.\nfor x: = 0; x \u0026lt;3; x ++ { fmt.Println (\u0026#34;iteration\u0026#34;, x) } La instrucción for es la única instrucción de iteración en el lenguaje Go y tiene otra formas, de la siguiente manera:\n// repetición infinita for { // break para detener la repetición break // continue para ir a la siguiente iteración continue } Se puede utilizar el range para pasar elementos de array, slice, text string, map, channel.\nEl range de canal (channel) devuelve un valor, y dos valores cuando se usa en slice, array, text string, o map.\n// ejemplo: for key, value := range map [string] int {\u0026#34;one\u0026#34;: 1, \u0026#34;two\u0026#34;: 2, \u0026#34;three\u0026#34;: 3} { // imprimir el valor de cada elemento del mapa fmt.Printf (\u0026#34;key =% s, value =% d \\n\u0026#34;, key, value) } Usar el guión bajo (_) contra valor de retorno en la clave si solo se desea el valor, de la siguiente manera:\nfor _, name: = range [] string {\u0026#34;Bob\u0026#34;, \u0026#34;Bill\u0026#34;, \u0026#34;Joe\u0026#34;} { fmt.Printf (\u0026#34;Hello,% s \\n\u0026#34;, name) } Se puede usar la declaración corta con la sentencia condicional para que se defina una variable y luego se verifique en la sentencia de condición.\nPor ejemplo se define una variable y, se le da un valor y luego se coloca la condición de la sentencia para que estén separadas por un punto y coma.\nif y := expensiveComputation(); y \u0026gt; x { x = y } Se puede definir funciones anónimas falsas directamente en el código.\nxBig := func() bool { // x:= 42 que fue declarada antes donde de menciona la sentencia switch return x \u0026gt; 10000 } x = 99999 // la función xBig ahora devuelve el valor verdadero fmt.Println (\u0026#34;xBig:\u0026#34;, xBig()) x = 1.3e3 // Después de modificar el valor de x a 1.3e3 que es igual a 1300 (es decir, mayor que 1000) // la función xBig devuelve falso fmt.Println (\u0026#34;xBig:\u0026#34;, xBig()) Además de lo anterior, es posible definir función fantasma y llamarla en la misma línea y pasarla a otra función siempre que se llame directamente y el tipo de resultado sea consistente con lo esperado en el parámetro de la función.\nfmt.Println (\u0026#34;Add + double two numbers:\u0026#34;, func (a, b int) int { return (a + b) * 2 } (10, 2)) goto love love: learnFunctionFactory() // Una función que devuelve una función learnDefer() // Dormir learnInterfaces() // Trabajar con interfaces } Generar funciones Se puede tratar las funciones como objetos separados. Por ejemplo, crear una función y el valor de retorno es otra.\nfunc learnFunctionFactory() { Los dos métodos siguientes para imprimir la oración son iguales, pero el segundo método es más claro, más legible y común.\nfmt.Println(sentenceFactory (\u0026#34;summer\u0026#34;) (\u0026#34;A beautiful\u0026#34;, \u0026#34;day!\u0026#34;)) d: = sentenceFactory (\u0026#34;summer\u0026#34;) fmt.Println(d (\u0026#34;A beautiful\u0026#34;, \u0026#34;day!\u0026#34;)) fmt.Println(d (\u0026#34;A lazy\u0026#34;, \u0026#34;afternoon!\u0026#34;)) } Los decoradores se encuentran en algunos lenguajes de programación y en el mismo concepto en Go para que poder pasar datos a funciones.\nfunc sentenceFactory(mystring string) func(before, after string) string { return func(before, after string) string { return fmt.Sprintf (\u0026#34;%s %s %s\u0026#34;, before, mystring, after) } } Ejecución diferida Se puede usar la función defer en funciones para realizar una acción antes de devolver el valor o resolver la funcion, y si se escribe más de una, el orden en ejecución de estas acciones es la contraria, como en learnDefer:\nfunc learnDefer() (ok bool) { // instrucciones diferidas se ejecutan antes de que la función devuelva el resultado. defer fmt.Println (\u0026#34;deferred statements execute in reverse (LIFO) order.\u0026#34;) defer fmt.Println (\u0026#34;\\nThis line is being printed first because\u0026#34;) // defer se utiliza normalmente para cerrar un archivo después de abrirlo. return true } Interfaces Como ejemplo se define una función llamada Stringer que contiene una función llamada String; luego se define una estructura de dos dígitos de tipo int nombrados x y y.\ntype Stringer interface { String() string } type pair struct { x, y int } Aquí se define la función String como un pair, convirtiéndose en un pair para la implementación de la interfaz Stringer. La variable p a continuación se llama receptor (receiver). Observar cómo se accede a los campos de estructura de pair utilizando el nombre de la estructura seguido de un punto y luego el nombre del campo.\nfunc(p pair) String() string { return fmt.Sprintf (\u0026#34;(%d, %d)\u0026#34;, p.x, p.y) } Los puntos y comas se utilizan para crear un elemento de estructura (struct). Se usa la definición corta en el siguiente ejemplo para crear una variable llamada p y especificar su tipo en la estructura de pair.\nfunc learnInterfaces() { p := pair{3, 4} // llamar función String de pair fmt.Println(p.String()) // definir una variable como i del tipo Stringer interface previamente definida var i Stringer // esta igualdad es correcta, porque se aplica pair de Stringer i = p // se llama función String de la variable i de tipo Stringer y se obtiene // el mismo resultado que antes fmt.Println(i.String()) // al pasar las variables anteriores directamente a las funciones de impresión y salida fmt, // estas funciones llaman a la función String para imprimir la representación de la variable. */ // Las siguientes dos líneas dan el mismo resultado de impresión fmt.Println(p) fmt.Println(i) learnVariadicParams (\u0026#34;great\u0026#34;, \u0026#34;learning\u0026#34;, \u0026#34;here!\u0026#34;) } Múltiples entradas Es posible pasar variedad de variables a funciones sin un número definido de parámetros.\nfunc learnVariadicParams (myStrings... interface{}) { // la siguiente iteración recorre los elementos de entrada de datos de la función. for _, param: = range myStrings { fmt.Println(\u0026#34;param:\u0026#34;, param) } // se pasa la entrada de la función variadica como parámetro de otra función (para Sprintln) fmt.Println (\u0026#34;params:\u0026#34;, fmt.Sprintln(myStrings...)) learnErrorHandling() } Manejo de errores La palabra clave \u0026ldquo;ok\u0026rdquo; se utiliza para determinar si una sentencia es correcta. Si ocurre un error, se puede usar una variable err para conocer más detalles sobre el error.\nfunc learnErrorHandling() { m := map [int] string{3: \u0026#34;three\u0026#34;, 4: \u0026#34;four\u0026#34;} if x, ok := m[1]; !ok { // ok aquí será falso porque el número 1 no está en el mapa m fmt.Println(\u0026#34;no one there\u0026#34;) } else { // x será el valor en el mapa fmt.Print(x) } // aqui se intenta convertir valor de texto a número que resultará en un error, // se imprimen los detalles del error si err no es nil */ if _, err := strconv.Atoi(\u0026#34;non-int\u0026#34;); err != nil { fmt.Println(err) } learnConcurrency() } Ejecución simultánea Usando una función anterior para hacer una suma numérica a algunos números en conjunto. Se usa make para crear una variable sin especificar un valor para ella.\nfunc learnConcurrency() { // se crea una variable de tipo canal llamada c c := make(chan int) // creando tres funciones Go concurrentes. Los números se incrementarán simultáneamente // (en paralelo si el dispositivo está configurado para hacerlo). // todas las transmisiones irán al mismo canal // \u0026#34;go\u0026#34; aquí significa iniciar una nueva función go inc(0, c) go inc(10, c) go inc(-805, c) // luego hacer tres lecturas desde el mismo canal e imprimir los resultados. // no hay un orden de acceso de lectura desde el canal, y // también cuando el canal aparece a la derecha de la operación // \u0026lt;- significa que esta leyendo y recibiendo del canal fmt.Println(\u0026lt;-c, \u0026lt;-c, \u0026lt;-c) // nuevo canal con texto cs := make(chan string) // canal contiene canales de texto ccs := make(chan chan string) // enviar valor 84 al canal c go func() {c \u0026lt;- 84}() // enviar palabra al canal cs go func() {cs \u0026lt;- \u0026#34;wordy\u0026#34;}() // instrucción select es similar a la instrucción switch, // pero en cada caso contiene un proceso para un canal que // está listo para comunicarse. select { // valor recibido del canal se puede guardar en una variable case i := \u0026lt;-c: fmt.Printf(\u0026#34;it\u0026#39;s a %T\u0026#34;, i) case \u0026lt;-cs: fmt.Println(\u0026#34;it\u0026#39;s a string\u0026#34;) // canal vacío pero listo para comunicarse case \u0026lt;-ccs: fmt.Println(\u0026#34;didn\u0026#39;t happen.\u0026#34;) } } "},{"href":"https://gophers-latam.github.io/opensource/","title":"Open Source","body":"Software Open Source compartido en GitHub por Gophers LATAM.\n"},{"href":"https://gophers-latam.github.io/contacto/","title":"Contacto","body":"Medios de contacto con Gophers LATAM.\n"},{"href":"https://gophers-latam.github.io/colaboradores/","title":"Colaboradores","body":"Miembros públicos en github.com/gophers-latam\n"},{"href":"https://gophers-latam.github.io/biografia/","title":"Biografía","body":"Gophers LATAM es un esfuerzo conjunto por hacer una comunidad de programadores Golang en Español-Latino.\nLos inicios son desde el canal de YouTube de Tomás Lingotti, luego se adopto la idea del Discord el cual ha sido impulsado desde el mismo canal y en otros canales de YouTube, tales como el de Golandia. Compartido en otros medios como Facebook, Twitter y Linkedin. Y con apoyo desde los inicios de zeroidentidad.\nOtra forma en la que se ha adoptado hacer presencia es en Github.\n\u0026ndash; Todo lo mencionado surgió desde octubre del 2020.\n"},{"href":"https://gophers-latam.github.io/proyectos/awesomelatam/","title":"Awesome Latam","body":"Colección de contenidos y recursos principalmente en Español para desarrolladores de Golang\n"},{"href":"https://gophers-latam.github.io/proyectos/go-tour/","title":"Go Tour","body":"Para aquellos que aún no lo conocen, el \u0026lsquo;Tour de Go\u0026rsquo; representa una introducción excepcional al lenguaje de programación Go. Ofrece ejemplos interactivos y explicaciones detalladas, convirtiéndose en una herramienta invaluable para aquellos que desean aprender Go.\nComo comunidad, hemos realizado la traducción del sitio, permitiendo que cualquier persona de habla hispana tenga acceso a esta valiosa herramienta de aprendizaje.\nEstatus: Pendiente de aprobación por el sitio oficial de Go (https://go-review.googlesource.com/c/website/+/545855).\n"},{"href":"https://gophers-latam.github.io/proyectos/gokey/","title":"GoKey","body":"GoKey es un cache en memoria. El principal aspecto es guardar, leer y borrar entradas dentro del ciclo de vida de la goroutine main. Es decir, si deja de correr, los datos se pierden.\nEstatus: ETAPA 1 - libreria cliente\n"},{"href":"https://gophers-latam.github.io/proyectos/gopherbot/","title":"Gopher-Bot","body":"Bot de discord como mascota y utilidad de comandos en server discord.me/gophers-latam.\nEl bot se encuentra inactivo debido a que kintohub ya dejo de dar servicio. "}]}
\ No newline at end of file
diff --git a/sitemap.xml b/sitemap.xml
index cb1b737..1928931 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml"><url><loc>https://gophers-latam.github.io/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod><priority>0</priority></url><url><loc>https://gophers-latam.github.io/posts/2024/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/concurrencia/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/concurrencia/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/golang/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/software/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/year/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/aprendizaje/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/comunidad/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2024/01/concatenando-strings.-construyendo-sql/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/sql/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/strings/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2024/01/desarrollo-con-go-en-neovim/</loc><lastmod>2024-01-03T12:19:35-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/ide/</loc><lastmod>2024-01-03T12:19:35-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/neovim/</loc><lastmod>2024-01-03T12:19:35-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/aprendizaje/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/golang/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/12/manejo-de-memoria-101.-memoria-virtual-stack-y-heap/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/memoria/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/programaci%C3%B3n/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/12/fuga-de-gorutinas/</loc><lastmod>2023-12-20T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/gorutinas/</loc><lastmod>2023-12-20T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/comunidad/</loc><lastmod>2023-10-27T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/10/el-tour-de-go-ahora-en-espa%C3%B1ol/</loc><lastmod>2023-10-27T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/03/handlers-con-timeout/</loc><lastmod>2023-03-27T00:21:15-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/seguridad/</loc><lastmod>2023-03-27T00:21:15-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/web/</loc><lastmod>2023-03-27T00:21:15-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2022/</loc><lastmod>2022-08-01T18:54:04-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/examples/</loc><lastmod>2022-08-01T18:54:04-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/experiencias/</loc><lastmod>2022-08-01T18:54:04-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2022/08/intro-go-mistakes-okno/</loc><lastmod>2022-08-01T18:54:04-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/</loc><lastmod>2021-12-27T11:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/ecosistema/</loc><lastmod>2021-12-27T11:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/12/ecosistema-lenguage-go/</loc><lastmod>2021-12-27T11:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/ecosystem/</loc><lastmod>2021-12-27T11:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/08/go-talks/</loc><lastmod>2021-08-18T18:11:39-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/talks/</loc><lastmod>2021-08-18T18:11:39-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/06/conversi%C3%B3n-json-a-go/</loc><lastmod>2021-06-05T13:01:11-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/tools/</loc><lastmod>2021-06-05T13:01:11-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/tools/</loc><lastmod>2021-06-05T13:01:11-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/tutorial/</loc><lastmod>2021-06-05T13:01:11-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/</loc><lastmod>2021-05-06T15:12:12-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/librerias/</loc><lastmod>2021-05-06T15:12:12-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/built-in/</loc><lastmod>2021-05-05T13:05:28-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/fundamentos/</loc><lastmod>2021-05-05T13:05:28-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/05/golang-init-func/</loc><lastmod>2021-05-05T13:05:28-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/incorparados/</loc><lastmod>2021-05-05T13:05:28-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/04/golang-referencia-esencial-go-modules/</loc><lastmod>2021-04-30T18:02:17-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/modules/</loc><lastmod>2021-04-30T18:02:17-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/referencia/</loc><lastmod>2021-04-30T18:02:17-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/estandar/</loc><lastmod>2021-04-22T23:06:22-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/fundamentos/</loc><lastmod>2021-04-22T23:06:22-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/04/golang-la-interfaz-vac%C3%ADa/</loc><lastmod>2021-04-22T23:06:22-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/search/</loc><lastmod>2021-04-12T19:00:35-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/actualizar-sdk/</loc><lastmod>2021-04-12T00:12:24-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/04/golang-mantener-actualizado-el-sdk/</loc><lastmod>2021-04-12T00:12:24-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/</loc><lastmod>2021-04-10T21:01:18-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/04/golang-resumen-reglas/</loc><lastmod>2021-04-10T20:21:07-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/reglas/</loc><lastmod>2021-04-10T20:21:07-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/opensource/</loc><lastmod>2021-04-10T12:16:19-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/contacto/</loc><lastmod>2021-04-03T14:38:41-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/colaboradores/</loc><lastmod>2021-04-03T14:06:23-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/biografia/</loc><lastmod>2021-04-03T13:19:25-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/10/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/04/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/05/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/06/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/08/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/12/</loc></url><url><loc>https://gophers-latam.github.io/posts/2022/08/</loc></url><url><loc>https://gophers-latam.github.io/posts/2023/03/</loc></url><url><loc>https://gophers-latam.github.io/posts/2023/10/</loc></url><url><loc>https://gophers-latam.github.io/posts/2023/12/</loc></url><url><loc>https://gophers-latam.github.io/posts/2024/01/</loc></url><url><loc>https://gophers-latam.github.io/posts/2024/02/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/awesomelatam/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/go-tour/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/gokey/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/gopherbot/</loc></url><url><loc>https://gophers-latam.github.io/month/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/</loc></url></urlset>
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml"><url><loc>https://gophers-latam.github.io/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod><priority>0</priority></url><url><loc>https://gophers-latam.github.io/posts/2024/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/frameworks/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/frameworks/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/golang/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/principiantes/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/principiantes/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/year/</loc><lastmod>2024-04-12T19:44:34-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/concurrencia/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/concurrencia/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/software/</loc><lastmod>2024-02-06T08:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/aprendizaje/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/comunidad/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2024/01/concatenando-strings.-construyendo-sql/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/sql/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/strings/</loc><lastmod>2024-01-21T12:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2024/01/desarrollo-con-go-en-neovim/</loc><lastmod>2024-01-03T12:19:35-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/ide/</loc><lastmod>2024-01-03T12:19:35-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/neovim/</loc><lastmod>2024-01-03T12:19:35-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/aprendizaje/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/golang/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/12/manejo-de-memoria-101.-memoria-virtual-stack-y-heap/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/memoria/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/programaci%C3%B3n/</loc><lastmod>2023-12-30T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/12/fuga-de-gorutinas/</loc><lastmod>2023-12-20T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/gorutinas/</loc><lastmod>2023-12-20T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/comunidad/</loc><lastmod>2023-10-27T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/10/el-tour-de-go-ahora-en-espa%C3%B1ol/</loc><lastmod>2023-10-27T15:33:31-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2023/03/handlers-con-timeout/</loc><lastmod>2023-03-27T00:21:15-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/seguridad/</loc><lastmod>2023-03-27T00:21:15-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/web/</loc><lastmod>2023-03-27T00:21:15-03:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2022/</loc><lastmod>2022-08-01T18:54:04-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/examples/</loc><lastmod>2022-08-01T18:54:04-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/experiencias/</loc><lastmod>2022-08-01T18:54:04-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2022/08/intro-go-mistakes-okno/</loc><lastmod>2022-08-01T18:54:04-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/</loc><lastmod>2021-12-27T11:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/ecosistema/</loc><lastmod>2021-12-27T11:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/12/ecosistema-lenguage-go/</loc><lastmod>2021-12-27T11:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/ecosystem/</loc><lastmod>2021-12-27T11:22:53-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/08/go-talks/</loc><lastmod>2021-08-18T18:11:39-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/talks/</loc><lastmod>2021-08-18T18:11:39-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/06/conversi%C3%B3n-json-a-go/</loc><lastmod>2021-06-05T13:01:11-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/tools/</loc><lastmod>2021-06-05T13:01:11-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/tools/</loc><lastmod>2021-06-05T13:01:11-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/tutorial/</loc><lastmod>2021-06-05T13:01:11-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/</loc><lastmod>2021-05-06T15:12:12-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/librerias/</loc><lastmod>2021-05-06T15:12:12-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/built-in/</loc><lastmod>2021-05-05T13:05:28-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/fundamentos/</loc><lastmod>2021-05-05T13:05:28-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/05/golang-init-func/</loc><lastmod>2021-05-05T13:05:28-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/incorparados/</loc><lastmod>2021-05-05T13:05:28-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/04/golang-referencia-esencial-go-modules/</loc><lastmod>2021-04-30T18:02:17-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/modules/</loc><lastmod>2021-04-30T18:02:17-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/referencia/</loc><lastmod>2021-04-30T18:02:17-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/categories/estandar/</loc><lastmod>2021-04-22T23:06:22-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/fundamentos/</loc><lastmod>2021-04-22T23:06:22-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/04/golang-la-interfaz-vac%C3%ADa/</loc><lastmod>2021-04-22T23:06:22-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/search/</loc><lastmod>2021-04-12T19:00:35-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/actualizar-sdk/</loc><lastmod>2021-04-12T00:12:24-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/04/golang-mantener-actualizado-el-sdk/</loc><lastmod>2021-04-12T00:12:24-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/</loc><lastmod>2021-04-10T21:01:18-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/posts/2021/04/golang-resumen-reglas/</loc><lastmod>2021-04-10T20:21:07-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/tags/reglas/</loc><lastmod>2021-04-10T20:21:07-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/opensource/</loc><lastmod>2021-04-10T12:16:19-05:00</lastmod></url><url><loc>https://gophers-latam.github.io/contacto/</loc><lastmod>2021-04-03T14:38:41-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/colaboradores/</loc><lastmod>2021-04-03T14:06:23-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/biografia/</loc><lastmod>2021-04-03T13:19:25-06:00</lastmod></url><url><loc>https://gophers-latam.github.io/10/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/04/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/05/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/06/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/08/</loc></url><url><loc>https://gophers-latam.github.io/posts/2021/12/</loc></url><url><loc>https://gophers-latam.github.io/posts/2022/08/</loc></url><url><loc>https://gophers-latam.github.io/posts/2023/03/</loc></url><url><loc>https://gophers-latam.github.io/posts/2023/10/</loc></url><url><loc>https://gophers-latam.github.io/posts/2023/12/</loc></url><url><loc>https://gophers-latam.github.io/posts/2024/01/</loc></url><url><loc>https://gophers-latam.github.io/posts/2024/02/</loc></url><url><loc>https://gophers-latam.github.io/posts/2024/04/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/awesomelatam/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/go-tour/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/gokey/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/gopherbot/</loc></url><url><loc>https://gophers-latam.github.io/month/</loc></url><url><loc>https://gophers-latam.github.io/proyectos/</loc></url></urlset>
\ No newline at end of file
diff --git a/tags/frameworks/index.html b/tags/frameworks/index.html
new file mode 100644
index 0000000..48ed951
--- /dev/null
+++ b/tags/frameworks/index.html
@@ -0,0 +1,8 @@
+<!doctype html><html><head><meta charset=utf-8><meta name=viewport content="width=device-width,initial-scale=1"><meta name=author content="ZeroIdentidad"><meta name=description content="Gophers LATAM"><meta property="og:image" content="https://gophers-latam.github.io//logo.png"><title>frameworks – Gophers LATAM</title><link rel="shortcut icon" type=image/x-icon href=/favicon.ico><link rel=stylesheet href=/css/style.min.5c43d42176932b665337e50d7340aece08d086e5c40b6f4eecff0e6abb091d0a.css><link rel=stylesheet href=/css/syntax.min.f1fef9cbbfe9d2935981821d59853e89db60d137f9117a1279371320195f1d1a.css><link href='https://fonts.googleapis.com/css2?family=Work+Sans' rel=stylesheet type=text/css><link rel=alternate type=application/rss+xml href=https://gophers-latam.github.io/tags/frameworks/index.xml title="frameworks - Gophers LATAM"><script type=application/javascript>var doNotTrack=!1;doNotTrack||(window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)},ga.l=+new Date,ga("create","UA-192145152-1","auto"),ga("send","pageview"))</script><script async src=https://www.google-analytics.com/analytics.js></script>
+<script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-7766642915413571" crossorigin=anonymous></script></head><body><div class=container><header class="page-header app-width"><div class=header-left><a href=/><img alt="Gophers LATAM" src=/img/gopher.png style=height:90px></a></div><div class=header-center><nav><a href=/>Inicio</a>
+<a href=/biografia>Biografía</a>
+<a href=/proyectos>Proyectos</a>
+<a href=/posts>Posts</a>
+<a href=/colaboradores>Colaboradores</a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>frameworks</h2><ul><li><a href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/>Explorando Frameworks en Go: Una Guía para Principiantes</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/tags/frameworks/index.xml b/tags/frameworks/index.xml
new file mode 100644
index 0000000..7ab94e9
--- /dev/null
+++ b/tags/frameworks/index.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>frameworks on Gophers LATAM</title><link>https://gophers-latam.github.io/tags/frameworks/</link><description>Recent content in frameworks on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/tags/frameworks/index.xml" rel="self" type="application/rss+xml"/><item><title>Explorando Frameworks en Go: Una Guía para Principiantes</title><link>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</guid><description>&lt;figure class="post-figure">
+&lt;a href="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png">
+&lt;img src="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" width="1024" height="626" alt="go frameworks" />
+&lt;/a>
+&lt;figcaption>go frameworks&lt;/figcaption>
+&lt;/figure>
+&lt;p>Últimamente, en nuestro canal de &lt;a href="https://discord.me/gophers-latam">discord&lt;/a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.&lt;/p></description></item></channel></rss>
\ No newline at end of file
diff --git a/tags/golang/index.html b/tags/golang/index.html
index 8bdab38..ece7e19 100644
--- a/tags/golang/index.html
+++ b/tags/golang/index.html
@@ -4,5 +4,5 @@
 <a href=/proyectos>Proyectos</a>
 <a href=/posts>Posts</a>
 <a href=/colaboradores>Colaboradores</a>
-<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>golang</h2><ul><li><a href=/posts/2024/02/codelab.-implementemos-un-worker-pool/>CodeLab. Implementemos un Worker Pool</a></li><li><a href=/posts/2024/01/concatenando-strings.-construyendo-sql/>Concatenando strings. Construyendo SQL</a></li><li><a href=/posts/2024/01/desarrollo-con-go-en-neovim/>Desarrollo con Go en Neovim</a></li><li><a href=/posts/2023/10/el-tour-de-go-ahora-en-espa%C3%B1ol/>El tour de Go ahora en Español</a></li><li><a href=/posts/2023/03/handlers-con-timeout/>Handlers Con Timeout</a></li><li><a href=/posts/2022/08/intro-go-mistakes-okno/>Intro Go Mistakes Okno</a></li><li><a href=/posts/2021/12/ecosistema-lenguage-go/>Ecosistema lenguage Go</a></li><li><a href=/posts/2021/08/go-talks/>Go Talks</a></li><li><a href=/posts/2021/06/conversi%C3%B3n-json-a-go/>Conversión JSON a Go</a></li><li><a href=/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/>Golang: Implementación del almacenamiento en caché</a></li><li><a href=/posts/2021/05/golang-init-func/>Golang: Init func</a></li><li><a href=/posts/2021/04/golang-referencia-esencial-go-modules/>Golang: Referencia esencial Go modules</a></li><li><a href=/posts/2021/04/golang-la-interfaz-vac%C3%ADa/>Golang: La interfaz vacía</a></li><li><a href=/posts/2021/04/golang-mantener-actualizado-el-sdk/>Golang: Mantener actualizado el SDK</a></li><li><a href=/posts/2021/04/golang-resumen-reglas/>Golang: Resumen reglas</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>golang</h2><ul><li><a href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/>Explorando Frameworks en Go: Una Guía para Principiantes</a></li><li><a href=/posts/2024/02/codelab.-implementemos-un-worker-pool/>CodeLab. Implementemos un Worker Pool</a></li><li><a href=/posts/2024/01/concatenando-strings.-construyendo-sql/>Concatenando strings. Construyendo SQL</a></li><li><a href=/posts/2024/01/desarrollo-con-go-en-neovim/>Desarrollo con Go en Neovim</a></li><li><a href=/posts/2023/10/el-tour-de-go-ahora-en-espa%C3%B1ol/>El tour de Go ahora en Español</a></li><li><a href=/posts/2023/03/handlers-con-timeout/>Handlers Con Timeout</a></li><li><a href=/posts/2022/08/intro-go-mistakes-okno/>Intro Go Mistakes Okno</a></li><li><a href=/posts/2021/12/ecosistema-lenguage-go/>Ecosistema lenguage Go</a></li><li><a href=/posts/2021/08/go-talks/>Go Talks</a></li><li><a href=/posts/2021/06/conversi%C3%B3n-json-a-go/>Conversión JSON a Go</a></li><li><a href=/posts/2021/05/golang-implementaci%C3%B3n-del-almacenamiento-en-cach%C3%A9/>Golang: Implementación del almacenamiento en caché</a></li><li><a href=/posts/2021/05/golang-init-func/>Golang: Init func</a></li><li><a href=/posts/2021/04/golang-referencia-esencial-go-modules/>Golang: Referencia esencial Go modules</a></li><li><a href=/posts/2021/04/golang-la-interfaz-vac%C3%ADa/>Golang: La interfaz vacía</a></li><li><a href=/posts/2021/04/golang-mantener-actualizado-el-sdk/>Golang: Mantener actualizado el SDK</a></li><li><a href=/posts/2021/04/golang-resumen-reglas/>Golang: Resumen reglas</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
 <small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/tags/golang/index.xml b/tags/golang/index.xml
index 152f05c..ae1bf73 100644
--- a/tags/golang/index.xml
+++ b/tags/golang/index.xml
@@ -1,4 +1,11 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>golang on Gophers LATAM</title><link>https://gophers-latam.github.io/tags/golang/</link><description>Recent content in golang on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Tue, 06 Feb 2024 08:22:53 -0600</lastBuildDate><atom:link href="https://gophers-latam.github.io/tags/golang/index.xml" rel="self" type="application/rss+xml"/><item><title>CodeLab. Implementemos un Worker Pool</title><link>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</guid><description>&lt;figure class="post-figure">
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>golang on Gophers LATAM</title><link>https://gophers-latam.github.io/tags/golang/</link><description>Recent content in golang on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/tags/golang/index.xml" rel="self" type="application/rss+xml"/><item><title>Explorando Frameworks en Go: Una Guía para Principiantes</title><link>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</guid><description>&lt;figure class="post-figure">
+&lt;a href="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png">
+&lt;img src="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" width="1024" height="626" alt="go frameworks" />
+&lt;/a>
+&lt;figcaption>go frameworks&lt;/figcaption>
+&lt;/figure>
+&lt;p>Últimamente, en nuestro canal de &lt;a href="https://discord.me/gophers-latam">discord&lt;/a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.&lt;/p></description></item><item><title>CodeLab. Implementemos un Worker Pool</title><link>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/</guid><description>&lt;figure class="post-figure">
 &lt;a href="https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools.png">
 &lt;img src="https://gophers-latam.github.io/posts/2024/02/codelab.-implementemos-un-worker-pool/images/pools_hu25c2df14317a6a74ebc7cc77c76ece4a_666661_1024x0_resize_box_3.png" width="1024" height="794" alt=" Mengniu Dairy production line. Gentileza de Peter Tittenberger y flickr. https://www.flickr.com/photos/ext504/3639675762/in/photostream/" />
 &lt;/a>
diff --git a/tags/index.html b/tags/index.html
index 4f9de3f..0ed1188 100644
--- a/tags/index.html
+++ b/tags/index.html
@@ -11,13 +11,15 @@
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/concurrencia/>concurrencia</a>
 <span class=count>(2)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/ecosystem/>ecosystem</a>
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/examples/>examples</a>
+<span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/frameworks/>frameworks</a>
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/fundamentos/>fundamentos</a>
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/golang/>golang</a>
-<span class=count>(15)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/gorutinas/>gorutinas</a>
+<span class=count>(16)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/gorutinas/>gorutinas</a>
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/librerias/>librerias</a>
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/memoria/>memoria</a>
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/modules/>modules</a>
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/neovim/>neovim</a>
+<span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/principiantes/>principiantes</a>
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/reglas/>reglas</a>
 <span class=count>(1)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/software/>software</a>
 <span class=count>(4)</span></p><p class=tag><a href=https://gophers-latam.github.io/tags/sql/>sql</a>
diff --git a/tags/index.xml b/tags/index.xml
index ffd6662..56a075c 100644
--- a/tags/index.xml
+++ b/tags/index.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Tags on Gophers LATAM</title><link>https://gophers-latam.github.io/tags/</link><description>Recent content in Tags on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Sat, 10 Apr 2021 21:01:18 -0500</lastBuildDate><atom:link href="https://gophers-latam.github.io/tags/index.xml" rel="self" type="application/rss+xml"/><item><title>concurrencia</title><link>https://gophers-latam.github.io/tags/concurrencia/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/tags/concurrencia/</guid><description/></item><item><title>golang</title><link>https://gophers-latam.github.io/tags/golang/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/tags/golang/</guid><description/></item><item><title>software</title><link>https://gophers-latam.github.io/tags/software/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/tags/software/</guid><description/></item><item><title>sql</title><link>https://gophers-latam.github.io/tags/sql/</link><pubDate>Sun, 21 Jan 2024 12:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/sql/</guid><description/></item><item><title>strings</title><link>https://gophers-latam.github.io/tags/strings/</link><pubDate>Sun, 21 Jan 2024 12:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/strings/</guid><description/></item><item><title>neovim</title><link>https://gophers-latam.github.io/tags/neovim/</link><pubDate>Wed, 03 Jan 2024 12:19:35 -0300</pubDate><guid>https://gophers-latam.github.io/tags/neovim/</guid><description/></item><item><title>aprendizaje</title><link>https://gophers-latam.github.io/tags/aprendizaje/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/aprendizaje/</guid><description/></item><item><title>memoria</title><link>https://gophers-latam.github.io/tags/memoria/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/memoria/</guid><description/></item><item><title>gorutinas</title><link>https://gophers-latam.github.io/tags/gorutinas/</link><pubDate>Wed, 20 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/gorutinas/</guid><description/></item><item><title>comunidad</title><link>https://gophers-latam.github.io/tags/comunidad/</link><pubDate>Fri, 27 Oct 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/comunidad/</guid><description/></item><item><title>examples</title><link>https://gophers-latam.github.io/tags/examples/</link><pubDate>Mon, 01 Aug 2022 18:54:04 -0500</pubDate><guid>https://gophers-latam.github.io/tags/examples/</guid><description/></item><item><title>ecosystem</title><link>https://gophers-latam.github.io/tags/ecosystem/</link><pubDate>Mon, 27 Dec 2021 11:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/tags/ecosystem/</guid><description/></item><item><title>talks</title><link>https://gophers-latam.github.io/tags/talks/</link><pubDate>Wed, 18 Aug 2021 18:11:39 -0500</pubDate><guid>https://gophers-latam.github.io/tags/talks/</guid><description/></item><item><title>tools</title><link>https://gophers-latam.github.io/tags/tools/</link><pubDate>Sat, 05 Jun 2021 13:01:11 -0500</pubDate><guid>https://gophers-latam.github.io/tags/tools/</guid><description/></item><item><title>librerias</title><link>https://gophers-latam.github.io/tags/librerias/</link><pubDate>Thu, 06 May 2021 15:12:12 -0500</pubDate><guid>https://gophers-latam.github.io/tags/librerias/</guid><description/></item><item><title>built-in</title><link>https://gophers-latam.github.io/tags/built-in/</link><pubDate>Wed, 05 May 2021 13:05:28 -0500</pubDate><guid>https://gophers-latam.github.io/tags/built-in/</guid><description/></item><item><title>modules</title><link>https://gophers-latam.github.io/tags/modules/</link><pubDate>Fri, 30 Apr 2021 18:02:17 -0500</pubDate><guid>https://gophers-latam.github.io/tags/modules/</guid><description/></item><item><title>fundamentos</title><link>https://gophers-latam.github.io/tags/fundamentos/</link><pubDate>Thu, 22 Apr 2021 23:06:22 -0500</pubDate><guid>https://gophers-latam.github.io/tags/fundamentos/</guid><description/></item><item><title>actualizar sdk</title><link>https://gophers-latam.github.io/tags/actualizar-sdk/</link><pubDate>Mon, 12 Apr 2021 00:12:24 -0500</pubDate><guid>https://gophers-latam.github.io/tags/actualizar-sdk/</guid><description/></item><item><title>reglas</title><link>https://gophers-latam.github.io/tags/reglas/</link><pubDate>Sat, 10 Apr 2021 20:21:07 -0500</pubDate><guid>https://gophers-latam.github.io/tags/reglas/</guid><description/></item></channel></rss>
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Tags on Gophers LATAM</title><link>https://gophers-latam.github.io/tags/</link><description>Recent content in Tags on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Sat, 10 Apr 2021 21:01:18 -0500</lastBuildDate><atom:link href="https://gophers-latam.github.io/tags/index.xml" rel="self" type="application/rss+xml"/><item><title>frameworks</title><link>https://gophers-latam.github.io/tags/frameworks/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/tags/frameworks/</guid><description/></item><item><title>golang</title><link>https://gophers-latam.github.io/tags/golang/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/tags/golang/</guid><description/></item><item><title>principiantes</title><link>https://gophers-latam.github.io/tags/principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/tags/principiantes/</guid><description/></item><item><title>concurrencia</title><link>https://gophers-latam.github.io/tags/concurrencia/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/tags/concurrencia/</guid><description/></item><item><title>software</title><link>https://gophers-latam.github.io/tags/software/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/tags/software/</guid><description/></item><item><title>sql</title><link>https://gophers-latam.github.io/tags/sql/</link><pubDate>Sun, 21 Jan 2024 12:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/sql/</guid><description/></item><item><title>strings</title><link>https://gophers-latam.github.io/tags/strings/</link><pubDate>Sun, 21 Jan 2024 12:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/strings/</guid><description/></item><item><title>neovim</title><link>https://gophers-latam.github.io/tags/neovim/</link><pubDate>Wed, 03 Jan 2024 12:19:35 -0300</pubDate><guid>https://gophers-latam.github.io/tags/neovim/</guid><description/></item><item><title>aprendizaje</title><link>https://gophers-latam.github.io/tags/aprendizaje/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/aprendizaje/</guid><description/></item><item><title>memoria</title><link>https://gophers-latam.github.io/tags/memoria/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/memoria/</guid><description/></item><item><title>gorutinas</title><link>https://gophers-latam.github.io/tags/gorutinas/</link><pubDate>Wed, 20 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/gorutinas/</guid><description/></item><item><title>comunidad</title><link>https://gophers-latam.github.io/tags/comunidad/</link><pubDate>Fri, 27 Oct 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/tags/comunidad/</guid><description/></item><item><title>examples</title><link>https://gophers-latam.github.io/tags/examples/</link><pubDate>Mon, 01 Aug 2022 18:54:04 -0500</pubDate><guid>https://gophers-latam.github.io/tags/examples/</guid><description/></item><item><title>ecosystem</title><link>https://gophers-latam.github.io/tags/ecosystem/</link><pubDate>Mon, 27 Dec 2021 11:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/tags/ecosystem/</guid><description/></item><item><title>talks</title><link>https://gophers-latam.github.io/tags/talks/</link><pubDate>Wed, 18 Aug 2021 18:11:39 -0500</pubDate><guid>https://gophers-latam.github.io/tags/talks/</guid><description/></item><item><title>tools</title><link>https://gophers-latam.github.io/tags/tools/</link><pubDate>Sat, 05 Jun 2021 13:01:11 -0500</pubDate><guid>https://gophers-latam.github.io/tags/tools/</guid><description/></item><item><title>librerias</title><link>https://gophers-latam.github.io/tags/librerias/</link><pubDate>Thu, 06 May 2021 15:12:12 -0500</pubDate><guid>https://gophers-latam.github.io/tags/librerias/</guid><description/></item><item><title>built-in</title><link>https://gophers-latam.github.io/tags/built-in/</link><pubDate>Wed, 05 May 2021 13:05:28 -0500</pubDate><guid>https://gophers-latam.github.io/tags/built-in/</guid><description/></item><item><title>modules</title><link>https://gophers-latam.github.io/tags/modules/</link><pubDate>Fri, 30 Apr 2021 18:02:17 -0500</pubDate><guid>https://gophers-latam.github.io/tags/modules/</guid><description/></item><item><title>fundamentos</title><link>https://gophers-latam.github.io/tags/fundamentos/</link><pubDate>Thu, 22 Apr 2021 23:06:22 -0500</pubDate><guid>https://gophers-latam.github.io/tags/fundamentos/</guid><description/></item><item><title>actualizar sdk</title><link>https://gophers-latam.github.io/tags/actualizar-sdk/</link><pubDate>Mon, 12 Apr 2021 00:12:24 -0500</pubDate><guid>https://gophers-latam.github.io/tags/actualizar-sdk/</guid><description/></item><item><title>reglas</title><link>https://gophers-latam.github.io/tags/reglas/</link><pubDate>Sat, 10 Apr 2021 20:21:07 -0500</pubDate><guid>https://gophers-latam.github.io/tags/reglas/</guid><description/></item></channel></rss>
\ No newline at end of file
diff --git a/tags/principiantes/index.html b/tags/principiantes/index.html
new file mode 100644
index 0000000..3957dbb
--- /dev/null
+++ b/tags/principiantes/index.html
@@ -0,0 +1,8 @@
+<!doctype html><html><head><meta charset=utf-8><meta name=viewport content="width=device-width,initial-scale=1"><meta name=author content="ZeroIdentidad"><meta name=description content="Gophers LATAM"><meta property="og:image" content="https://gophers-latam.github.io//logo.png"><title>principiantes – Gophers LATAM</title><link rel="shortcut icon" type=image/x-icon href=/favicon.ico><link rel=stylesheet href=/css/style.min.5c43d42176932b665337e50d7340aece08d086e5c40b6f4eecff0e6abb091d0a.css><link rel=stylesheet href=/css/syntax.min.f1fef9cbbfe9d2935981821d59853e89db60d137f9117a1279371320195f1d1a.css><link href='https://fonts.googleapis.com/css2?family=Work+Sans' rel=stylesheet type=text/css><link rel=alternate type=application/rss+xml href=https://gophers-latam.github.io/tags/principiantes/index.xml title="principiantes - Gophers LATAM"><script type=application/javascript>var doNotTrack=!1;doNotTrack||(window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)},ga.l=+new Date,ga("create","UA-192145152-1","auto"),ga("send","pageview"))</script><script async src=https://www.google-analytics.com/analytics.js></script>
+<script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-7766642915413571" crossorigin=anonymous></script></head><body><div class=container><header class="page-header app-width"><div class=header-left><a href=/><img alt="Gophers LATAM" src=/img/gopher.png style=height:90px></a></div><div class=header-center><nav><a href=/>Inicio</a>
+<a href=/biografia>Biografía</a>
+<a href=/proyectos>Proyectos</a>
+<a href=/posts>Posts</a>
+<a href=/colaboradores>Colaboradores</a>
+<a href=/contacto>Contacto</a></nav></div><div class=header-right><a class=button-search href=/search><img alt=Búsqueda src=/img/search.png></a></div></header><main class=app-width><h2>principiantes</h2><ul><li><a href=/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/>Explorando Frameworks en Go: Una Guía para Principiantes</a></li></ul></main><footer><a href=https://gohugo.io><img src=/img/hugo-logo.svg width=90 height=21></a>
+<small>© 2024, Gophers LATAM. - Theme by <a href=https://github.com/zeroidentidad>zeroidentidad</a>.</small></footer></div></body></html>
\ No newline at end of file
diff --git a/tags/principiantes/index.xml b/tags/principiantes/index.xml
new file mode 100644
index 0000000..e8dc89d
--- /dev/null
+++ b/tags/principiantes/index.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>principiantes on Gophers LATAM</title><link>https://gophers-latam.github.io/tags/principiantes/</link><description>Recent content in principiantes on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/tags/principiantes/index.xml" rel="self" type="application/rss+xml"/><item><title>Explorando Frameworks en Go: Una Guía para Principiantes</title><link>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/</guid><description>&lt;figure class="post-figure">
+&lt;a href="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks.png">
+&lt;img src="https://gophers-latam.github.io/posts/2024/04/explorando-frameworks-en-go-una-gu%C3%ADa-para-principiantes/images/go-frameworks_hu9ed9cb27069741b0ea452de8869c0657_86705_1024x0_resize_box_3.png" width="1024" height="626" alt="go frameworks" />
+&lt;/a>
+&lt;figcaption>go frameworks&lt;/figcaption>
+&lt;/figure>
+&lt;p>Últimamente, en nuestro canal de &lt;a href="https://discord.me/gophers-latam">discord&lt;/a>, hemos recibido numerosas preguntas, especialmente de aquellos que están dando sus primeros pasos con Go, sobre qué frameworks deberían considerar al comenzar a desarrollar con este lenguaje.
+En este post, vamos a explorar temas como la biblioteca estándar, los diferentes frameworks disponibles en Go, sus opciones, cuáles son los más rápidos y los más utilizados.&lt;/p></description></item></channel></rss>
\ No newline at end of file
diff --git a/year/index.xml b/year/index.xml
index 763d99b..b77931d 100644
--- a/year/index.xml
+++ b/year/index.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Year on Gophers LATAM</title><link>https://gophers-latam.github.io/year/</link><description>Recent content in Year on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Tue, 06 Feb 2024 08:22:53 -0600</lastBuildDate><atom:link href="https://gophers-latam.github.io/year/index.xml" rel="self" type="application/rss+xml"/><item><title>2024</title><link>https://gophers-latam.github.io/posts/2024/</link><pubDate>Tue, 06 Feb 2024 08:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2024/</guid><description/></item><item><title>2023</title><link>https://gophers-latam.github.io/posts/2023/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2023/</guid><description/></item><item><title>2022</title><link>https://gophers-latam.github.io/posts/2022/</link><pubDate>Mon, 01 Aug 2022 18:54:04 -0500</pubDate><guid>https://gophers-latam.github.io/posts/2022/</guid><description/></item><item><title>2021</title><link>https://gophers-latam.github.io/posts/2021/</link><pubDate>Mon, 27 Dec 2021 11:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2021/</guid><description/></item></channel></rss>
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Year on Gophers LATAM</title><link>https://gophers-latam.github.io/year/</link><description>Recent content in Year on Gophers LATAM</description><generator>Hugo -- gohugo.io</generator><language>es-mx</language><lastBuildDate>Fri, 12 Apr 2024 19:44:34 -0300</lastBuildDate><atom:link href="https://gophers-latam.github.io/year/index.xml" rel="self" type="application/rss+xml"/><item><title>2024</title><link>https://gophers-latam.github.io/posts/2024/</link><pubDate>Fri, 12 Apr 2024 19:44:34 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2024/</guid><description/></item><item><title>2023</title><link>https://gophers-latam.github.io/posts/2023/</link><pubDate>Sat, 30 Dec 2023 15:33:31 -0300</pubDate><guid>https://gophers-latam.github.io/posts/2023/</guid><description/></item><item><title>2022</title><link>https://gophers-latam.github.io/posts/2022/</link><pubDate>Mon, 01 Aug 2022 18:54:04 -0500</pubDate><guid>https://gophers-latam.github.io/posts/2022/</guid><description/></item><item><title>2021</title><link>https://gophers-latam.github.io/posts/2021/</link><pubDate>Mon, 27 Dec 2021 11:22:53 -0600</pubDate><guid>https://gophers-latam.github.io/posts/2021/</guid><description/></item></channel></rss>
\ No newline at end of file
