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
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
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.
230. The HackerNoon Newsletter: Your Personality is a Lie (10/4/2025)
10/4/2025: Top 5 stories on the HackerNoon homepage!
231. This Lightweight Tool Flags Breaking Changes Before You Ship
Release Impact Analyzer for Go projects — catch breaking API changes, docs updates & important file diffs — fast.
232. The HackerNoon Newsletter: What The Heck is DeltaStream? (12/12/2024)
12/12/2024: Top 5 stories on the HackerNoon homepage!
233. Ritual Protocol Reimagines Secret Storage
What if your password couldn't be stolen — because it doesn't exist? Not hidden, not encrypted, not split between servers. Just... not there. Until you need it.
234. The HackerNoon Newsletter: My Experience With KCDC 2025: Is It Worth Going to? (8/23/2025)
8/23/2025: Top 5 stories on the HackerNoon homepage!
235. I Built A Handy Browser Plugin To Search Docs And Packages Directly From The Address Bar
Hi all. I'm so honored to introduce my product: Go Search Extension, a handy browser plugin to help every Go developer search docs and package in the address bar instantly.
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.