Go Programming Language, The (Addison-Wesley Professional Computing Series)
Original price was: $49,99.$19,95Current price is: $19,95.
- 100% Satisfaction Guaranteed!
- Immediate Digital Delivery
- Download Risk-Free
✔️ File: PDF 6 MB • Pages: 400
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.
37 reviews for Go Programming Language, The (Addison-Wesley Professional Computing Series)
You must be logged in to post a review.
Related products
-
Discrete Mathematics and Its Applications
Original price was: $200,00.$19,99Current price is: $19,99. -
Proofs from THE BOOK
Original price was: $59,99.$16,99Current price is: $16,99. -
Build a Mathematical Mind – Even If You Think You Can’t Have One: Become a Pattern Detective. Boost Your Critical and Logical Thinking Skills. (Advanced Thinking Skills)
Original price was: $42,00.$14,99Current price is: $14,99.
Dennis Coyle –
I had high expectations coming into this book, given that the author was Kernighan. After finishing the book, I can easily say that my expectations were too low. This book blew me away. The detailed explanations of not only the Go language but general computer science topics were a delight to read. In my experience, a lot of computer science books get too bogged down in low level details and forget to come up for air and give the reader practical use cases. This book is full of great examples of idiomatic Go that have real world applications, a wonderful mix of cookbook style examples and introductory explanations. The Go Programming Language might have ruined me because it will now be the book I compare all future computer science books with and it will be a tall task to measure up. I actually went through the book twice. On the first pass I read for comprehension. On the second pass, I typed out all of the examples and made sure I fully understood the subtleties that I missed by just reading them. I can easily say this is the only Go book you will need to become proficient in the language (well the book and a lot of practice).
A –
This is a pretty good book about the Go programming language. However, Go is so extensive that it will take a substantially larger book to cover most or all of it with adequate examples. Warning: Do NOT buy the “Phrasebook” by Chisnall (also from Addison-Wesley).
Chris Townsend –
Yah, hrm. Yoo bad it tyumpossible to ygoog golangu.
john kennedy –
Great book, great authors. Easy to read, has the fundamentals.
Robert F. –
A bit of discontinuity here and there
Robert Solomon –
Not an introductory book, which is what I was expecting. Other books here are better introductions. I’ve already described them as Go as a second language. This book is not that. It’s clear, but too advanced for me.
Inky Digits –
This is the best book (out of 5) that I have read on Go. It’s rare to find something in the computer science world that is as accessible and yet as accurate as this work. The examples are excellent and the explanations and instructions clear. Like the language itself it emphasizes clarity and simplicity and abstracts away the right parts, allowing for both accurate understanding and the avoidance of unnecessary complexity.
It also provides the most solid grounding for getting more deeply involved in the more complex areas of the language, which it introduces on a gradient, without getting too thoroughly involved in them.
I have a feeling that It would work reasonably well as a beginner’s book, although you might want to make it the second book (or a follow up to the many free tutorials on-line) if you’re brand new to programming. It could easily be a first Go book if you’ve produced even trivial programs in any other language. I highly recommend it to anyone who is not yet fully comfortable reading the language spec and standard library source code. And even if you are happy doing so, you’re not going to be doing yourself any harm by reading this work.
Bruce R. Baker –
An excellent book for someone who has had previous programming experience, particularly with C language.
SEGFAULT –
I really liked this book and I learned quite a bit. That being said, I bought another book that was about the same price that had quite a bit more information. I wouldn’t recommend this book to someone because I think it is too short for the price but it does have a lot of good information. If you are looking for a quick primer on Go then this book will work quite well for you. I was looking more for a manual and I should have read the description a little more carefully. The book doesn’t really go into that much depth on Web Development and that is what I’m most interested in. It has a couple of short sections but that is it. There are some really good examples of Concurrency and channels. If you’re interested in that sort of thing then this book will teach you quite a bit.
G.S. Fordham –
Very good book to get me ready to use Golang.
But not just that: it also helps get people into better coding habits.
Golang is a language based on best practices, and I feel I not only learned a new language this past Summer, but I also learned more about being a good programmer in general.
I would definitely consider using this language in bigger projects in the future, and I have already adopted several practices they listed across other languages I use.
The only things I am not a fan of with this language are the ways it implements public vs private data members and interfaces. I feel the variable name casing should not determine public or private members, because it is less explicit. I also did try a few things out, after reading, and I came across some nasty bugs that were not the easiest to track, due to the implicit interface implementation — things would go from implementing part of my interface and not another to getting changed and implementing them in reverse, even with only the parts in question being changed; I would much rather say “implements x, y, z”, and the compiler would know EXACTLY what I’m trying to do.
MBC –
not bad
L. Hall –
Not a book for the impatient; but if you’re a novice, this is the book to trust to take you through from beginner to competence and well on your way to proficiency. I’ve been a professional C/UNIX developer since the mid-80’s and Java and Python for the past 20 years. Don’t get me wrong: Go is not a difficult language to learn; but I thought I could pick it up in a few hours. There are serious ground-shattering differences between Go and everything else. Although it borrows liberally from C, Java, and Python – it really is a different approach because the language authors aren’t afraid to address the shortcomings made in those and other languages for the sake of conforming with the ideas long held to be “norms”.
Case in point: Go builds statically-bound executables. No more runtime dependency woes from mis-matched DLL / .so versions.
Another example: a radically different approach to polymorphism and encapsulation leading to an easier and cleaner object model than any other.
The more I learn about Go, the more I am convinced that it will eventually overtake C/C++ as the defacto standard for system level development – and may even challenge Java and the dynamic languages for business-critical applications.
Michael Barnes –
Great book. I’ve read the K&R C book, and this book is better. Goes into the history and rationale behind the language. The book is very well written and I didn’t notice any errors, and the book covers the core types and aspects of the language with examples and exercises.
4 stars because I wish it covered more on the ecosystem and the builtin tools. For example, there was no mention of go vet in this book.
Go is a great language and platform for systems development. About as fast as C, but without all of the manual and laborious nuances that C and C++ have.
Chris –
This is an awesome book for learning the Go language. It covers all the major areas of the language and has a lot of good example code to learn from. At first I was not a fan of how they would go from using full listings to just snippets. But, I started get used to it when I realized that this was helping me to think more about how to actually build a Go package.
My only complaint that I have for the book is that there are sections that feel a little glazed over to me. Topics are just briefly touched on and then they move on. However, this not impede the reader in learning the major portions and important features of the language.
Kent R. Spillner –
Personally, I haven’t quite made up my mind about the Go language itself just yet, but this book is undeniably fantastic! Every programming language needs an introductory book like this: clear and concise, thorough coverage of the entire language without being dense or boring, and puts as much effort into teaching good taste & style as learning the language itself. (Obviously, we’d expect nothing less from anything bearing Brian Kernighan’s name on the cover)
I especially appreciated the way this book was organized: the very first chapter starts with several illustrative examples before even introducing the language itself. Then the next several chapters cover all of the basic & advanced features of the language. The final few chapters cover some of the other concerns of modern professional programmers beyond just the language itself: the build environment, packaging, testing, etc.
If you want to learn the Go programming language, or if you already know how to program in Go but want to improve your understanding of the language, then this is the first & only book you’ll need.
Sush –
The book goes informs the reader on the actual choice on why GOlang is structured as it is. I really like that there are Asides which also show you the typical gotcha mistakes that even the most experienced Go programmers make.
It’s a bit dry at times, compared to say “Thinking in C++”. Great to get to know the language and usage in depth.. perhaps after your intro to Go course.
Dean D. –
This 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.
VK –
Intermediate level of difficulty, it will be difficult to read if you are a novice. For example “for” loops are discussed in the intro section of the book, so basically you should be already familiar with that concept. And that makes it difficult to find some basic things in the beginning of your learning process. Honestly, I would expect a little bit more from the authors of the language.
Zeyuan Hu –
The book content itself is fine but I find the one I got is the 3rd printing. There are many typos fixed in the 4th printing but unfortunately, I didn’t get one in my purchase.
Steve Belczyk –
Great exposition of a difficult topic (at least for me, coming from a C and Fortran background).
The writing is dense. That is to say, there is a lot of important information packed into each sentence.
Nice sample code, although I do wish there was more.
Not much about how to acquire your own Go development environment; you’re pretty much on your own there.
Excellent advice on programming style.
Finally, the assumption is you have Internet access all the time. For me personally, Internet access is unreliable but hey, that’s my own problem, not the author’s. 🙂
For me, the whole object-oriented paradigm is new and still a bit baffling.
Sean/Dad –
You’re on a tour of a museum. You’ll be going thru 13 rooms after the lobby, each full of content.
In room 1, your guide spends his time describing content from rooms 2-13.
That is Chapter 1 in this book.
So if you don’t already know GO, Chapter 1 half-reads as “blah, blah, blah”.
I will use this as the CONCLUSION.
Better yet, I will read this book AFTER I learn the language with another book I have, that is NOT doing this to its readers.
Code Monkey –
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.
Gelberm –
Al principio dudé por ser una edición con varios años de publicación, pero en verdad el libro logra explicar los fundamentos del lenguaje, brindando una sólida base para conocer y aprender sobre las últimas características. Ordenado y bien explicado, considero que es un buen material de aprendizaje.
Chanh D Pham –
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.
StrangerPearl –
This book starts out right away with the standard Hello, World (unlike what others have reported???) and quickly moves on to much more interesting and useful tutorial samples. There are, in fact, many interesting tutorials with plenty of good code samples, along with exercises to test your understanding of the material. The authors do a nice job of building up knowledge of the language. Much more importantly, they teach the idioms of the language so that one learns to write Go, rather than writing C in Go or Java in Go or some other unfortunate monstrosity.
As other reviewers have noted, however, this comes at the cost of really requiring that you read the whole book through to get the most out of it. It is not a quick reference book, nor a book of “recipes” or “design patterns”. It is a much slimmer volume than some of the other, similar Addison-Wesley imprints, though there is no wasted space. Think of it like the original K&R C book (featuring one of the same authors, of course!). It is a solid introduction to the language that can take any serious programmer/software engineer/developer very far on its own merits. It includes enough technical information about design decisions, the compiler, practical trade-offs, &c to help inform the Why without ever getting bogged down in unnecessary detail.
Although the book is well worth the price, especially as a textbook, I would have liked more discussion on the exercises or perhaps some online canonical references to, “This is what our solution would look like”. That said, all the source code is available online and serves as good quality, idiomatic Go. Of course, the code samples are best served within the context they are supplied in the book; don’t expect the ch10/cross/main.go to be an easy drop in for any project you need!
If you want to learn Go and write quality software therein, buy this book, read it, and keep it for reference and reminders. You will probably want other books to tell you how to do some particular thing, or search online for particular algorithms or libraries, but this book will help you separate good, maintainable, idiomatic Go from all the cruft.
Dan Ponte –
I consider myself an intermediate Go programmer, using it on and off for several years until diving in to writing it full-time a few months ago. I bought this book almost immediately upon learning that it existed, namely because Brian Kernighan had co-written. So, mostly for the fanboy value. However, within minutes of skimming and skipping around, I had several “a-ha!” moments. This book, much like Kernighan’s (and Dennis Ritchie’s) The C Programming Language before it, carefully and thoroughly presents not only the how, but the why of Go’s semantics and syntax. You’ll definitely get more rationale for design decisions in this than any other treatment of the topic, and Go’s sometimes idiosyncratic nature definitely benefits from it. You will come to appreciate this awesome language even more.
I am not even done with this book, but I fully expect it to make me an even better Go programmer. Highly recommended.
Pedram T’Kanchi –
This is the one book to rule them all when it comes to learning Go. It gives a clear introduction to the fundamentals of the language which give you a strong foundation in tackling a variety of different problems. The exercises at the end of each section are well thought out and an additional vehicle for learning what was taught. It’s simply not enough to just read, the craft must be practiced.
A lot of the negative reviews here have misguided expectations of the purpose of this book. This is not a beginner friendly programming book. No where does this book claim to be for beginners. This book is for programmers who have developed competency in another language and want to learn Go. If you’re unfamiliar with the basics of programming you will be lost reading this book.
Laurence Cable –
A quality Golang book, as you would expect form both the authors and the publishers.
However with the advent of Golang 1.18 and Generics the book seriously requires urgent revision to include this important addition not too mention the module support added in 1.11 & 1.12 …
This preeminent book really needs to track the evolution of the language faster ….
Darny Blehow –
The book is well written.
“The book does not assume prior knowledge of Go nor experience with any specific language, so you’ll find it accessible whether you’re most comfortable with JavaScript, Ruber, Python, Java, or C++.” Some buyers misread this sentence. You don’t need to know any specific language, but you need to be comfortable with at least one language.
Ignore the reviews with irrelevant or false statements. There is no assembly in Chapter 3. And don’t worry about what one reads on StackOverflow or Reddit. It’s simple: Learn because you want to learn.
Luc –
Highly recommended for anyone looking to learn GO. I’m a seasoned developer, and this book took all the “scary” out of learning GO from scratch. At the end of each chapter, there are little challenges to extend the code examples used in the chapter with additional functionality. The challenges are just tricky enough to cause you to flex your dev brain and really flex your coding muscles. I’m not fully done with the book yet, but it’s organized quite well and all examples are very relevant to today’s real world scenarios.
Michael D. Messmore –
Like any other book that I’ve read that Brian Kernighan has written or been involved in, this is amazing. The writing is incredible and the value is greater than just covering the topic. Inevitably I walk out of the experience really understanding larger concepts than just the particular technology itself.
Even when it becomes outdated, I’d recommend it just to “get” the language beyond keywords and syntax.
hol –
Well written and straight to the point. This book, together with the tour of go (on go.dev) are all one need to get started/migrate to go.
I wish we have more books like this one for other programming languages, this book is simple and very professional.
Joseph S. –
I had another book, which did not do it for me. Bought this book. It is great! A good reference book, and covers much more than the first book.
Kevin Hernández –
Nice presentation, good way to be learning go.
Jerry Yan –
This book is probably the best programming language book that I’ve read in the last 5-8 years. The content was very thoroughly thought, well written and professional. For anyone who is interested in learning GoLang, this is the only book you need to start.
I wish more books like this one can be published in the future.
Carlos A. Zepeda S. –
Excellent
Ishmael –
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.