Top products from r/golang

> 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
  

What about some classics like Uncle Bob talks?

A lot of good design focuses on decoupling and creating components which work together but separately also.

Id first look into language agnostic design principles such as SOLID

https://youtu.be/TMuno5RZNeE
https://youtu.be/zzAdEt3xZ1M (golang)

A good book will help.

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

I still keep a copy of the Gang of Four book at arms reach even tho the popularity is dwindling as OOP is not topic of most convos today. However when dealing with DI and sharable components in Golang, i find myself still falling back to abstract factories patterns. Its a good breathe of knowledge to at least glimpse at the patterns here:
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_cp_api_i_7BzvDbXJC5WS4

Once you get thru these topics, you can start picking up what I consider the "hot" architectures of today:
Microservices, event based systems, domain driven design, event sourcing, and architectures aiding themselves to functional programming.

I really enjoy reading Martin Fowler blog posts: https://martinfowler.com/tags/application%20architecture.html

He covers a lot of these topics.

PS: maybe a niche and a personal favorite of mine but ive learned ALOT by researching the different types of kernel architectures. Nothing really geeks me out like those topic, but not for everyone.

A fabulous free course exists on these topics:
https://www.udacity.com/course/advanced-operating-systems--ud189

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

that would be very great, but maybe it needs a pretty loooong weekend. Python Cookbook DO offers a wealth of useful code for all Python programmers.

Thanks for sharing this!

Your Advocates Doc is ver useful for beginners! Do you also have a Markdown version of this on Github?

And yes William Kennedy is a genius I read Go in Action and in my opinion its one of the best books about Go around..

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?

> http://www.amazon.com/Mastering-Concurrency-Go-Nathan-Kozyra/product-reviews/1783983485/

Most of the 1-2 star reviews on that book seem to be well thought out reviews. The 5-star ones look generated by bots with sentence structures of the form: "I simply love to concurrency in go" and "This book slays. I simply love to do a concurrency in go.".... I'm gonna side with the 1-2 star reviews I think.

Have you checked out Robert Martin's 'Clean Code' book and/or videos?

I've found Martin's material to be very helpful in actually identifying the attributes of clean code (and conversely, code smells). His examples are all in Java, which would be good for you, given your Java background. Despite his focus on Java and OOP more broadly, I think the fundamentals of clean code are language agnostic and there is plenty of carry-over to Go. He starts with rules around naming things and moves all the way through higher level design principles.

Fair warning though -- Martin goes totally overboard with props, green screens, theatrics, and astronomy history lessons in his videos. The book is more concise, but I'm a better visual learner, so after reading the book I started going through the videos.

Before rolling out personal definitions, consider reading a book.

> So what is your definition of science

"All science is either physics or stamp collecting."

> And don't tell me data mining is not seeking to explain the material universe better, that is the entire point.

Please tell me you were joking.

And no, what you describe there is not science. The theory part is just applied mathematics, rest is engineering. The heuristics used are educated guesses about the model at best.

A few kids trying to infer what kind of video I'd like to watch next, they're not doing science either.

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

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.

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.

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.

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

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!

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.

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

Sometimes there are language specific ideas there, but in general those are much more general. This is older, but still very good. It's also by Kernighan and Pike, so the ideals there are certainly reflected somewhat in Go.

https://www.amazon.com/Practice-Programming-Addison-Wesley-Professional-Computing/dp/020161586X/

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!

In addition, he co-wrote The UNIX Programming Environment and The Practice of Programming with Rob Pike and The Elements of Programming Style with PJ Plauger. I've never read the Practice of Programming (add it to the wish list) but the other two books are fantastic. The Elements of Programming Style is somewhat dated (code is in PL/I and Fortran, and it discourages things like goto which we all already know is bad) but a lot of it is still relevant and worth picking up a used copy if you can find it.

Have a look at strings.Join() for combining a slice of strings.

Programming in Go is a great book that got me started. Everything else I've picked up on has come through reading the source code of projects on GitHub. Check out awesome-go which has a bunch of cool projects and examples. Otherwise, referencing the docs and source of Go's standard packages.

to be honest I don't feel there is a lack of it. But maybe is because I'm already a web dev with experience in other languages & frameworks, but I understand it might be challenging for a newb in web dev.

I would recommend learning with this book: Go web programming

Follow through code with it, then just use the seed project there and build your own web app from it. Use it as a "seed project"

Yeah and it's probably not fair of me to dismiss JS before reading about The Good Parts. That said I just looked at TypeScript again. Looks interesting and has some IDE support. I'll keep it in mind next time JS makes me want to drink a Gin & Clorox just to make the hurting stop.

BTW, have you read the Feathers book on legacy code? It's pretty damn good and helped me a lot.

I'm not saying you're a bad developer. What I am saying is that Feathers is a rare genius.

edit: https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

(There might be a newer edition)

The LISP 1.5 manual is a great example of concise tech writing, too.

https://www.amazon.com/LISP-Programmers-Manual-Michael-Levin/dp/0262130114

Please put the title/name of what you're linking to so everyone doesn't have to follow an opaque link to find out.

The link is to: Database Systems: The Complete Book (2nd Edition) by Garcia-Molina, Ullman, and Widom.
(I've never read or head of this book, I'm just giving the name not recommending it).

Best book: Computer Networking Top Down Approach: https://www.amazon.com/Computer-Networking-Top-Down-Approach-7th/dp/0133594149/?pldnSite=1
It’s not Go specific but you need to start at the fundamentals.

Good advices for code reading strategies can be found in this book http://www.amazon.com/Code-Reading-Open-Source-Perspective/dp/0201799405, not in Go however.

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

Generally the Adapter Pattern is what you're describing, but it could also be used in combination with a Façade or other Structural Patterns from the Gang of Four book.

You* can try this book - Distributed computing with Go.

After a brief intro into testing with Go and other such stuff, it explains how goroutines & channels work under the hood then shows how to use them. And rest of the book is about using these concepts with networking applications etc.

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.

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

https://www.amazon.com/gp/product/0131873253/

Is this the book, "Design Patterns", that you were referencing?

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

packt also released this one, which has gotten 17 reviews, evenly split between 5- or (1- and 2-) stars: http://www.amazon.com/Mastering-Concurrency-Go-Nathan-Kozyra/product-reviews/1783983485/

$46 new, $60 used?!

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

First use on-line available resources mentioned already. as far as books go I'm reading "Go in action" at the moment and it has quite interesting approach, more problem based than tutorial.
https://www.amazon.co.uk/Go-Practice-Matt-Butcher/dp/1633430073/ref=sr_1_1?ie=UTF8&qid=1483963854&sr=8-1&keywords=go+in+practice