|
|
|
|
| LEADER |
00000cam a2200000Ii 4500 |
| 001 |
OR_ocn976408022 |
| 003 |
OCoLC |
| 005 |
20231017213018.0 |
| 006 |
m o d |
| 007 |
cr unu|||||||| |
| 008 |
170317s2017 enka o 000 0 eng d |
| 040 |
|
|
|a UMI
|b eng
|e rda
|e pn
|c UMI
|d YDX
|d TEFOD
|d OCLCF
|d IDEBK
|d STF
|d TOH
|d COO
|d OCLCQ
|d VT2
|d UOK
|d CEF
|d KSU
|d OCLCQ
|d DEBBG
|d WYU
|d N$T
|d ZCU
|d UAB
|d AU@
|d OCLCO
|d OCLCQ
|
| 019 |
|
|
|a 974559930
|a 974693705
|a 974748271
|a 974959653
|a 975021883
|a 1079834794
|
| 020 |
|
|
|a 9781786461902
|q (electronic bk.)
|
| 020 |
|
|
|a 1786461900
|q (electronic bk.)
|
| 020 |
|
|
|z 9781786466204
|
| 020 |
|
|
|z 1786466201
|
| 029 |
1 |
|
|a GBVCP
|b 897169948
|
| 035 |
|
|
|a (OCoLC)976408022
|z (OCoLC)974559930
|z (OCoLC)974693705
|z (OCoLC)974748271
|z (OCoLC)974959653
|z (OCoLC)975021883
|z (OCoLC)1079834794
|
| 037 |
|
|
|a CL0500000840
|b Safari Books Online
|
| 037 |
|
|
|a 92333FFA-35D0-4C04-BE29-E375B6AEDD49
|b OverDrive, Inc.
|n http://www.overdrive.com
|
| 050 |
|
4 |
|a QA76.73.G63
|
| 072 |
|
7 |
|a COM
|x 051230
|2 bisacsh
|
| 082 |
0 |
4 |
|a 005.133
|2 23
|
| 049 |
|
|
|a UAMI
|
| 100 |
1 |
|
|a Castro Contreras, Mario,
|e author.
|
| 245 |
1 |
0 |
|a Go design patterns :
|b learn idiomatic, efficient, clean and extensible Go design and concurrency patterns by using TDD /
|c Mario Castro Contreras.
|
| 264 |
|
1 |
|a Birmingham, UK :
|b Packt Publishing,
|c [2017]
|
| 264 |
|
4 |
|c ©2017
|
| 300 |
|
|
|a 1 online resource (1 volume) :
|b illustrations
|
| 336 |
|
|
|a text
|b txt
|2 rdacontent
|
| 337 |
|
|
|a computer
|b c
|2 rdamedia
|
| 338 |
|
|
|a online resource
|b cr
|2 rdacarrier
|
| 588 |
0 |
|
|a Online resource; title from cover (viewed March 17, 2017).
|
| 505 |
0 |
|
|a 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.
|
| 505 |
8 |
|
|a 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.
|
| 505 |
8 |
|
|a 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.
|
| 505 |
8 |
|
|a 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.
|
| 505 |
8 |
|
|a 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.
|
| 590 |
|
|
|a O'Reilly
|b O'Reilly Online Learning: Academic/Public Library Edition
|
| 590 |
|
|
|a eBooks on EBSCOhost
|b EBSCO eBook Subscription Academic Collection - Worldwide
|
| 650 |
|
0 |
|a Go (Computer program language)
|
| 650 |
|
0 |
|a Computer software
|x Development.
|
| 650 |
|
6 |
|a Go (Langage de programmation)
|
| 650 |
|
7 |
|a COMPUTERS / Software Development & Engineering / General.
|2 bisacsh
|
| 650 |
|
7 |
|a Computer software
|x Development.
|2 fast
|0 (OCoLC)fst00872537
|
| 650 |
|
7 |
|a Go (Computer program language)
|2 fast
|0 (OCoLC)fst01893916
|
| 655 |
|
7 |
|a Handbooks and manuals.
|2 fast
|0 (OCoLC)fst01423877
|
| 776 |
0 |
8 |
|i Print version:
|a Contreras, Mario Castro.
|t Go Design Patterns.
|d Birmingham : Packt Publishing, ©2017
|
| 856 |
4 |
0 |
|u https://learning.oreilly.com/library/view/~/9781786466204/?ar
|z Texto completo (Requiere registro previo con correo institucional)
|
| 938 |
|
|
|a ProQuest MyiLibrary Digital eBook Collection
|b IDEB
|n cis35309948
|
| 938 |
|
|
|a YBP Library Services
|b YANK
|n 13522892
|
| 938 |
|
|
|a EBSCOhost
|b EBSC
|n 1477566
|
| 994 |
|
|
|a 92
|b IZTAP
|
