| Description |
1 online resource (1 volume) : illustrations |
| Contents |
Cover -- Copyright -- Credits -- About the Author -- About the Reviewer -- www.PacktPub.com -- Customer Feedback -- Table of Contents -- Preface -- Chapter 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 -- Chapter 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 -- Chapter 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 -- Chapter 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 -- Chapter 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 -- Chapter 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 -- Chapter 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 -- Chapter 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 -- Chapter 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 -- Chapter 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 -- Index. |
| Subject |
Go (Computer program language)
|
|
Computer software -- Development.
|
|
Go (Langage de programmation) |
|
Computer software -- Development |
|
Go (Computer program language) |
| Genre |
Handbooks and manuals
|
| Other Form: |
Print version: Contreras, Mario Castro. Go Design Patterns. Birmingham : Packt Publishing, ©2017 |
| ISBN |
9781786461902 (electronic bk.) |
|
1786461900 (electronic bk.) |
|
More Resources