What Is This Course About?

Introduction

Before we dive directly into the course material itself, let’s take a minute to discuss what this course is about. As the title might have given away, we will discuss building scalable back-end services. Our language of choice will be Go, but the core focus will not be as much on the language’s syntax. It will instead be on the school of thought and decision-making that a developer should adopt while building microservices that do their job efficiently and scalably.

We’ve used the buzzwords “microservices” and “scalable” casually enough, but what are we trying to build?

We know that all our favorite interfaces on the internet are backed by some form of mechanism that provides the data we consume and often facilitates services for us. This entity could directly expose functionalities for the web and mobile applications to leverage, such as social media apps showing us our feed or e-commerce apps allowing us to purchase a product. They could also be more silent players in the equation—personalization engines merrily chugging along behind the curtains, tweaking search results to our taste, proving prime examples for the same.

We will primarily focus on the former—web services that expose REST APIs for front-end applications to consume. These applications often store or read data from databases and interact with queues, caches, etc., to help provide the core functionalities needed by the product. Our goal is to ensure that the applications we build can elegantly handle an increasing amount of incoming requests while meeting functional requirements without degradation in the quality of service within the reasonable limits of the resources available. Note that most of the concepts we will learn in this course will prove helpful regardless of the nature of the back-end applications we write in the future.

Now, for communication between applications, there are two popular protocols in place. They have been given below:

• HTTP1.1: It is the current gold standard across the internet. Front-end apps (user-facing interfaces) communicate with the back-end servers using REST API calls.

• HTTP2.0: It is a next-generation solution in some ways, offering additional benefits over HTTP1.1. Front-end and back-end apps use Remote Procedure Calls (RPCs) to communicate. It is not as widely adopted as HTTP1.1 but is still very popular.

While HTTP3.0 is still maturing at the time of writing this course, HTTP2.0 is readily available in Go. However, for this course, we will stick to HTTP1.1 for simplicity. The concepts learned here can be applied later to migrate to using something like gRPC instead of REST if desired.

Course structure

• Server fundamentals: We’ll build our first REST microservice and explore test-driven development and API design.

• Mini project: We’ll test the skills you will have learned to build a Create, Read, Update, and Delete (CRUD) API server.

• Networking and interfaces: We’ll make API calls to resolve data dependencies, deal with time-outs, and optimize for latency concerns.

• Mini project: We’ll test the skills you will have learned to build APIs that allow users to compare products.

• Dealing with databases and queues: We’ll understand how best to interact with databases and queues to read and write large volumes of data.

• Design patterns: We’ll learn about basic creational design patterns that help master the ability to write clean, efficient, and robust code for every type of situation that we can find ourselves in.