Customers who viewed this item also viewed
Buy New
-36%
$32.19$32.19
FREE delivery Monday, April 27 on orders shipped by Amazon over $35
Advertisement
Advertisement
Ships from: Amazon Sold by: Rockwood_Books
Used - Very Good
$16.00$16.00
$3.98 delivery Wednesday, April 29
Advertisement
Advertisement
Ships from: World of Books (previously glenthebookseller) Sold by: World of Books (previously glenthebookseller)
Sorry, there was a problem.
There was an error retrieving your Wish Lists. Please try again.Sorry, there was a problem.
List unavailable.
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the authors
OK
Go Programming Language, The (Addison-Wesley Professional Computing Series) 1st Edition
Purchase options and add-ons
The authoritative resource to writing clear and idiomatic Go to solve real-world problems
Google’s Go team member Alan A. A. Donovan and Brian Kernighan, co-author of The C Programming Language, provide hundreds of interesting and practical examples of well-written Go code to help programmers learn this flexible, and fast, language. It is designed to get you started programming with Go right away and then to progress on to more advanced topics.
- Basic components : an opening tutorial provides information and examples to get you off the ground and doing useful things as quickly as possible. This includes:
- command-line arguments
- gifs
- URLs
- web servers
- Program structure : simple examples cover the basic structural elements of a Go program without getting sidetracked by complicated algorithms or data structures.
- Data types: Go offers a variety of ways to organize data, with a spectrum of data types that at one end match the features of the hardware and at the other end provide what programmers need to conveniently represent complicated data structures.
- Composite types :
- arrays
- slices
- maps
- structs
- JSON
- test and HTML templates
- Functions : break a big job into smaller pieces that might well be written by different people separated by both time and space.
- Methods :
- declarations
- with a pointer receiver
- struct embedding
- values and expressions
- Interfaces : write functions that are more flexible and adaptable because they are not tied to the details of one particular implementation.
- Concurrent programming : Goroutines, channels, and with shared variables.
- Packages : use existing packages and create new ones.
- Automated testing : write small programs that check the code.
- Reflection features : update variables and inspect their values at run time.
- Low-level programming : step outside the usual rules to achieve the highest possible performance, interoperate with libraries written in other languages, or implement a function that cannot be expressed in pure Go.
Each chapter has exercises to test your understanding and explore extensions and alternatives. Source code is freely available for download and may be conveniently fetched, built, and installed using the go get command.
- ISBN-109780134190440
- ISBN-13978-0134190440
- Edition1st
- PublisherAddison-Wesley Professional
- Publication dateOctober 26, 2015
- LanguageEnglish
- Dimensions9.1 x 7.3 x 1 inches
- Print length400 pages
Frequently bought together

Deals on related products
Customers also bought or read
- Concurrency in Go: Tools and Techniques for Developers
Paperback$46.76$46.76FREE delivery Mon, Apr 27 - Mastering Go: Leverage Go's expertise for advanced utilities, empowering you to develop professional software
Paperback$41.90$41.90FREE delivery Apr 30 - May 1 - Network Programming with Go: Code Secure and Reliable Network Services from Scratch
Paperback$35.58$35.58FREE delivery May 3 - 8 - Programming Rust: Fast, Safe Systems Development#1 Best SellerParallel Computer Programming
Paperback$43.99$43.99FREE delivery Mon, Apr 27 - C Programming Language, 2nd Edition#1 Best SellerC Programming Language
Paperback$60.30$60.30FREE delivery Mon, Apr 27 - System Programming Essentials with Go: System calls, networking, efficiency, and security practices with practical projects in Golang
Paperback$27.36$27.36Delivery Tue, Apr 28 - Design Patterns: Elements of Reusable Object-Oriented Software#1 Best SellerObject-Oriented Design
Hardcover$33.61$33.61Delivery Mon, Apr 27 - Systems Performance (Addison-Wesley Professional Computing Series)#1 Best SellerComputer Performance Optimization
Paperback$65.95$65.95FREE delivery Mon, Apr 27 - The Pragmatic Programmer: Your Journey To Mastery, 20th Anniversary Edition (2nd Edition)#1 Best SellerSoftware Design & Engineering
Hardcover$41.64$41.64FREE delivery Mon, Apr 27 - Rust for Rustaceans: Idiomatic Programming for Experienced Developers
Paperback$29.49$29.49Delivery Mon, Apr 27 - Fluent Python: Clear, Concise, and Effective Programming
Paperback$43.99$43.99FREE delivery Mon, Apr 27 - Operating Systems: Three Easy Pieces#1 Best SellerComputer Operating Systems Theory
Paperback$28.27$28.27Delivery Tue, Apr 28 - Powerful Command-Line Applications in Go: Build Fast and Maintainable Tools
Paperback$40.05$40.05FREE delivery Mon, Apr 27 - Programming TypeScript: Making Your JavaScript Applications Scale
Paperback$29.43$29.43Delivery Apr 29 - May 1 - Domain-Driven Design: Tackling Complexity in the Heart of Software
Hardcover$57.61$57.61FREE delivery Mon, Apr 27 - The AWK Programming Language (Addison-Wesley Professional Computing Series)
Paperback$37.41$37.41FREE delivery Tue, Apr 28 - Effective Python: 125 Specific Ways to Write Better Python (Effective Software Development Series)
Paperback$52.80$52.80FREE delivery Mon, Apr 27 - Tour of C++, A (C++ In-Depth Series)#1 Best SellerC++ Programming Language
Paperback$39.99$39.99FREE delivery Mon, Apr 27 - Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series)
Paperback$36.14$36.14FREE delivery Mon, Apr 27 - AI Engineering: Building Applications with Foundation Models#1 Best SellerNatural Language Processing
Paperback$57.19$57.19FREE delivery Mon, Apr 27
From the Publisher
Why You Should Learn Go with this Authoritative Guide
Flexible
Go bears a surface similarity to C and, like C, is a tool for professional programmers, achieving maximum effect with minimum means. But it is much more than an updated version of C.
Go borrows and adapts good ideas from many other languages, while avoiding features that have led to complexity and unreliable code.
Co-author Brian Kernighan was a co-creator of several programming languages and the co-author of one of the most popular programming books of all-time The C Programming Language.
General-purpose language
Go is especially well suited for building infrastructure like networked servers, and tools and systems for programmers, but it is truly a general-purpose language and finds use in domains as diverse as graphics, mobile applications, and machine learning.
The book features hundreds of interesting and practical examples of well-written Go code that cover the whole language, its most important packages, and a wide range of applications
Efficient
Go programs typically run faster than programs written in dynamic languages and suffer far fewer crashes due to unexpected type errors.
This book is meant to help you start using Go effectively right away and to use it well, taking full advantage of Go’s language features and standard libraries to write clear, idiomatic, and efficient programs.
Editorial Reviews
About the Author
Alan A. A. Donovan is a member of Google’s Go team in New York. He holds computer science degrees from Cambridge and MIT and has been programming in industry since 1996. Since 2005, he has worked at Google on infrastructure projects and was the co-designer of its proprietary build system, Blaze. He has built many libraries and tools for static analysis of Go programs, including oracle, godoc -analysis, eg, and gorename.
Brian W. Kernighan is a professor in the Computer Science Department at Princeton University. He was a member of technical staff in the Computing Science Research Center at Bell Labs from 1969 until 2000, where he worked on languages and tools for Unix. He is the co-author of several books, including The C Programming Language, Second Edition (Prentice Hall, 1988), and The Practice of Programming (Addison-Wesley, 1999).
Product details
- ASIN : 0134190440
- Publisher : Addison-Wesley Professional
- Publication date : October 26, 2015
- Edition : 1st
- Language : English
- Print length : 400 pages
- ISBN-10 : 9780134190440
- ISBN-13 : 978-0134190440
- Item Weight : 1.48 pounds
- Dimensions : 9.1 x 7.3 x 1 inches
- Part of series : Addison-Wesley Professional Computing
- Best Sellers Rank: #96,345 in Books (See Top 100 in Books)
- #21 in Computer Programming Languages
- #106 in Programming Languages (Books)
- Customer Reviews:
About the authors

Discover more of the author’s books, see similar authors, read book recommendations and more.

Discover more of the author’s books, see similar authors, read book recommendations and more.
Related products with free delivery on eligible orders
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on AmazonCustomers say
Generated from the text of customer reviewsSelect to learn more
Top reviews from the United States
There was a problem filtering reviews. Please reload the page.
- Reviewed in the United States on August 19, 2020Format: PaperbackVerified PurchaseI 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.
- Reviewed in the United States on March 9, 2019Format: PaperbackVerified PurchaseThis book is not only one of the best books I've read on Go, but also one of the best programming books I've read in general. It is easy to understand and well edited. I thought the first chapter was really entertaining, explaining the origins of go (Plan 9, etc.), and the pacing from there is really great for my tastes. It's not overly verbose (there are a few sentences that are short but pack a punch that I re-read a few times just to make sure I understood them) and it's not trying to teach you how to program.
I am a gopher by way of .NET Core (among others), and this helped me immensely. It explains *why* golang is the way it is as well as nearly all aspects of the language. I have been programming professionally for > 15 years but I became a golang dev in a "trial by fire" manner. I took over a full-stack Angular/go project that was written by a brand new developer, so there were a ton of terrible practices / bugs and it was already in production (as it turns out, in the real world things are sometimes less than ideal!). I read the docs, did the "Tour of Go" (which is really nice, by the way) and "Go by Example" (also recommend), and hit the ground running. Go is a simple language to learn, so I was able to squash bugs and ship new features immediately; but this book really helped flesh out the gaps in my knowledge.
If you have some experience programming but are new to Go (or want to dig deeper), this is the one to get. If you are new to programming, I would approach this with some trepidation. I don't think it's completely out of the question for a brand new programmer, but you might have to do some googling along the way to help you with concepts that maybe aren't explained in detail in this book because it's assumed they are already known.
- Reviewed in the United States on July 18, 2020Format: PaperbackVerified PurchaseIf 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.
Top reviews from other countries
TomReviewed in the United Kingdom on March 8, 20215.0 out of 5 stars Very well written with lots of interesting examples
Format: PaperbackVerified PurchaseOver the past years I've read many programming books. I must admin that this one really stands out!
After completing the book you will have good understand of go language. However, note that this book will not cover all subject in depth so more advanced go programmers may not find this book very interesting.
Examples are not trivial but rather interesting ones. Apart from letting you understand go better, they also give you interesting programming challenges, which could be used in other programming languages.
I was really enjoying this book and highly recommend that book to any one who wants to start his adventure with go.
JohnReviewed in Australia on March 24, 20245.0 out of 5 stars Clear exposition of the Language
Format: PaperbackVerified PurchaseA very clearly written book with good examples explaining the language, emphasizing the simplicity and utility of the language. Only thing would have liked is a second edition with Generics added !
-
Alexandre EstanislauReviewed in Brazil on September 13, 20205.0 out of 5 stars Excelente
Format: KindleVerified PurchaseExcelente livro, traz explicacões claras sobre a linguagem. Não conhecia Go e tive de aprender para uso profissional, ajudou muito na curva de aprendizado.
VKReviewed in Canada on December 31, 20255.0 out of 5 stars Good introduction!
Format: PaperbackVerified PurchaseGood starting point! Recommend if you are starting with the language!
-
MatReviewed in France on October 10, 20255.0 out of 5 stars Référence pour le Go
Format: PaperbackVerified PurchaseJ'adore ce livre de Go, il est très bien, je l'ai feuilleté pas en entier, mais il est très bien, il y a beaucoup d'exemples, le livre est joli et assez conséquent, c'est un bon achat si vous voulez apprendre le Go, c'est un peu la référence.



















![Computer Networking Bible: [3 in 1] The Complete Crash Course to Effectively Design, Implement and Manage Networks. Including Sections on Security, Performance and Scalability](https://m.media-amazon.com/images/I/41H4YJnxKgL._AC_SR100,100_QL65_.jpg)

