235 Blog Posts To Learn About Go

Let’s learn about Go via these 235 free blog posts. They are ordered by HackerNoon reader engagement data. Visit the Learn Repo or LearnRepo.com to find the most read blog posts about any technology.

Go is an open-source programming language developed by Google, known for its simplicity, efficiency, and strong support for concurrent programming. Go is increasingly popular for building scalable network services, microservices, and high-performance systems.

1. In-Memory Caching in Golang

How to implement in-memory cache in Golang App

2. ChatGPT Go Libraries: A Comparison With Examples

Comparison of ChatGPT API clients for Go language

3. Mastering Synchronization Primitives in Go

Golang’s Goroutines make it easy to run code concurrently. We can simply add the keyword “go” in front of a function call to make it run in a separate routine, or asynchronously.

4. This 150-Line Go Script Is Actually a Full-On Load Balancer

This article will show you how to create a simple HTTP load balancer in Go, using only the standard library.

5. How To Create Golang REST API: Project Layout Configuration [Part 1]

During past couple of years I have worked on few projects written in GO. I noticed that the biggest challenge developers are facing is lack of constraints or standards when it comes to project layout. I’d like to share some findings and patterns that have worked best for me and my team. For better understanding I’ll go through steps of creating a simple REST API.

6. GO Design Patterns: An Introduction to SOLID

Adopt SOLID design principles in GO for better code quality and easier software maintenance.

7. Some insights on Maps in Golang

Article is about maps internal structure, hashes and performance. How data is actually stored inside.

8. Go: Handling JSON in MySQL

9. PostgreSQL Transaction Isolation Levels with Go Examples

Illustration composed from MariaLetta/free-gophers-pack, original gopher by Renee French.

10. No-stress CUDA programming using Go and C

Programming CUDA using Go is a bit more complex than in other languages. Although there are some excellent packages, such as mumax, the documentation is poor, lacks examples and it’s difficult to use.

11. Understanding sync.Cond in Go: A Guide for Beginner’s

Understanding sync.Cond in Go that is a synchronization primitive used for coordinating goroutines by allowing them to wait for a specific condition.

12. Generate Swagger Doc Files From Go Code Using Go-swagger

In this article, I will try to explain basic ideas on how to generate swagger docs using go-swagger package.

13. 6 Best Go Programming Books Ranked by Reviews

Learning Go and Black Hat Go are some of the best Go programming books based on their review scores.

14. Practice with Functional Programming in Go

Take a look at a functional programming paradigm in Go

15. A Comprehensive Guide for Using DuckDB With Go

A comprehensive guide how to use popular embedded OLAP database DuckDB with Go.

16. NATS JetStream — a New Way to Create Resilient Message Queue

Today, I’ll walk you through how to use NATS JetStream with a Golang app.

17. Leveraging Multithreading To Read Large Files Faster In Go

The other day I was interviewing at one of the companies, and I was asked the following question, how can you count occurrences of a word in a 50gb file with 4gb of RAM. The trick is to not load the whole file into memory and keep processing each word as we keep on moving the pointer of the file. With this, we can easily process the whole file with a minimal amount of memory resources.

18. Comparing Optimistic and Pessimistic Locking With GO and PostgreSQL

Comparison between Optimistic and Pessimistic locking with Golang and PostgreSQL

19. Goroutines: How to Run Concurrency Code in Go

Try out concurrency in Go on a simple example. What are greenthreads and asynchronous preemtpion? Understanding channels by using worker-pool pattern.

20. GO Design Patterns: An Introduction to Builder

Streamlining Your Code: An Introduction to the Builder Pattern in Go

21. Introducing Bun: A Golang ORM

Bun is a SQL-first Golang ORM for PostgreSQL, MySQL/MariaDB, MSSQL, and SQLite. It supports migrations, fixtures, and performance monitoring.

22. How to Make Global Constant Maps and Slices in Go

For the most part, Go developers are pretty good about using constants for global configuration, rather than global variables. A problem arises however when we want a global constant slice or map. The go compiler doesn’t allow these more complex types to be set as constant. Many developers, upon making this realization, decide to then use a dangerous global variable. In this article we will explore a better option.

23. Custom TraceID in Elastic APM

Elastic APM is extensively useful in monitoring the lifecycle of a HTTP request in a system especially in µservices architecture. Wide variety of web frameworks and databases are supported which is useful in tracking the request up to DB calls. The documentation is simple and concise which makes it easy to instrument the application.

This article aims to help or at least make it easy to trace the HTTP request lifecycle after instrumentation. Golang is used in this article for code snippets but the concept can be extended to other languages as well.

24. How to Detect and Delete Emojis in Golang

I encountered an issue when 10 million messages with emoji were written in the MySQL table with utf8 encoding.

25. Real Time Data Processing: Easily Processing 10 Million Messages With Golang, Kafka and MongoDB

How fast Golang can be for processing a high number of messages coming from a Kafka topic?

26. Golang Unsafe Type Conversions and Memory Access

Illustration composed from MariaLetta/free-gophers-pack, original gopher by Renee French.

27. How to Use Maps Safely in Go

Different ways to protect maps from concurrent access in Golang.
Golang, concurrent programming, sync.Mutex, sync.RWMutex, sync.Map, channels

28. ‘Hello, World!’ in Golang – How to Develop a Simple Web App in Go

I’m going to show you how easy it is to develop a simple web application in Go, package it as a lightweight Docker image, and deploy it to Heroku.

29. How to Use Consul as a Host Resolver in gRPC

Recently, I faced with lack of documentation when I wanted to use Consul as a host resolver in gRPC connections. That’s why I wanted to write this story.

30. Go and sync.Pool

The garbage collector (GC) does not collect garbage constantly, but at certain intervals.

31. How to Encode a URL in Go

URL encoding in Go (Golang) is the process of converting a string into a URL-encoded format that is safe to include in a URL.

32. Concurrency in Golang And WorkerPool [Part 1]

Project Link: https://github.com/Joker666/goworkerpool

33. Unit Test AWS Lambda in Go

When I started working in Go and AWS Lambda, one of the difficulties that I faced was unit testing. I had a decent idea about what is unit testing and knew how to do it in Ruby but in Go, I had no idea because I was a beginner.

34. Validating Zero Enum Value in the Protocol Buffer

How to validate that an enum value field in Protobuf can not be empty? Turn out that is not supported directly by Protobuf!

35. Why Do Developers Love Working With Google’s Go Programming Language?

With the extensive number of programming languages available out there, for any language to emerge among the best is no easy feat.

36. 5 Best Practices for Integrating with External APIs

the must-have practices if you use external APIs

37. Go and Protocol Buffers (Quick Tutorial)

How to use Protocol Buffers in Go using proto3.

38. Master the Art of Command Line: Your Ultimate Guide to Developing Powerful Tools

Command line tools are programs that can be executed from a terminal or command prompt, allowing users to interact with a computer system through typed commands

39. How to Remove Duplicates in Go Slices

Different ways to remove duplicates in slices in Go, a powerful language whose lack of tools makes learning this necessary if you want to make full use of it.

40. Understanding Mux and Handler by Writing Your Own RESTful Mux

In this article, we will try to understand two crucial Go concepts – mux and Handler.

41. Building a Media Streaming Server Using Go And HLS Protocol

In this tutorial, I’m going to walk you through building a streaming API using Golang. Don’t worry, its surprisingly easy to build a robust streaming server, especially if we utilize one of the more modern protocols: HLS.

42. Golang ― More Error Handling with Less Checking

Error checks are essential but turn to noise without automatic propagation. Fixing Go’s error-handling.

43. Golang: Using systemd for Zero Downtime Restarts and Deploys

By configuring a systemd socket, you can tell systemd to listen on the configured ports and start your service with a copy of the listening sockets.

44. How a Go Program Compiles down to Machine Code

Here at <a href=”https://getstream.io” target=”_blank”>Stream</a>, we use Go extensively, and it has drastically improved our productivity. We have also found that by using Go, the speed is outstanding and since we started using it, we have implemented mission-critical portions of our stack, such as our in-house storage engine powered by gRPC, Raft, and RocksDB.

45. Concurrency in Golang And WorkerPool [Part 2]

Project Link: https://github.com/Joker666/goworkerpool

46. Generic Programming in Go

Generic Programming in Go using different methods: interfaces, typecasting, Generic Functions

47. Let’s Go tiny with tinyGo

Go was designed at Google in 2007, the evolution of this language is tremendous. Nowadays we are almost can create any kind of application using Go, from API, tooling, game, library, and so on. So how about the embedded system or today hot term as IoT, can we use Golang for this kind of application? The answer is yes, we can.

48. How to Connect a Python and Go App Using gRPC and Mutual TLS

This tutorial walks you through the process of connecting services written in Python and Go via the gRPC framework using mutual TLS authentication.

49. How To Generate A PDF Report From HTML with Go

HTML for PDF in Go for creating quality PDF reports with Table of Contents, Bookmarks and other important native PDF features.

50. How to Find and Fix Goroutine Leaks in Go

Learn how to identify and fix goroutine leaks in Go applications using techniques like monitoring, profiling, and tools like Prometheus and Grafana.

51. Security Considerations in Golang

Golang recently turned 10 and the success this language has created over the last 10 years is overwhelming. Today, many of the most popular DevOps tools are now written in Go. This proves that Go is a language that has a great future in the DevOps industry. It is meant for cloud network infrastructure practitioners – this was one of the primary goals of the Go creators. As a result, Every major cloud provider today has turned to Go for their core cloud infrastructure, to name some – Docker, Kubernetes, Istio, Etcd, Prometheus, and Terraform.

52. Billion-Dollar Mistake in Go?

The following sample code is from Go’s standard library documentation:

53. Go’s Cryptography Packages Were Audited: The Results

The audit produced a single low-severity finding, in the legacy and unsupported Go+BoringCrypto integration, and a handful of informational findings.

54. Is Go faster than Java? – The Wrong Question to Ask

This means to compare programming languages on what really matters, which in most cases, specifically in the enterprise world, is how efficient it is to develop

55. Modern Hashing With Go: A Guide

Let’s break down everything you need to know about using hash functions in Go, with plenty of real-world examples you can start using today.

56. How To Create Golang REST API: Project Layout Configuration [Part 3]

Good cake is the one you can easily slice into parts with no crumbs falling apart. That’s all this project is about: 3 simple parts, no nasty additives. In part 1 and part 2 I’ve explained the basics of setting up golang project using docker, creating configurable server, interacting with DB, adding routes and handlers.

57. How to Build a Bitcoin Telegram Bot

I created a simple Telegram bot that could retrieve Bitcoin’s Price to convince my friends that Telegram is far superior to Whatsapp.

58. How to Use GoReleaser to Automate GoLang Build Releases

This is a quick start for GoReleaser to automate the building and publishing GoLang projects.

59. Kong Plugins as Microservices: Writing a Single-Plugin Server for Kong in Go

Many developers and DevOps engineers have been deploying Kong Gateway in front of their microservices-based applications.

60. Protobuf Under the Hood: How Serialization and Deserialization Work in Go

Protocol Buffers (Protobuf) is a fast, efficient, and language-agnostic data serialization mechanism.

61. Getting to Know gRPC

Need a quick beginner’s guide to gRPC? What is it? How do you set up a client and server, and make an RPC call? All your answers are here!

62. How to Develop a Facebook Messenger Bot in Golang

A comprehensive guide on how to create a Facebook Messenger bot in Golang.

63. Optimizing Memory Usage in Golang: When is a Variable Allocated to the Heap

Optimize memory usage in Golang by understanding stack vs heap allocation, escape analysis, and improving performance with efficient memory management

64. Introduction to RDS Proxy: Exploring with Benchmarks in Go

A deep dive into the performance characteristics of RDS Proxy vs RDS

65. Pointer and Nil in Go: Reasons Why You Should Be wary

The harmful part of Go that you might not be aware of.

66. Understanding the Basic Concepts of Heap Data Structure in GoLang

We are trying to learn the basic concepts about heaps like inserting and extracting data from heaps and also the time complexity of heaps.

67. Understanding Concurrency Patterns in Go

Explore Go’s concurrency patterns, including worker pools, fan-out/fan-in, and pipelines, to build efficient, robust, and scalable applications.

68. Top 5 Trends in Software Development for 2019

Everything is moving extremely quickly in the software industry, so it requires a lot of effort just to keep up. This is exactly why we, at Coding Sans, publish the State of Software Development survey every year. To learn what is happening in the industry at the moment, and see how trends are forming over time.

69. 5 Programming Languages To Kickstart your Software Development Career

5 Programming Languages To Learn In 2022. Python is in the boom, mainly due to Data Science and Machine Learning.

70. Making a Simple Service App for a Yocto-Based Linux Distro

I decided to make the first steps in Yocto-oriented software development and make a rather simple service app for Yocto-based Linux distro.

71. Purity in My Programming: Functions in Go

Pure functions are often hyped up in the Javascript world, probably because of the abundance of state in front end applications. While pure functions have their downsides (i.e. inconvenience, potentially large argument lists), I believe they should be used as much as reasonably possible, and I want to focus on pure functions in Go.

72. Flight Recorder: A New Go Execution Tracer

Flight recording is now available in Go 1.25, and it’s a powerful new tool in the Go diagnostics toolbox.

73. Checking Palindrome With Generics in Go 1.18

Palindrome checking function in go that can receive integer or string. Utilize new generics feature in Go 1.18.

74. Interfaces in Go

What are Interfaces in Golang?

75. Golang: Declarative Validation Made Similar to Ruby on Rails

Using declarative validation in Golang, in a similar way to Active Record validations.

76. 2 Error-Free Options for Decimal handling in Golang

CockroachDB and using a popular database are two error-free options for decimal handling in Golang.

77. How to Create a Dynamic Pipeline Route in Go

Is it possible to create a pipeline with dynamic routes in Go? How to do it?

78. Serverless API with Terraform, GO and AWS, Part 1

Knowing how to build REST API with latest tech is cool. You know what’s even cooler? It’s being able to deploy it to the cloud! I’ll walk you through the process of building simple, server-less application using GO, AWS (Lambda, API Gateway, Dynamodb) and Terraform.

79. Creating Production Grade Microservices with Go and gRPC

Microservices have emerged as a powerful architectural paradigm for developing complex, scalable, and maintainable software systems.

80. How to Track Email Effectiveness in Mixpanel Analytics w/Latenode.com

Learn how to seamlessly incorporate Mixpanel analytics into your email communication by integrating it with Mailgun using Latenode.com automation platform.

81. Mastering Go Channels for Elegant Synchronization

Channels in Go are a core part of the language’s concurrency model, which is built around the principles of Communicating Sequential Processes.

82. Everything You Need To Know About Managing Go Processes

Explore techniques for managing blocking processes in Go, focusing on signal handling, process groups, & platform-specific considerations in linux environments.

83. Node.js vs Go vs SpringBoot: Performance Comparison for I/O Bound App

Find out how Node.js, Go, and SpringBoot performs for I/O bound app (URL shortener service).

84. A Step-by-step Guide for Building a Simple TODO App With Gin-gonic in Zerops

Learn how to build a sample CRUD TODO API written in GO using gin-gonic, one of the most popular web frameworks, which saves data to a PostgreSQL database

85. Managing Go Module Pseudo-Versions in Go 1.13

Go modules have helped bring order to Go development, but there’s been some disorder lurking. Managing module pseudo-versions can be difficult, especially with some of the latest changes to Go.

86. Passing and Returning Structured Datatypes to and From Go WebAssembly Module

We will write our guest application in Go, compile it to Wasm with TinyGo, and embed it with Wasmtime runtime into the host application, also written in Go.

87. Why Front End Developers Going Full Stack Should Choose Go

So you’re a front end developer, and you want to learn some backend stuff. You want to become a full stack developer someday, so where do you start? Google’s Go language is an excellent place.

88. Golang: a RESTful API Using Temporal Table With MariaDB

Temporal tables are a type of database table that store historical data, allowing users to query the data as it existed at specific points in time.

89. Bloom Filter Basics in Go

Learn about Bloom filters: memory-efficient data structures using hashing for fast set membership queries.

90. The 3 Important Lessons I Learned From Implementing Raft in Go

Implementing Raft was an overall great experience that added many practical tools under my belt and improved my proficiency with Go.

91. Native Fuzzing in Go 1.18

Go adds fuzzing as a part of its testing tools. This feature is planned for the 1.18 release and is already available for beta testing

92. fmt.Sprintf: Looks Simple But Will Burn A Hole in Your Pocket

Explore efficient string concatenation and conversion in Go using alternatives to fmt.Sprintf for better performance and lower memory usage.

93. Fixing Race Conditions in Go with Redis-Based Distributed Locks

Go’s ‘sync.Mutex’ is a lock designed to lock critical sections of code.

94. How One ExpressJS Programmer Visited Go Land

I describe why Fiber it’s really a good start for learn Go when you have experience in ExpressJS, what similarities and differences to expect, and what things I learned when building my first API on Go.

95. Pet Projects are Fun

I love pet projects, they are great excuse to use libraries and other technologies that you can’t use at work. Lately I’ve been working on a bigger pet project that needs to parse Go files, I’ve used ANTLR before to make this kind of things but unfortunately, ANTLR’s Go target has poor performance. So I began to search for alternatives written in pure Go and came across with this one, which took a different approach on creating parsers with Go, but before we’re going to understand how this library is different from others, let’s cover some basic concepts about parsing.

96. What Is so Great About Golang?

Check out why you should use golang for your next project

97. Choosing the Right Microservices Framework

Microservices architecture is a methodology that allows you to split a monolithic single application into small applications and services.

98. Spend Zero Time on DevOps with Render PaaS

Check out how efficient it is to create a new API using Go, and then deploy it to the Render PaaS, both for the first time with zero DevOps.

99. Filling And Flattening PDF Forms In Go With Examples

PDF forms are a convenient tool for gathering and storing information about your customers or users. This is a breakdown of how you can fill and flatten them.

100. What Heroku is Good For

You’ve probably heard about Heroku by now, but do you really know how Heroku works and when it should be a consideration?

101. Using the Events API to Build a Slack Bot

I’m a huge fan of automating working processes. I try to automate everything and save my coworkers time.

102. How to Embed Static Resources Into a Go Project

I wanted to create a small standalone web application in Go, the opposite of a regular web application

103. Building a Go Dependency Scanner From Scratch

Build a Go dependency scanner with the standard library: parse go.mod, query OSV for vulnerabilities, and analyze licenses.

104. A Guide to Familiarize Yourself With Workspaces in Go

Go 1.18 adds workspace mode to Go, which lets you work on multiple modules simultaneously.

105. The Noonification: How to Use React to Replace useEffect (12/31/2022)

12/31/2022: Top 5 stories on the Hackernoon homepage!

106. Go’s New Experimental Packages: What to Know

This blog post is about Go 1.25’s new experimental encoding/json/v2 and encoding/json/jsontext packages, which bring long-awaited improvements and fixes.

107. Weird Things About GOLANG [Part 1]

On a first glance when I started working on go, for me it seems very very weird language. I am working on node-js for two and more years and then start working on golang is not so cool for me.

108. Implementing a Web Service With Go and Fiber

Let’s learn the basics of web development with the help of Go programming language and Fiber framework and write the most uncomplicated web service.

109. ES7-style Async/Await Implementation in Golang

In Golang, we use goroutines to execute asynchronous tasks while these goroutines communicate with each other via the data structure called Channel.

110. 3 Golang Pitfalls Every Developer Needs to Know

Over-viewing common coding pitfalls we’ve encountered when we started to use GoLang for production systems

111. Go 1.25 is released – The Go Programming Language

Go 1.25 comes with improvements over Go 1.24 across its tools, the runtime, compiler, linker, and the standard library

112. Go’s 16th Anniversary and the Major Highlights of 2025

The Go team is applying its thoughtful and uncompromising mindset to the problems and opportunities of this dynamic space.

113. Discover the Pros and Cons of the top Web Development Languages

Choosing the correct language for web development can be difficult.

114. What Is Go Protobuf? Exploring The New Opaque API

This blog post explains the motivation for creating a new API and shows you how to use it in your projects.

115. Does Golang Follow the Object Oriented Programming Paradigm?

Many are wondering whether Golang is a language that can apply the Object Oriented Programming paradigm. Let’s discuss this here.

116. How To Prevent Server Overload In Go

An in-depth guide on server overload, rate limiting, load shedding, Golang, and resilience.

117. How to Deploy Go + Templ + HTMX + TailwindCSS to Production

In this article, I will be showing you how to deploy the GoTTH stack (Go Templ htmx tailwind) to production.

118. Publish Go Packages With Goreleaser

Goreleaser is awesome. It’s a simple tool that allows you to release your go packages.

119. Daily Coding Problem: Remove the k-th Index From the Linked List in One Pass

Algorithm to remove an element from a linked list given its index in one pass only

120. Golang: A Short History of My Tech Journey

The journey of a thousand miles begins with a single step. That’s how everything in our tech journey begins. We all got here with a single step, that slowly became multiple steps. Before we know it, we are a thousand miles in. When I first started my career, I was in helpdesk. Now, I’m a developer advocate. The way that happened was with thousands of steps.

121. Don’t Procrastinate, GO Code!

This guide shows you how to write your first lines of GO code.

122. Go: The Testing/Synctest Package Explained

In Go 1.25, the testing/synctest package has graduated from experiment to general availability.

123. How to Force Slack to Make Your User Appear Online

How to get the green dot to turn on for slack users with a headless browser because their API just won’t allow it.

124. What Are Generics? An Introduction for Beginners

Generics are a way of writing code that is independent of the specific types being used. Functions and types may now be written to use any of a set of types.

125. The All-Purpose Programmer: Episode 1 – “Hello World”

I love to learn, I love to code. I’m on a journey to learn (at least the basics of) several new languages to enhance my resume. Join me!

126. Prevent Errors From Growing With This New Framework

This is the story of how we started with a simple error handling approach, got thoroughly frustrated, and eventually built our own error framework.

127. gRPC Between Web and Server: A Simple gRPC Communication

A simple gRPC communication between a web browser and server with an Envoy proxy.

128. Go: When Should You Use Generics? When Shouldn’t You?

I’ll provide general guidelines, not hard and fast rules. Use your own judgement. But if you aren’t sure, I recommend using the guidelines shown here.

129. Building a Type-Safe JSON Merge Pipeline in Go

A beginner-friendly walkthrough of a Go CLI tool that reads two JSON files, merges them, validates required fields, and writes the output based on my first real

130. Go 1.21: A Guide to Profile Guided Optimization

We will run through an example of using PGO to improve the performance of an application. Before we get to that, what exactly is “profile-guided optimization”?

131. testing.B.Loop: Some More Predictable Benchmarking for You

Go developers who have written benchmarks using the testing package might have encountered some of its various pitfalls.

132. Build a Go Web API with the New Digital Ocean App Platform: A How-To Guide

Recently, Digital Ocean announced they’re entering the PaaS market with their new application platform. They’ve hosted virtual machines (droplets) and Kubernetes based services for years, but now they’re creating a platform that’s a simple point and click to get an application up and running.

133. Top 5 IDEs and Tools for Golang Development

Top 5 IDEs and Tools for Golang Development – here is the list of top Golang IDEs that are worth your attention.

134. Daily Coding Problem: Rotating Matrices

In this article we are building an algorithm to rotate a matrix by a certain degree, doing this with in-place and not-in-place algorithms

135. Some Things You Should Know About Maps in Go

Tips for working with go maps – deep copy and memory allocation.

136. Serverless API with Terraform: GO and AWS [Part 2]

In part 2, we’ll go over deploying serverless API to AWS Cloud with Terraform.

137. Building a Multi-Language Monster Pipeline? Here’s the Smart Way to Do It

Instead of forcing every team or process to use the same tech stack, build a modular, interoperable pipeline where each function operates independently.

138. A Few Words on VS Code

Go has hard opinions about how you should style and format your code. The big upside of this is that you don’t need to spend hours setting up tools like ESLint, Prettier, JSLint, etc. That said, in order to take advantage of the styling and listing tools available in the toolchain, you need a dev environment that makes them easy to use.

139. Understanding Concurrency in Golang with Goroutines: Latest Update in Version 1.23

Explore the power of Goroutines in Golang for concurrency management, including new enhancements in Golang 1.23 that optimize performance and memory usage.

140. What Is Type Inference? What It Is and How It Works

Here’s everything you need to know about type inference, type pattern matching, type equations, and more.

141. Daily Coding Problem: Pascal’s Triangles and Space Complexity

Build Pascal’s triangles with code, with different algorithms, analyze theirs speed and space complexity.

142. How to Find Unreachable Functions With Deadcode

Functions that are part of your project’s source code but can never be reached in any execution are called “dead code”

143. How to Build LLM-Powered Applications Using Go

This blog post works through an example of using Go for a simple LLM-powered application. It starts by describing the problem the demo application is solving

144. How Goroutines Behave on CPU-Bound vs I/O-Bound Tasks

Goroutines can supercharge Go apps—or slow them down. Learn when they help, when they hurt, and how to benchmark your workloads.

145. Go 1.22: Bringing Math/rand and Crypto/rand together

This post is about how Go 1.22 brings the two closer together, by using a cryptographic random number source in math/rand.

146. Go 1.21: An Inside Look at Forward Compatibility and Toolchain Management

Go 1.21 introduced toolchain management, so that different modules can use different Go toolchains just as they can use different versions of a required module.

147. Guide to Integrating With Non-AWS Cloud Storage Services Supporting the S3 Protocol using Golang

In this article we learn about S3 protocol, how to Integrate with Non-AWS Cloud Storage Service that supports S3 protocol, and a little bit about wrapper.

148. Go (Golang): Your Cheatsheet On Ways To Create New Maps And Slices

There are quite a few ways to create new maps and slices in Go. Which one is best? Or perhaps better asked, which one is best in your situation? Let’s take a look.

149. Tracing Go’s Garbage Collection Journey: Reference Counting, Tri-Color, and Beyond

Garbage collection (GC) is one of the most critical components of any modern programming language runtime.

150. Creating Homebrew Formulas with GoReleaser

We chose to use GoReleaser with our distro of the OpenTelemetry Collector in order to simplify how we build and support many operating systems and architectures

151. Go 1.22: A Change in Loop Scoping

Go 1.21 includes a preview of a change to for loop scoping that we plan to ship in Go 1.22, removing one of the most common Go mistakes.

152. Training Neural Networks with Gorgonia

Deep learning and neural networks are very interesting subjects and Go language supports this technology using the framework Gorgonia.

153. How And When To Use Pointers in Go

Go has become increasingly popular in recent years, especially in my local area. It has been consistently displacing other backend languages like Ruby, Python, C# and Java. Go is wanted for its simplicity, explicitness, speed, and low memory consumption.

154. Pointer Pitfalls: A Simple Utility Function That Makes Pointers in Go Easier

Simpler way to deal with pointers in Go.

155. Backward Compatibility in Go: What to Know

This post is about the important work we shipped in Go 1.21 to keep Go boring.

156. New Feature in Go Makes it Easier to Iterate, Manipulate JSON Data

What if you could loop through your JSON data, grab the path of each item, and decide exactly what to do with it on the fly?

157. A Beginner’s Guide to Code Coverage for Go Integration Tests

In this blog post we’ll give an example of how these new features work, and outline some of the use cases and workflow for collecting coverage profiles

158. Efficient Enterprise Data Solutions With Stream Processing

Enterprise data solutions—handling myriad data sources and massive data volume—are expensive. Stream processing reduces costs and brings real-time scalability.

159. Container-aware GOMAXPROCS: What it is and Why It’s Important

In this post, we will dive into how Go schedules goroutines, how that scheduling interacts with container-level CPU controls, and how Go can perform better.

160. Daily Coding Problem: Computing Big Exponentials

Calculating high exponentials with a simple algorithm

161. How to Build a URL Shortener in Go: A Short Guide

In this article, I will be going through how to make a URL shortener in Go. The final result will look something like this shortr, source code.

162. Generic Alias Types: Why We Need Them

This post is about generic alias types, what they are, and why we need them.

163. Generic interfaces: When to Use Them

In this post, we’ll discuss the use of interfaces with type parameters in a couple of common scenarios.

164. A Tour of Slog: Everything You Need to Know About Structured Logging With Slog

By including structured logging in the standard library, we can provide a common framework that all the other structured logging packages can share.

165. Introduction to Numeral Systems in Go

numeral is a Go package. It gives you the ability to create custom (positional) numeral systems and perform operations on them.

166. Gopher Pythonista #1: Transitioning from Python to Go

The transition from one language to another doesn’t need to be hard. Especially, when you are building backend apps in Python and you want to switch to Go.

167. Everything You Need to Know About Go 1.23

Go 1.23 comes with many improvements over Go 1.22. Some of the highlights include: language changes, tool improvements, and standard library improvements.

168. Here’s How to Test Concurrent Code With Testing/Synctest: Go 1.24

This post will explain the motivation behind this experiment, demonstrate how to use the synctest package, and discuss its potential future.

169. The HackerNoon Newsletter: DevOps Isnt a Tool, Its a Chain Reaction (11/8/2025)

11/8/2025: Top 5 stories on the HackerNoon homepage!

170. How Order in iF Statement Impacts on Performance

Explore how optimizing condition order in code led to a 50% performance boost in Skaffold’s latest update. Learn practical tips for improving code efficiency.

171. Go Context Timeouts and External Calls: Cook Them Properly

Optimizing external service calls in Go with context package: balancing timeouts and performance for efficient operations.

172. The Top 25 Golang Interview Questions That’ll Make You Question Your Life Choices

Here’s a list of 25 Golang interview questions that’ll probably keep you up at night.

173. Get Certified by CIA for Exploring Archives — my Golang Solution for Web Archive Data Extraction

Get Certified by CIA for Exploring Archives — my Golang Solution for Web Archive Data Extraction

174. Walking You Through WASI Support in Go

Go 1.21 adds a new port targeting the WASI preview 1 syscall API through the new GOOS value wasip1. This port builds on the existing WebAssembly port

175. Everything You Have to Know About Go 1.24

Go 1.24 comes with many improvements over Go 1.23. Here are some of the notable changes; for the full list, refer to the release notes.

176. Hands-on IPLD Tutorial in Golang: Part 2

Quick recap from PART-1

177. Why I Switched to Table Driven Testing approach in Go

Table driven tests, also known as parameterized tests, have became very popular over the past few years due to their ability to eliminate repetition.

178. Go: Can It Mitigate Supply Chain Attacks?

It is an explicit security design goal of the Go toolchain that neither fetching nor building code will let that code execute, even if it is untrusted.

179. The 2022 State of Software Engineers Report

Hired released its 2022 State of Software Engineers, a report that analyzes key software engineering trends around demand, salaries, skills, and preferences.

180. Reproducible Go Toolchains: What You Need to Know

This post explains what goes into making builds reproducible, and then demonstrates one of the benefits of reproducibility by verifying the Ubuntu package

181. Should You Rust, or Should You Go?

Let’s talk about Go versus Rust in 2024, with our special guest, John Arundel.

182. A Quick Coding Lesson On Go’s ‘WaitGroup’ (vs. JavaScript’s ‘PromiseAll’)

In applications that are i/o heavy, it can get clunky to synchronously execute high-latency functions one after the other.

183. µjson — A minimal JSON parser and transformer in Go

µjson is a minimal JSON parser and transformer that works on unstructured (and trusted) JSON. It works by parsing input and calling the given callback function when encountering each item.

184. How I Built My First Go App and The Deployed it to Heroku

In this tutorial, we’ll learn to build and deploy a Go web service to Heroku, showcasing the ease of use, speed, and power of Golang for modern web services.

185. How to Install Go on Linux – Tutorial

The Go programming language has become quite popular over the past few years. Why? The primary reason is that it has become the language of choice for distributed and highly scalable servers. Go was based on C and brings code efficiency to the table, which generates faster software and apps for businesses.

186. Go Interfaces – Stepping Beyond the Fundamentals

It’s time to take a deeper dive into how interfaces work under the hood, common pitfalls, and advanced best practices.

187. What You Have to Know About Syntactic Support for Error Handling

One of the oldest and most persistent complaints about Go concerns the verbosity of error handling.

188. How To Create a Simple Application Using Golangspell

For a couple of years I’ve been working with Golang, is such a great experience, Golang is a great language, in my opinion, simple, fast, and focused on high performance. But, not only it can help us to create a microservice that is fast, but we can also code quite quickly.

189. Everything You Need to Know About All Comparable Types

In this blog post, we hope to shine some light on the language mechanics behind all comparable types.

190. Building CLI Tools with Go (Golang): A JSON File Formatter

191. The HackerNoon Newsletter: Gos New Experimental Packages: What to Know (12/20/2025)

12/20/2025: Top 5 stories on the HackerNoon homepage!

192. Go 1.21: Taking Your Go Apps to the Next Level

Discover Go 1.21’s cutting-edge features: profile-guided optimization, min-max functions, clear function, loop variable enhancement, and more.

193. Overlapping Rectangles: A Daily Coding Problem

How to calculate the area size of two overlapping rectangles with an algorithm using go.

194. Go Concurrency Face-Off: Channels vs Mutexes

Demystify when to use channels and when to use mutexes, and why blindly following “Go concurrency patterns” can backfire.

195. Here’s What You Need to Know About Go 1.22

Go 1.22 comes with several important new features and improvements. Here are some of the notable changes; for the full list, refer to the release notes.

196. Kickstarting Your GoLang Journey

Embark on a 100-day journey to master Go Lang, a modern programming language ideal for cloud computing, web development, and DevOps.

197. Here’s What You Need to Know About Vulnerability Management for Go

Go provides tooling to analyze your codebase and surface known vulnerabilities. This tooling is backed by the Go vulnerability database

198. As the Go Ecosystem Continues to Grow, gopls Continues to Scale

Gopls provides language-agnostic editors with IDE-like features such as auto-completion, formatting, cross-references, and refactoring.

199. Implementing Red-Black Tree in Go — Part 2: The Delete Operation

We figured out how the search and insert operation works in the red-black tree in the first part. In this part, we figure out how the delete operation works.

200. Go Interfaces Are Just Like Magic

Discover how Go’s implicit interface implementation simplifies code, reduces complexity, and promotes flexibility.

201. How Go 1.24 Enhances its WebAssembly Capabilities

Go 1.24 enhances its WebAssembly (Wasm) capabilities with the addition of the go:wasmexport directive and the ability to build a reactor for WebAssembly System

202. How to Organize Your Go Projects Like a Pro

Beginner’s guide to structuring Go projects with packages, internal folders, and imports — using a calculator project as an example.

203. The Noonification: Understanding sync.Cond in Go: A Guide for Beginners (4/29/2024)

4/29/2024: Top 5 stories on the HackerNoon homepage!

204. The Search Experience on pkg.go.dev: How It Works

Search results for packages in the same module are now grouped together. The most relevant package for the search request is highlighted.

205. Connecting Dots: Go, Docker and k8s [Part 2]

Nowadays, the successful application often consists of containers and some sort of container management system to ease scaling, reduce downtime, and more.

206. The Routing Enhancements for Go 1.22 That You Have to Know About

Go 1.22 brings two enhancements to the net/http package’s router: method matching and wildcards.

207. Boost Your API Development Skills: Implementing GraphQL in Go

GraphQL is a powerful tool for modern API development due to its flexibility, efficiency, and developer-friendly features.

208. Constants in Go Vs. Constants in Javascript

Constants can be confusing and easy to misuse in Go if you are coming from an untyped language. In this article we will learn what constants are, and when it is best to make use of them.

209. What You Have to Know About the New Features in Go 1.24: Cleanups and Weak Pointers

These new features are the runtime.AddCleanup function, which queues up a function to run when an object is no longer reachable, and the weak.Pointer type.

210. Happy 15th Birthday Go!

Go is going strong! Go’s user base has more than tripled in the past five years, making it one of the fastest growing languages.

211. The HackerNoon Newsletter: Flight Recorder: A New Go Execution Tracer (12/13/2025)

12/13/2025: Top 5 stories on the HackerNoon homepage!

212. Go Interfaces: Favoring Composition Over Inheritance (With a Dash of Common Sense)

Coming from a language like C# or JavaScript, interfaces in Go can feel like a cruel joke.

213. Using Go Defer and Rust Drop to Defer the Call to Rollback

Forgetting to close things off in Go can potentially come back to bite you. The most basic and straightforward method is to call rollback or commit.

214. Go Project Templates: How to Get Started

Anyone can write templates, which are packaged and distributed as modules, leveraging the Go module proxy and checksum database for better security

215. Generic Functions on Slices: A Guide to Help You Understand

In this blog post we’ll discuss how you can use these functions more effectively by understanding how slices are represented in memory

216. Breaking Down and Explaining Type Parameters

Since all Go types can be built up from component types, we can always use type parameters to deconstruct those types and constrain them as we like.

217. Go Execution Traces Have Become More Powerful

Thanks to work by Felix Geisendörfer and Nick Ripley on optimizing the efficiency of tracebacks, the run-time CPU overhead of execution traces has been cut

218. math/rand/v2: How It’s Evolving the Go Standard Library

This blog post is about Go 1.22’s new math/rand/v2 package, the first “v2” in the standard library.

219. Telemetry in Go: How We’ve Improved It

Go 1.23 provides a new way for you to help improve the Go toolchain.

220. Go 1.23: The New, Unique Package That Comes With It

The standard library of Go 1.23 now includes the new unique package. The purpose behind this package is to enable the canonicalization of comparable values.

221. Webdevs Are Melting 🫠 Typescript Will Be 10x Faster Thanks To Go Language

There’s no other thing on earth that brings a smile to soon-cease-to-exist (apparently) developers as faster tools.

222. Go-CoNLLU Introduction: OSS Tool For Machine Learning Support in Go

Python is commonly seen as the AI/ML language, but is often a dull blade due to unsafe typing and being slow, like really slow. Many popular natural language processing toolkits only have Python APIs, and we want to see that change. At Nuvi, we use Go for the majority of our data processing tasks because we can write simple and fast code. Today we are open-sourcing a tool that has helped make our ML lives easier in Go. Say hello to go-conllu.

223. ZUSE Is What Happens When IRC Meets Go, Bubble Tea, and Lipgloss

ZUSE is an IRC client for your terminal crafted with the elegance and power of Go, Bubble Tea, and Lipgloss.

224. The HackerNoon Newsletter: How to Set Up Simhub With Gran Turismo 7 (4/27/2025)

4/27/2025: Top 5 stories on the HackerNoon homepage!

225. Let’s Have a Talk About Go Slices

Today we will discover Slices, one of the core data structures in Go.

226. Range Over Function Types: The New Feature in the Go 1.23 Release

Range over function types is a new language feature in the Go 1.23 release. This blog post will explain what exactly it is and how to use it.

227. I Made ezpkg.io: Simplify Your Go Projects with Reusable Packages

I created ezpkg.io to have all these utilities and packages in one place.

228. How to Get Faster Go Maps Using Swiss Tables

In this blog post, we’ll look at how Swiss Tables improve upon traditional hash tables

229. BitBanged Serial Peripheral Interface in Go on Raspberry Pi [Explained]

I’m going to focus mostly on some design decisions and also how I went about writing an SPI interface using Go on a Raspberry Pi. I assume my readers have a basic understanding of what a Raspberry Pi is, and how basic electronics work. If not, read on anyway and I will be sure to include some valuable resources below.

Thank you for checking out the 235 most read blog posts about Go on HackerNoon.

Visit the /Learn Repo to find the most read blog posts about any technology.