Cargando…
Go design patterns : learn idiomatic, efficient, clean and extensible Go design and concurrency patterns by using TDD /
| Clasificación: | Libro Electrónico |
|---|---|
| Autor principal: | |
| Formato: | Electrónico eBook |
| Idioma: | Inglés |
| Publicado: |
Birmingham, UK :
Packt Publishing,
[2017]
|
| Temas: | |
| Acceso en línea: | Texto completo (Requiere registro previo con correo institucional) |
Tabla de Contenidos:
- 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{u2026} else statement
- The switch statement
- The for{u2026}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.