

Buy anything from 5,000+ international stores. One checkout price. No surprise fees. Join 2M+ shoppers on Desertcart.
Desertcart purchases this item on your behalf and handles shipping, customs, and support to British Virgin Islands.
Summary Go in Practice guides you through 70 real-world techniques in key areas like package management, microservice communication, and more. Following a cookbook-style Problem/Solution/Discussion format, this practical handbook builds on the foundational concepts of the Go language and introduces specific strategies you can use in your day-to-day applications. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the Technology Go may be the perfect systems language. Built with simplicity, concurrency, and modern applications in mind, Go provides the core tool set for rapidly building web, cloud, and systems applications. If you know a language like Java or C#, it's easy to get started with Go; the trick is finding the practical dirt-under-the-fingernails techniques that you need to build production-ready code. About the Book Go in Practice guides you through dozens of real-world techniques in key areas. Following a cookbook-style Problem/Solution/Discussion format, this practical handbook builds on the foundational concepts of the Go language and introduces specific strategies you can use in your day-to-day applications. You'll learn techniques for building web services, using Go in the cloud, testing and debugging, routing, network applications, and much more. After finishing this book, you will be ready to build sophisticated cloud-native Go applications. What's Inside Dozens of specific, practical Golang techniques Using Go for devops and cloudops Writing RESTful web services and microservices Practical web dev techniques About the Reader Written for experienced developers who have already started exploring Go and want to use it effectively in a production setting. About the Authors Matt Farina is a software architect at Deis. Matt Butcher is a Principal Engineer in the Advanced Technology Group at Hewlett Packard Enterprise. They are both authors, speakers, and regular open source contributors. Table of Contents PART 1 - BACKGROUND AND FUNDAMENTALS Getting into Go A solid foundation Concurrency in Go PART 2 - WELL-ROUNDED APPLICATIONS Handling errors and panic Debugging and testing PART 3 - AN INTERFACE FOR YOUR APPLICATIONS HTML and email template patterns Serving and receiving assets and forms Working with web services PART 4 - TAKING YOUR APPLICATIONS TO THE CLOUD Using the cloud Communication between cloud services Reflection and code generation Review: The BEST Go Programming book and perhaps the best of any development/programming book - I've gone through quite a few books on GO lately and this may be the best I've ever read of any programming book. There is an interesting notation where examples are numerically notated - then descriptions for each of those notations - This is near identical to live training I have experienced from classroom environments. The numbers make it absolutely clear what the authors are trying to show in the code examples. The background of Golang throws out some neat elements you probably dont know about the thoughts behind Go and its makers approach(es). The examples. samples are clear and concise without being too contrived - they build on previous examples in many cases but use practical demonstration that will allow those new to repeat the style and even reuse some of the code to get going on their own projects. Sure they are 1000 line blocks or get too mired in detail - but they are useful. The book covers the necessities and doesnt skimp on concurrency. Coming to go without a background in concurrency and the GO implementation via goroutines, channels, waitgroup, etc. it helped me understand the confusing elements of how to manage channels. The notation that was useful before, becomes critical here... and it succeeds. Other diagrams are a bit blocky - but luckily they aren't critical to any real understanding - boxes within boxes honestly... not sure what that represents except perhaps container/scope ideas. Overall there is nice coverage of so many areas - you are sure to find something that applies to what you might be looking for: templates, Logging, error handling, command line interfaces, web app, JSON, file handling, etc... Like I said - maybe the best development book i've read. Review: A Very Solid Introduction after you know the Basics - After working with Java for years I needed to quickly ramp up on Go. I learn better by reading, doing, reading again so followed these books in order - 1. Go in Action (for a whirlwind tour) 2. The Go Programming Language (for deep understanding of language construct, philosophy and design intuitions) 3. Go in Practice (to rapidly gain acclimatize myself to the new ecosystem) 4. Concurrency in Go (to try to gain mastery in Go's CSP-oriented Concurrent Patterns and building blocks) 5. Building Restful Services with Go This book (# 3 above) is a superb tour of the development practices and will reaffirm the lessons learned elsewhere (books, hands-on tutorials etc). For example, it quickly shows how to "inject" configuration data into an app running on PaaS cloud; how to use BOTH syncGroup and Locks; idiomatic usage of channels etc. Like all Manning books, the depth of writing surpasses expectation with clear annotations indicating critical parts of the code. I wish the authors gave a few more examples on benchmarking (especially with highly concurrent functions) and fewer on how to reading properties /configuration. There were probably four recipes for the latter, mostly differing on subtle library patterns, that felt more than what one would typically need.
| Best Sellers Rank | #1,479,599 in Books ( See Top 100 in Books ) #251 in Web Services #1,761 in Software Development (Books) #2,070 in Internet & Telecommunications |
| Customer Reviews | 4.5 out of 5 stars 84 Reviews |
S**N
The BEST Go Programming book and perhaps the best of any development/programming book
I've gone through quite a few books on GO lately and this may be the best I've ever read of any programming book. There is an interesting notation where examples are numerically notated - then descriptions for each of those notations - This is near identical to live training I have experienced from classroom environments. The numbers make it absolutely clear what the authors are trying to show in the code examples. The background of Golang throws out some neat elements you probably dont know about the thoughts behind Go and its makers approach(es). The examples. samples are clear and concise without being too contrived - they build on previous examples in many cases but use practical demonstration that will allow those new to repeat the style and even reuse some of the code to get going on their own projects. Sure they are 1000 line blocks or get too mired in detail - but they are useful. The book covers the necessities and doesnt skimp on concurrency. Coming to go without a background in concurrency and the GO implementation via goroutines, channels, waitgroup, etc. it helped me understand the confusing elements of how to manage channels. The notation that was useful before, becomes critical here... and it succeeds. Other diagrams are a bit blocky - but luckily they aren't critical to any real understanding - boxes within boxes honestly... not sure what that represents except perhaps container/scope ideas. Overall there is nice coverage of so many areas - you are sure to find something that applies to what you might be looking for: templates, Logging, error handling, command line interfaces, web app, JSON, file handling, etc... Like I said - maybe the best development book i've read.
N**A
A Very Solid Introduction after you know the Basics
After working with Java for years I needed to quickly ramp up on Go. I learn better by reading, doing, reading again so followed these books in order - 1. Go in Action (for a whirlwind tour) 2. The Go Programming Language (for deep understanding of language construct, philosophy and design intuitions) 3. Go in Practice (to rapidly gain acclimatize myself to the new ecosystem) 4. Concurrency in Go (to try to gain mastery in Go's CSP-oriented Concurrent Patterns and building blocks) 5. Building Restful Services with Go This book (# 3 above) is a superb tour of the development practices and will reaffirm the lessons learned elsewhere (books, hands-on tutorials etc). For example, it quickly shows how to "inject" configuration data into an app running on PaaS cloud; how to use BOTH syncGroup and Locks; idiomatic usage of channels etc. Like all Manning books, the depth of writing surpasses expectation with clear annotations indicating critical parts of the code. I wish the authors gave a few more examples on benchmarking (especially with highly concurrent functions) and fewer on how to reading properties /configuration. There were probably four recipes for the latter, mostly differing on subtle library patterns, that felt more than what one would typically need.
K**R
actual lines of working code are a better starting point than anything else
actual lines of working code are a better starting point than anything else this book helped me more than any of the other golang books. if you want to download the source code instead of copying it from the book, manning supplies it by telling you to enter the code on two named pages. i thought there were no codes on the given pages but there were in a micro font, running vertically from the bottom of the page in the inseam. BEST BOOK BY FAR ON GOLANG!
N**S
Description was accurate
Book was delivered as described.
S**N
An excellent how-to book if you are ready to move beyond the basics of Go
I seldom give five-star reviews to programming books. But, clearly, a lot of effort and care have gone into writing "Go in Practice." And I really like the book's structure and its approach to helping Go newcomers move beyond the basics. After a Chapter 1 refresher on the history, advantages and key features of Go, the 11-chapter book moves into areas that include "well-rounded applications", "an interface for your applications", and "taking your applications to the cloud." In each of these three sections, the authors present useful techniques such as "Avoiding CLI boilerplate code", "Using multiple channels", "Serving subdirectories", "Incrementally saving a file", "Custom HTTP error passing", and "Using protocol buffers," among many others. Indeed, some 70 techniques are presented in Problem, Solution and Discussion format, along with useful, but not unwieldy, code examples to illustrate what happens. If you are still learning the basics of Go, this should be your next book. Stick with "Go in Action" or another starter book, for now. But if you know the basics and are now ready to get more serious about learning and applying this versatile programming language, definitely give "Go in Practice" some serious consideration. And if you already are developing with Go, it can't hurt to take a look, as well. You may pick up some new techniques. The two authors have been described as"key contributors in the Go ecosystem for years." (My thanks to Manning for sending a review copy.)
J**Y
Great Balance of Breadth, Depth, and Readability
I am an experienced software developer with very little experience in Go and wanted a book suited to someone like me. This is it! It's not a "Go Bible" type of book that bores you with language minutiae nor is it a "Cookbook" that leaves you with little foundation in the language. This book does a fabulous job taking you on a quick tour through the important parts of the language to get you productive in Go. Along the way, the author presents plenty of well-annotated Golang code which I followed along with on my computer to maximize my uptake of this information. To get the most out of this book, I recommend that you first run through at least one good Go tutorial to get a basic understanding of the language constructs. Then follow-up with this book to accelerate your learning of Go and apply it to many real-world issues covering command line apps, JSON, server-side programming, concurrency, REST, and cloud programming.
L**R
This should be your second book about Go
Immediately after an intro book like "Introducing Go", you should pick up this book. I'll simply confirmed the other positive reviews here. The text are very clear and concise. The examples illuminating and the structure logical. Worth every penny.
M**K
Bridges the gap between the excellent online resources and what you need to know in order to hit the ground running
If one were to perform a statistical analysis on the word occurrence in this book, I’m certain that the word “idiomatic” would appear right at the top of the list. This book is not about teaching you the basics of Go - you can use the already excellent online resources for that - no, once you’ve learned the syntax and structure of a Go program, you would probably like some kind of guide, or instructions, on how to attack the program writing process in a way that shows you’ve been influenced by best practices - the idiomatic approach. If you agree with me on this, then this book is probably for you. If you, like me, are learning Go while already having a background knowledge from languages such as C and JavaScript, and perhaps from the more object-oriented languages as well, you’ll learn the differences between these and Go pretty fast on your own; there is no while loop, for is more versatile, there are no exceptions etc. This book will not teach you that, it will assume that you already know this. It will, however, teach you about all the new topics such as goroutines, channels, debugging etc. but focus will be on taking your new knowledge of Go and getting you started writing actual applications, teaching you how to parse command line arguments, building a file server and a REST API, and deploying and scaling your app in the cloud among other things. Structurally, the book begins with a quick comparison between Go and other modern scripted and compiled languages, just to ascertain “what is Go, anyway, and when should you use it”, followed by the compulsory “Hello, World” example. The author then dives straight into the challenge of writing actual applications (in contrast to teaching language basics), showing you how to build a CLI application, and then covering concurrency, error handling and debugging. From there on, it gets into the meat of real application building. Each section starts with an introduction, then starts describing different techniques, which are numbered sequentially throughout. Each technique is described in a problem-solution-discussion format that generally works really well, although it feels a bit forced at times. The book is well-written, and generally a very easy read. I like the focus on learning the idiomatic ways of Go. For example, in Go, functions support multiple return values and the idiomatic way is to return the error as the last (right-most) return value. You could easily have written many Go programs in the “wrong” way before this revelation puts you on the right track - this book’s got your back. At the time of this review, I’m almost halfway through the book, and I intend to read every single chapter. This is not like one of those bibles that try to cover everything, encouraging you to skip entire chapters by force of sheer page count alone, making you roll your eyes and think “An entire chapter about private versus public class properties, really!?” At 280 pages, Go in Practice is short and to the point, bridging the gap between the excellent online resources to help you get started with the language and what you would probably have learned anyway, but through a time-consuming trial and error process. After reading this book, you can’t allow yourself to get caught in surprises like “Why didn’t anybody tell me how to properly close my channels?”. It’s a highly recommended read.
O**R
Happy I got this book
It really covers topics hard to find elsewhere. I am happy I got this book.
R**A
Muy recomendable
Este libro me gusto ya explica detalladamente y de forma entendible varias técnicas a implementar en situaciones comunes a las que nos encontraremos al programar en este gran lenguaje, el libro en físico es aceptable en calidad, las hojas y la impresión son buenas y adecuadas al precio, recomendado
M**O
Après Go en pratiquant !
Il reflète bien sa 4ème de couverture et a bien des projets guidés. Anglais nécessaire 😎
M**L
Excellent for those who want to go from learning to using Golang
Really good book. Ideal for those who learn best by doing and viewing real world examples. After working through online courses to try and grok golang conceptually, this book helped turn that knowledge into something tangible. Having an Infrastructure background and being wired a little differently from most people anyway. I found that this book explained clearly and concisely the "why" as well as the "how", which a lot of instructors, as well as online examples, neglect to cover well. I like this book a lot because of the real world application as opposed to the typical "Here's how < INSERT LANGUAGE> works with a hundred different `fmt.Println` examples". Hint, hint; "Pluralsight, CBT nuggets..etc" . I'll definitely be keeping this book close by as a reference... :)
Trustpilot
2 weeks ago
2 months ago