CF

Working with Design Patterns in Go (Golang)

10h 20m 8s
English
Paid

Working with Design Patterns in Go (Golang) is a 113-lesson 10 hours 20 minutes self-paced course by Udemy. Go is a powerful language for building efficient and scalable applications.

Course facts

Lessons
113
Duration
10 hours 20 minutes
Level
All levels
Language
English
Updated
Instructor
Udemy
Price
Premium

Go is a powerful language for building efficient and scalable applications. However, as your projects grow, you'll encounter common problems that can be elegantly solved with design patterns.

This course will equip you with the knowledge and skills to leverage these design patterns effectively in your Go code. We'll explore various categories of patterns, including:

Types of Design Patterns

Creational Patterns

Learn techniques for object creation that promote flexibility and decoupling.

Structural Patterns

Discover ways to compose classes and objects to achieve desired functionality.

Behavioral Patterns

Explore patterns that define communication and interaction between objects.

Benefits of Using Design Patterns

By understanding these patterns, you'll gain the ability to:

  • Write cleaner, more maintainable, and reusable code.
  • Improve the design and architecture of your Go applications.
  • Solve common programming challenges with proven solutions.
  • Communicate design concepts more effectively with other developers.

Practical Application

We'll approach design patterns with a practical lens, focusing on real-world Go scenarios. In fact, we'll build a simple web application to see how, why, and when to use a particular design pattern to make your code more efficient, maintainable, and easy to understand. My goal is to ensure that you'll gain hands-on experience implementing these patterns so that you can use them in your own projects.

So, whether you're a seasoned Go developer or just getting started with the language, this course will provide you with valuable tools to take your Go development skills to the next level.

Who teaches Working with Design Patterns in Go (Golang)? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in Working with Design Patterns in Go (Golang)?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 113 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (113)
#Lesson TitleDurationAccess
1
Introduction Demo
05:57
2
A bit about me
01:02
3
Installing Go
01:28
4
Installing an Integrated Development Environment
03:15
5
Installing Docker
00:52
6
Asking for Help
01:15
7
Mistakes. We all make them.
01:07
8
What we'll build in this section
00:59
9
How web applications work
02:13
10
Setting up our main application
09:53
11
Installing a routing package
02:31
12
Setting up routes
11:18
13
Setting up a simple HTML template
08:49
14
Creating a render function
16:37
15
Rendering our first page
04:33
16
Adding navigation
04:51
17
Creating templates for all site pages
05:25
18
Setting up a route & handler for site pages
05:49
19
Trying out our template cache
02:14
20
Adding WebP and jpeg images to the home page
22:48
21
What we'll build in this section
01:03
22
The Factory Pattern
06:24
23
Setting up some types
13:39
24
Creating a simple Factory
02:51
25
Creating handlers for the simple Factory
03:57
26
Setting up the front end
09:25
27
Adding routes for our Factory handlers
02:37
28
Trying our Factory pattern out
01:24
29
The Abstract Factory pattern
13:45
30
Creating an Abstract Factory
08:36
31
Creating a route and handler for the Abstract Factory
03:04
32
Updating the front end
05:09
33
Trying out our Abstract Factory
02:10
34
What we'll build in this section
00:36
35
Adding a module to support MySQL/MariaDB
01:26
36
Setting up a local MariaDB instance with Docker
08:23
37
Connecting our application to MariaDB
11:44
38
What we'll build in this section
01:28
39
Writing our first database function
12:15
40
Creating a handler to list dog breeds
07:33
41
Updating the front end to fetch the list of dog breeds
02:52
42
Updating the front end to display the list of dog breeds
14:19
43
Writing a test for our handler
10:23
44
Implementing the Repository pattern I
03:50
45
Implementing the Repository pattern II
03:37
46
Implementing the Repository pattern III
01:19
47
Trying things out
01:31
48
Implementing a test database repository
03:33
49
Updating our handler test
04:03
50
What we'll build in this section
00:52
51
Creating a simple Singleton
06:56
52
Updating our project to use our configuration package (singleton)
04:15
53
What we'll build in this section
01:14
54
The Builder Pattern (& Fluent Interface)
06:25
55
Getting started with the Builder pattern in our project
05:19
56
Setting up our Builder code
08:32
57
Fixing three problems with our Builder code
02:01
58
Setting up a handler to use our Builder pattern
05:33
59
Setting up a route to our handler
01:02
60
Modifying the front end to call our Builder route
06:12
61
Challenge
01:14
62
Solution to challenge
02:22
63
What we'll cover in this section
01:29
64
The Adapter Pattern - Overview
22:43
65
Installing an application to serve JSON and XML
03:34
66
Setting up the Adapter type & the Adaptee
07:28
67
Adding the Adapter to our application config
02:34
68
Setting up a handler
02:35
69
Adding a route
02:25
70
Updating the Cat Breeds template
02:03
71
Switching adapters from JSON to XML
09:24
72
Adding a test for the Cat Breeds handler, using our adapter pattern
05:00
73
What we'll cover in this section
01:14
74
Creating a stub AnimalFromAbstractFactory handler
02:55
75
Creating a New factory function for pet with embedded breed
04:53
76
Creating stub newPetWithBreed method for Cats and Dogs
08:07
77
Adding a GetDogBreedByName method in the database Repository
08:18
78
Refactoring adapters.go to new package
02:12
79
Adding a GetCatBreedByName method on our JSON adapter
04:05
80
Adding a GetCatBreedByName method on our XML adapter
03:15
81
Finishing up the new Adapter and Abstract Factory code
08:48
82
Finishing up the changes in our Abstract Factory to use the new adapters
02:58
83
Setting up a route to our stub handler
04:43
84
Finishing off the handler code
04:11
85
Updating the front end to try things out
07:04
86
Writing the necessary javascript to call our back end
04:22
87
What we'll cover in this section
01:30
88
Setting up a route and a stub handler
02:04
89
Setting up the database table
01:41
90
Adding database methods for Dog of Month
06:25
91
Completing our DogOfMonth handler
07:53
92
Creating the Dog of Month template and trying things out
07:08
93
What we'll cover in this section
02:57
94
Worker Pool Overview
08:08
95
Setting up a Go Workspace to develop our new module
02:31
96
Getting started with the App and Streamer projects
06:12
97
Creating a Factory function for our Worker Pool
07:56
98
Getting started on the worker pool functionality
03:06
99
Setting up the Processor type
03:11
100
Setting up the Pool functionality
12:18
101
Creating Videos to send to the worker pool
08:34
102
Sending videos to the worker pool
04:43
103
Filling in the encode() function's logic
13:10
104
Trying things out and tracing through program execution
12:57
105
Installing ffmpeg
02:20
106
Adding logic to encode to MP4
06:06
107
Trying out the EncodeToMP4 method
02:49
108
Adding logic to encode to HLS: Part One
05:30
109
Adding logic to encode to HLS: Part Two
16:44
110
Trying out our HLS encoder
03:22
111
Adding random filename generation to our videos
02:46
112
Trying out our worker pool with four videos
07:01
113
Adding streamer to our Breeders project
06:57
Unlock unlimited learning

Get instant access to all 112 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Working with Design Patterns in Go (Golang)?

More courses by Udemy

Frequently asked questions

What are the prerequisites for this course?
Before enrolling in this course, you should have a basic understanding of the Go programming language and general programming concepts. Familiarity with web development and tools like Docker will be beneficial, as the course involves setting up environments and working with web applications.
What kind of project will we build in this course?
The course involves building a simple web application to demonstrate how to apply various design patterns in Go. This practical approach helps in understanding the application of creational, structural, and behavioral patterns in real-world scenarios, ensuring that you gain hands-on experience.
Who is the target audience for this course?
This course is designed for Go developers who want to enhance their skills by learning design patterns. It's suitable for those looking to write more maintainable and scalable code by applying proven solutions to common programming challenges.
How does this course compare to other Go programming courses?
Unlike general Go programming courses, this course focuses specifically on design patterns and their application within the Go language. It delves into creational, structural, and behavioral patterns, providing a specialized understanding that enhances code quality and architecture.
What specific tools or platforms will be covered?
The course covers tools like Docker for setting up a local database instance with MariaDB. It also involves using an Integrated Development Environment (IDE) and installing a routing package for web development, illustrating practical use in Go projects.
What topics are not covered in this course?
The course does not cover advanced networking, concurrency patterns in Go, or frontend development frameworks in detail. The focus remains on applying design patterns to backend Go applications, particularly through building a simple web application.
How much time should I expect to commit to this course?
The course consists of 113 lessons. While the exact runtime is not specified, you should anticipate dedicating several hours to cover all topics, build projects, and practice applying design patterns in Go, ensuring a comprehensive understanding of the material.