Search icon CANCEL
Subscription
0
Cart icon
Your Cart (0 item)
Close icon
You have no products in your basket yet
Arrow left icon
Explore Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Newsletter Hub
Free Learning
Arrow right icon
timer SALE ENDS IN
0 Days
:
00 Hours
:
00 Minutes
:
00 Seconds
Go Design Patterns
Go Design Patterns

Go Design Patterns: Best practices in software development and CSP

Arrow left icon
Profile Icon Castro Contreras
Arrow right icon
Free Trial
Full star icon Half star icon Empty star icon Empty star icon Empty star icon 1.8 (6 Ratings)
Paperback Feb 2017 402 pages 1st Edition
eBook
Mex$631.99 Mex$902.99
Paperback
Mex$1128.99
Subscription
Free Trial
Arrow left icon
Profile Icon Castro Contreras
Arrow right icon
Free Trial
Full star icon Half star icon Empty star icon Empty star icon Empty star icon 1.8 (6 Ratings)
Paperback Feb 2017 402 pages 1st Edition
eBook
Mex$631.99 Mex$902.99
Paperback
Mex$1128.99
Subscription
Free Trial
eBook
Mex$631.99 Mex$902.99
Paperback
Mex$1128.99
Subscription
Free Trial

What do you get with a Packt Subscription?

Free for first 7 days. $19.99 p/m after that. Cancel any time!
Product feature icon Unlimited ad-free access to the largest independent learning library in tech. Access this title and thousands more!
Product feature icon 50+ new titles added per month, including many first-to-market concepts and exclusive early access to books as they are being written.
Product feature icon Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.
Product feature icon Thousands of reference materials covering every tech concept you need to stay up to date.
Subscribe now
View plans & pricing
Table of content icon View table of contents Preview book icon Preview Book

Go Design Patterns

Chapter 2. Creational Patterns - Singleton, Builder, Factory, Prototype, and Abstract Factory Design Patterns

We have defined two types of cars-luxury and family. The car Factory will have to return The first groups of design patterns that we are going to cover are the Creational patterns. As the name implies, it groups common practices for creating objects, so object creation is more encapsulated from the users that need those objects. Mainly, creational patterns try to give ready-to-use objects to users instead of asking for their creation, which, in some cases, could be complex, or which would couple your code with the concrete implementations of the functionality that should be defined in an interface.

Singleton design pattern - having a unique instance of a type in the entire program

Have you ever done interviews for software engineers? It's interesting that when you ask them about design patterns, more than 80% will mention Singleton design pattern. Why is that? Maybe it's because it is one of the most used design patterns out there or one of the easiest to grasp. We will start our journey on creational design patterns because of the latter reason.

Description

The Singleton pattern is easy to remember. As the name implies, it will provide you with a single instance of an object, and guarantee that there are no duplicates.

At the first call to use the instance, it is created and then reused between all the parts in the application that need to use that particular behavior.

You'll use the Singleton pattern in many different situations. For example:

  • When you want to use the same connection to a database to make every query
  • When you open a Secure Shell (SSH) connection to...

Builder design pattern - reusing an algorithm to create many implementations of an interface

Talking about Creational design patterns, it looks pretty semantic to have a Builder design pattern. The Builder pattern helps us construct complex objects without directly instantiating their struct, or writing the logic they require. Imagine an object that could have dozens of fields that are more complex structs themselves. Now imagine that you have many objects with these characteristics, and you could have more. We don't want to write the logic to create all these objects in the package that just needs to use the objects.

Description

Instance creation can be as simple as providing the opening and closing braces {} and leaving the instance with zero values, or as complex as an object that needs to make some API calls, check states, and create objects for its fields. You could also have an object that is composed of many objects, something that's really idiomatic in Go, as it doesn&apos...

Factory method - delegating the creation of different types of payments

The Factory method pattern (or simply, Factory) is probably the second-best known and used design pattern in the industry. Its purpose is to abstract the user from the knowledge of the struct he needs to achieve for a specific purpose, such as retrieving some value, maybe from a web service or a database. The user only needs an interface that provides him this value. By delegating this decision to a Factory, this Factory can provide an interface that fits the user needs. It also eases the process of downgrading or upgrading of the implementation of the underlying type if needed.

Description

When using the Factory method design pattern, we gain an extra layer of encapsulation so that our program can grow in a controlled environment. With the Factory method, we delegate the creation of families of objects to a different package or object to abstract us from the knowledge of the pool of possible objects we could use. Imagine...

Abstract Factory - a factory of factories

After learning about the factory design pattern, where we grouped a family of related objects in our case payment methods, one can be quick to think--what if I group families of objects in a more structured hierarchy of families?

Description

The Abstract Factory design pattern is a new layer of grouping to achieve a bigger (and more complex) composite object, which is used through its interfaces. The idea behind grouping objects in families and grouping families is to have big factories that can be interchangeable and can grow more easily. In the early stages of development, it is also easier to work with factories and abstract factories than to wait until all concrete implementations are done to start your code. Also, you won't write an Abstract Factory from the beginning unless you know that your object's inventory for a particular field is going to be very large and it could be easily grouped into families.

The objectives

Grouping related...

Singleton design pattern - having a unique instance of a type in the entire program


Have you ever done interviews for software engineers? It's interesting that when you ask them about design patterns, more than 80% will mention Singleton design pattern. Why is that? Maybe it's because it is one of the most used design patterns out there or one of the easiest to grasp. We will start our journey on creational design patterns because of the latter reason.

Description

The Singleton pattern is easy to remember. As the name implies, it will provide you with a single instance of an object, and guarantee that there are no duplicates.

At the first call to use the instance, it is created and then reused between all the parts in the application that need to use that particular behavior.

You'll use the Singleton pattern in many different situations. For example:

  • When you want to use the same connection to a database to make every query

  • When you open a Secure Shell (SSH) connection to a server to do a few...

Builder design pattern - reusing an algorithm to create many implementations of an interface


Talking about Creational design patterns, it looks pretty semantic to have a Builder design pattern. The Builder pattern helps us construct complex objects without directly instantiating their struct, or writing the logic they require. Imagine an object that could have dozens of fields that are more complex structs themselves. Now imagine that you have many objects with these characteristics, and you could have more. We don't want to write the logic to create all these objects in the package that just needs to use the objects.

Description

Instance creation can be as simple as providing the opening and closing braces {} and leaving the instance with zero values, or as complex as an object that needs to make some API calls, check states, and create objects for its fields. You could also have an object that is composed of many objects, something that's really idiomatic in Go, as it doesn't support inheritance...

Left arrow icon Right arrow icon
Download code icon Download Code

Key benefits

  • A highly practical guide filled with numerous examples unleashing the power of design patterns with Go.
  • Discover an introduction of the CSP concurrency model by explaining GoRoutines and channels.
  • Get a full explanation, including comprehensive text and examples, of all known GoF design patterns in Go.

Description

Go is a multi-paradigm programming language that has built-in facilities to create concurrent applications. Design patterns allow developers to efficiently address common problems faced during developing applications. Go Design Patterns will provide readers with a reference point to software design patterns and CSP concurrency design patterns to help them build applications in a more idiomatic, robust, and convenient way in Go. The book starts with a brief introduction to Go programming essentials and quickly moves on to explain the idea behind the creation of design patterns and how they appeared in the 90’s as a common "language" between developers to solve common tasks in object-oriented programming languages. You will then learn how to apply the 23 Gang of Four (GoF) design patterns in Go and also learn about CSP concurrency patterns, the "killer feature" in Go that has helped Google develop software to maintain thousands of servers. With all of this the book will enable you to understand and apply design patterns in an idiomatic way that will produce concise, readable, and maintainable software.

Who is this book for?

The target audience is both beginner- and advanced-level developers in the Go programming language. No knowledge of design patterns is expected.

What you will learn

  • All basic syntax and tools needed to start coding in Go
  • Encapsulate the creation of complex objects in an idiomatic way in Go
  • Create unique instances that cannot be duplicated within a program
  • 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
  • Deal with channels and GoRoutines within the Go context to build concurrent application in Go in an idiomatic way

Product Details

Country selected
Publication date, Length, Edition, Language, ISBN-13
Publication date : Feb 24, 2017
Length: 402 pages
Edition : 1st
Language : English
ISBN-13 : 9781786466204
Vendor :
Google
Category :
Languages :

What do you get with a Packt Subscription?

Free for first 7 days. $19.99 p/m after that. Cancel any time!
Product feature icon Unlimited ad-free access to the largest independent learning library in tech. Access this title and thousands more!
Product feature icon 50+ new titles added per month, including many first-to-market concepts and exclusive early access to books as they are being written.
Product feature icon Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.
Product feature icon Thousands of reference materials covering every tech concept you need to stay up to date.
Subscribe now
View plans & pricing

Product Details

Publication date : Feb 24, 2017
Length: 402 pages
Edition : 1st
Language : English
ISBN-13 : 9781786466204
Vendor :
Google
Category :
Languages :

Packt Subscriptions

See our plans and pricing
Modal Close icon
$19.99 billed monthly
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Simple pricing, no contract
$199.99 billed annually
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just Mex$85 each
Feature tick icon Exclusive print discounts
$279.99 billed in 18 months
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just Mex$85 each
Feature tick icon Exclusive print discounts

Frequently bought together


Stars icon
Total Mex$ 3,262.97
Go Design Patterns
Mex$1128.99
Building Microservices with Go
Mex$1004.99
.Go Programming Blueprints
Mex$1128.99
Total Mex$ 3,262.97 Stars icon

Table of Contents

10 Chapters
1. Ready... Steady... Go! Chevron down icon Chevron up icon
2. Creational Patterns - Singleton, Builder, Factory, Prototype, and Abstract Factory Design Patterns Chevron down icon Chevron up icon
3. Structural Patterns - Composite, Adapter, and Bridge Design Patterns Chevron down icon Chevron up icon
4. Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns Chevron down icon Chevron up icon
5. Behavioral Patterns - Strategy, Chain of Responsibility, and Command Design Patterns Chevron down icon Chevron up icon
6. Behavioral Patterns - Template, Memento, and Interpreter Design Patterns Chevron down icon Chevron up icon
7. Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns Chevron down icon Chevron up icon
8. Introduction to Gos Concurrency Chevron down icon Chevron up icon
9. Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns Chevron down icon Chevron up icon
10. Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns Chevron down icon Chevron up icon

Customer reviews

Top Reviews
Rating distribution
Full star icon Half star icon Empty star icon Empty star icon Empty star icon 1.8
(6 Ratings)
5 star 0%
4 star 16.7%
3 star 16.7%
2 star 0%
1 star 66.7%
Filter icon Filter
Top Reviews

Filter reviews by




Simone Gentili Sep 17, 2017
Full star icon Full star icon Full star icon Full star icon Empty star icon 4
Ogni pattern e' accompagnato da una serie di test. Non e' un libro sul TDD, quindi non si trovano tutti gli step della metodologia. Anzi, ... ci si concentra sopratutto sul design pattern. Mi sembra un ottimo testo. Sono solo ai primi capitoli ma mi sento gia' in dovere di consigliarlo. Mi hanno parlato di questo libro sullo slack ufficiale di go, nel canale #italy. Credo sia poco pubblicizzato, e che valga ogni singolo centesimo speso per acquistarlo.
Amazon Verified review Amazon
Amazon Customer Apr 10, 2017
Full star icon Full star icon Full star icon Empty star icon Empty star icon 3
The book is a good attempt at explaining the Gang of Four patterns using GO. Its main problem is the code examples; which are riddled with inconsistencies and errors. I would have given it a higher rating if this was not the case. The code examples that are supplied by Packt (the publisher) for download are correct though. It seems to me that the book was a rush job and it might have done with the editor giving it "the once over" before publishing. Great potential, hopefully fixed by 2nd edition.
Amazon Verified review Amazon
Brandon Bennett Apr 15, 2017
Full star icon Empty star icon Empty star icon Empty star icon Empty star icon 1
This book falls into the category of other poorly written OOP design programming books. It is riddled with errors and lacks a lot of reasoning and examples for each pattern. The examples used in the book are also the tragic abstract examples that have zero real world use. Instead of describing how a a design pattern could be used, it uses examples with objects Cars, or Tshirts which have fields like NumWheels, or Size. All of it is useless outside of the poor example in the bookOn the subject of patterns. The patterns presented are just the Gang of Four OOP patterns which are shoehorned into the Go language. They are not go idiomatic and a lot of the examples should not be used to write idiomatic code. If you are just learning Go this book does a poor job of describing the language and also teaches you how to be a OOP/Java programmer in a different language
Amazon Verified review Amazon
Patrick Jusic Dec 19, 2018
Full star icon Empty star icon Empty star icon Empty star icon Empty star icon 1
I just started reading the book and the largest part of examples are wrong... variables declared and not used (the intent was to call other variables), dublicate arguments call, function values return not specified.... Did they just try the code they wrote? I have doubts about it. One start because you cannot deliver a product like this. The star is for the author and for Packt too
Amazon Verified review Amazon
Houssem Jan 05, 2018
Full star icon Empty star icon Empty star icon Empty star icon Empty star icon 1
horrible
Amazon Verified review Amazon
Get free access to Packt library with over 7500+ books and video courses for 7 days!
Start Free Trial

FAQs

What is included in a Packt subscription? Chevron down icon Chevron up icon

A subscription provides you with full access to view all Packt and licnesed content online, this includes exclusive access to Early Access titles. Depending on the tier chosen you can also earn credits and discounts to use for owning content

How can I cancel my subscription? Chevron down icon Chevron up icon

To cancel your subscription with us simply go to the account page - found in the top right of the page or at https://subscription.packtpub.com/my-account/subscription - From here you will see the ‘cancel subscription’ button in the grey box with your subscription information in.

What are credits? Chevron down icon Chevron up icon

Credits can be earned from reading 40 section of any title within the payment cycle - a month starting from the day of subscription payment. You also earn a Credit every month if you subscribe to our annual or 18 month plans. Credits can be used to buy books DRM free, the same way that you would pay for a book. Your credits can be found in the subscription homepage - subscription.packtpub.com - clicking on ‘the my’ library dropdown and selecting ‘credits’.

What happens if an Early Access Course is cancelled? Chevron down icon Chevron up icon

Projects are rarely cancelled, but sometimes it's unavoidable. If an Early Access course is cancelled or excessively delayed, you can exchange your purchase for another course. For further details, please contact us here.

Where can I send feedback about an Early Access title? Chevron down icon Chevron up icon

If you have any feedback about the product you're reading, or Early Access in general, then please fill out a contact form here and we'll make sure the feedback gets to the right team. 

Can I download the code files for Early Access titles? Chevron down icon Chevron up icon

We try to ensure that all books in Early Access have code available to use, download, and fork on GitHub. This helps us be more agile in the development of the book, and helps keep the often changing code base of new versions and new technologies as up to date as possible. Unfortunately, however, there will be rare cases when it is not possible for us to have downloadable code samples available until publication.

When we publish the book, the code files will also be available to download from the Packt website.

How accurate is the publication date? Chevron down icon Chevron up icon

The publication date is as accurate as we can be at any point in the project. Unfortunately, delays can happen. Often those delays are out of our control, such as changes to the technology code base or delays in the tech release. We do our best to give you an accurate estimate of the publication date at any given time, and as more chapters are delivered, the more accurate the delivery date will become.

How will I know when new chapters are ready? Chevron down icon Chevron up icon

We'll let you know every time there has been an update to a course that you've bought in Early Access. You'll get an email to let you know there has been a new chapter, or a change to a previous chapter. The new chapters are automatically added to your account, so you can also check back there any time you're ready and download or read them online.

I am a Packt subscriber, do I get Early Access? Chevron down icon Chevron up icon

Yes, all Early Access content is fully available through your subscription. You will need to have a paid for or active trial subscription in order to access all titles.

How is Early Access delivered? Chevron down icon Chevron up icon

Early Access is currently only available as a PDF or through our online reader. As we make changes or add new chapters, the files in your Packt account will be updated so you can download them again or view them online immediately.

How do I buy Early Access content? Chevron down icon Chevron up icon

Early Access is a way of us getting our content to you quicker, but the method of buying the Early Access course is still the same. Just find the course you want to buy, go through the check-out steps, and you’ll get a confirmation email from us with information and a link to the relevant Early Access courses.

What is Early Access? Chevron down icon Chevron up icon

Keeping up to date with the latest technology is difficult; new versions, new frameworks, new techniques. This feature gives you a head-start to our content, as it's being created. With Early Access you'll receive each chapter as it's written, and get regular updates throughout the product's development, as well as the final course as soon as it's ready.We created Early Access as a means of giving you the information you need, as soon as it's available. As we go through the process of developing a course, 99% of it can be ready but we can't publish until that last 1% falls in to place. Early Access helps to unlock the potential of our content early, to help you start your learning when you need it most. You not only get access to every chapter as it's delivered, edited, and updated, but you'll also get the finalized, DRM-free product to download in any format you want when it's published. As a member of Packt, you'll also be eligible for our exclusive offers, including a free course every day, and discounts on new and popular titles.