TutorialEdge.net

Building a web server is one of the best first projects when learning a new language — it touches routing, request handling, and the standard library all at once.

Welcome to the final part of the series!

In the previous tutorial, we added rate limiting to protect our backends from abuse.

In the previous tutorial, we built a middleware pipeline with logging, CORS, and header injection.

In the previous tutorial, we added routing to our gateway.

In the previous tutorial, we built a basic reverse proxy that forwards all requests to a single backend server.

Welcome to the first part of this series on building an API gateway in Rust!

Removing an element from a slice in Go requires creating a new slice that excludes the element at the specified index.

Regular expressions in Go are handled by the regexp package, which provides powerful pattern matching capabilities.

Go provides simple and efficient ways to read and write files using the os package.

Go allows you to define methods on both pointer and value receivers.

Nil checking in Go is straightforward for pointers and simple types, but interfaces introduce a subtle gotcha.

Merging maps is a common operation when working with configuration data, combining results from multiple sources, or aggregating information.

Mapping over slice elements allows you to transform each element in a slice and collect the results into a new slice.

When working with APIs, you often need to send custom headers for authentication, content negotiation, or other purposes.

The os.ReadDir function provides an efficient way to list the contents of a directory in Go.

Maps in Go are unordered collections, meaning iteration order is random and non-deterministic.

Query parameters are a fundamental part of HTTP requests and Go makes it easy to extract and work with them.

The os.Stat function returns a FileInfo interface that provides comprehensive metadata about a file or directory.

Finding the index of an element in a slice is a common task in Go programming.

Filtering a slice to extract only elements that meet certain criteria is a fundamental operation in Go.

The fan-out fan-in pattern is a Go concurrency technique where you distribute work across multiple goroutines (fan-out) and then collect their results back into a single channel (fan-in).

In Go, you can extract substrings using slice notation with the syntax string[start:end], where start is inclusive and end is exclusive.

Go provides two different built-in functions for memory allocation: make() and new().

Deep copying is important when you need to ensure that modifications to a copied struct do not affect the original.

Custom marshaling allows you to control how your types are converted to and from JSON.

Middleware in Go is implemented by wrapping handler functions or multiplexers.

Counting occurrences of items is a fundamental pattern in data processing and analysis.

Checking whether a slice contains a specific element is a common operation in Go.

Checking whether a file or directory exists is a common operation in Go programs.

Welcome all, in this tutorial, we are going to be taking a look at how you can read in JSON files, or JSON HTTP responses and parse them to your hearts desire.

🚀 My new course - The Golang Testing Bible is out now and covers everything you need to get up and running creating tests for your Go applications!

In this tutorial, we are going to be looking at how you can use channels within your Go-based applications.

If you are writing any form of web application, then you are most likely interfacing with 1 or more REST APIs in order to populate the dynamic parts of your application and to perform tasks such as updating or deleting data within a database.

This is a quick and simple tutorial on how to read in console text input into your Go (GoLang) program.

Last Updated - 7th March, 2026 In this tutorial, we are going to be taking a look at the os/exec package in the standard library and how we can use this to successfully execute system commands within our Go applications.

The latest Go releases are absolutely stuffed with a number of fantastic new features, one of which, is the ability to significantly improve the performance of the hot paths within your applications using something called Profile Guided Optimizations.

Welcome Gophers!

Welcome Gophers!

Note - For a tutorial on how to build a RESTful API in Go, click here.

There are times, when creating applications in Go, that you need to be able to set up some form of state on the initial startup of your program.

In the previous video in this course, we looked at how we could implement the transport package.

So now that we’ve defined our comment service interface, let’s set about actually implementing the methods that we’ve defined.

In this video, we’ll be defining the HTTP endpoints that are effectively going to expose the our comment service.

Now that our Postgres DB is up and running, we now have to implement the package that we’ll use to communicate to this database.

Now, at present we don’t currently handle JSON and we don’t return JSON from our API, so it’s not exactly what you would call a JSON REST API just yet.

Now that we have our database setup, we have everything we need to start implementing our comment service and build it in a test-driven way.

So, we have our basic app structure defined, let’s start looking at how we can build out the server aspect and start serving some basic endpoints.

We’ll start off our journey setting up a locally running instance of RabbitMQ that we can connect to and base our learnings off for now.

Welcome Gophers!