Let's learn about Golang via these 390 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.
Real work applications of a statically typed language option, one identified to be particularly useful for lightweight micro-services, API generation and so forth.
1. Async/Await in Golang: An Introductory Guide
Golang is a concurrent programming language. It has powerful features like Goroutines and Channels that can handle asynchronous tasks very well. Also, goroutines are not OS threads, and that's why you can spin up as many goroutines as you want without much overhead, it's stack size starts at 2KB only. So why async/await? Async/Await is a nice language feature that provides a simpler interface to asynchronous programming.
2. Go: The Complete Guide to Profiling Your Code
Go is a programming language often used for applications in which performance matters. Optimizing your code based on assumptions is not a best practice of course. You need to have insights about your code performance and bottlenecks to be able to optimize it efficiently.
3. In-Memory Caching in Golang
How to implement in-memory cache in Golang App
4. How to Set Up Docker Compose For Prometheus + Grafana
Want to have Prometheus and Grafanna locally so that you could test the metrics sent by your service? check this guide using Docker Compose
5. Dependency Inversion Principle in Go: What It Is and How to Use It
In this article, we will discuss the Dependency Inversion principle. In short, we'll talk about what it is and examine this principle
6. ChatGPT Go Libraries: A Comparison With Examples
Comparison of ChatGPT API clients for Go language
7. Avoiding Memory Leak in Golang API
You must read this before releasing your Golang API into production. Based on our true story at Kurio, how we struggling for every release because we are not doing it in the right ways.
8. 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.
9. NodeJS: 4.8x Faster if You go Back to Callbacks!
Callbacks are 4.8x faster when running them parallel over async/await in parallel. And only 1.9x faster when we run sequential callbacks.
10. Creating a Middleware in Golang for JWT based Authentication
11. A Look Ahead to Programming Languages in 2020
Python and JavaScript are the two hottest programming languages today. However, they cannot remain on top forever. Eventually, they must fall out of favour, as all languages do. This is likely to happen within the next decade or so.
12. How To Write Benchmarks In Golang Like An Expert
Golang: benchmarking made easy
In this article we'll see how we can use golang's benchmark utility to easily write benchmark tests. Also, we'll see how to plot
13. Today I Learned: Pass By Reference on Interface Parameter in Golang
Pass Parameters by Reference in GolangA simple diary about a simple thing that I learned about Pass By Reference in Golangpass by reference on interface parameter in Golang
14. Golang - How to Parse JSON Data in Go
Want to parse JSON data in Go? Learn the step-by-step process of parsing JSON and accessing its data in Go with this comprehensive guide.
15. 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.
16. 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.
17. How to Send Millions of Push Notifications with Go and Firebase Cloud Messaging
A Go service implementation that dispatches push messages via Firebase.
18. Golang in Machine Learning
Can Golang be used in Machine Learning? In the article you will learn advantages and disadvantages of using Go lang in Machine learning
19. Running a gRPC Service with Docker
Let's learn how to write a dockerized gRPC service in Go.
20. MongoDB and Docker-Compose: How to Enable a Custom User and Password Automatically
How can we create a custom user and password to access MongoDB when using docker-compose? Let's see how.
21. GO Design Patterns: An Introduction to SOLID
Adopt SOLID design principles in GO for better code quality and easier software maintenance.
22. Creating Clean Architecture Using Golang
Hi guys, I’m a Front-End developer. Before there was a time 2 years working CMS Magento, I like CMS Magento because system clean, and architecture database EAV (Entity — Attribute — Value) but I don’t understand why present I’m dev front-end (I don’t know) in the 2-year current. And present I chance comeback working position Back-End that I like.
23. The Anatomy of an API Gateway in Golang
Build your own API gateway in Go
24. Some insights on Maps in Golang
Article is about maps internal structure, hashes and performance. How data is actually stored inside.
25. Go: Handling JSON in MySQL
26. PostgreSQL Transaction Isolation Levels with Go Examples
Illustration composed from MariaLetta/free-gophers-pack, original gopher by Renee French.
27. 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.
28. 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.
29. Practice with Functional Programming in Go
Take a look at a functional programming paradigm in Go
30. 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.
31. An Argument For Using Golang to Code Your Next Projects
After spending years sticking to conventional programming languages, why should tech business founders use Golang? That’s one of the buzzing questions that founders will be asking, as the decade-old programming language is getting more prominence.
32. 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.
33. Comparing Optimistic and Pessimistic Locking With GO and PostgreSQL
Comparison between Optimistic and Pessimistic locking with Golang and PostgreSQL
34. The True Importance of Exceptions: Error Handling in PHP vs. Golang
Looking back, the ways we've dealt with errors show how developer’s needs and challenges have changed over time.
35. Mastering Maps in Go: Everything You Need to Know
Learn about using maps in Go (golang), including associative arrays, hash maps, collision handling, and sync.Map, with practical code examples.
36. GO Design Patterns: An Introduction to Builder
Streamlining Your Code: An Introduction to the Builder Pattern in Go
37. 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.
38. Golang Templating: Substituting Values Between Different YAML Files
In this tutorial we'll see how we can use Go templating to replace values in a YAML file with values from another YAML file, similar to what Helm does.
39. Building An In-memory Database in Go
Building an in-memory database in golang is a basic task that you are likely to have to do. It needs you to make a database and a table before organising.
40. 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.
41. 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.
42. 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.
43. Platforms on k8s with Golang - Watch any CRD
Let’s say you want to do more with Kubernetes than run off-the-shelf apps. Perhaps you want to stitch apps together into a bespoke platform. Imagine that when your user clicks a button you want to provision a new database or open up a new public-facing endpoint.
44. 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?
45. Golang Unsafe Type Conversions and Memory Access
Illustration composed from MariaLetta/free-gophers-pack, original gopher by Renee French.
46. 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
47. '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.
48. Faster than Linux
FTL usually refers to "faster than light". A theoretical particle known as a tachyon that powers certain spaceships in the Star Trek universe keeps the plot going for decades through multiple series and and movie franchises.
49. 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.
50. Go and sync.Pool
The garbage collector (GC) does not collect garbage constantly, but at certain intervals.
51. 3 Steps To Learn Go: Moving From JavaScript and Python to Golang
Mastering a programming language takes years of time but learning a new language does not. And Trust me, Nobody is perfect when it comes to coding. As a software engineer, one should be at least familiar with minimum 4–5 different languages or at least he should know how to learn a new language in small amount of time.
52. Choosing the Best Protocol: gRPC vs. Apache Thrift
The choice of communication protocol can significantly impact your applications' performance, scalability, and maintainability.
53. Concurrency in Golang And WorkerPool [Part 1]
Project Link: https://github.com/Joker666/goworkerpool
54. Unit Test AWS Lambda in Go
55. Optimizing String Comparisons in Go
Want your Go programs to run faster? Optimizing string comparisons in Go can improve your application’s response time and help scalability. Comparing two strings to see if they’re equal takes processing power, but not all comparisons are the same.
56. Golang Can Remove Code From the Binary, and You May Want to Know That!
Simple linter which can highlight non-trivial bugs which lead Golang compiler to remove code completely (due to optimizator logic).
57. 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!
58. Avoid XSS and CSRF Attacks in JWT (React + Golang): A Tutorial
Avoid XSS and CSRF attack in JWT with Golang and React for backend and frontend respectively.
59. 5 Best Practices for Integrating with External APIs
the must-have practices if you use external APIs
60. Go and Protocol Buffers (Quick Tutorial)
How to use Protocol Buffers in Go using proto3.
61. 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.
62. Building Reproducible, Verifiable Binaries with Golang
A quick and easy way to compile reproducible binaries with Golang.
63. Functional Testing With Your Backend in Go
For Terrastruct, which has a little over 50K lines of code as of now, I've only written functional end-to-end tests. This blog post describes a successful setup that took some iterating to get to, and it's one I wish existed when I started with a Go API backend.
64. Smoke Your Server Using Goroutines
We all want to test our servers and the latency induced by scale. There are different ways to do that one way would be to use postman to send multiple requests. But how do I send concurrent requests? Say I want to a million requests with different levels of concurrency. This can be easily achieved by leveraging the power of Goroutines.
65. 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.
66. Golang ― More Error Handling with Less Checking
Error checks are essential but turn to noise without automatic propagation. Fixing Go's error-handling.
67. 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.
68. 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.
69. Choosing the Right Programming Language for Your Project: A Comprehensive Guide
In this comprehensive guide, we'll explore practical insights, real-world examples, and actionable tips to help you navigate this crucial choice...
70. Concurrency in Golang And WorkerPool [Part 2]
Project Link: https://github.com/Joker666/goworkerpool
71. We Built The World's Largest Real time High-Frequency, Low Latency Streaming System on Golang
The evolution, failures and design decisions behind one of the world’s largest real-time, high-frequency and low-latency streaming systems.
72. The Complete Microservice Tutorial: Introduction [Part 1]
Project Link: https://github.com/Joker666/microservice-demo/
73. The Noonification: Whats Inside Play to Earn (5/21/2024)
5/21/2024: Top 5 stories on the HackerNoon homepage!
74. Generic Programming in Go
Generic Programming in Go using different methods: interfaces, typecasting, Generic Functions
75. 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.
76. 8 Top Programming Languages in 2020 According to TIOBE & Stack Overflow [An Overview]
At the moment, the TIOBE index monitors 265 popular programming languages. The TIOBE includes a language on the list if it matches three key requirements: it is Turing complete, has its own Wikipedia page, and provides more than 5,000 search results on Google.
77. Security Considerations in Golang
78. A Step by Step Guide to immudb — the open source immutable database
immudb is lightweight, high-speed immutable database for systems and applications.
79. Debugging Go Applications Inside Kubernetes From IDE
When your application only works with api expose by kubernetes, you can simply launch your application from IDE in debug mode and debug your application. But when your application needs to connect to other services or components which are only available inside the Kubernetes cluster then this solution will not work.
80. How to Download Files Using Golang and gRPC
Sometimes we need to download files from some storage. Let's do it using Golang and gRPC using io.Reader interface.
81. How To Create Golang REST API: Project Layout Configuration [Part 2]
In a previous post I was explaining the basics of setting up GO application for REST API. Now I'll go into details by first creating configurable server, adding http router (mux) and some DB interaction. Let's get (the indoors party) started!
82. Cross Compiling Rust on MacOS to Run as a Unikernel
Most programs on Linux are dynamically linked. So when you are creating a unikernel with OPS out of a linux application OPS goes out and finds all the libraries it's dynamically linked to and throws it onto the disk image. This works well if you are on linux - 99% of everything on linux is dynamically linked.
83. How I Built a Redis-Compatible Pub/Sub System Using Golang
EchoVault's Pub/Sub implementation aims to be compatible with Redis clients. This article is a brief description of how EchoVault implements the Pub/Sub module.
84. The History of Hackathons: A Digital Evolution
The term hackathon is a compound word, a fusion of hacking and marathon, where hack is used in the sense of exploratory programming.
85. Running Linux Applications as Unikernels with K8S
If you've read some of my prior articles you might've thought I'd never write this one huh? :) Well here goes.
86. Billion-Dollar Mistake in Go?
The following sample code is from Go's standard library documentation:
87. 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.
88. 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
89. 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.
90. 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.
91. 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.
92. How to Use GoReleaser to Automate GoLang Build Releases
This is a quick start for GoReleaser to automate the building and publishing GoLang projects.
93. Custom Rego Function by Example
Extending Open Policy Agent and creating custom rego functions
94. Protobuf Under the Hood: How Serialization and Deserialization Work in Go
Protocol Buffers (Protobuf) is a fast, efficient, and language-agnostic data serialization mechanism.
95. 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!
96. How to Develop a Facebook Messenger Bot in Golang
A comprehensive guide on how to create a Facebook Messenger bot in Golang.
97. 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
98. Don't Make These 5 Golang Mistakes
These are mistakes that I’ve made writing Go. Although these might not
cause any sort of error but they can potentially affect the software.
99. Microservices Deserve Modern Programming Platforms: Java May Not be the Best Option
Microservices are very popular today, even in traditional corporate IT shops. Often though they are implemented using languages, such as Java, born in the early ’90s and designed for a world of monolithic applications. Do you remember the big old Application Servers?
100. Let's Go! 5 Use Cases When You Need Golang for Your Tech Project
Reveal why there is hype around Golang and describe the best application variants for this programming language as well as cases when Go is not the best choice.
101. Introduction to RDS Proxy: Exploring with Benchmarks in Go
A deep dive into the performance characteristics of RDS Proxy vs RDS
102. Golang Linters: How they Analyze Code, Formatting, Complexity, and Comparison
Curious about which linters are available in Golang ecosystem? Here's an introduction of how to get started.
103. Red Team Phishing Simulations: Using Evilginx2 and GoPhish
I'd like to share my experiences using evilginx2 and gophish for red teaming phishing simulations.
104. How To Generate API Blueprint using SwagGo
Generating API blueprint REST API Golang using SwagGo tools
105. Interview with Anderson Queiroz: Golang is The Perfect Language for the 21st Century
Introduction
106. Using Bitwise Operators To Handle Permissions in GO
107. Mojo Traits: How Do They Compare to Go Interfaces?
A walkthrough on working with Mojo Traits with examples, and a comparison of Mojo Traits to Go Interfaces. Limitations and caveats of Mojo traits.
108. Using Guard Clauses to Clean Up Your Conditionals [A How-To Guide]
One of the first techniques developers learn is the if/else statement. For obvious reasons if/else statements are a primary way to create logic trees. This is where we handle calculations differently depending on the input variables. However, complex and nested if/else statements become a cognitive burden to reason about. Therefore, it can be hard for the next developer to understand quickly.
109. Mastering Graceful Shutdowns in Go: A Comprehensive Guide for Kubernetes
For applications deployed in orchestrated environments (e.g., Kubernetes), graceful handling of termination signals is crucial.
110. Pointer and Nil in Go: Reasons Why You Should Be wary
The harmful part of Go that you might not be aware of.
111. Monitor Your Kubernetes Cluster Events With EventRouter, Golang, and Kafka
In this article, I will show you how to build such a pipeline for processing and storing Kubernetes cluster events.
112. gRPC-Secret: Mastering Deadlines, Timeouts, and Custom Contexts
gRPC is an open-source remote procedure call (RPC) framework. It enables efficient and scalable communication between services.
113. 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.
114. 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.
115. How to Configure Useful User Snippets in VSCode for Golang
In this article, I'll show how we can configure some useful user snippets in VSCode to make our life easier.
116. A Practical Guide to Interfaces in Golang
A simple and explanatory guide to understanding interfaces in golang.
117. Why Should You Go With GoLang [Newbie's Guide]
Go is a programming language that was designed in 2007, and this fact directly puts it into the young budding category. Even it is fairly young, as compared to others, it has a lot to offer. No, don't get confused with its adorable and goofy Gopher mascot. This language is more like a dominant alien trying to rule the universe of development!
118. Easy Steps to Create Static Websites Using Hugo-Github Pages
How to create a static web sites using Hugo-Github Pages
119. Fast Golang Router With Error Handling
Getting started with fast Golang router that allows to handle and monitor errors using middlewares.
120. How to Build a Concurrent Chat App with Go and Websockets
Go emerged from Google out of a need to build highly performant applications using an easy-to-understand syntax. It's a statically typed, compiled language developed by some of the innovators of C, without the programming burden of manual memory management. Primarily, it was designed to take advantage of modern multicore CPUs and networked machines.
121. 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.
122. How I Got My Website To Load in 1 Second
The front page of JeremyMorgan.com loads less than a second, most of the time, from various parts of the world.
123. 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.
124. 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.
125. GitHACK! We are the vulnerability
Github has been hacked. The affected computers cloned the affected repositories. How much is it Github's fault? How can we protect ourselves from this?
126. 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.
127. Mastering Contexts in Go
Learn how to use contexts in Go for managing execution time, cancellations, and data passing between goroutines with practical examples.
128. Interfaces in Go
What are Interfaces in Golang?
129. Golang: Declarative Validation Made Similar to Ruby on Rails
Using declarative validation in Golang, in a similar way to Active Record validations.
130. “Go Has Indeed Become The Language Of Cloud Infrastructure“ - Rob Pike
We spoke to Rob Pike, the co-author of the Go programming language, about a career spanning four decades, the evolution of Go over the last ten years, and into the future.
131. An Intro to Rio: A Lightweight Job Scheduler in Go
Rio is a lightweight job scheduler and job chaining library. Its mainly build for Golang web apps, but it can be very easily mold to serve any applications.
132. 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.
133. Golang Tutorial: How to Migrate Your Database
Golang - How to handle database migration using GORM.
134. How a Unicorn Startup in Japan Leveraged the Power of Microservices
Startup experience in Mercari. Road to microservices from monolith.
135. 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?
136. 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.
137. Golang Sudoku Solver for Hard Sudoku Puzzles
Motivation
138. Creating an Image Recognizer on Golang Telegram Bot
In this article, we will go over a project on image recognition using Go. We will also create a Telegram bot, through which we can send images for recognition.
139. Decouple Your Go Components by Leveraging Mediator and Event Aggregator Patterns
Decouple your Go components by leveraging Mediator and Event Aggregator patterns. Learn how to use open-source mediator / event aggregator library called mob.
140. SnapPoint: A Hard Reset for Your Dev Machine
SnapPoint helps developers audit, clean, and realign their system by finding ghost binaries, PATH conflicts, and leftover tool junk.
141. 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.
142. 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.
143. Building a REST API in Go with MongoDB Integration: A Step-by-Step Guide
Code or Write a REST API with GO internal libraries and MongoDB as database
144. Building a Solar Harvesting Wi-Fi Camera
Compact and waterproof camera based on ESP32 usable for short periods of time, powered by solar energy.
145. Top 6 Golang Logging Best Practices
Let’s discuss a few rules of thumb for logging in Go, as well as some features you may not have heard of that can make debugging easier.
146. Top 6 Programming Languages to Learn in 2022
This blog will outline the top 6 trending programming languages to learn in 2022 and equip you with some tips to choose the best one.
147. Navigating the Path to Becoming a Backend Developer: What I Learned From My Self-Taught Journey
Gain insights from my Golang journey. Choose a job-friendly language. Avoid stress. Forge your path.
148. Portal: The Easy Way to Transfer Large Files Between Computers 🌌✨
Portal is a platform-agnostic command-line file transfer utility for sending files from any computer to another.
149. 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
150. How to Make a Linux Kernel with Nasm, Go Binary, Mini Linux
How to Make a Linux Kernel with Nasm, Go Binary, Mini Linux
151. What is Protobuf in Hyperledger Fabric? [Explained]
In this article, I’ll explain the technique used in serializing structured data using Protobuf in Hyperledger Fabric. Protobuf makes simpler in data processing and formatting. It structures the data with specially generated source code to easily write and read data within the same smartcontract.
152. The Latest Software Development Trends To Watch Right Now
The latest software development trends are discussed with topics including web development programming languages, app development, and the us of AI.
153. Let's Explore the Top Uses of the Golang Web Framework in 2022
The ever-evolving technological era has necessitated the need for cost-effective, high-speed, and reliable sources for web applications. The current market trend of cost reduction and efficiency has dictated that an Internet-based one replaces the traditional desktop-based application.
154. A Comprehensive Guide to Approaching Package Organization in Go
Let's find out together how to structure Go code according to the best software engineering practices.
155. How To Build JWT's in Go
Go is becoming very popular for backend web development, and JWT's are one of the most popular ways to handle authentication on API requests. In this article, we are going to go over the basics of JWT's and how to implement a secure authentication strategy in Go!
156. Golang: A Beginner' Guide To Getting Started
In this guide, you will learn everything you need to know to get started using Go to build real-world applications.
157. Making A Case for OffChain Storage in Hyperledger Fabric [Deep Dive]
In this article, I’ll try to explain the significance of OffChain Storage in Hyperledger Fabric and also the offchaindata application that I have built to demonstrate the offchain storage implementation using the Go Programming language for Hyperledger Fabric.
158. A RESTful API Template Project for Developers
Building a RESTful API can be daunting for developers who have never done it before. That’s why we’re pleased to announce the RESTful API template project.
159. 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.
160. 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.
161. 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.
162. Building a RESTful API Service in Go Without Having Repetitive Boilerplate
How to build a RESTful API service without repetitive boilerplate and hassle.
163. Bloom Filter Basics in Go
Learn about Bloom filters: memory-efficient data structures using hashing for fast set membership queries.
164. How to Build a Twitter Bot with IPFS Cluster
Till now, we have explored a number of fun examples using InterPlanetary File System (IPFS), InterPlanetary Linked Data (IPLD) & Libp2p. We have built Websites on IPFS, Youtube on IPFS, Online Publication on IPLD & Chat Application on Libp2p.
165. 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.
166. Evaluating Swoft — A PHP Microservices Framework
Swoft is a PHP high performance microservice co-routine framework.
167. 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
168. Adding Encryption to a Fast Database, Without Compromise
This article will be of particular interest to people who are curious about how powerful encryption can be implemented in high performance systems. It is also for people who just want to know a bit more about how strong encryption works and how all the pieces fit together.
169. Fixing Race Conditions in Go with Redis-Based Distributed Locks
Go's 'sync.Mutex' is a lock designed to lock critical sections of code.
170. Surviving Tech Debt: How 2,611 Golang Linter Issues Solved in 3 Days
Automate fixing 2600+ Golang linter issues using AI. This guide shows how DDD isolation and a triage matrix cut 130 hours of tech debt to just 3.5 days.
171. 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.
172. How I Built a Simple Forex App with Telegram Bots and AWS Lambda
As a freelancer working for different countries, I needed to optimize my currency exchange. So, I built a simple forex app with AWS Lamda and Telegram bots.
173. 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.
174. What Is so Great About Golang?
Check out why you should use golang for your next project
175. Best Regexp Alternative for Go; Benchmarks and Plots
In this article, we will look at alternatives to the standard regexp library in Go and benchmark them for speed and memory consumption.
176. How I Built a 1 GB Observability Stack for My Go Startup Using Prometheus, Loki, and Grafana
How to set up Prometheus, Loki, and Grafana on a free VPS with just 1 GB of RAM for a Go service. Stack comparison, configs, and Grafana dashboards
177. 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.
178. 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.
179. Building Stupid Stuff
A first blog post to reduce (or increase?) the awkwardness.
180. Daily Coding Problem: Triangular Numbers and Big Divisors
Finding triangular numbers and their divisors
181. Automate and Deploy a Docker Container to Google Cloud Run from Scratch Using Pulumi and Go
Automate and Deploy a Docker Container to Google Cloud Run from Scratch using Pulumi and Go with minimal permissions.
Step by Step
182. Clean Code: Functions and Error Handling in Go: From Chaos to Clarity [Part 1]
Learn how to write clean Go functions that pass code review. Practical patterns for single responsibility, error handling, and the defer statement from 6 years
183. 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
184. Clean Code: Interfaces in Go - Why Small Is Beautiful [Part 3]
Master Go interfaces: why single-method interfaces rule, accept interfaces return structs, and the nil interface gotcha that crashes production. From 6 years of
185. A Programmer's History of Golang
Go was created in 2007 to address the unique challenges of large-scale software projects. It's not about cramming in features but about trimming out the fat.
186. 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.
187. 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.
188. Express Setup: Golang and Testcontainers Unwrapped
Do we need all of this just to run a couple of integration tests for the database? The answer is obviously no.
189. How to Build Your Own TODO-list Service With Golang and MongoDB
Many have wondered how a simple task sheet or applications that provide such functionality work. In this article, we will write a small TODO service.
190. 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.
191. 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.
192. Finally, a Way to Run Your Shopify Store Without Clicking Yourself Into Madness
ShopCTL lets you easily manage your Shopify store via the command line, offering quick commands to access your store’s data right from your terminal.
193. Here's How I Scaled A Cryptocurrency Exchange's Trading Engine to 1 Million TPS
Crypto exchange has been in great demand with the adaptability of cryptocurrencies surging and multiple new tokens/coins been put there attracting users by showcasing their great potential.
194. Skip List From Scratch: A Guide
A skip list is a probabilistic data structure that serves as a dynamic set. It offers an alternative to red-black or AVL trees.
195. 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.
196. 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
197. 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
198. 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.
199. How to Accelerate Your Golang Backend With Supabase API
Boost your Golang backend with the Supabase API: A seamless guide to setting up and utilizing supabase for efficient database operations and authentication.
200. 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.
201. Issues With Private Data and Confidentiality in Hyperledger Fabric [Deep Dive]
In many blockchain platforms such as Ethereum and Bitcoin, data confidentiality is a kind of excluded item in their blockchain framework. In these distributed blockchain platform transactions are executed in every participant node in the network. So, every transaction in the network can be visible to all the peers. The ledger update process through all the endorsed peers and has to reach an agreement among all before it committed successfully to the ledger. So, in this scenario creating a private record and comprises within a certain group of participants in the network is a complete “No”.
202. The Testing Hack That Makes Bugs Easier to Catch (and Code Easier to Read)
Table-driven testing simplifies how we test multiple input-output cases by organizing them like data rows.
203. How to Append to a Slice in Golang
Slices in go are not same as slices in other programming language
204. Is Kafka the Key? The Evolution of Highlight's Ingest
Building a distributed message processing queue using Apache Kafka requires some thought. We walk through how we process thousands of large messages per second.
205. The One Config to Rule Them All
Goplicate - An epic tale about a developer trying to maintain dozens of project config files and finding the one config to bind them and rule them all.
206. 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.
207. Hands-on IPLD Tutorial in Golang
This article was first published on our open-source platform, SimpleAsWater.com. If you are interested in IPFS, Libp2p, Ethereum, Zero-knowledge Proofs, DeFi, CryptoEconomics, IPLD, Multiformats, and other Web 3.0 projects, concepts and interactive tutorials, then be sure to check out SimpleAsWater.
208. How To Prevent Server Overload In Go
An in-depth guide on server overload, rate limiting, load shedding, Golang, and resilience.
209. Daily Coding Problem: Minimum Coins Count
Counting the minimum numbers of coin to reach a certain amount
210. What is the Best Way to Design a Budget-Friendly Mobile App?
Today to build a mobile application is a mandate for businesses. But, when it comes to investing money for that mobile application, most people have different strategies. Many enterprises believe that a quality mobile app development cost higher and that mobile apps developed with a low budget are bound to fail.
211. Publish Go Packages With Goreleaser
Goreleaser is awesome. It's a simple tool that allows you to release your go packages.
212. 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
213. Connecting Dots: Go, Docker and k8s [Part 1]
In this post my plan is to create open tcp port scanning tool, use GO and worker pool to make it very fast. Expose it via REST resource, containerise and deploy
214. Learning Go by Building a Specification-by-Example Framework
215. Clean Code: Structs, Methods, and Composition Over Inheritance [Part 2]
Write cleaner Go code. Learn how structs, methods, and composition replace OOP inheritance the idiomatic Go way.
216. Using the Kubernetes Controller for Envoy
Creating Kubernetes controller for Envoyproxy with xDS protocol and Custom Resource Definition
217. 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.
218. The Ten Best Programming Languages for Beginners to Learn in 2021
Here are my top ten best programming languages to learn first. Start from here, choose your path and get yourself on the road to your dream job.
219. Don't Procrastinate, GO Code!
This guide shows you how to write your first lines of GO code.
220. Go: The Testing/Synctest Package Explained
In Go 1.25, the testing/synctest package has graduated from experiment to general availability.
221. 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.
222. Slack’n Go: Batch Presence Aware Bot
We shall create a <a href="https://slack.com/" target="_blank">Slack</a> Bot in <a href="https://golang.org/" target="_blank">Go</a> which aware of Batch Presence change event.
223. Application Testing In Go: Do It Right And Don't Create a Mess
Problem - How many times have we faced this problem of worrying about cleaning up after running test cases. When some of our test cases run, they might add data to our database or add files to our directory which we don’t want to worry about every time.
224. 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.
225. Go Builds Packages, Not Files — Here’s Why That Matters
Go's build system isn't something to fight or work around. It's an API in its own right - one that rewards understanding.
226. 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.
227. Inteview with Frank Müller: One Decade of Go - the Power of Concurrency
Frank Müller, Solution Engineer at Loodse, is one of the co-organizers of the GoDays conference in Berlin, which took place in January of 2020. It has been an exciting moment when Google announced its Language Go in 2009. After some hype and early years of establishing the language, it was settled as a robust and scalable fundament for networked systems. We invite you to enjoy a travel through a decade of our beloved Go within the interview of Grigory Petrov, Dev Rel at Evrone.com with Frank Müller.
228. 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
229. Building a Simple Rest API with Go
230. 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”?
231. Retired Software Richard Eng Discusses Rust, Golang, Smalltalk, China and More!
Richard Eng 2020 Noonie Nominee for Blockchain from India has been nominated for a 2020#Noonie in the Future Heroes and Technology categories.. The Noonies are Hacker Noon’s way of getting to know — from a community perspective — what matters in tech today. So, we asked our Noonie Nominees to tell us. Here’s what Richard had to share.
232. The Top Backend Development Frameworks in 2023
Take a look at our annual breakdown of the top web backend frameworks in 2023. Leading the list is the clear leader NodeJS.
233. Now You Can Use GitHub Issues to Track Customer Feedback
If you need a simple issue tracker for your app I'd recommend looking into using Github issues via the API, at least until it stops working for you!
234. 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.
235. 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.
236. Go Fast, Small, and Productive With GolangSpell
Before reading this article, make sure you have a good understanding of basic concepts of software development as Algorithms, Object Oriented design, Domain Driven Design. These will be the building blocks to digest the contents.
237. Using the Kubernetes Controller for Envoy (Part 2)
In this article, I will show you how you can write a controller that will monitor changes in custom resources.
238. Why ‘Incomparable Types’ in Go Are More Than Just a Compiler Error
With this short post, I’ll walk you through what comparable is, why it’s useful and how you can leverage it for cleaner, type-safe Go code.
239. 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.
240. GoLang Programming Overview
An overview of golang programming language. Know the pros and cons of golang.
241. Some Things You Should Know About Maps in Go
Tips for working with go maps - deep copy and memory allocation.
242. Go Concurrency: Goroutines, Mutexes, WaitGroups & Condition Variables
Comprehensive guide to Go concurrency: goroutines, mutexes, WaitGroups, and condition variables with examples, best practices, and gotchas.
243. One Go Codebase, Five Platforms: My Cross-Platform Build Journey
Golang is a powerful language for Cross-Platform Development. Read this article to learn how Golang can target every mobile and desktop architecture today.
244. Serverless API with Terraform: GO and AWS [Part 2]
In part 2, we'll go over deploying serverless API to AWS Cloud with Terraform.
245. Prometheus + Grafana Turns Your Go App into a Real-Time Dashboard of Truth
Export custom Prometheus metrics from your Go application and visualize in Grafana
246. Building a Simple REST API in Go Without Frameworks
Learn how to build a RESTful API in Go from scratch using only the net/http package, in-memory data, and mutex for concurrency.
247. 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.
248. 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.
249. 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.
250. Daily Coding Problem: Pascal’s Triangles and Space Complexity
Build Pascal's triangles with code, with different algorithms, analyze theirs speed and space complexity.
251. 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”
252. 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
253. IoT Tutorial: Room Temperature Sensors From A Raspberry Pi, Using Go
In this tutorial, I’ll show you how to grab temperature from a Raspberry Pi and build an endpoint to store the data, with Go.
254. A Mistake That Could Cost You Millions: What it Is and How to Fix It
This small golang mistake could cost your business a million-dollar problem. You could easily avoid the mistake read the blog
255. Golang: Debugging CLI Applications in VSCode
How do debug CLI apps in VSCode? We'll see how to do it with a sample Golang app.
256. Go vs Rust: A Sto-array of Arrays
Want to see disappearing data in Go caused by an innocent append of data to an array? Can this happen in Rust, too? Check this data-driven horror story out!
257. How to Combine two Programming Languages: A Ruby and Golang Tutorial
During past projects, I experienced difficulties when developing with a Ruby encryption pack.
258. 10 Questions for Aswin Ganesh, Noonie Nominee for Functional Programming
The 2020 #Noonies are here! And they are both much greener and much bigger than last year. Among the 2,000+ deserving humans nominated across 5 categories for over 200 award titles, we discovered Aswin Ganesh from India, who’s has been nominated for Hacker Noon's Contributor of the Year in our Functional Programming category. Without further ado, we present to you, our big techy world in 10 questions, from the perspective of Aswin.
259. An Introductory Guide to Variables and Data Types in Go
Hello there! So today we would be learning about Go variables and the different data types associated with Go.
260. I Built a Go-Based ngrok Alternative With Zero Dependencies
Built a fast, zero-dependency ngrok alternative in Go using Cloudflare tunnels. Here’s how it works, why Go won, and what I learned.
261. 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.
262. How to Build a Status Monitoring Service in Go
Build a Go-based monitoring app that probes services, opens/closes incidents, sends Teams/Slack alerts, and exports Prometheus metrics in Docker.
263. 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.
264. 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.
265. How to Run Go in Your Browser With Web Assembly [ Tutorial ]
If you are familiar with the Go Playground, then you know how convenient it is to be able to have a Go scratchpad in the browser. Want to show someone a code snippet? Want to quickly test some syntax? Browser-based code pads a helpful. On that note, I created a new playground. The cool thing about this new playground that it doesn't use a remote server to run code, just to compile it. The code runs in your browser using web assembly (WASM).
266. 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.
267. Build Your Own Blog at $5 a Month [A Step by Step Guide]
Blogging about tech is fun. Having your own blog allows you to help others, polish your skills, and maybe get you a job. Blogging on popular tech sites is great. Obviously you're reading this on Hackernoon, so you know I do it. It's fun. But having your OWN site to manage your content is important as well. This gives you freedom to do things exactly as you want, try out weird applications and patterns, and experiment.
268. 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.
269. Training Neural Networks with Gorgonia
Deep learning and neural networks are very interesting subjects and Go language supports this technology using the framework Gorgonia.
270. 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.
271. What Every Gopher Should Know About the Go Memory Model
Learn how Go's memory model defines visibility between goroutines using happens-before rules and synchronization primitives like channels and mutexes.
272. Pointer Pitfalls: A Simple Utility Function That Makes Pointers in Go Easier
Simpler way to deal with pointers in Go.
273. A Guide on How to Develop and Benchmark the Same Feature in Node and Go
Node vs Go: Same Feature, Different Design. Discover how two runtimes handle hot config reload differently, plus benchmark results showing Go's 1.9x performance
274. Backward Compatibility in Go: What to Know
This post is about the important work we shipped in Go 1.21 to keep Go boring.
275. 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?
276. Top 10 Golang Bugs to Spot Fast in Code Reviews
Common Golang code bugs to point out quickly during code reviews.
277. 6 DevOps Trends in 2022 That DevOps Engineers Should Adopt
The role of DevOps engineers, their responsibilities, growth opportunities, a set of important soft & hard skills, and most importantly, DevOps trends in 2022.
278. 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
279. 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.
280. Daily Coding Problem: Computing Big Exponentials
Calculating high exponentials with a simple algorithm
281. Free Extension To Scan Go Vulnerabilities in Visual Studio Code
If you’re a Golang developer using Visual Studio Code, keeping at-risk Go Modules out of your apps just got easier, and for free.
282. Generic Alias Types: Why We Need Them
This post is about generic alias types, what they are, and why we need them.
283. 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.
284. 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.
285. 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.
286. Examine Your App's Speed and Bottlenecks: A Tutorial to Mastering Performance Testing with K6!
Performance tests are useful for uncovering bottlenecks, and scalability issues.
287. Clean Code: Package Architecture, Dependency Flow, and Scalability [Part 4]
Learn how to organize Go packages, avoid import cycles, structure scalable projects, and use interfaces and internal directories the right way.
288. 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.
289. Why Using "^" Instead of "<<" Causes Errors in Go Programs
How a simple ^ operator mistake in Go can degrade performance and cause hidden bugs—and how static analysis tools can detect the problem early.
290. 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.
291. 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.
292. Concurrency Bugs You Can’t See (Until Your System Fails in Production)
At first glance, the promise of concurrency is appealing, but lurking beneath that promise are several complex challenges.
293. 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
294. 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
295. Github Actions and Go: AreYouOk My URL?
Check and audit link/URL health using Github actions. Test dead links in a fast and efficient manner
296. Building an API with Go, PostgreSQL, Google Cloud and CockroachDB
A Golang API based on the game "Crisis Core: Final Fantasy VII", for simulating fusion of materia.
297. Debugging Microservices: A Journey into Distributed Debugging
A framework for debugging microservices using gRPC interceptors to automatically collect and propagate debug information across service calls.
298. Hands-on IPLD Tutorial in Golang: Part 2
Quick recap from PART-1
299. 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.
300. 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
301. Should You Rust, or Should You Go?
Let’s talk about Go versus Rust in 2024, with our special guest, John Arundel.
302. 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.
303. Implement Your Own Tool Using HCL (Part 2)
This is the second part of my HCL series.
304. Leveraging Yandex Pandora: Stress Testing GRPC and Flatbuffer Services
Yandex Tank stress tests with Pandora for grpc and flatbuffer. Golang integration guide. Custom scenarios and load setup for robust service performance
305. µ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.
306. Generating Images For My Dad’s Meetups With Go
I recently read a great article by Mat Ryer about programmatically generating images in Go and got inspired by it to solve a repetitive task I usually do every month.
307. 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.
308. The HackerNoon Newsletter: Go Builds Packages, Not Files — Here’s Why That Matters (1/10/2026)
1/10/2026: Top 5 stories on the HackerNoon homepage!
309. 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.
310. 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.
311. 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.
312. Clean Code: Concurrency Patterns, Context Management, and Goroutine Safety [Part 5]
A practical guide to clean, safe Go concurrency—covering context, goroutines, channels, patterns, pitfalls, and lessons learned from production systems.
313. Building a Better Debugging Experience: A Deep Dive into Capturing and Replaying gRPC Traffic
Debugging microservices is hard because it's difficult to see the data flowing between them.
314. Advantages Of Go Language For Creating Web Servers
The Go programming language is great choice for web server development and beyond.
315. Introducing CricLang: The Cricket-Inspired Programming Language 🏏
I made CricLang, a cricket-inspired programming language built on GoLang.
316. 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.
317. Building CLI Tools with Go (Golang): A JSON File Formatter
318. 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.
319. The Practical Way for Developers to Learn Algorithms
Many developers quietly assume Big-O and data structures are only for low-level specialists.
320. 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.
321. Reveal Go Module Vulnerabilities With Xray
Golang developers care a lot about security and as Go modules become more widely used, they need more ways to assure these publicly shared files are safe.
322. BitBanged SPI in Go [Explained]
I’m going to focus mostly on some design decisions and 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.
323. How to Use Joblet: Secure Linux Process Execution Made Simple
Joblet is a lightweight process isolation platform that lets you run commands and scripts in secure, resource-controlled environments.
324. 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.
325. 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.
326. The Internet Is Full of Duplicate Requests—Here’s How Smart Developers Prevent Them
Idempotency is an essential tool for preventing duplicate operations, improving API stability, and ensuring consistent behavior in unsafe HTTP methods.
327. Go Interfaces, Explained for TypeScript Developers
Go’s interfaces are behavioral typing, meaning a struct matches an interface as long as it has matching method signatures.
328. Crush Your Competition with Prometheus at Your Side!
Uncover Prometheus's secrets and use its capabilities to dominate the monitoring game!
329. 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
330. 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.
331. How to Build a Production-Ready Go Diagnostic Rule
Build and ship a production-ready Go diagnostic rule using go/analysis.
332. Go Interfaces Are Just Like Magic
Discover how Go's implicit interface implementation simplifies code, reduces complexity, and promotes flexibility.
333. 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.
334. 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.
335. Abdullah Al Tarek Is Excited About the Upcoming Generics Feature in Golang
You know that feeling when you work really hard on something for really long and it feels like nobody really notices?
336. The HackerNoon Newsletter: The Physics of AI (10/27/2025)
10/27/2025: Top 5 stories on the HackerNoon homepage!
337. 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.
338. 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.
339. GoLang Guide: Automating Data Consistency in DynamoDB
Discover automatic data deserialization in Go with DynamoDB. Learn through examples, and explore the pros and cons of using the Unmarshaler interface.
340. How To Setup An Effective Refactoring Process of a Heavy Database Interface
This story is about pain, agony, and denial of ready-made solutions. It is also about changes that improve the code’s readability and help the development team stay happy. The object of this post is an interface that helps a program communicate with a database.
341. The Noonification: Augmented Linked Lists: An Essential Guide (8/2/2024)
8/2/2024: Top 5 stories on the HackerNoon homepage!
342. Kubernetes Annotations: Harnessing Power in Operator Development
How you can harness the power of Kubernetes annotations to add new and flexible functionality to your custom operators!
343. Streamlining Go Concurrency Using a Worker Pool
Before you start spawning thousands of goroutines, let's take a step back and understand how to do this efficiently.
344. New WAL Archiving Tool ‘pgrwl’ Delivers Zero Data Loss for PostgreSQL in Containerized Environments
pgrwl enables zero data loss (RPO=0) PostgreSQL backups via streaming WAL archiving, built for containers with S3/SFTP support, compression, and encryption.
345. 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.
346. 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.
347. Binary Size in Go Applications: How to Use Go-size-analyze
Go is known for its simplicity and efficiency, but as projects grow in size, so can the binaries.
348. How to Migrate Your Blog from Pelican to Hugo
Recorded the journey I took to migrate my data science blog from Python-based Pelican to Golang-based Hugo, then deploy to Netlify for free.
349. I Needed Better Go Benchmark Visuals, So I Made Vizb
Vizb turns Go benchmark results into beautiful, interactive HTML charts with a single command.
350. 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.
351. Optimizing OpenTelemetry Tracing with Multi-Stack Warehouse Components
352. 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
353. 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
354. Why Parallelism Isn't Always Concurrency (and Vice Versa)?
An in-depth exploration of concurrency and parallelism in Go, covering key concepts.
355. Reliable Protection of User Data: Hashing and Obfuscation
In the digital era, the volume of user data being processed is growing at a geometric rate.
356. 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.
357. 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
358. Build a Command-Line Tool for Skyline Queries in Golang
Learn how to implement skyline queries in Go using real datasets, CLI tools, and visualize skyline points from a CSV file—no backend needed.
359. 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.
360. Telemetry in Go: How We've Improved It
Go 1.23 provides a new way for you to help improve the Go toolchain.
361. 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.
362. Well-Known Concurrency Problems and How Go Handles Them
Explore classic concurrency problems in Go. Including producer-consumer, dining philosophers, and rate limiting with simple code examples and clear explanation.
363. How Hot Does it Get Inside a Car During a Heat Wave?
Using a Raspberry Pi to measure the temperature inside a Ford Focus during a record-breaking heatwave.
364. Operator Performance Tuning: Building a GUI for Prometheus Metrics Visualization in Kubernetes
An in-depth exploration of how I built a terminal-based dashboard to display Kubernetes operator Prometheus metrics for local development
365. Efficient Concurrency in Serverless Architectures with Go and AWS
Goroutines let you run multiple operations in parallel within one request.
366. How to Use KEDA and Prometheus to Scale your Kubernetes Workloads
Learn how to scale your kubernetes deployments with keda and prometheus
367. 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.
368. Unlock the Secrets of Range Loops: How Element Evaluation Affects Your Go Code
Discover how Go's range loops work, common pitfalls to avoid, and tips for writing efficient, bug-free code. Elevate your Go programming skills today!
369. Meet Gno.land: The Smart Contract Platform That Will Improve Our Understanding of the World
Gno.land is the first L1 smart contract platform to use Gnolang (Gno), an interpretation of Go, to address accessibility and ease of use in web3 development
370. 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.
371. Why I Ditched JavaScript and Built a SaaS Stack With HTMX, Go & Postgres That Just Works
I have now built two apps using this stack.
372. How to Implement your Own Tool Using HCL (bc I Hate YAML)
Do you hate YAML? Then learn how to build your next tool on HCL!
373. Inside Go Channels: Buffers, Locks, and the Runtime Memory Model
Go channels look simple, but under the hood they use buffers, queues, and scheduler tricks. Explore hchan, sudog, and Go’s concurrency model.
374. The HackerNoon Newsletter: Clean Code: Interfaces in Go - Why Small Is Beautiful [Part 3] (11/19/2025)
11/19/2025: Top 5 stories on the HackerNoon homepage!
375. The Noonification: Dear America, I Am Breaking Up With You (5/26/2024)
5/26/2024: Top 5 stories on the HackerNoon homepage!
376. "I want people to be able to access content without too many restrictions" #Noonies2021
As someone in the tech industry, I believe that the most exciting open-source technology of the present is Kubernetes because of its general-purpose nature.
377. Say Farewell to Core Types: The Benefits of Getting Rid of It
For the upcoming Go 1.25 release (August 2025), we decided to remove the notion of core types from the language spec in favor of explicit prose where needed
378. Building Modular Code with Composition: Go vs TypeScript
Learn how Go and TypeScript handle composition to build flexible, modular code without rigid inheritance hierarchies.
379. GoLang Guide: Manual Handling of Inconsistent DynamoDB Data
This GoLang guide covers handling inconsistent DynamoDB data types with manual conversion, offering examples, pros, cons, and future advanced methods.
380. Cloud Infrastructure Can Set Legacy Data Free
381. 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.
382. Pre-IBC Hackathon—Get Your Spacesuits Ready for HackAtom V
IBC is coming. Come and hack on it before it gets shipped on Cosmos Hub mainnet.
383. 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.
384. Ethereum Nodes and Clients: A Quick Guide
The Ethereum protocol is used by a variety of different networks. Each of these networks is effectively its own Ethereum environment.
385. 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.
386. Advanced Process Manager for Linux Earns a 49.5 Proof of Usefulness Score
APM runs, monitors, and proxies apps from a single binary, simplifying Linux service management, earning a 49.5 Proof of Usefulness score.
387. How to Build a High-Performance Concurrent Leaderboard in Go
Build a scalable, concurrent leaderboard in Go using sharding, heaps, and RWMutex to handle live updates and efficient Top-N queries.
388. 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.
389. Kubepatch Lets You Patch Kubernetes Without Touching Your Base Manifests
Patch Kubernetes manifests cleanly across environments with kubepatch—no templates, no YAML hacks, just pure declarative patches.
390. Katomik Brings Atomic Apply and Rollback Support to Kubernetes Manifests
Deploy safely with Katomik—a CLI tool that applies Kubernetes manifests atomically with rollback support to prevent partial or failed updates.
Thank you for checking out the 390 most read blog posts about Golang on HackerNoon.
Visit the /Learn Repo to find the most read blog posts about any technology.