Go in Practice: Includes 70 Techniques

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.

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.

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!

Book was delivered as described.

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.)

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.

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.

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.

It really covers topics hard to find elsewhere. I am happy I got this book.

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

Il reflète bien sa 4ème de couverture et a bien des projets guidés. Anglais nécessaire 😎

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... :)