Log In
Or create an account -> 
Imperial Library
  • Home
  • About
  • News
  • Upload
  • Forum
  • Help
  • Login/SignUp

Index
Go Design Patterns
Go Design Patterns Credits About the Author About the Reviewer www.PacktPub.com
Why subscribe?
Customer Feedback Preface
What this book covers What you need for this book Who this book is for Conventions Reader feedback Customer support
Downloading the example code Errata Piracy Questions
1. Ready... Steady... Go!
A little bit of history Installing Go
Linux
Go Linux advanced installation
Windows Mac OS X Setting the workspace - Linux and Apple OS X
Starting with Hello World Integrated Development Environment - IDE Types Variables and constants Operators Flow control
The if... else statement The switch statement The for…range statement
Functions
What does a function look like? What is an anonymous function? Closures Creating errors, handling errors and returning errors. Function with undetermined number of parameters
Naming returned types
Arrays, slices, and maps
Arrays
Zero-initialization
Slices Maps
Visibility Zero-initialization Pointers and structures
What is a pointer? Why are they good? Structs
Interfaces
Interfaces - signing a contract
Testing and TDD
The testing package What is TDD?
Libraries The Go get tool Managing JSON data
The encoding package
Go tools
The golint tool The gofmt tool The godoc tool The goimport tool
Contributing to Go open source projects in GitHub Summary
2. Creational Patterns - Singleton, Builder, Factory, Prototype, and Abstract Factory Design Patterns
Singleton design pattern - having a unique instance of a type in the entire program
Description Objectives Example - a unique counter Requirements and acceptance criteria Writing unit tests first Implementation A few words about the Singleton design pattern
Builder design pattern - reusing an algorithm to create many implementations of an interface
Description Objectives Example - vehicle manufacturing Requirements and acceptance criteria Unit test for the vehicle builder Implementation Wrapping up the Builder design pattern
Factory method - delegating the creation of different types of payments
Description Objectives The example - a factory of payment methods for a shop Acceptance criteria First unit test Implementation Upgrading the Debitcard method to a new platform What we learned about the Factory method
Abstract Factory - a factory of factories
Description The objectives The vehicle factory example, again? Acceptance criteria Unit test Implementation A few lines about the Abstract Factory method
Prototype design pattern
Description Objective Example Acceptance criteria Unit test Implementation What we learned about the Prototype design pattern
Summary
3. Structural Patterns - Composite, Adapter, and Bridge Design Patterns
Composite design pattern
Description Objectives The swimmer and the fish Requirements and acceptance criteria Creating compositions Binary Tree compositions Composite pattern versus inheritance Final words on the Composite pattern
Adapter design pattern
Description Objectives Using an incompatible interface with an Adapter object Requirements and acceptance criteria Unit testing our Printer adapter Implementation Examples of the Adapter pattern in Go's source code What the Go source code tells us about the Adapter pattern
Bridge design pattern
Description Objectives Two printers and two ways of printing for each Requirements and acceptance criteria Unit testing the Bridge pattern Implementation Reuse everything with the Bridge pattern
Summary
4. Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns
Proxy design pattern
Description Objectives Example Acceptance criteria Unit test Implementation Proxying around actions
Decorator design pattern
Description Objectives Example Acceptance criteria Unit test Implementation A real-life example - server middleware
Starting with the common interface, http.Handler
A few words about Go's structural typing Summarizing the Decorator design pattern - Proxy versus Decorator
Facade design pattern
Description Objectives Example Acceptance criteria Unit test Implementation Library created with the Facade pattern
Flyweight design pattern
Description Objectives Example Acceptance criteria Basic structs and tests Implementation What's the difference between Singleton and Flyweight then?
Summary
5. Behavioral Patterns - Strategy, Chain of Responsibility, and Command Design Patterns
Strategy design pattern
Description Objectives Rendering images or text Acceptance criteria Implementation Solving small issues in our library Final words on the Strategy pattern
Chain of responsibility design pattern
Description Objectives A multi-logger chain Unit test Implementation What about a closure? Putting it together
Command design pattern
Description Objectives A simple queue Acceptance criteria Implementation More examples Chain of responsibility of commands Rounding-up the Command pattern up
Summary
6. Behavioral Patterns - Template, Memento, and Interpreter Design Patterns
Template design pattern
Description Objectives Example - a simple algorithm with a deferred step Requirements and acceptance criteria Unit tests for the simple algorithm Implementing the Template pattern Anonymous functions How to avoid modifications on the interface Looking for the Template pattern in Go's source code Summarizing the Template design pattern
Memento design pattern
Description Objectives A simple example with strings Requirements and acceptance criteria Unit test Implementing the Memento pattern Another example using the Command and Facade patterns Last words on the Memento pattern
Interpreter design pattern
Description Objectives Example - a polish notation calculator Acceptance criteria for the calculator Unit test of some operations Implementation Complexity with the Interpreter design pattern Interpreter pattern again - now using interfaces The power of the Interpreter pattern
Summary
7. Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns
Visitor design pattern
Description Objectives A log appender Acceptance criteria Unit tests Implementation of Visitor pattern Another example Visitors to the rescue!
State design pattern
Description Objectives A small guess the number game Acceptance criteria Implementation of State pattern A state to win and a state to lose The game built using the State pattern
Mediator design pattern
Description Objectives A calculator Acceptance criteria Implementation Uncoupling two types with the Mediator
Observer design pattern
Description Objectives The notifier Acceptance criteria Unit tests Implementation Summary
8. Introduction to Gos Concurrency
A little bit of history and theory
Concurrency versus parallelism CSP versus actor-based concurrency
Goroutines
Our first Goroutine Anonymous functions launched as new Goroutines WaitGroups
Callbacks
Callback hell
Mutexes
An example with mutexes - concurrent counter Presenting the race detector
Channels
Our first channel Buffered channels Directional channels The select statement Ranging over channels too!
Using it all - concurrent singleton
Unit test Implementation
Summary
9. Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns
Barrier concurrency pattern
Description Objectives An HTTP GET aggregator Acceptance criteria Unit test - integration Implementation Waiting for responses with the Barrier design pattern
Future design pattern
Description Objectives A simple asynchronous requester Acceptance criteria Unit tests Implementation Putting the Future together
Pipeline design pattern
Description Objectives A concurrent multi-operation Acceptance criteria Beginning with tests Implementation
The list generator Raising numbers to the power of 2 Final reduce operation Launching the Pipeline pattern
Final words on the Pipeline pattern
Summary
10. Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns
Workers pool
Description Objectives A pool of pipelines Acceptance criteria Implementation
The dispatcher The pipeline
An app using the workers pool No tests? Wrapping up the Worker pool
Concurrent Publish/Subscriber design pattern
Description Objectives Example - a concurrent notifier Acceptance criteria Unit test
Testing subscriber Testing publisher
Implementation
Implementing the publisher Handling channels without race conditions
A few words on the concurrent Observer pattern
Summary
  • ← Prev
  • Back
  • Next →
  • ← Prev
  • Back
  • Next →

Chief Librarian: Las Zenow <zenow@riseup.net>
Fork the source code from gitlab.

This is a mirror of the Tor onion service:
http://kx5thpx2olielkihfyo4jgjqfb7zx7wxr3sd4xzt26ochei4m6f7tayd.onion