Reddit mentions of Go Programming Language, The (Addison-Wesley Professional Computing Series)

Golang is a great choice for getting started on backend dev!

• It's a fairly simple language that is mostly written in a very straightforward, imperative manner, so it can be easier to read and reason about the code in comparison to other languages (not a lot of magic here).
  
• It has great tooling built in, so there's no need to download/learn about a bunch of extra software/conventions to get started.
  
• It's a great chance to gain a deeper understanding of concurrency and writing thread-safe code, which is very relevant in context of modern computing.
  
  Don't take my word for it though - check out some of these resources and see what you think:
  
  
• Official docs: https://golang.org/doc/
  
• Stdlib: https://golang.org/pkg/
  
• The Go book: https://www.amazon.com/Programming-Language-Addison-Wesley-Professional-Computing/dp/0134190440
  
• A Tour of Go: https://tour.golang.org/welcome/1 (this would probably be the best starting point)
  
• "Concurrency is not parallelism" from the Go Blog: https://blog.golang.org/concurrency-is-not-parallelism

In some ways, I can sympathize for your frustrations; it doesn't seem like releases happen very quickly. On the other hand, I don't feel the struggle when I'm actually developing in Elm. If the language stayed the same as it is today, I'd still continue to use it for quite a while.

Where I feel there's room for growth is around tooling and libraries. The tools that are out there aren't bad, but (like everything) they can improve and expand. We as a community can start working on this and let Evan continue to deliver the quality he has been at the pace that's been working.

I think the trouble is that Elm competes with JS technologies. Love it or hate it, JS is probably the fastest moving community ever.

Its hard to ignore JS market share, but I don't personally feel its because of the outstanding merits of the language, its because everyone who is involved with frontend web development HAS to touch it at some point or another so there's a lot of effort around improving their experience. I chose to use Elm because its brings sanity to the browser and the predictability of the language.

I think a comparable situation on the backend is Go. Both Elm and Go are engineered languages (versus languages that evolve as needs change). Even now, the book recommended to most beginner is The Go Programming Language, which was published in October of 2015. Find a JS book published two and a half years ago that's still the #1 recommend book for people to learn the language.

I'm sure this relates a lot to my personality type, but I use both Elm and Go because of the consistency. Elm programming at one job is VERY similar to Elm programming at another job. JS programming at one job may be a completely difference experience than you'll find at another job (or even another team within the same company).

I view the price of consistency and good design is slower release cycles.

All that said, I don't blame you semorg, you seem genuinely interested in helping, not just complaining. Your post has me thinking of things I can do to help the community out with adoption. I'll let that idea simmer a bit and try to think of what I can do too.

I'm using The Go Programming Language along with the official Go Tour.

> Is it common to use a reverse proxy for HTTP heavylifting, or handling it in Go itself?
> I see a lot of references using go's http library directly. Is it advisable to use it straight rather than frameworks as in most of the other languages (not very common)?

Already explained.

> How does go take advantage of multiple cores? (natively, not containers).

If you write a simple hello world web server in Go, it will already be concurrent and parallel: whenever a new client connection comes, a new goroutine will be spawned to handle it and run on an available core (paralellism). Suppose you have something more complex than a 'hello world', something that queries a MySQL server, for example: after you write the query request to the network, your application will wait for an answer from MySQL. At this point, your 'goroutine' is suspended and another goroutine that is ready to do some work is awakened, and it's execution resumes from where it left off.

Once MySQL performs the query and replies with data, the event loop that runs inside the Go runtime will notice that there is data available to be read in the socket and will wake up your goroutine for you to deal with that data, and you'll work with the query rows. No need for callbacks or explicit async/await or futures, the runtime manages it for you. As far as your code is concerned, everything happened without interruption.

A lot of things will take advantage of multiple cores automatically for you: the webserver will spawn new goroutines to handle new clients (you don't need to do that yourself), when sorting integers from an array, the sorting implementation is already "multithreaded", etc.

To take advantage of multiple cores explicitly in your code, you basically just need to spawn goroutines to do the work that needs to be done and have a way to communicate with your goroutines (channels, usually) and a way to know when those goroutines are done with their work (sync.WaitGroup). There are a ton of great articles and talks on this subject:

• A Tour of Go - Goroutines
  
• Learn Concurrency
  
• Denis Uraganov - Concurrency: goroutines and channels
  
• Evan Huus - Complex Concurrency Patterns with Go
  
• Sameer Ajmani - Advanced Go Concurrency Patterns
  
• Rob Pike - Concurrency Is Not Parallelism
  
• Fun with Channels in Golang
  
• Golang Concurrency
  
  > Testing. Are test runners common, or go has something built in for unit tests. Is the ecosystem mature?
  
  Yes, tests are common and a first class citizen in Go - Go has a built-in testing/benchmarking framework.
  Some talks on it:
  
  
• Testing Techniques
  
• Mitchell Hashimoto - Advanced Testing with Go
  
  > C bindings? (JNI/swig in other languages)
  
  Yes, it's possible, but too complicated to explain here and I don't have a lot of experience with it. Basically the Go compiler also includes a small C compiler (!) to interface with C at compile-time (you can include C header files inside your Go code, or embed C code, for example). One thing to note is that because the Go ABI differs from the C ABI, there's a small extra overhead when making foreign calls. Some references:
  
  
• C? Go? Cgo!
  
• cgo
  
• How to include C code in your Go package
  
• Go Bindings for Various External APIs
  
  > Anything else you'd like me to know?
  
  
• the official Tour of Go is a great place to start.
  
• The Go Programming Language is a great book to read
  
  When writing Go applications:
  
  
• Logging is very important, I recommend logrus logging to a local JSON file that gets forwarded to a centralized logging stack like ELK.
  
• metrics will give you observability on the state, performance and health of your systems
  
• I use spew a lot for debugging too (think Python's pprint or PHP's print_r).
  
• gorm makes working with databases easier.
  
• so does upper
  
• learning to profile and optimize your applications will come in handy
  
• so will learning about how the Go race detector and optionally, how it works
  
• and learning how to detect memory leaks
  
• Go comes with great tooling by default, learn about it
  
• working with weird/non-standard JSON can be a pain sometimes - I like to gjson and sjson when it makes sense
  
• GopherCon 2014 Best Practices for Production Environments by Peter Bourgon
  

https://arp242.net/weblog/learning-a-programming-language.html

In the specific case of Go, The Go Programming Language is the best book that I know of. It does assume some programming knowledge though.

As for Go vs. Python vs. Perl, I agree with the commenters that it would depend a lot on what you're hoping to do with it.

I started with the Tour of Go, and continued with The Go Programming Language, along with playing with the AWS Go SDK examples and code in my employer's repositories.

Coming from a C++-ish background, it was pretty easy to read a bit about, then start writing. There are things that are obviously inspired by object orientation, both in the class-based and message-passing-based senses.

1. Take the go tour
   
2. Read official docs or The go programming language if you prefer books

Did you do research on your customer base? Is there really a need for yet another Learn Go for a Beginner style of book? I'm really struggling to actually find some good advanced material about Go being used in production environment. And production level architecture and deployment systems and builds with jenkins, or whatever. But there are many beginner guides out there already.

It's fine if you want to, I'm just saying, that something a bit more advanced might sell better? Or would be altogether beneficial?

I guess it depends on how far along you are with Go. I used the following:

"The Go Programming Language" from Addison-Wesley, one of the authors Kernighan, co-authored the "C Programming Language" book. I'm kinda a programming language theory nerd, so I loved it. https://www.amazon.com/Programming-Language-Addison-Wesley-Professional-Computing/dp/0134190440/

I really got a lot out of "Go in Practice" from Manning Publications, especially liked the Concurrency + Concurrency Patterns chapters.

https://www.amazon.com/Go-Practice-Techniques-Matt-Butcher/dp/1633430073/

Since we almost always need some web programming these days, I used "Web Development with Go" for learning some basics and more advanced Go web programming. The code from the book is in github here: https://github.com/Apress/web-dev-w-go. It was good to get started with some APIs in the Go ecosystem.

Next I'm going to start on GUI development with go from Packt: https://www.packtpub.com/application-development/hands-gui-application-development-go

I've also been going through the O'Reilly learning path for Go from Rachel Roumeliotis. https://learning.oreilly.com/videos/learning-path-go/9781491958100/

Some others:

Profiling Go applications: https://www.integralist.co.uk/posts/profiling-go/

I always love the Java/JavaScript/Groovy/Ruby/Python "puzzlers" talks, check out the go puzzlers here: https://talks.godoc.org/github.com/davecheney/presentations/gopher-puzzlers.slide#1

You can read the go book which I think is a pretty good source. If you don't have the money for that I would do the go tour, read the Go language specification, and then read Effective Go.

If you haven't seen, Kernighan is coming out with a Go version of the old classic (amazon)

Sans Ritchie of course, RIP.

Comes out in August. I'm totally getting it, just started learning some Go.

I started with this book:

https://www.amazon.com/Programming-Language-Addison-Wesley-Professional-Computing/dp/0134190440

very very good. And then a lot of resource around the web.

Then it depends on what kind of backend you wanna do. Have fun!

I have a few recommendations from someone who started with go about 2 years ago. Get https://www.amazon.com/Programming-Language-Addison-Wesley-Professional-Computing/dp/0134190440 book and work through the whole thing, then work with go for a little on something, then go find https://www.oreilly.com/library/view/ultimate-go-programming/9780135261651/ course by Bill Kennedy and go through the WHOLE thing. Also while you're doing that listen to the Go Time podcast, check out @francesc https://www.youtube.com/channel/UC_BzFbxG2za3bp5NRRRXJSw youtube channel, and do some https://gophercises.com/ from @joncalhoun These were all the best things I found to successfully animorph into a gopher. Also mandatory recommendation to read the standard library source as you get into things and https://golang.org/doc/effective_go.html

An Introduction to Programming in Go by Caleb Doxsey

http://www.golang-book.com/books/intro

I'm not sure if one can go through it in 30 minutes though. It took me a long afternoon. Neither is it very comprehensive.


The best book in my opinion, however, is The Go Programming Language by K&D. Clear and crisp!

I buy books because they go into a lot more details, or often are written really well, and easy to follow. Also, it's really nice to read paper. Often I keep books in the office as it's a quick and reliable way to research a topic in-depth without scrolling through hundreds of shit articles on a particular (and even controversial subject).

I really recommend these:

High Performance MySQL: Optimization, Backups, and Replication - I've read snippets, but it's recommended a lot and very good for more advanced readers.

SQL Antipatterns: Avoiding the Pitfalls of Database Programming - VERY beginner friendly, easy to read, follow, provides real and common scenarios and explains the anti-pattern, it's problems, the reasons to sometime excuse their use, and solutions. I love this book.

The Go Programming Language - Very good read, not TOO technical jargon, very nice to read, explains in depth and in an understandable way.

I've had plenty more over the years, but these are my current I have at home. Still more on order. :)

The Go Programming Language (Addison-Wesley Professional Computing Series) https://www.amazon.com/dp/0134190440/ref=cm_sw_r_cp_apa_D9y7BbQRNKRQS

I recently asked my Udemy instructor for some reading ideas. These are the ones I purchased.

Go Web Programming

The Go Programming Language

Go in Action

The Go Programming Language by Alan Donovan, and Brian Kernighan is a start.

I wouldn't seriously use Go for gaming or mobile, maybe as an experiment but you'll have to get used to using the best tool for the job.

Web development: Javascript/HTML for Front-end, Python/Ruby/Javascript/PHP/Go/Java for the back-end work
Mobile: Android(Java), iOS(Objective-c, Swift)

Absolutely! I recommend this book as a good general-purpose resource.

Then, I recommend reading source code, especially the Golang stdlib. IMO, one of Go's biggest strengths is the readability of the stdlib as a resource to find code that can help you do what you want to do.

If you want something fun to try and learn Golang, you might be interested to check out the CryptoPals challenges. They can be done in any language, but they're a good excuse to learn a new language. Plus, you get to learn some neat crypto :)

Terminei de ler o Clean Code e o The Choose Yourself Guide To Wealth, agora comecei a ler o The Go Programming Language. Queria ler alguma aventura, mas pra ser sincero dei uma procurada por cima e nenhum título atual realmente me chamou a atenção.

I purchased this:

https://smile.amazon.com/Programming-Language-Addison-Wesley-Professional-Computing/dp/0134190440/ref=sr_1_1?ie=UTF8&qid=1499285738&sr=8-1&keywords=golang

and started doing programming exercises here:

http://exercism.io/languages/go/about

back in February and never looked back. However. I've also been programming for ages so YMMV with this approach.

I applied as well. If you haven't, look at courses and video from Todd McLeod. I think most of his Udemy courses were fairly cheap, and he offers a lot of valuable information on his YouTube channel. "The Go Programming Language" is a great book too.

https://www.amazon.com/Programming-Language-Addison-Wesley-Professional-Computing/dp/0134190440

Worth it.

Yeah best practice depends on your code.

I'd say the best resources for this are go only and you are not going to get that from one source.

https://github.com/golang-standards/project-layout/blob/master/README.md

https://peter.bourgon.org/go-best-practices-2016/

https://github.com/tmrts/go-patterns/blob/master/README.md

https://github.com/ardanlabs/service/blob/master/README.md

https://golang.org/doc/effective_go.html#Getters


https://github.com/ardanlabs/gotraining/blob/master/topics/go/README.md

https://www.amazon.com/Programming-Language-Addison-Wesley-Professional-Computing/dp/0134190440/ref=asc_df_0134190440/




I wouldn't trust Uncle Bob. He doesn't even like go.

https://twitter.com/unclebobmartin/status/758387162270183424?s=09