Course Outline (original) (raw)

"As a program evolves and acquires more features, it becomes complicated, with subtle dependencies between components. Over time, complexity accumulates, and it becomes harder and harder for programmers to keep all the relevant factors in their minds as they modify the system. This slows down development and leads to bugs, which slow development even more and add to its cost. Complexity increases inevitably over the life of any program. The larger the program, and the more people that work on it, the more difficult it is to manage complexity." - John Ousterhout

This class teaches you how to engineer production-level software in Go leveraging the power of a domain-driven, data- oriented architecture that can run in Kubernetes. From the beginning, you will pair-program with the instructor as he walks through the design philosophies and guidelines for engineering software in Go. With each new feature added to the project, you will learn how to think about, read, maintain, manage, and debug code. The core of this class is to teach you how to handle and reduce the spread of complexity in the systems you are building.

If one of your biggest challenges is maintaining consistent coding standards across your codebase, maybe because team members have different levels of Go experience and are coming from different programming backgrounds, this course is for you. You will learn a set of idiomatic coding standards that everyone can adopt and apply to your existing projects.

For further class information, please see the class schedule or review the self-study options

Ultimate Go: Software Design and Engineering v2.0 Video Class

Here are the two places you can go to see the code for the class.

This tag is the code when we filmed the class. You can see what the project looked like at the time of filming.

https://github.com/ardanlabs/service/tree/service6

This is the repo you can follow along with the class.

https://github.com/ardanlabs/service6-video

Design Philosophy, Review, and Culture

This class tries to teach to these core design philosophies, review practices, and culture.

There are three core design philosophies that drive every guideline:

There are three core reviews that must be performed with each change:

There are three core aspects of a team’s culture that should be cultivated:

Course Curriculum

1.0 - Introduction

Introduction to the class and all the engineering that you will learn.

2.0 - Deploy First Mentality

We begin to build the service with a focus on the ability to deploy the service in Kuberenetes.

3.0 - Kubernetes

We introduce Kubernetes and get a K8s environment up and running. At this point, everything we do runs in the K8s environment.

4.0 - Kubernetes Quotas

We introduce applying Quotas to the deployment and discuss the problems that can result.

5.0 - Finish Initial Service Startup/Shutdown

We finish the initial startup and shutdown of the service.

6.0 - Web Framework

We build out our own router by extending an existing one. This gives us a framework for injecting business logic into the processing of requests. It also allows for more consistency in the handling of requests.

7.0 - Middleware

We add middleware functions for business-level logic that needs to be injected into the processing of requests.

8.0 - JSON Web Tokens (JWT) and Open Policy Agent (OPA)

We gain an understanding of how JWT's work and their shortcomings. We also learn about OPA and how we will use it to perform the actual authentication and authorization.

9.0 - Key Store

We create a simple key store for the project to store and retrieve the private key.

10.0 - Authentication / Authorization

We integrate authentication and authorization support into the project by developing a packages to generate and validate tokens. Then we integrate the packages into the application and test things are working.

11.0 - Domain Driven, Data Oriented Archiecture

We talk about the data driven data oriented architecture that is implemented in the project. We discuss the design philosophy, guidelines, and semantics of how the three layers of App, Business, and Storage work together.

12.0 - Database Support

We add a Postgres database to our K8s environment. Then we write a small database package that provides support for using the SQLx package more effectively. Finally, integrate the database package on application startup.

13.0 - Database Migrations and Seeding

We define our schema and provide support for migration schema changes over time. We also provide support for seeding the database. Finally, we add support in Kubernetes to run the migration and seeding on POD startup.

14.0 - API, App, Business, and Storage Domain Implementation

We implement the User domain inside the App, Business, and Storage layers.

15.0 - Testing

We add docker and unit testing support for writing tests against a real database and write the actual user package tests.

16.0 - Delegate and Transactions

We talk about how the delegate and transaction systems work.

17.0 - Observability

We add tracing to the project by integrating Open Telemetry and Zipkin.

18.0 - Review Service Project

Review service project and get it running

Extra Curriculum

Modules

A walkthrough of how the module ecosystem works. We talk about the engineering decisions you need to make as they relate to modules.