Every programming language has one book that become the de-facto book. C has K&R and other programming languages has their own. This book is for Go what is K&R for C. If you ever want to buy a Go programming language book, this book should be the one. I have been programming in Go from almost an year and I also find some new tricks from the book. Also I use this book as a reference when I need to brush up some concept.
Great book, a must read for anyone seriously looking into picking up Go for a future project, the language seems simple but the nuances of it are very important and the book dives into it and provide a great guidance and gotchas here and there that are just priceless.
I can try to understand that abstraction, hut isn't this book for Go starters? It's like trying to read anything from Google (with their xomplexities they anyway lose the whole picture due to lost brain RAM, like with Tensor Flow they had marketed failure on finnancial markets) or Iris (Go web farmework) "examples". shouldn't examples supposed to work?
Wtf is make, map, string, int in this nonsense bucnh of code. OK, I can exytrapolate that from Python, but still not good.
Well, seems it's much easier to just go to documntation of 1) basics, like data types, functions and2) bufio than to read such examples that hell knows where can be applied or for what the're hell they needed at this points. Should we'll be building search engine?
Animated GIFs on opage 30. WTF I need this shit? I remember when I had started Python I was starting from
a = 2 b = 2 c = a + b print c # 4
Easy and immediately all concepts grasped.
Dropped,. too long for what can be learned much faster. I just ran simple hello world web server without the help of this book. Will go for online docs.
I am amazed by the fact that most people, simply by checking the authors name, go for the five stars, indipendently of the goodness of the content. Being a great engineer does not mean being great at teaching and/or explaining.
Just like the good old K&R C book, the book covers the basics of the language, but in a very formal, strict way, which makes it hard for a beginner to get the most out of it. The examples are good and evolved through the text.
A good book. Not a great book. Definitely NOT the very FIRST book you want to get your hands on to taste Go.
It's a great introduction to Go, and despite the age of the book, the language hasn't changed that much since then.
However, it finds some ways to waste your time. The examples are a tad bit too contrived (too much graphics, especially if you haven't done any), and the doing the exercises is a actually a bad idea, because they ask you to implement too many things that are awkward to implement without reading the rest of the book first.
When I started, I made the mistake of doing the exercises, and I eventually stopped reading. I picked it up a few years later, tried doing the exercises again, but gave up and decided to just finish the book. I don't plan going back to them, because some are just a poor investment of time if you want to optimize learning Go, rather than fiddling with stuff (e.g. one of them is "write a command like interface to the GitHub API that does a bunch of things", which, no, thank you, that's 50% of the time spent on figuring out GitHub, 30% fiddling with CLI and 20% actually learning Go).
Really nice book about golang. I've read more than a few books about programming languages, and found this one to be one of the best. It's super well structured, has a good level of detail, has tons and tons of code examples (all working examples and downloadable at http://www.gopl.io/), and has interesting exercises at the end of each subchapter. Reading this book is definitely not enough to be a go expert, but I think it's a great intro to the language.
I knew I had to get this book. I have already consumed a lot of other books on Go inclusing teh very valuable books of Jan Newmarch and Ivo Balbaert.
This book is different. It contains many more examples, and the advice in this book is extremely valuable and based on extensive experience. For instance, this work is one of the first that extensively documents locks and mutexes and how and when certain concurrency 'patterns' or styles are useful in the concurrent programming space.
I would argue that this slim (<400) and yet fat book is the fattest out there and is accessible to both college students and experienced programmers.
This entire review has been hidden because of spoilers.
Truly old school programming book (in terms of composition) - leads you through all the necessary topics in a natural order. Pace is very good, space granted for each topic is very carefully tuned - you're flying through easy stuff instantly, but if something needs more consideration, it's given substantially more elaboration & samples. What I like a lot was tuning the teaching style to language specifics - there's a lot of attention put into describing idioms, conventions & ecosystems -> these topics are crucial to Golang & it's very good that there's a strong emphasis on them. Some nice tricks ("typical patterns") included, e.g.: what to use empty interfaces for, how to implement monitors on channels, etc.
Code samples are top notch - clear, goal-oriented, readable & concise. Zero complaints here.
Last two chapters (as it has been stated in the book) are a bit hardcore & quite likely you won't need them much, so feel free to skip during the 1st read. Book doesn't cover any description of Go's standard library - it ain't much of a problem as this information is easily reachable on the web & lib is so vast, that creating such a description would take a complete book.
Book is reasonably up-to-date, but unfortunately it seems that publishing editor is not updating an e-book version after subsequent language version releases (which is a standard practice in PragProg, for instance).
Anyway - it's a good book to learn idiomatic Golang. It's long, it's not a blitz-read, but definitely worth your money.
One of the authors is Kernighan (yes, that one), so it's as easy to read and as useful as your well-thumbed C book. It was longer, though, with more to cover. Still, I was able to write a substantial Go library after reading it. I'm going to get a paper copy to keep next to the C bible.
Great, fairly comprehensive intro to golang. Covers syntax and philosophy of writing in the style of golang. Not for beginners, good amount of concurrent code (although to be fair, concurrency in golang is a lot safer and easier to understand than most other languages.)
After reading this book you could write small, idiomatic Go programs. My only real complaint: the book introduces go's unique interface/typing system, but doesn't really leave the reader with a great idea on how to effectively use them in a maintainable way in large-scale codebases.
The book gives good overview of the programing language. It contains a lot of exercises after every chapter that teaches you about the concept. The book gives good insight why certain things are made by designers of the language. As prerequisite before you start reading this book is good to have basic knowledge about C or C++, because low level concepts as pointers and memory management are not well explained. After reading this book the reader can start developing programs in Go with ease.
This book is like a bible for Golang. It covers all topics for the language from A to Z. One of the interesting things is exercise section which helps to test your knowledge and skills! I would have it on the shelf.
Amazing introduction to a programming language. One needs to know how to code in other languages, and in that case, the first chapter just gives you a taste of what it's like to code in Go. The following chapters explain more about various language specifics. And you are ready to go (ha!). The book is also a good reference, I've been using it a lot for advice on testing and concurrency. The only reason that I did not finish it earlier was that I was left with the last chapters on reflection and low-level programming that I didn't need at work, and so I couldn't find time to read them. The coding exercises (though I did only a fraction of them), especially from the first chapter, are a delight to code. Great book!
A very decent book on the Go language. Succinct, with enough code examples. I'm not sure it's a good fit for people with no programming experience though. Also hope it will get an update with coverage of "Generics".
This is about as good as technical books get; A comprehensive introduction to Go, that packs a lot of detail and multiple examples into its relatively short length. This is also a very good reference source for when you're firming up details after the fact.
A nice introduction to the Go programming language. Go is not a difficult language to learn but has some unique features which may take a while to get used to. This book does a great job explaining those things and has some very good example programs that I use as models for my own programs.
The only problem is this book feels wordy at places. And working through some of the examples feel like a slog. Some chapters like the one on Go tool could have been omitted altogether.
An excelent book about the Go programming language, covers most of the important topics with plenty of examples and exercises for the neophite Go programmer, a must-read book for those who want to program in Go using best practices and a lot of low level knowledge.
Even though Go is not one of my favorite languages, this book is really well written and contains tons of examples and exercises. Every programming book should be like it, with plenty of material for you to get your hands dirty practcing. If you need or want to learn Go, I can't recommend this book enough! It is also a good reference book to remember some details.
My attitude towards Go in the past has been one of superior contempt. After all, I had visited the higher planes of programming, where one can see macros and monads in their full brilliance, and thus relegated Go to the unwashed masses. On the few occasions I had used it--alas, professional programmers are merely mercenaries--it was surprisingly easy to write. Almost enjoyable. But no, I had seen the pure snows on the peaks of the Olympian mountains of abstraction. Once you breathe the rarefied air of higher abstraction you can't wallow in the mud that is programming in lesser languages. So I continued to look down on Go and its users.
I have crossed paths with this book a number of times. I leafed through it, I even read the introduction, but I never picked it up properly. This changed because, of all things, a book on Zen Buddhism. You see, the book explained, us westerners are prone to dual thinking (thanks a bunch Plato and Aristotle). We like to think of things in clear cut categories (heh): black-white, good-bad, superior-inferior. Gradually, as I made my way through that book, I realised more and more that I'd been a victim of this dual way thinking myself! And what better way to step out of it than trying a language I had labeled as "bad", "inferior" and a bunch of other hasty cargo culted generalisations? So I ordered "The Go Programming Language" (GoPL).
Let me say it upfront: GoPL is a *good* technical book. This is how a book introducing a programming language should be written. It treats the reader as an adult (even more so, as an engineer!). Go is rooted in the Unix world, and the authors want you to know that, God dammit. It doesn't use cutesy examples with meme names for variables. The examples are very much the seeds of applications you would use in the real world (also known as "tools" in Unix parlance). The nature of the Buddha is continuous.
You can see this is a "Kernighan"--if we can use painters' names as nouns, we can use authors' names as nouns! The book's structure and exposition style echo those of "The C Programming Language" and "Software Tools (in Pascal)". The authors don't shy away from using programs they've written in earlier chapters to illustrate the behaviour of later programs. They even *gasp* compose them in shell pipelines. You see, the truth is GoPL also moonlights as a Unix philosophy book. And it does a great job at it. If you're so inclined, you'll learn more from this book than all the "do one thing and do it well" blog posts out there.
The examples are engaging. The first chapter is a whirlwind tour of Go and its standard library. And it's a very convincing one. It even has pictures of pretty 3d graphs. In the browser! Oh boy, tell me more about this Go thing you're talking about. The rest of the chapters treat one topic at a time. Most of the times in depth. The final chapter, the one on unsafe programming, is a glimpse of the dark world of juggling with chainsaws. And an admonishment to not do so lightly. The authors even have the audacity to lightly bash C. You can't run from your past Mr. Kernighan!
And I can't be sure, but I think the authors were reading my mind, because whenever I had a question, the answer was close by--in the next paragraph or the next page. Seriously, it's a well organised book.
One thing I appreciate is that the authors are honest when they take shortcuts (lack of error checking, brittle practices) in order to save space. If only all programmers would be this honest.
But this review is getting long, and a mercenary's day is busy. Glue code doesn't write itself. So, should you read this book? The answer depends on what you're looking for.
Do you want to learn Go? What are you waiting for? Go for it!
Do you want to write an introductory book for you own language or favourite language? Steal this book!
Do you find Go uninteresting, but you're one of those weirdos who reads technical books just because? Give it a go. You might even change you opinion about the language by the end of it.
Do you want to dine with the gods from the ambrosia of pure abstraction? I'm afraid you're out of luck. But hey, at least you'll get a taste of what passes as programming amongst us, the unwashed masses.
Dozens of programming books, years of reading them, most of them helpful but of mediocre quality. This is a great example of what a high quality programming book is like. Unlike a lot of books--some of which are written by undergrads!--this book is written by very experienced programmers. Kernighan? He was involved with creating UNIX and C. Every page of this book, you can tell a lot of work went into refining it. A lot of it is example-driven, which I love. The examples were impressive. They managed to find practical or fascinating examples that fit neatly into a book format. For example, in one, they generate image files of fractals. In another, they create a web server.
Go is a new programming language, fostered by Google. It's designed to be radically simple. It's like they took C, notoriously one of the smallest, simplest languages ever created, and REMOVED things. For example, there are no while loops, and no preprocessor. It does add some modern features that most programmers are now accustomed to, but surprisingly few. For example, there's no templates or exception handling. I was pretty skeptical, but this book won me over. I'm not sure if it will become my language of choice, but it's definitely a contender. It showed me that a language doesn't need to be insanely convoluted and complex (ahem, C++, ahem) to be fully-functional and modern.
This book has very few weaknesses. A couple that I'll point out. The first, maybe more a feature than a bug, is that it's wide in breadth but short in depth. You will get a wonderful tour of every feature of the language, but you won't learn enough from this book to use them very well. You'll have to read the online documentation for more details. Another weakness I found is the last two chapters: reflection and low-level programming. They seemed rushed compared to the rest of the book. They kept apologizing for how cursory their treatment of these topics were, as if they knew they were disappointed with their treatment of these topics. Finally, I'd have liked to see more details about error handling, which is one of my biggest sticking points with the language.
But I'm giving this book five stars because it earned it. I only rate books with 5-stars that are so persuasive and so well done that they win me over, and change my understanding of something, which is exactly what this book did. It's not perfect, nor is any book, but this book really is as good as it gets.
For those who don't know, the author of this book, Brian Kernighan, wrote the infamous "The C Programming Language" book (https://en.wikipedia.org/wiki/The_C_P...) back in 1978. Since then, he has gained a reputation for being quite an amazing technical writer, and The Go Programming Language is his latest showcase of that.
I quite enjoyed this book. Rarely do I say "I couldn't put it down!" when describing a dense book of this nature, however Brian's deep technical understanding, succinct style, and overall tone give a wonderful introduction to the Go Programming language, in addition to general teaching around computing. He really has a deep, deep understanding of the language and it all comes across in this book.
For example, I (re)learned concepts around Unicode, including its history, how the authors of UTF-8 went on to become the authors of golang, and as such made their popular encoding pattern first class in the language ("runes").
Or, how computers store memory as 'words', how those operations are stored locally as cache in the CPU, and how it's important to understand when that cache is flushed to memory to write robust concurrent programs.
Overall, I feel quite prepared to dive into my next project with Go, and after some general perusing on Hacker News to check out the latest (Hello, generics!), have gained a comprehensive introduction of the language. GO read this book (had to pun it). Highly recommended.
Will write a full review later. This book is excellent. It is not a guide to Go for a beginner programmer, to address some of the reviews. It expects a fair amount of programming experience and maturity in order to understand some of the off-hand references and code samples. That said, it is a very well written book for its audience, and has cleared up a lot of things that I was always a bit fuzzy about, or had a less than clear understanding of in my programming. It is concise. It builds beautifully through sequential examples to show most parts of the language in a helpful order. I highly recommend it, and plan to re-read it. If you've never used go before, it might be best to first go through the official tour: https://go.dev/tour/welcome/1 , then play with the language a bit, try out some tutorials or tutorial books (Alex Edwards, Travis Jeffery, e.g.) and the effective go document: https://go.dev/doc/effective_go , then read the book. If you already have a fair amount of programming experience, you may do fine diving in, but I think you'll still get more out of it if you've already gone through the official tour and played with the language first. Also recommended, at some point, is reading the source for the standard library, which does a beautiful job in showing off the language to its best advantage, and proper idiomatic go code style.
Quintessential text for learning the Go Programming Language. After working through some of the examples you will discover the simple elegance of the programming language--stripped down but expressive.
The chapter on testing, benchmarking, and profiling needs some work. However, I think these will require another book in itself.
There is little or no mention of symbolic debugging. Some may argues that with the proper array of functional tests, you don't really need a debugger. However, I am in the camp which believes that there is nothing more insightful to understanding the behavior of code that stepping through it with a debugger.
Excellent book. Buy it, or more importantly read it, then keep a copy on your shelf for reference.
This book provides a comprehensive overview of Go, and techniques on how to best use the language's features. I had expected this book to be similar to The Practice of Programming, it doesn't quite live up to the timelessness of that work.
The Go Programming Language has more contrived examples than The Practice of Programming. I would like to think that's caused by the fact that it is hard to find useful examples that aren't already solved by Go's extensive core library. There are some obvious problems with the solutions (those problems are often the topic of later chapters), which does affect some of the book's charm.
An absolute must for anyone starting with the Go language. I have done the go tutorial and went through the effective go website but this book made the trick: I was able to feel more and more comfortable with the language and accomplished as I read on. There are a few things left out of the pot that I learned whilst perusing other people's code, but even so the book provides a good narrative that eases the consumption of the knowledge and idioms required to speak the language properly.