<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Pedro Bertao</title>
    <description>The latest articles on DEV Community by Pedro Bertao (@pedrobertao).</description>
    <link>https://dev.to/pedrobertao</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F210463%2F7c7bf32b-6947-4aae-b7ba-37c4751cb8c6.jpeg</url>
      <title>DEV Community: Pedro Bertao</title>
      <link>https://dev.to/pedrobertao</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/pedrobertao"/>
    <language>en</language>
    <item>
      <title>LangGraph and LangChain - Learn Fast</title>
      <dc:creator>Pedro Bertao</dc:creator>
      <pubDate>Tue, 17 Nov 2026 12:02:11 +0000</pubDate>
      <link>https://dev.to/pedrobertao/langgraph-and-langchain-learn-fast-2och</link>
      <guid>https://dev.to/pedrobertao/langgraph-and-langchain-learn-fast-2och</guid>
      <description>&lt;h1&gt;
  
  
  LangChain vs. LangGraph: Learn Fast
&lt;/h1&gt;

&lt;p&gt;You are learning Artificial Intelligence, and there is a good number of terms and concepts that you need to learn or even memorize. For example, nowadays, there are approximately 300 concepts used throughout the AI and LLM world. But this is nothing to be afraid of. Some of them are very specific to certain topics, while others are just general ideas that connect different areas.&lt;/p&gt;

&lt;p&gt;In this article, my goal is to introduce you to two concepts—or, more formally, two frameworks—that you will need to know if you are planning to work with AI agents. I'll do my best to keep it fast and compact.&lt;/p&gt;

&lt;h2&gt;
  
  
  Overview
&lt;/h2&gt;

&lt;p&gt;I will start with LangChain, and soon you will know why.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;LangChain&lt;/strong&gt; is an open-source framework for building applications powered by large language models (LLMs). With this framework, you have access to open-source libraries in Python and JavaScript that allow your LLM to connect to data sources, external applications, search engines, databases, and so on [1].&lt;/p&gt;

&lt;p&gt;In a sentence:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;LangChain is a framework for building LLM-powered applications by integrating language models, tools, data sources, and agents.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;strong&gt;LangGraph&lt;/strong&gt; is an open-source framework developed by the LangChain team for building AI agents and managing more complex workflows. LangGraph uses a graph-based structure, where nodes represent individual tasks or functions, and edges determine how the agent moves between them based on the current state [1].&lt;/p&gt;

&lt;p&gt;In a sentence:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;LangGraph is an open-source framework for building stateful AI agents and workflows using graphs of interconnected nodes and edges, where nodes are functions and edges act like routes.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Key Differences
&lt;/h2&gt;

&lt;p&gt;LangChain makes building AI agents easier by providing ready-to-use components, support for different LLM providers, and tools for customization.&lt;/p&gt;

&lt;p&gt;LangGraph takes a different approach. It is a lower-level framework that gives developers more control over how agents behave, especially when working with complex workflows or long-running tasks.&lt;/p&gt;

&lt;p&gt;Both frameworks are part of the same ecosystem, but the main difference comes down to how much control you need over your agent.&lt;/p&gt;

&lt;p&gt;Here are some differences worth knowing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Ease of Use:&lt;/strong&gt; LangChain comes with ready-to-use tools, making it easier and faster to build AI agents. LangGraph requires more setup but gives you more control.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Workflow:&lt;/strong&gt; LangChain handles common tasks for you, while LangGraph lets you decide exactly how your agent moves from one step to another.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;State Management:&lt;/strong&gt; LangChain can manage conversation memory, while LangGraph gives you more control over what your agent remembers and how it uses that information.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Customization:&lt;/strong&gt; LangChain is great for building agents with common features. LangGraph is better when you need your agent to follow specific rules or make more complex decisions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Production:&lt;/strong&gt; Both can be used in real applications, but LangGraph is especially useful for agents that need to handle longer or more complicated tasks.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  A Simple Example
&lt;/h2&gt;

&lt;p&gt;Let's say you want to build an AI agent for customer support.&lt;/p&gt;

&lt;p&gt;Using &lt;strong&gt;LangChain&lt;/strong&gt;, you could create an agent that receives a question, searches a knowledge base, calls an external API if needed, and returns an answer. Most of the components needed for this are already available in the framework.&lt;/p&gt;

&lt;p&gt;Now imagine that your support agent needs to do more than just answer questions.&lt;/p&gt;

&lt;p&gt;Maybe it needs to identify the customer's problem, search different sources, check whether the information is reliable, and decide what to do next. Sometimes it might need to search again, and other times it might need to send the request to a human.&lt;/p&gt;

&lt;p&gt;This is where &lt;strong&gt;LangGraph&lt;/strong&gt; becomes interesting. You can organize these steps into a graph, define the conditions between them, and control how the agent moves from one step to another.&lt;/p&gt;

&lt;p&gt;Of course, you could build similar behavior with LangChain. The difference is that LangGraph gives you more direct control over the process.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which One Should You Use?
&lt;/h2&gt;

&lt;p&gt;If you're just getting started with AI agents, I would recommend &lt;strong&gt;LangChain&lt;/strong&gt;. It provides most of what you need to build a working agent without spending too much time defining the execution flow.&lt;/p&gt;

&lt;p&gt;On the other hand, if your application requires complex decisions, multiple steps, or more control over state and execution, &lt;strong&gt;LangGraph&lt;/strong&gt; might be a better choice.&lt;/p&gt;

&lt;p&gt;One last thing worth mentioning: &lt;strong&gt;you don't necessarily have to choose between them.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;LangChain agents are built on top of LangGraph, so both frameworks can be used together. You can start with LangChain and move to LangGraph when your application needs more control [2].&lt;/p&gt;

&lt;p&gt;In short, &lt;strong&gt;LangChain makes it easier to build AI agents, while LangGraph gives you more control over how they work.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;p&gt;[1] &lt;a href="https://www.coursera.org/articles/langchain-vs-langgraph" rel="noopener noreferrer"&gt;https://www.coursera.org/articles/langchain-vs-langgraph&lt;/a&gt;&lt;br&gt;
[2] &lt;a href="https://www.langchain.com/blog/langchain-langgraph-1dot0" rel="noopener noreferrer"&gt;https://www.langchain.com/blog/langchain-langgraph-1dot0&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>learning</category>
      <category>langgraph</category>
      <category>langchain</category>
    </item>
    <item>
      <title>Highlights of Golang 1.25</title>
      <dc:creator>Pedro Bertao</dc:creator>
      <pubDate>Fri, 05 Sep 2025 12:23:23 +0000</pubDate>
      <link>https://dev.to/pedrobertao/highlights-of-golang-125-3bhb</link>
      <guid>https://dev.to/pedrobertao/highlights-of-golang-125-3bhb</guid>
      <description>&lt;p&gt;Go 1.25 isn’t a flashy release with big syntax changes. Instead, it’s a practical one: it fixes long-standing pitfalls, improves runtime safety, adds smarter tooling, and introduces a powerful new JSON engine. These are the kinds of updates that make your day-to-day coding experience smoother and your production apps more reliable.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Goodbye “Core Types”
&lt;/h2&gt;

&lt;p&gt;Core types were a formal definition introduced in Go 1.18, where “a core type is an abstract construct that was introduced for expediency and to simplify dealing with generic operands”.  For example, we have:&lt;/p&gt;

&lt;p&gt;If a type is not a type parameter, its core type is simply its underlying type.&lt;/p&gt;

&lt;p&gt;If the type is a type parameter, its core type exists only if all types in its type set share the same underlying type. In such cases, that common underlying type becomes the core type. Otherwise, no core type exists.&lt;/p&gt;

&lt;p&gt;In Go 1.25, the team removed the notion of core types from the spec and instead defined each feature with explicit rules for generics, simplifying the language while keeping everything fully backward-compatible. For example, operations like addition on a generic type are now described directly in terms of type sets, without needing to reference core types.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Safer Nil-Pointer Handling
&lt;/h2&gt;

&lt;p&gt;A bug introduced in Go 1.21 sometimes prevented nil pointer panics from triggering. That’s now fixed. If you dereference a nil, it will reliably panic. Previously, the behavior was:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;main&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="s"&gt;"fmt"&lt;/span&gt;
    &lt;span class="s"&gt;"os"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="n"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c"&gt;// Try to open a file that doesn't exist.&lt;/span&gt;
    &lt;span class="c"&gt;// os.Open returns a nil file handle and a non-nil error.&lt;/span&gt;
    &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"does-not-exist.txt"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="c"&gt;// f is nil, err is non-nil&lt;/span&gt;
    &lt;span class="n"&gt;fmt&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Println&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"err:"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="c"&gt;// Prints the error&lt;/span&gt;

    &lt;span class="c"&gt;// Buggy behavior explanation:&lt;/span&gt;
    &lt;span class="c"&gt;// The program uses f.Name() before checking the error.&lt;/span&gt;
    &lt;span class="c"&gt;// Since f is nil, this call panics at runtime.&lt;/span&gt;
    &lt;span class="c"&gt;// Older Go versions (1.21–1.24) sometimes let this run,&lt;/span&gt;
    &lt;span class="n"&gt;fmt&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Println&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"name:"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Name&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;In Go 1.21–1.24, a compiler bug sometimes suppressed the panic on the code above and made it looked like your program was "fine," but it wasn’t. In Go 1.25, it will no longer run successfully. Now with the fixed behavior we have:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;main&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="s"&gt;"fmt"&lt;/span&gt;
    &lt;span class="s"&gt;"os"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="n"&gt;main&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c"&gt;// Try to open a file that doesn't exist.&lt;/span&gt;
    &lt;span class="c"&gt;// os.Open returns a nil file handle and a non-nil error.&lt;/span&gt;
    &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"does-not-exist.txt"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; 
    &lt;span class="n"&gt;fmt&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Println&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"err:"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="c"&gt;// Prints an error&lt;/span&gt;

    &lt;span class="c"&gt;// This now reliably panics, since f is nil and you’re dereferencing it.&lt;/span&gt;
    &lt;span class="n"&gt;fmt&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Println&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"name:"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Name&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The key difference is that it now throws a panic, making the behavior more predictable&lt;/p&gt;

&lt;h2&gt;
  
  
  3. DWARF v5 Debug Info by Default
&lt;/h2&gt;

&lt;p&gt;DWARF is a standardized format for storing debugging information inside compiled binaries.&lt;br&gt;
Think of it as a map that tells debuggers (like gdb, dlv for Go, or IDEs like VS Code/GoLand) how your compiled program relates back to your source code.&lt;br&gt;
Go 1.25 now uses DWARF v5 for debug information. The result is smaller binaries and faster linking. If you need older tooling compatibility, you can disable it with GOEXPERIMENT=nodwarf5.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# Normal build (DWARF v5 enabled automatically):
go build ./...

# If you have tooling that doesn’t support DWARF v5, you can disable it:
GOEXPERIMENT=nodwarf5 go build ./...`
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  4. testing/synctest is Stable
&lt;/h2&gt;

&lt;p&gt;Testing concurrent code just got easier. The new testing/synctest package lets you run concurrency tests in a controlled environment where goroutines and time are deterministic.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="c"&gt;// Run with: go test&lt;/span&gt;
&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;counter&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="s"&gt;"testing"&lt;/span&gt;
    &lt;span class="s"&gt;"testing/synctest"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="c"&gt;// Counter is a simple struct holding an integer.&lt;/span&gt;
&lt;span class="c"&gt;// It has methods to increment the count and retrieve the value.&lt;/span&gt;
&lt;span class="k"&gt;type&lt;/span&gt; &lt;span class="n"&gt;Counter&lt;/span&gt; &lt;span class="k"&gt;struct&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;Counter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;Inc&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="c"&gt;// Increase counter by 1&lt;/span&gt;
&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;Counter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;N&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="c"&gt;// Return the current count&lt;/span&gt;

&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="n"&gt;TestCounter_Inc_Deterministic&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;testing&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c"&gt;// synctest.New creates a special deterministic test environment ("bubble").&lt;/span&gt;
    &lt;span class="c"&gt;// Inside this bubble, goroutines are scheduled in a controlled way,&lt;/span&gt;
    &lt;span class="c"&gt;// so the test result is always predictable (no race conditions).&lt;/span&gt;
    &lt;span class="n"&gt;st&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;synctest&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;New&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
    &lt;span class="k"&gt;defer&lt;/span&gt; &lt;span class="n"&gt;st&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Done&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="c"&gt;// Cleanup: always close the test bubble at the end.&lt;/span&gt;

    &lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;Counter&lt;/span&gt;&lt;span class="p"&gt;{}&lt;/span&gt;
    &lt;span class="k"&gt;const&lt;/span&gt; &lt;span class="n"&gt;workers&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="m"&gt;10&lt;/span&gt;

    &lt;span class="c"&gt;// Start 10 goroutines inside the synctest bubble.&lt;/span&gt;
    &lt;span class="c"&gt;// Each goroutine calls c.Inc(), incrementing the counter.&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="m"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="n"&gt;workers&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;st&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Go&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;func&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Inc&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;})&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="c"&gt;// Run the bubble until all goroutines are finished.&lt;/span&gt;
    &lt;span class="c"&gt;// This ensures deterministic completion of the test.&lt;/span&gt;
    &lt;span class="n"&gt;st&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Run&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;

    &lt;span class="c"&gt;// Verify the result: counter should equal number of goroutines (10).&lt;/span&gt;
    &lt;span class="c"&gt;// If not, fail the test with a clear message.&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;got&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;want&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;N&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="n"&gt;workers&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="n"&gt;got&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="n"&gt;want&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Fatalf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"got %d, want %d"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;got&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;want&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With the new testing/synctest, tests ensure a deterministic, flake-free run, so the counter always ends up at 10.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Experimental encoding/json/v2
&lt;/h2&gt;

&lt;p&gt;A brand-new JSON engine is available under the GOEXPERIMENT=jsonv2 flag. It’s faster, more efficient, and includes a streaming-friendly jsontext package. Even better, the old encoding/json can piggyback on the new engine—so you get performance boosts without breaking old code.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Tooling Improvements
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;go vet now catches common mistakes like incorrect sync.WaitGroup.Add usage and unsafe host:port handling.&lt;/li&gt;
&lt;li&gt;go doc -http serves documentation locally in your browser.&lt;/li&gt;
&lt;li&gt;go build -asan can detect memory leaks automatically.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These small upgrades add up to a smoother dev workflow.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Runtime Improvements
&lt;/h2&gt;

&lt;p&gt;Go now runs smarter inside containers. On Linux, it automatically detects how many CPUs the container is allowed to use and adjusts itself. There’s also a new experimental garbage collector called greenteagc, which can make memory cleanup up to 40% faster in some cases.&lt;/p&gt;

&lt;h2&gt;
  
  
  9. Flight Recorder API
&lt;/h2&gt;

&lt;p&gt;Have you ever wished you could see exactly what your Go application was doing when something went wrong—like when a request suddenly takes 10 seconds instead of 100 milliseconds, or your app mysteriously starts using too much CPU? By the time you notice, it’s usually too late to debug because the issue has already passed. Go’s new FlightRecorder feature solves this by continuously capturing a lightweight runtime trace in memory, allowing your program to snapshot the last few seconds of activity to a file whenever a significant event occurs.&lt;/p&gt;

&lt;h2&gt;
  
  
  10. Platform Updates
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;macOS 12 (Monterey) is now the minimum supported version.&lt;/li&gt;
&lt;li&gt;Windows/ARM 32-bit support is deprecated and will be removed in Go 1.26.&lt;/li&gt;
&lt;li&gt;RISC-V and Loong64 gained new capabilities like plugin builds and race detection.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Key Takeaways
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Safer by default: no more silent nil pointer bugs, better panic reporting.&lt;/li&gt;
&lt;li&gt;Faster builds &amp;amp; runtime: DWARF v5 debug info, container-aware scheduling, and optional GC improvements.&lt;/li&gt;
&lt;li&gt;Better tooling: smarter go vet, memory-leak detection, local docs.&lt;/li&gt;
&lt;li&gt;Modern JSON: encoding/json/v2 is the future, with huge performance gains.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Go 1.25 brings meaningful improvements across performance, correctness, and developer experience. From smarter CPU usage in containers to reduced garbage collector overhead, from more predictable runtime behavior to new tools like FlightRecorder, this release shows Go’s commitment to staying simple while evolving with modern workloads. If you haven’t tried it yet, now’s the time—upgrade, experiment with the new features, and see how they can make your applications faster, safer, and easier to debug.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources:
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://go.dev/doc/go1.25" rel="noopener noreferrer"&gt;https://go.dev/doc/go1.25&lt;/a&gt;&lt;/p&gt;

</description>
      <category>go</category>
      <category>programming</category>
    </item>
    <item>
      <title>What means to be a Senior Software Engineer focused on Backend</title>
      <dc:creator>Pedro Bertao</dc:creator>
      <pubDate>Wed, 16 Jul 2025 15:15:32 +0000</pubDate>
      <link>https://dev.to/pedrobertao/what-means-to-be-a-senior-software-engineer-focused-on-backend-53ac</link>
      <guid>https://dev.to/pedrobertao/what-means-to-be-a-senior-software-engineer-focused-on-backend-53ac</guid>
      <description>&lt;p&gt;As I keep studying to improve at what I do, I keep asking myself this question and never seem to have a solid answer. Is seniority simply about years of experience? Or is it about expertise, autonomy, and the ability to design and deliver reliable, scalable systems while mentoring and guiding teams? The result was good, though with an interesting twist. &lt;/p&gt;

&lt;p&gt;The way I conducted this quick survey was by using a generic prompt across the three most popular AI models at the time of this writing, which I will keep undisclosed. The goal was simply to examine the results and see whether they converge on a similar plan.&lt;/p&gt;

&lt;p&gt;Prompt:&lt;br&gt;
What does it mean to be a Senior Software Engineer (focused on backend)? You can discuss years of experience, programming languages they should know, key books, and any other arguments to provide a precise and concise summary.&lt;/p&gt;

&lt;p&gt;✍🏼 Results&lt;/p&gt;

&lt;p&gt;AI 1 - To be a Senior Backend Software Engineer means possessing a deep, independent expertise in designing, developing, and maintaining robust, scalable, and efficient server-side systems, typically backed by 5+ years of dedicated experience. This involves mastering at least one backend language (e.g., Python, Java, Go, Node.js), coupled with a strong command of databases (SQL/NoSQL), APIs (REST/gRPC), system architecture, distributed systems, and cloud platforms like AWS, Azure, or GCP, alongside proficiency in CI/CD. Beyond coding, it encompasses mentorship, solving complex technical challenges, driving strategic technical decisions, and contributing to the overall architectural vision. Essential reads like "Designing Data-Intensive Applications" and "Clean Code" encapsulate the theoretical and practical knowledge expected, ultimately positioning the senior engineer as a leader who transforms business requirements into reliable, performant, and maintainable backend solutions.&lt;/p&gt;

&lt;p&gt;AI 2 - A Senior Software Engineer focused on backend development typically brings 5-8+ years of experience and represents a blend of deep technical expertise and leadership capabilities. They possess mastery of backend languages like Java, Python, Go, or C#, along with comprehensive knowledge of databases (both SQL and NoSQL), system design principles, API development, and cloud platforms such as AWS, Azure, or GCP. Beyond pure coding skills, they demonstrate system thinking by designing scalable and maintainable architectures, understanding distributed systems, microservices patterns, caching strategies, and performance optimization techniques. Their role extends into mentoring junior developers, leading technical decisions, conducting thorough code reviews, and driving architectural choices that impact entire product ecosystems. Essential reading includes "Designing Data-Intensive Applications" by Kleppmann, "System Design Interview" by Xu, and "Clean Architecture" by Martin. Most importantly, senior engineers translate business requirements into robust technical solutions while balancing technical debt against feature delivery, possessing strong debugging skills, DevOps knowledge including CI/CD and containerization, security awareness, and the ability to collaborate effectively across product and design teams to deliver meaningful business impact&lt;/p&gt;

&lt;p&gt;AI3 - Being a Senior Software Engineer (backend) means having 5+ years of experience, technical autonomy, system design skills, and focus on delivering value. Strong in languages like Go, Java, or Python, databases (SQL/NoSQL), messaging, and scalable architectures. Familiar with Clean Code, Design Patterns, and DDD. Leads by example, reviews code, proposes robust solutions, anticipates issues, and drives impact with a strong sense of ownership.&lt;/p&gt;

&lt;p&gt;Analysis and Thoughts&lt;/p&gt;

&lt;p&gt;After reviewing the responses, I consolidated and summarized them into key points, as follows:&lt;/p&gt;

&lt;p&gt;🧑🏽‍🏭 Experience&lt;/p&gt;

&lt;p&gt;5+ years (typically 5-8+) of backend-focused professional experience&lt;/p&gt;

&lt;p&gt;Technical autonomy and independence&lt;/p&gt;

&lt;p&gt;📊 Technical Expertise&lt;/p&gt;

&lt;p&gt;Mastery of one or more backend languages: Go, Java, Python, Node.js, C#&lt;/p&gt;

&lt;p&gt;Deep knowledge of databases (SQL &amp;amp; NoSQL)&lt;/p&gt;

&lt;p&gt;API development (REST, gRPC)&lt;/p&gt;

&lt;p&gt;Strong understanding of system design, distributed systems, microservices&lt;/p&gt;

&lt;p&gt;Familiar with caching strategies, messaging systems, performance optimization&lt;/p&gt;

&lt;p&gt;☁️ Architecture &amp;amp; Cloud&lt;/p&gt;

&lt;p&gt;Experience with scalable and maintainable architectures&lt;/p&gt;

&lt;p&gt;Cloud platforms: AWS, Azure, GCP&lt;/p&gt;

&lt;p&gt;Proficient in CI/CD, DevOps, containerization (e.g., Docker, Kubernetes)&lt;/p&gt;

&lt;p&gt;👥 Leadership &amp;amp; Mentorship&lt;/p&gt;

&lt;p&gt;Mentoring junior engineers&lt;/p&gt;

&lt;p&gt;Leading technical decisions and architectural choices&lt;/p&gt;

&lt;p&gt;Conducting thorough code reviews&lt;/p&gt;

&lt;p&gt;👔 Soft Skills &amp;amp; Business Impact&lt;/p&gt;

&lt;p&gt;Ability to translate business requirements into robust technical solutions&lt;/p&gt;

&lt;p&gt;Balance technical debt vs. delivery&lt;/p&gt;

&lt;p&gt;Collaborate effectively across teams (e.g., product, design)&lt;/p&gt;

&lt;p&gt;📚 Essential Knowledge &amp;amp; Books&lt;/p&gt;

&lt;p&gt;"Designing Data-Intensive Applications" by Martin Kleppmann&lt;/p&gt;

&lt;p&gt;"Clean Code" by Robert C. Martin&lt;/p&gt;

&lt;p&gt;"System Design Interview" by Alex Xu&lt;/p&gt;

&lt;p&gt;Familiar with Design Patterns, DDD (Domain-Driven Design)&lt;/p&gt;

&lt;p&gt;As expected, the responses were very good, and I agree with every single point — especially those related to backend engineering itself, such as cloud and architecture. However, for some reason, none of them mentioned AI as a tool or as part of the requirements. Was this omission intentional, or was my prompt not phrased correctly? I leave this question to you, the reader, and will provide an additional prompt to help explore the role of AI in this context.&lt;/p&gt;

&lt;p&gt;▶️ Bonus prompt: What about AI and how it helps the engineer ?&lt;/p&gt;

&lt;p&gt;While AI is incredibly powerful, it's crucial to remember that it augments, rather than replaces, the human engineer. Human intuition, creativity, ethical judgment, and the ability to understand nuanced user needs and business context remain irreplaceable. The most effective engineers in the AI era will be those who can leverage these tools effectively to amplify their own capabilities and tackle more challenging and impactful problems.&lt;/p&gt;

</description>
      <category>senior</category>
      <category>software</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>Golang 1.21 is here (Part 3)</title>
      <dc:creator>Pedro Bertao</dc:creator>
      <pubDate>Sun, 08 Oct 2023 12:36:49 +0000</pubDate>
      <link>https://dev.to/pedrobertao/golang-121-is-here-part-3-11j</link>
      <guid>https://dev.to/pedrobertao/golang-121-is-here-part-3-11j</guid>
      <description>&lt;p&gt;This final part we will be looking at some features of the new &lt;strong&gt;&lt;em&gt;slices&lt;/em&gt;&lt;/strong&gt; packages which brings a lot of awesome features.&lt;/p&gt;

&lt;p&gt;First we are going to use &lt;code&gt;slices.Compare&lt;/code&gt; which is a very useful function when comparing two slices.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;        intSliceA := []int{1, 2, 3}
        isEqual := slices.Compare(intSliceA, []int{1, 2, 3})
    if isEqual == 0 {
        fmt.Println("Is Equal")
    } else {
        fmt.Println("Not Equal")
    }
    // Is Equal

    isEqual = slices.Compare(intSliceA, []int{4, 5, 6})
    if isEqual == 0 {
        fmt.Println("Is Equal")
    } else {
        fmt.Println("Not equal")
    }
    // Not Equal
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Another great use of &lt;code&gt;slices&lt;/code&gt; packages is slices.contains&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;        intSliceA := []int{1, 2, 3}
    isEqual := slices.Contains(intSliceA, 1)
    if isEqual {
        fmt.Println("Contains")
    } else {
        fmt.Println("Does not Contain")
    }
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Finally another interesting function is &lt;code&gt;slices.Max&lt;/code&gt; where it locates the max value inside the slice as shown below&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;    intSliceA := []int{3, 123, 23, 57, 98, 4, 3, 2}

    max := slices.Max(intSliceA)
    fmt.Println("Max:", max)
    // Max:  123
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If you wanna to check more of the 1.21 slices package, you can click &lt;a href="https://pkg.go.dev/slices#pkg-overview" rel="noopener noreferrer"&gt;here&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;To finish this post I will quote the overview of changelog &lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;The latest Go release, version 1.21, arrives six months after Go 1.20. Most of its changes are in the implementation of the toolchain, runtime, and libraries. As always, the release maintains the Go 1 promise of compatibility; in fact, Go 1.21 improves upon that promise. We expect almost all Go programs to continue to compile and run as before.&lt;br&gt;
Go 1.21 introduces a small change to the numbering of releases. In the past, we used Go 1.N to refer to both the overall Go language version and release family as well as the first release in that family. Starting in Go 1.21, the first release is now Go 1.N.0. Today we are releasing both the Go 1.21 language and its initial implementation, the Go 1.21.0 release. These notes refer to “Go 1.21”; tools like go version will report “go1.21.0” (until you upgrade to Go 1.21.1). See “Go versions” in the “Go Toolchains” documentation for details about the new version numbering.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Go 1.21 brings a lot of features that will makes your code more cleaner and readable. It is must read if you want to use this version for your next projects.&lt;/p&gt;

</description>
      <category>go</category>
      <category>tutorial</category>
      <category>development</category>
    </item>
    <item>
      <title>Golang 1.21 is here (Part 2)</title>
      <dc:creator>Pedro Bertao</dc:creator>
      <pubDate>Thu, 31 Aug 2023 10:07:07 +0000</pubDate>
      <link>https://dev.to/pedrobertao/golang-121-is-here-part-2-5b66</link>
      <guid>https://dev.to/pedrobertao/golang-121-is-here-part-2-5b66</guid>
      <description>&lt;p&gt;In this comprehensive post, I will delve into the intricacies of &lt;strong&gt;maps&lt;/strong&gt; and &lt;strong&gt;cmp&lt;/strong&gt; packages in the context of Go programming. I'll shed light on the standout features that have been intelligently incorporated to enhance your day-to-day experience while developing Go applications. Stay tuned for valuable insights and practical tips!&lt;/p&gt;

&lt;h2&gt;
  
  
  Maps
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;    m := map[string]string{
        "name": "Pedro",
        "age":  "20",
    }

    m2 := map[string]string{
        "name": "Pedro",
        "age":  "20",
    }

    m3 := make(map[string]string)

    r := maps.Equal(m, m2)
    r2 := maps.EqualFunc(m, m2, func(s1, s2 string) bool {
        return m["name"] == m2["name"] &amp;amp;&amp;amp; m["age"] == m2["age"]
    })

    fmt.Println("Equal: ", r)
    fmt.Println("Equal Func: ", r2)

    cloned := maps.Clone[map[string]string](m)
    maps.Copy[map[string]string](m3, m)

    fmt.Printf("Cloned: %+v: \n", cloned)
    fmt.Printf("Copied: %+v: \n", m3)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;In the presented code snippet, we can observe the introduction of some remarkably useful functions for maps. When using &lt;strong&gt;copy&lt;/strong&gt; it generates a shallow clone of the chosen map, when use &lt;strong&gt;clone&lt;/strong&gt; it generates a full copy of the the map. This becomes incredibly advantageous when the aim is to duplicate a map variable while preserving the integrity of the original data.&lt;/p&gt;

&lt;p&gt;The result of the previous code is:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Equal:  true
Equal Func:  true
Cloned: map[age:20 name:Pedro] 
Copied: map[age:20 name:Pedro] 
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You can also check the code &lt;a href="https://gist.github.com/pedrobertao/5d11c8ff0f3de6f8878640620ea9f439" rel="noopener noreferrer"&gt;here&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Cmp
&lt;/h2&gt;

&lt;p&gt;From the documentation, it is simple as:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Package cmp provides types and functions related to comparing ordered values.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;It's crucial to grasp that the cmp functions exclusively operate with &lt;a href="https://pkg.go.dev/cmp@master#Ordered" rel="noopener noreferrer"&gt;ordered types constraints&lt;/a&gt;, adding a layer of convenience for mathematical operations and more.&lt;/p&gt;

&lt;p&gt;Here is the code of two functions available in the cmp package&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;    var num, num2, num3 int64 = 1, 2, 1
    var str, str2, str3 = "ab", "abc", "ab"

    r := cmp.Compare[int64](num, num2)
    r2 := cmp.Compare[int64](num, num3)

    r3 := cmp.Less[string](str, str2)
    r4 := cmp.Less[string](str, str3)

    fmt.Println("Num is less than Num2: ", r &amp;lt;= 0)
    fmt.Println("Num is equal to Num3: ", r2 &amp;gt;= 0)
    fmt.Println("Num2 is greater than Num: ", r2 &amp;gt;= 0)
    fmt.Println("")
    fmt.Println("Str is less than Str2: ", r3)
    fmt.Println("Str is less than Str3 ", r4)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With the result&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Num is less than Num2:  true
Num is equal to Num3:  true
Num2 is greater than Num:  true

Str is less than Str2:  true
Str is less than Str3  false
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;When using &lt;strong&gt;cmp.Compare&lt;/strong&gt; it will return -1,0,1 which means from the documentation:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;-1 if x is less than y,&lt;br&gt;
 0 if x equals y,&lt;br&gt;
+1 if x is greater than y.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;When employing &lt;strong&gt;cmp.Less&lt;/strong&gt;, it evaluates whether the first value is less than or equal to the second. This utility proves highly beneficial for tackling algorithmic challenges.&lt;/p&gt;

&lt;p&gt;You can check the code &lt;a href="https://gist.github.com/pedrobertao/3f7b32dcbeacefdfa7ede2f64270bfdf" rel="noopener noreferrer"&gt;here&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;And that concludes this post. In our next installment, we'll wrap up with discussions on slices packages. Stay tuned!&lt;/p&gt;

&lt;p&gt;&lt;a href="https://dev.to/pedrobertao/golang-121-is-here-part-3-11j"&gt;Part three&lt;/a&gt;&lt;/p&gt;

</description>
      <category>go</category>
      <category>development</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Golang 1.21 is here (Part 1)</title>
      <dc:creator>Pedro Bertao</dc:creator>
      <pubDate>Sat, 26 Aug 2023 10:57:27 +0000</pubDate>
      <link>https://dev.to/pedrobertao/golang-121-is-here-part-1-5524</link>
      <guid>https://dev.to/pedrobertao/golang-121-is-here-part-1-5524</guid>
      <description>&lt;p&gt;Golang 1.21 arrived on August 8th with some performance improvements, the addition of native packages, and functions that will enhance your code syntax and productivity in your daily work. Below, I've selected the a fews topics along with examples of how to use them. You can follow the complete change log &lt;a href="https://tip.golang.org/doc/go1.21" rel="noopener noreferrer"&gt;here&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Let's start with the changes in the language itself, where utility functions were implemented: &lt;strong&gt;min&lt;/strong&gt;, &lt;strong&gt;max&lt;/strong&gt; and &lt;strong&gt;clear&lt;/strong&gt;. &lt;/p&gt;

&lt;h2&gt;
  
  
  Min and Max
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;func main() {
    minInt := min(3, 2, 1, 4)
    minFloat := min(4.0, 2.0, 3.0, 1.0)
    minString := min("ab", "a", "abcd", "abc")

    fmt.Println("Min Integer:", minInt)
    fmt.Println("Min Float:", minFloat)
    fmt.Println("Min String:", minString)

    fmt.Println("==================")

    maxInt := max(4, 2, 3, 1)
    maxFloat := max(1.0, 4.0, 2.0, 3.0)
    maxString := max("a", "ab", "abc", "abcd")

    fmt.Println("Max Integer:", maxInt)
    fmt.Println("Max Float:", maxFloat)
    fmt.Println("Max String:", maxString)

}


&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;With the result&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Min Integer: 1
Min Float: 1
Min String: a
==================
Max Integer: 4
Max Float: 4
Max String: abcd
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;What's interesting is that with the addition of these two helper functions, Generics are used as input, and the type of the Generics is &lt;a href="https://pkg.go.dev/cmp#Ordered" rel="noopener noreferrer"&gt;cmp.Ordered&lt;/a&gt;, which basically applies to all comparable types in the Go language.&lt;/p&gt;

&lt;p&gt;You can see the Min-Max code &lt;a href="https://gist.github.com/pedrobertao/ecb14746900c8730e6c066ca2cf2ebeb" rel="noopener noreferrer"&gt;here&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Clear
&lt;/h2&gt;

&lt;p&gt;According to the documentation,&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;The new clear function deletes all elements from a map or zeroes all elements of a slice.&lt;br&gt;
&lt;/p&gt;
&lt;/blockquote&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;func main() {
    intSlice := []int{1, 2, 3}
    floatSlice := []float64{1.0, 2.0, 3.0}
    stringSlice := []string{"a", "b", "c"}
    mapString := map[string]string{
        "Name": "Pedro",
        "Age":  "20",
    }

    clear(intSlice)
    clear(floatSlice)
    clear(stringSlice)
    clear(mapString)

    fmt.Println("Int Slice", intSlice)
    fmt.Println("Float Slice", floatSlice)
    fmt.Println("String Slice", stringSlice)
    fmt.Println("Map", mapString)

}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;With the result&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Int Slice [0 0 0]
Float Slice [0 0 0]
String Slice [  ]
Map map[]
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;As we can see, it not only clears the Slices, but also makes their sizes equal and replaces the values with default ones. In the case of the Map, after using the Clear function, it's as if it were an empty Map.&lt;/p&gt;

&lt;p&gt;You can check the Clear code &lt;a href="https://gist.github.com/pedrobertao/6ec6f4942744036afeb1e05b6d76d177" rel="noopener noreferrer"&gt;here&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;For the next parts I will cover some new cool Log, Cmp and Maps features that were added.]&lt;/p&gt;

&lt;p&gt;&lt;a href="https://dev.to/pedrobertao/golang-121-is-here-part-2-5b66"&gt;Part two&lt;/a&gt;&lt;/p&gt;

</description>
      <category>go</category>
      <category>programming</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>What I learned building my first side project</title>
      <dc:creator>Pedro Bertao</dc:creator>
      <pubDate>Sun, 11 Aug 2019 18:23:33 +0000</pubDate>
      <link>https://dev.to/pedrobertao/what-i-learned-building-my-first-side-project-2nen</link>
      <guid>https://dev.to/pedrobertao/what-i-learned-building-my-first-side-project-2nen</guid>
      <description>&lt;p&gt;I have always wanted to be a better programmer since my first job a few years ago. And by wanting to be a better programmer you would naturally look for ways to achieve that goal.&lt;/p&gt;

&lt;p&gt;It's not hard to find lists explaining step by step what you should do to enhance your programming skills. Almost all of those guides would mention building a side project. &lt;/p&gt;

&lt;p&gt;So I decide to build a Crypto Tracker App where you could follow your favorite cryptocurrencies values with local notifications.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/cdn-cgi/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fpsmj6hl8m42mjb6rz3x5.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/cdn-cgi/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fpsmj6hl8m42mjb6rz3x5.png" width="800" height="691"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Here are the lessons taken from it&lt;/p&gt;

&lt;h2&gt;
  
  
  1. You have to deal with problems outside of your comfort zone.
&lt;/h2&gt;

&lt;p&gt;This project was built using React Native and I'm working with this technology for sometime now. It wasn't difficult until I had to deal with Local Notifications (iOS/Android), something that I never had done before. It took me a couple of days of reading and testing to finally get to work. After that, background tasks are something very blurry in the RN world leading to more problems with my original idea.&lt;/p&gt;

&lt;p&gt;I ended up solving those issues and I'm more prepare to handle tasks related to those topics in the near of far future. &lt;/p&gt;

&lt;h2&gt;
  
  
  2. You code, you review, you fix
&lt;/h2&gt;

&lt;p&gt;Build something by yourself can be sometimes make you produce lazy code and poor syntax. I've had more than one occasion that my codes were so bad that even though was working, I didn't want to commit it. I would patiently rewrite to follow a design pattern or the very minimum syntax standards. That's because I knew I would want others to look at my code and send me feedbacks about general architecture and UI/UX, not about how poorly my code was written. &lt;/p&gt;

&lt;p&gt;After finishing this first version I can say for sure that my ability to search for inconsistencies and flaws throughout codes (mine or others) have increase significantly.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Motivation is tricky, you have to set micro and macro goals
&lt;/h2&gt;

&lt;p&gt;Something that delayed this side project from being released early was probably because I wasn't motivated enough to keep going. In the very start I was trying to build everything in one go. Of course that didn't work and kept me thinking if this was really a good idea. But at the same time I didn't want this project to end up in the 'I don't have time' purgatory. &lt;br&gt;
So I changed my routine of work and added small incremental steps (just like any other agile methodology) and gradually build the core of the app. After that, every time I'd sit to code this project I would focus on one micro task at the time always pursuing the macro objective.&lt;/p&gt;

&lt;p&gt;That way I managed to finish the first version within 2 months (I was expecting one month) and I have to say, this was of a great relief. &lt;/p&gt;

&lt;h3&gt;
  
  
  Conclusion
&lt;/h3&gt;

&lt;p&gt;Building a side project can be somewhat stressful and can lead to some headaches, but the overall experience and learning are worth taking. &lt;br&gt;
You should build a side project because will increase your knowledge about the technology, you will face and solve new problems and you will have something awesome to share with the community. Don't let your ideas purge away on the 'I don't have time' zone.&lt;/p&gt;

&lt;p&gt;Checkout the project &lt;a href="https://studio.youtube.com/video/zY7jNN5JEGU/edit" rel="noopener noreferrer"&gt;here&lt;/a&gt; and the &lt;a href="https://github.com/pedrobertao/mycrypto" rel="noopener noreferrer"&gt;source code&lt;/a&gt;&lt;/p&gt;

</description>
      <category>reactnative</category>
      <category>react</category>
      <category>crypto</category>
    </item>
  </channel>
</rss>
