Go Programming Language, The (Addison-Wesley Professional Computing Series)

This is a very thorough introduction to Go. The author's code examples are available on Github which spares you the trouble of retyping them. It' s probably best for someone with some programming experience as in the interests of brevity some low-level features and common programming shortcuts are demonstrated but not explained. However Go is much-better documented than other languages I've used so there's ample resources on the web to help you out with the small details. As a small aside, it's actually nice to have a book that announces what you're up to if you work in co-working spaces or cafes. Sometimes another engineer will see the book cover and let you know that they're available to answer your questions. Well, this happened to me once anyway.

I like GO because It implements cleanly such modern features as abstract data type, data encapsulation, object composition, interface, package, CSP model (Tony Hoare) concurrent programing, multi-value-return function, deferred function calls, garbage collection, exporting names by capitalization, simple but effective exception handling and memory model. It is a static type language. Higher abstract data types such as map (hash table), string, array and slice are built in to simplify memory management. Its syntax is succinct (only 25 keywords). Yet using it correctly can lead to powerful program constructs. Little redundancies are built into the language. As such, there are not many alternate ways to do one thing which leads to codes that are easy to understand and maintain. The designers deliberately choose to implement features to support object composition instead of inheritance, to handle exception where it happens instead of the throw and catch clauses, to use simple "struct literals" to initialize abstract data type instead of constructor functions, and "type" expression to help users consistently define user types, interface (abstract) type as a standard protocols to call different concrete-objects methods (the correct way to implement polymorphism). It does not have default arithmetic type conversion, and function name overloading, which together with class inheritance (function overwrite), constructor functions, throw-and-catch exception handling are the sources of needlessly programing complexity. Importantly, both procedure (functions and data structures) and object-oriented (objects and methods) methodologies can be used. There are just enough features that help make GO a pleasant language to write. All features are careful designed to work well together which facilitate a program model that is quite powerful, but simple to learn, reason, write, and support.The book is well written by a GO expert programmer and a computer pioneer and noted author of programing books. Concepts are coherently and timely presented. Examples are usually not code fragments, but complete programs which can be compiled and run. Programs of complex concepts are presented in multiple versions from simpler to more elaborated ones. Like the efficient design of GO, the book is never overwritten. It is the most enjoyable programing book I have read in a long while.

If you want to learn the Go programming language using a printed book, you can't really go wrong with this one. People (of a certain age!) who grew up with K&R being a gold standard for language documentation, will certainly recognize the same qualities in this text. Other than an overly long introductory chapter, it is brief, to the point, and accurate. It uses realistic, and complete, examples to illustrate the design philosophy behind the language. All the code is easily downloadable using standard Go tools, so it is easy to try things out as you learn.It is probably worth noting that the book is very slightly dated (mine is a 2015 first printing; I only needed to learn Go for real a full five years after I purchased it!). Go has obviously evolved since the publication of the book. Most notably it now has a real module system. Many small tweaks have also been made to the language and platform. For example, error wrapping, and allowing for the embedding of interfaces with overlapping methods. Obviously, these are not in the book, but for a working programmer I believe it still remains a complete introduction to the language. Understanding the new changes in the context of the information in the book actually gave me a much better appreciation for how the language designers (and community) think about programming in Go.