3.58 out of 5
6 reviews on Udemy

Go Behavioral Patterns

Learn idiomatic, efficient, clean, and extensible Go Behavioral patterns by using TDD
Packt Publishing
73 students enrolled
English [Auto-generated]
Encapsulate the creation of complex objects in an idiomatic way in Go
Create unique instances that cannot be duplicated within a program
Learn to make Objects react in an expected or bounded way
Explore tremendously popular design patterns in distributed systems and reactive programming
Understand the importance of object encapsulation to provide clarity and maintainability
Prepare cost-effective actions so that different parts of the program aren’t affected by expensive tasks

Go is a multi-paradigm programming language that has built-in facilities for creating concurrent applications. Design patterns allow developers to efficiently address common problems faced during developing applications.

Go Design Patterns will provide viewers with a reference point for software design patterns and help to build applications in a more idiomatic, robust, and convenient way in Go. The course will take you to an advanced level of knowledge about classic design patterns but, as you will see, the design patterns covered here are quite different, partly because of the lack of inheritance in Go, but also because we have different and more optimal ways to solve the same problems.

With all this, the course will enable you to understand and apply design patterns in an idiomatic way that will produce concise, readable, and maintainable software.

About the Author

Mario Castro Contreras is a software engineer who has specialized in distributed systems and big data solutions. He works as a site reliability engineer, and now he is focused on containerized solutions and apps using most of the Google Cloud suite, especially Kubernetes. He has wide experience in systems and solutions integration, and he has written many scalable and reliable 12-factor apps using Go and Docker. He has designed big data architectures for financial services and media, and he has written data processing pipelines using event-driven architectures written purely in Go. He is also very active in the open source community, and you can find him on his GitHub account with the username sayden. In the past, he has also written mobile applications and backends in Java.

Mario is passionate about programming languages, and he found the best balance between fun and productivity in Go; however, recently, he enjoys writing in Rust and embedded systems in C. He is also passionate about road cycling and winter sports.

Strategy, Chain of Responsibility, and Command Design Patterns

The Course Overview

This video gives an overview of the entire course.

Strategy Design Pattern

This video will walk you through the most important design pattern in object-oriented programming, with which many design patterns have something in common.

Chain of Responsibility Pattern

Through this video, you will learn to build chains of objects that can decide which between them must deal with a particular case.

Command Design Pattern

This video will show you how to encapsulate actions that don’t necessarily need to be executed immediately or must be stored.

Template, Memento, and Interpreter Design Patterns

Template Design Pattern

How could you provide a user some way to execute code within an algorithm? This video will let you answer this question. You will be able to write idiomatic Go Template patterns.

Memento Design Pattern

This video will show you how you could save milestones of a state when you have a type with some state. You will learn to recover them if necessary for a variety of tasks: undo operations, historic, and so on.

Interpreter Design Pattern

This video will let you dig into a quite complex pattern, which is widely used to solve business cases where it's useful to have a language to perform common operations. 

Visitor, State, Mediator, and Observer Design Patterns

Visitor Design Pattern

What if you want to abstract away some functionality from a set of objects? Let’s do it through this video.

State Design Pattern

You may require something that has one or more states and travels between them to execute some behaviors. These are termed as FSMs. Let's see how the State pattern helps us to define FSM.

Mediator Design Pattern

How do we avoid tight coupling between objects?

Observer Design Pattern

How can you uncouple an event from its possible handler? How can you achieve many actions that are triggered on one event? Let’s answer these questions with this video.

You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
3.6 out of 5
6 Ratings

Detailed Rating

Stars 5
Stars 4
Stars 3
Stars 2
Stars 1
30-Day Money-Back Guarantee


3 hours on-demand video
Full lifetime access
Access on mobile and TV
Certificate of Completion