Rating:
(14 reviews)
Author: Mark Summerfield
ISBN : 0321774639
New from $27.33
Format: PDF, EPUB
Download electronic versions of selected books Free Programming in Go: Creating Applications for the 21st Century for everyone book with Mediafire Link Download Link
Your Hands-On Guide to Go, the Revolutionary New Language Designed for Concurrency, Multicore Hardware, and Programmer Convenience
Today’s most exciting new programming language, Go, is designed from the ground up to help you easily leverage all the power of today’s multicore hardware. With this guide, pioneering Go programmer Mark Summerfield shows how to write code that takes full advantage of Go’s breakthrough features and idioms.
Both a tutorial and a language reference, Programming in Go brings together all the knowledge you need to evaluate Go, think in Go, and write high-performance software with Go. Summerfield presents multiple idiom comparisons showing exactly how Go improves upon older languages, calling special attention to Go’s key innovations. Along the way, he explains everything from the absolute basics through Go’s lock-free channel-based concurrency and its flexible and unusual duck-typing type-safe approach to object-orientation.
Throughout, Summerfield’s approach is thoroughly practical. Each chapter offers multiple live code examples designed to encourage experimentation and help you quickly develop mastery. Wherever possible, complete programs and packages are presented to provide realistic use cases, as well as exercises. Coverage includes
- Quickly getting and installing Go, and building and running Go programs
- Exploring Go’s syntax, features, and extensive standard library
- Programming Boolean values, expressions, and numeric types
- Creating, comparing, indexing, slicing, and formatting strings
- Understanding Go’s highly efficient built-in collection types: slices and maps
- Using Go as a procedural programming language
- Discovering Go’s unusual and flexible approach to object orientation
- Mastering Go’s unique, simple, and natural approach to fine-grained concurrency
- Reading and writing binary, text, JSON, and XML files
- Importing and using standard library packages, custom packages, and third-party packages
- Creating, documenting, unit testing, and benchmarking custom packages
Books with free ebook downloads available Free Programming in Go: Creating Applications for the 21st Century
- Series: Developer's Library
- Paperback: 496 pages
- Publisher: Addison-Wesley Professional; 1 edition (May 14, 2012)
- Language: English
- ISBN-10: 0321774639
- ISBN-13: 978-0321774637
- Product Dimensions: 1.2 x 7 x 8.7 inches
- Shipping Weight: 1.7 pounds (View shipping rates and policies)
Free Programming in Go: Creating Applications for the 21st Century
This is a resoundingly thorough walkthrough of the Go language and all of its features and idioms. Despite being a ground up introduction, the book appears to be written with the assumption of the reader having some basic programming experience; so while it begins with the usual foundational explanations of types and syntax, the wording is refreshingly precise, dense and informative and continues this way going forward. Most who don't have a need to be talked down to but still would appreciate clear writing and a thorough detailing of the language from the bottom up would find this book is really well-suited.
While the book assumes familiarity with programming in general it is not at all withholding of examples or clarification, and indeed it errs on the side of caution in presenting multiple demonstrations of ideas before moving on to the next hurdle. Examples abound throughout, in fact nearly all chapters tend to have a long block of demonstrations at their end. To some degree my attention started to wander sometimes during these parts. At times their length became a little exhausting as even when I had felt I'd already gotten the idea I tended to pore through the examples under the logic that if it was necessary to include them they must be hiding some subtle nuances I hadn't picked up on earlier, but for the most part that wasn't so. The example sections are simply available to reinforce and clarify ideas for anyone who didn't get them in the first pass. There seemed to be a glut of them but it's unreasonable to fault the author for being thorough and in places I did find them helpful, however the examples are supplemental, and in retrospect it's okay to move ahead if you feel you've understood a chapter by the time you've reached them.
I've read two other Go books besides this one. The first I just skimmed because it was too low level. The second I read cover to cover. They were both thoroughly mediocre. Here are a few of the reasons why this book is so much better.
1) High quality code samples. It must be said: Mark Summerfield is a REALLY good programmer. All of the code in this book gives the impression of being well thought out. The other books had a lot of "cargo cult programming", meaning the authors were going through the motions without thinking about what they were doing. For example, Go has a ridiculous number of ways to do error handling (fmt.Printf, fmt.Fprintf(os.Stderr), fmt.Errorf, errors.New, panic/recover, log.Fatal, log.Fatalf, log.Fatalln, ...). It's really easy to pick one of these methods and use it everywhere. There are subtle but important differences that I didn't understand until I saw how Summerfield was using them.
Also, when I would go through the exercises in the other books, I would find I could produce a smaller, cleaner solution than the book's solution maybe 1/4 of the time. That should never happen when you're a n00b like me. Indeed, it never did happen with Summerfield's code. Sometimes I would spend a lot of time on a problem and work up a solution I was proud of only to check out the author's solution and see that he had done it 10-100% better.
2) Idiomatic Go code. This language is so new it barely has any idioms (that I know of, anyway). If you're looking for patterns to imitate, this book is a good place to start.
3) Details that aren't in the docs. The official docs at golang.org are, well... better than a lot of languages, but in no way adequate. The official docs are extremely terse and missing examples, leaving me frequently mystified.