Read The Go Programming Language by Alan A. A. Donovan Brian W. Kernighan Online

the-go-programming-language

The Go Programming Language is the authoritative resource for any programmer who wants to learn Go. It shows how to write clear and idiomatic Go to solve real-world problems. 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, Ruby, Python, Java, or C++.T The Go Programming Language is the authoritative resource for any programmer who wants to learn Go. It shows how to write clear and idiomatic Go to solve real-world problems. 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, Ruby, Python, Java, or C++.The first chapter is a tutorial on the basic concepts of Go, introduced through programs for file I/O and text processing, simple graphics, and web clients and servers. Early chapters cover the structural elements of Go programs: syntax, control flow, data types, and the organization of a program into packages, files, and functions. The examples illustrate many packages from the standard library and show how to create new ones of your own. Later chapters explain the package mechanism in more detail, and how to build, test, and maintain projects using the go tool. The chapters on methods and interfaces introduce Go's unconventional approach to object-oriented programming, in which methods can be declared on any type and interfaces are implicitly satisfied. They explain the key principles of encapsulation, composition, and substitutability using realistic examples. Two chapters on concurrency present in-depth approaches to this increasingly important topic. The first, which covers the basic mechanisms of goroutines and channels, illustrates the style known as communicating sequential processes for which Go is renowned. The second covers more traditional aspects of concurrency with shared variables. These chapters provide a solid foundation for programmers encountering concurrency for the first time. The final two chapters explore lower-level features of Go. One covers the art of metaprogramming using reflection. The other shows how to use the unsafe package to step outside the type system for special situations, and how to use the cgo tool to create Go bindings for C libraries. 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. Each chapter has exercises to test your understanding and explore extensions and alternatives. Source code is freely available for download from http: //gopl.io/ and may be conveniently fetched, built, and installed using the go get command....

Title : The Go Programming Language
Author :
Rating :
ISBN : 9780134190563
Format Type : ebook
Number of Pages : 400 Pages
Status : Available For Download
Last checked : 21 Minutes ago!

The Go Programming Language Reviews

  • Varun
    2018-11-15 13:19

    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.

  • Jelmer De reus
    2018-10-24 13:19

    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.No regrets!

  • Tadas Talaikis
    2018-10-16 12:19

    You're kidding, second mention on the for cycle:for initialization; condition; post {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?Or few pages later:counts := make(map[string]int)input := bufio.NewScanner(os.Stdin)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 froma = 2b = 2c = a + bprint c# 4Easy 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.P.S. Even C#/.NET was clearer.P.P.S. Short, true intro and to the point online e-book: https://www.golang-book.com/books/intro

  • Vanessa
    2018-11-09 17:15

    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.

  • Marshall
    2018-10-19 19:26

    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.

  • Dexter
    2018-11-03 15:12

    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.

  • Jordi Gil
    2018-10-16 12:07

    5/5 starsAn 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.

  • L Dean
    2018-11-06 18:12

    Close in quality to K&R, may revise to 5 stars after a re-read. If you work with Go, read this book.

  • Steve
    2018-11-15 11:22

    Presumably the authoritative reference book on/introduction to Go for experienced programmers. Despite the plethora of online resources I like books because the good ones guide you through all the elements, point out subtleties and gotchas, and really let you explore rather than the utilitarian reference "I need to know this now."This is a good book. As a veteran C/C++ programmer and one familiar with (albeit not fluent) in Python I found the covered topics familiar and yet new, as Go has its own idiosyncratic take on elements of those languages. It's definitely a very opinionated language, in a way I'm mostly okay with (but ask me again in 6 months) and they generally call out the opinions. (But don't really explain them, like why interfaces, not objects? Or "defer", not destructors? Still the book isn't really the place for those explanations - that's either a blog post or another book.)On the downside, it's definitely aimed at practicing programmers - there's definitely a presumption of lots of background, closer to the C side than the Python side - and the examples range between "nicely-illustrative close-to-real" and "why are they doing that, the details lose the point."If you are new to programming you will probably be lost.

  • Murray Cumming
    2018-10-25 14:02

    This is perfectly written and structured. The examples are particularly well chosen. Unlike most such books, it can, and should be read, cover to cover.In the end, I have not become a huge fan of the Go programming language itself, though the book has shown me much there to respect and be inspired by, and I'd definitely choose it for some projects. I've written up some notes about the experience from my point of view as a C++ developer: https://www.murrayc.com/permalink/201...

  • Jeremy Huiskamp
    2018-10-31 16:16

    This is fairly straightforward coverage of the language. For someone who is already familiar with the language, it's mostly boring, though worth reading because there are always gaps to be filled in and a fairly quick read.I can't fault anything specific about the book, I just wish more programming language books were opinionated like Javascript: the Good Parts.

  • Stefano Zanella
    2018-11-08 15:08

    I thought I would never feel again the same kind of excitement and sense of unlimited possibilities I felt when I read "The C programming language". But then this book came and the fire started to burn again.

  • Imish
    2018-10-20 15:13

    Deep & thorough.Significantly improved my perception of Golang because it showed both the simplicity & power of the language.

  • Drew
    2018-11-03 13:27

    Kernighan (the second author) has added another book to the programmer's must own collection.

  • Mindaugas Mozūras
    2018-10-18 13:21

    Gets the job done. Well written and thorough overview of Go. I especially liked the examples that were used to explain new concepts.

  • Glenn Sills
    2018-11-02 11:20

    A real page-turner.

  • Sebastian Gebski
    2018-10-24 18:13

    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.

  • Steven Raspudic
    2018-11-09 17:02

    This is a rare programming b0ok that transcends the language it was written for. It really is a statement about where programming is today. The K&R of this generation.

  • Huu Khiem
    2018-11-09 14:09

    If you are at the beginning of your software career and is using Go often, definitely try to read the book cover-to-cover. It contains not just Go syntax, but certain principles behind the design, which seems to apply well when programming with languages in the C family.For example, when talking about Goroutines, instead of delving too much on *how to use synchronization syntax (mutex, channel, etc)*, the book talk about *confining varialbes during critical operations (paraphased)* as the principle to avoid race conditions. Internalizing this idea helped remembering syntax much easier.If you are somewhat experienced, the book contains many neat tricks to improve your code. However it's pretty shallow if you need to understand the runtime, garbage collector, scheduler, etc. You will need to read the design documents and source code to find out more. Last but not least, The Go programming language is definitely not a reference book, so to use Go effectively, you will need to write code and check with the official docs prequently. This is OK, imo, because Go is still an evolving language with roughly 2 major releases per year.Being a relatively young developers, I would say it's worth the money, probably more than any other Go books.

  • Gonzalo Fernández-Victorio
    2018-10-24 19:22

    Very good introduction to Go. It's really difficult to separate what you feel about the language from what you feel about the book. I enjoyed both.

  • Eduardo Seabra
    2018-10-22 14:18

    Book is good, language not much

  • Max Lybbert
    2018-11-10 14:03

    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.

  • Leandro López
    2018-11-10 18:22

    For years I thought that "The C Programming Language" by Kernighan & Ritchie was the quintessential programming book: excellently written, full of examples and exercises, concise yet deep. I shouldn't be surprised that Kernighan pull it off again with this book, but boy I was wrong: I'm probably writing a review for my new favorite book on programming. Whether you like Go or not, it's impossible to have some critic on this book. I'm sure Alan Donovan has lots to do with the outcome, and now I want to read more things from this tandem of authors. I cannot wait to start writing Go code, if not for production code to be a better programmer, because trust me: reading this book will make you a better programmer one way or to other.

  • Oleg
    2018-10-28 13:24

    Very good.

  • Joe Fowler
    2018-10-20 18:24

    This book is probably as good as Kernighan and Ritchie'sThe C Programming Language. It teaches the Go language by successively more complex examples, but it's also full of quick, important guidance about when certain constructs make the most sense, or *why* you might want to do things a certain way. And Brian Kernighan is, of course, one of the very best writers about computing for the non-academic audience. (Maybe for the academic audience, too; I would not know.)

  • Federico Saravia
    2018-11-06 19:30

    This is one of the best programming books I've ever read. It not only gives a great introduction to the language but also serves as a constant source for documentation.Besides the language, the book is full of great examples and good programming practices, so it is definitely a must read regarding of whether you are planning to use Go professionally or not.

  • Luca
    2018-11-01 19:08

    Required reading if you are interested in go. Brilliant writing, solid examples.

  • Andrey
    2018-10-25 14:30

    Really good book. Lots of real life examples. Most language design decisions explained why this or that design was used. Was fun to read it and play with exercises!

  • Ignas
    2018-11-16 14:04

    Great book and keeping it on my desk for the reference.