The Future of Tech Training has Arrived
Interactive Learning

Hybrid
Training

Introducing our new training format that provides you a mix of self-paced courses and live Q&A discussions with the instructors every week.

Our new training format has the following advantages:

go, docker, and Kubernetes training

Time Efficient

  • This training fits into any schedule you have.
  • You no longer have to stick to specific class times.
  • Freedom to study when it suits you.
go, docker, and Kubernetes training

Knowledge Retention

  • Review video lessons whenever you want.
  • Reinforce and consolidate your understanding.
  • Leads to better retention of the material.
go, docker, and Kubernetes training

Instructor Guidance

  • Live interaction with the instructor.
  • Ask specific questions and receive direct answers.
  • Get a clearer and more detailed explanation.
go, docker, and Kubernetes training

Discussion Recordings

  • Can't attend? You'll still receive the recordings.
  • Watch the Q&A recordings at your leisure.
  • Different points of view from the instructor & fellow students.

How It Works

Kick-off Session
1

Kick-off Session

At the start of every course session, the instructor will host a video call to answer questions and go over the curriculum.

Self-Paced Video
2

Self-Paced Video

Every week your instructor will assign the video lessons you need to watch in preparation for the next discussion.

Weekly Discussions
3

Weekly Discussions

The instructor will host a live Q&A to answer and expand on any questions from that week's lessons.

Continuous Education
4

Continuous Education

After your completed session, we have many options for you to continue your self-paced education with Ardan.

Can't attend the live discussions?

The Q&A portion of the training will be recorded, and the recordings will be made available to the participants.

Upcoming Sessions

Practical Go for Developers

Starting October 2023

This class helps experienced engineers become effective with the Go programming language by writing code to solve common programming tasks.

with Miki Tebeka
  Beginner - Intermediate
Enroll Now

16 Hours of Self-Paced Video + 5 Instructor-Led Sessions:

Date:

Starting October 2023

Format:

  • Kick-off session
  • Self Paced Video - (Weekly Lessons)
  • Instructor-Led Weekly Q & A
  • Continuous Education

Course Description:

The Practical Go for Developers training class helps experienced engineers get effective with the Go programming language and learn by writing code to solve common programming tasks.

Requirements:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

  • A basic understanding of the Go programming language.
  • Completed at least the majority of the Go Tour.

You should have the following installed on your computer prior to the workshop:

  • Go SDK from golang.org/dl/
  • An IDE, either VSCode with Go extension or GoLand
  • Git

Course Outline

Strings & Formatted Output:
  • What is a string?
  • Unicode basics
  • Using ftm package for formatted output

Calling REST APIs:
  • Making HTTP calls with net/http
  • Defining structs
  • Serializing JSON

Working with Files:
  • Handling errors
  • Using defer to manage resources
  • Working with io.Reader & io.Writer interfaces

Sorting:
  • Working with slices
  • Writing methods
  • Understanding interfaces

Catching Panics:
  • The built-in recover function
  • Named return values

Processing Text:
  • Reading line by line with bufio.Scanner
  • Using regular expressions

Distributing Work:
  • Using goroutines & channels
  • Using the sync package to coordinate work

Timeouts & Cancellation:
  • Working with multiple channels using select
  • Using context for timeouts & cancellations
  • Standard library support for context

Testing Your Code:
  • Working with the testing package
  • Using testify
  • Managing dependencies with go mod

Structuring Your Code:
  • Writing sub-packages

Writing an HTTP Server:
  • Writing handlers
  • Using gorilla/mux for routing

Adding Metrics & Logging:
  • Using expvar for metrics
  • Using the log package and a look at user/zap

Configuration Patterns:
  • Reading environment variables and a look at external packages
  • Using the flag package for command line processing

Ultimate Go: Service with Kubernetes

Coming Soon

This class teaches you how to build production-level services in Go, leveraging the power of Kubernetes.

with Bill Kennedy
  Intermediate - Advanced

25 Hours of Self-Paced Video + 5 Instructor-Led Sessions:

Date:

Coming Soon

Format:

  • Kick-off session
  • Self Paced Video - (Weekly Lessons)
  • Instructor-Led Weekly Q & A
  • Continuous Education

Course Description:

The Ultimate Go Service with Kubernetes class has been designed over the past 5 years and goes beyond just being a Go service class. This course teaches you how to build production-level services in Go, leveraging the power of Kubernetes.

From the beginning of the course, you will pair-program with your instructor Bill Kennedy as he walks you through the design philosophies, architectural decisions, and best practices as they apply to engineering a production-ready Go service.

With each new feature that is added to the service, you will learn how to deploy and manage the Kubernetes environment used to run the service. Throughout the class, the code being worked on is pushed to a repository for personal access and review.

Course Outline

Introduction:
  • 1.0 - Intro - (01:00)
  • 1.1 - Design Philosophy, Guidelines, What to Expect - (03:00)
  • 1.2 - Tooling to Install - (05:00)

Modules:
  • 2.0 - Intro - (01:00)
  • 2.1 - Adding Dependencies - (23:00)
  • 2.2 - Module Mirrors - (19:00)
  • 2.3 - Checksum Database - (05:00)
  • 2.4 - Vendoring - (05:00)
  • 2.5 - MVS Algorithm - (18:00)

Kubernetes:
  • 3.0 - Intro - (01:00)
  • 3.1 - Tooling Installation - (05:00)
  • 3.2 - Understanding Clusters, Nodes & Pods - (10:00)
  • 3.3 - Write Basic Service for Testing - (08:00)
  • 3.4 - Zarf Layer - (11:00)
  • 3.4.2 - Kind Configuration - (06:00)
  • 3.4.3 - Core K8s Configuration - (17:00)
  • 3.4.4 - K8s Quotas / Patching - (19:00)

Initial Service Design:
  • 4.0 - Intro - (01:00)
  • 4.1 - Project Layers, Policies, and Guidelines - (18:00)
  • 4.2 - Prepare Project - (19:00)
  • 4.3 - Logging Support - (17:00)
  • 4.4 - Configuration Support - (22:00)
  • 4.5 - Debugging / Metrics Support - (22:00)
  • 4.6 - Shutdown Signaling & Load Shedding - (11:00)

HTTP Routing Basics:
  • 5.0 - Intro - (01:00)
  • 5.1 - Basic Structure of an HTTP Router - (11:00)
  • 5.2 - Add a Readiness, Liveness & Test Handler - (24:00)

Web Framework:
  • 6.0 Intro - (01:00)
  • 6.1 Custom Router - (18:00)
  • 6.2 Custom Handler Function - (13:00)
  • 6.3 Middleware Support - (09:00)
  • 6.4 Sending Responses - (05:00)

Middleware:
  • 7.0 - Intro - (01:00)
  • 7.1 - Logging - (14:00)
  • 7.2 - Request Context - (16:00)
  • 7.3.1 - Understanding what Error Handling Means - (15:00)
  • 7.3.2 - Declaring Custom Error Types - (17:00)
  • 7.3.3 - Consistent Handling & Response - (13:00)
  • 7.4 - Panic Handling - (09:00)
  • 7.5 - Metrics - (18:00)

JSON Web Tokens (JWT):
  • 8.0 - Intro - (01:00)
  • 8.1 - Understanding JWT - (09:00)
  • 8.2 - Private/Public Key Generation - (12:00)
  • 8.3 - Token Generation - (21:00)
  • 8.4 - Token Signature Validation - (07:00)

Authentication / Authorization:
  • 9.0 - Intro - (01:00)
  • 9.1 - Auth Package - (11:00)
  • 9.2 - Implementation of an In-Memory Key Store - (09:00)
  • 9.3 - Middleware - (14:00)
  • 9.4 - Auth Unit Test - (20:00)

Database Support:
  • 10.0 - Intro - (01:00)
  • 10.1 - Kubernetes Support for Postgres - (10:00)
  • 10.2 - Using Sqlx - (01:00)
  • 10.3 - Update Readiness Handler to Perform DB Checks - (06:00)

Database Migrations and Seeding:
  • 11.0 - Intro - (01:00)
  • 11.1 - Maintaining Database Schemas - (16:00)
  • 11.2 - Seeding Data - (05:00)
  • 11.3 - Init Containers - (10:00)

Business Packages:
  • 12.0 - Intro -(01:00)
  • 12.1 - Design Philosophies, Policies, & Guidelines -(12:00)
  • 12.2 - User Data Models & API Precision -(18:00)
  • 12.3 - Data Model Validation -(08:00)
  • 12.4 - User CRUD Data Business Package APIs -(27:00)
  • 12.5 - User Core Business Package APIs -(08:00)

Testing Data Business Packages:
  • 13.0 - Intro - (01:00)
  • 13.1 - Support for Starting and Stopping Containers - (14:00)
  • 13.2 - Support for Starting & Stopping a Unit Test - (11:00)
  • 13.3 - Write User CRUD Data Unit Tests - (12:00)

Rest API:
  • 14.0 - Intro - (01:00)
  • 14.1 - Writing User Web Handlers - (14:00)
  • 14.2 - Support for Starting & Stopping an Integration Test - (04:00)
  • 14.3 - Write Integration Tests for Users - (11:00)

Open Telemetry:
  • 15.0 - Intro -(01:00)
  • 15.1 - Integrate OTEL Web Handler into the Framework -(12:00)
  • 15.2 - Integrate OTEL into Service Startup -(09:00)
  • 15.3 - Add Zipkin into POD -(11:00)
  • 15.4 - Add Tracing Calls Inside Functions to Trace -(08:00)

Review Service Project:
  • 16.0 - Intro - (01:00)
  • 16.1 - Check For Dependency Upgrades - (07:00)
  • 16.2 - Rebuild and Run the Project - (07:00)

Ultimate Rust: Foundations

Starting October 2023

This class helps experienced engineers become effective with the Rust programming language by writing code to solve common programming tasks.

with Herbert Wolverson
  Beginner - Intermediate
Enroll Now

20 Hours of Self-Paced Video + 5 Instructor-Led Sessions:

Date:

Starting October 2023

Format:

  • Kick-off session
  • Self Paced Video - (Weekly Lessons)
  • Instructor-Led Weekly Q & A
  • Continuous Education

Course Description:

The Ultimate Rust Foundations class starts with an introduction to Rust, and why you benefit from using – both as a foundation, and within your existing ecosystem.

Course Outline:

  • Rust includes Cargo, a swiss-army knife tool that can:
  • Using Rust without Cargo
  • Rust’s Safety Guarantees
  • “Hello World” application – the foundation of most languages.
  • Arrays, vectors and slices.
  • Strict types and strong typing.
  • Serializing and De-Serializing data.
  • Iterative Programming – using iterators to combine operations.
  • Working with Strings
  • Protection from data races
  • Easy multi-threaded concurrency with Rayon
  • Ultimate control with raw threads
  • High-performance Input/Output with Asynchronous design and Tokio.
  • Build a CPU bound program with Rayon, and use all of your CPU power.
  • Manage raw-threads and shared data.
  • Spin up a simple server in 10 minutes.
  • The classic Object-Oriented Programming example of different objects printing different text – but with traits.
  • Designing a simple generic function with ToString.
  • Stacked traits – traits that depend upon one another, combined with generic programming.

Our Instructors

Bill Kennedy

Go, blockchain

Bill has been developing software for more than 30 years. In 2013, he became a pioneer using Go and now has trained over 30,000 engineers that work for Fortune 100 companies. He also is the author of Go in Action, the Ultimate Go Notebook, and is the main contributor to our blog.

Miki Tebeka

Go, Python

Miki is a software developer with more than 20 years of experience. He has taught many workshops on various technical subjects all over the world at companies such as AT&T, Oracle, Dropbox, J.P. Morgan, and others.

Herbert Wolverson

Rust

Herbert has been developing software professionally for more than 20 years. Starting with Pascal, and then moving on to C and C++, Herbert has developed custom applications ranging from web-server filters to games. Herbert is the author of Hands-on Rust and Rust Brain Teasers.

Trusted by top technology companies

We've built our reputation as educators and bring that mentality to every project. When you partner with us, your team will learn best practices and grow along the way.

30,000+

Engineers Trained

1,000+

Companies Worldwide

12+

Years in Business
‍

Let’s start a conversation

Reach out and let us know what you are interested in.

Twitter Github Podcast YouTube LinkedIn Store

Ardan Labs Copyrights © 2023