Go

Go Sync or Go Home: WaitGroup Go’s goroutines, channels, and mutexes make it easy to develop complex concurrency systems. Most problems can be solved using these three mechanisms, but you might be asking yourself — what else is out there? https://medium.com/@yardenlaif/go-sync-or-go-home-waitgroup-5f074a03776e

Memory leaks can be a significant issue in any programming language, and Go is no exception. Despite being a garbage-collected language, Go is still susceptible to memory leaks, which can lead to performance degradation and cause your operating system to run out of memory. To defend itself, the Linux operating system implements an Out-of-Memory (OOM) killer that identifies and terminates processes that consume too much memory and cause the system to become unresponsive. In this blog post, we’ll explore the most common causes of memory leaks in Go and demonstrate how to use Grafana Pyroscope, an open source continuous profiling solution, to find and fix these leaks. https://grafana.com/blog/2023/04/19/how-to-troubleshoot-memory-leaks-in-go-with-grafana-pyroscope/

User or *User - Do We Need Struct Pointers Everywhere? The answer, as you might’ve guessed, is “no.” But, it’s also more nuanced due to the lifetime of a struct, its usage, and other aspects that boil this down to general guidelines and case-by-case analysis. https://preslav.me/2023/02/06/golang-do-we-need-struct-pointers-everywhere/

Error handling in Go is a little different than other mainstream programming languages like Java, JavaScript, or Python. Go’s built-in errors don’t contain stack traces, nor do they support conventional try/catch methods to handle them. Instead, errors in Go are just values returned by functions, and they can be treated in much the same way as any other datatype - leading to a surprisingly lightweight and simple design. In this article, Brandon Schurman demonstrates the basics of handling errors in Go, as well as some simple strategies you can follow in your code to ensure your program is robust and easy to debug. https://earthly.dev/blog/golang-errors/

A bit of a clickbait title, but still an interesting finding: https://hmarr.com/blog/go-allocation-hunting/

Backward compatibility in Go: discussion >>> We now have about ten years of experience with Go 1 compatibility. In general it works very well for the Go team and for users. However, there are also practices we've developed since then that it doesn't capture (specifically GODEBUG settings), and there are still times when users’ programs break. I think it is worth extending our approach to try to break programs even less often, as well as to explicitly codify GODEBUG settings and clarify when they are and are not appropriate. >>> by Russ Cox Join the discussion if you wish https://github.com/golang/go/discussions/55090

Breaking the Monolith at Twitch: Part One Twitch is one of a large group of successful companies that began life running as a monolithic Ruby on Rails app but they’ve written about where they went from there, how Go entered the picture, and their current practices. About the Author: My name is Mario Izquierdo, and I’ve been a Full Stack Engineer at Twitch since 2017. I’ve worked in a variety of systems in my time here, including the public API, infrastructure, and tools for services. From the author: This is Part One (of two) of our story chronicling Twitch’s journey from monolithic architecture to microservices. In Part One, you’ll learn about our early days, from our rapid growth to the performance bottlenecks that pushed us to find better solutions. Part Two, covers “Wexit,” our migration to microservices and all the challenges and benefits that came with the switch. https://blog.twitch.tv/en/2022/03/30/breaking-the-monolith-at-twitch/ Enjoy! 🤩

Hello everyone 👋 Today’s post is about finding Golang jobs abroad. A friend of mine is operating developer job board Relocate.me. The project is built around and focused entirely on tech jobs that offer visa sponsorship/relocation assistance. If working abroad is smth you're interested in, consider checking it out. Here's a link to the Golang jobs that are currently on offer - https://relocate.me/search/golang Also, subscribe to their Telegram channel to get alerts of new jobs - @relocateme

Go 1.18 is released! The Go Team 15 March 2022 Today the Go team is thrilled to release Go 1.18, which you can get by visiting the download page. Go 1.18 is a massive release that includes new features, performance improvements, and our biggest change ever to the language. It isn’t a stretch to say that the design for parts of Go 1.18 started over a decade ago when we first released Go. Generics In Go 1.18, we’re introducing new support for generic code using parameterized types. Supporting generics has been Go’s most often requested feature, and we’re proud to deliver the generic support that the majority of users need today. Subsequent releases will provide additional support for some of the more complicated generic use cases. We encourage you to get to know this new feature using our generics tutorial, and to explore the best ways to use generics to optimize and simplify your code today. The release notes have more details about using generics in Go 1.18. Fuzzing With Go 1.18, Go is the first major language with fuzzing fully integrated into its standard toolchain. Like generics, fuzzing has been in design for a long time, and we’re delighted to share it with the Go ecosystem with this release. Please check out our fuzzing tutorial to help you get started with this new feature. Workspaces Go modules have been almost universally adopted, and Go users have reported very high satisfaction scores in our annual surveys. In our 2021 user survey, the most common challenge users identified with modules was working across multiple modules. In Go 1.18, we’ve addressed this with a new Go workspace mode, which makes it simple to work with multiple modules. 20% Performance Improvements Apple M1, ARM64, and PowerPC64 users rejoice! Go 1.18 includes CPU performance improvements of up to 20% due to the expansion of Go 1.17’s register ABI calling convention to these architectures. Just to underscore how big this release is, a 20% performance improvement is the fourth most important headline! For a more detailed description of everything that’s in 1.18, please consult the release notes. Go 1.18 is a huge milestone for the entire Go community. We want to thank every Go user who filed a bug, sent in a change, wrote a tutorial, or helped in any way to make Go 1.18 a reality. We couldn’t do it without you. Thank you. Enjoy Go 1.18!

When More Parallelism != More Performance This is an important reading especially for beginners in Go to understand the pros and especially the cons of parallel computing in Go. The post shows by example how concurrency could lead into a bad performance and what one should pay attention to when working on concurrent/parallel computing https://convey.earth/conversation?id=44

Let’s talk about logging This is a post inspired by a thread that Nate Finch started on the Go Forum. This post focuses on Go, but if you can see your way past that, I think the ideas presented here are widely applicable. https://dave.cheney.net/2015/11/05/lets-talk-about-logging

Wondering how to make Ctrl+C safely stop the program in Go? Here’s a short blog post about syscalls handling and cancellation of context.Context: https://medium.com/@matryer/make-ctrl-c-cancel-the-context-context-bd006a8ad6ff

Hello, everyone! Here's a great post about what functional options are in Go, and how we can use the options pattern to implement them. Functional options take the form of extra arguments to a function, that extend or modify its behavior. Here’s an example which uses functional options to create a new House struct: h := NewHouse( WithConcrete(), WithoutFireplace(), ) Take a look at https://www.sohamkamani.com/golang/options-pattern/

Updating the Go Memory Model The final post in a three-part series that culminates with the outline of a proposal to change Go’s memory model. Link: https://research.swtch.com/gomm This post is very technical but the specific changes are clear and accessible. If this proposal is anything like Russ’s previous efforts, be prepared to see changes in Go before long :) Previous parts of the Memory Models series: Part 1: Hardware Memory Models; Part 2: Programming Language Memory Models

Top 5 Lessons I learned while working with Go for two years. In the article, Sayed Alesawy is sharing some of the mistakes and the lessons they faced by doing GoLang development for 2 years: “ I have been writing Go services for like two years now, both professionally and as personal projects. Using a certain language in numerous projects over an extended period of time allows you to make mistakes, fix them, realize it's still not the best way to do it, fix them again and generally get better the more you get to re-do stuff because each time you try to avoid a mistake you made the last time that caused you a headache throughout that project.” TLDR; 1. Take the Go highway to Concurrency 2. If it can be singleton, then make it singleton, but do it right! 3. Beware of Blocking Code 4. Graceful Termination and Clean Up 5. Go Modules FTW. Read more at: https://sayedalesawy.hashnode.dev/top-5-lessons-i-learned-while-working-with-go-for-two-years

Between Go and Elixir "Reason wanted me to make a choice, and I am so glad I didn’t. Because the more I kept delving into both Elixir and Go, the more I found out how complementary the two can be to one another." https://preslav.me/2021/04/23/between-golang-and-elixir/

You may be wondering how to... https://pmihaylov.com/vim-for-go-development/ 🙂

A lot of projects use gRPC framework nowadays to build an efficient cross-service communication layer., and usually the calls between services are fast, frequent, and expected to have low latencies. But what if we have a bit different problem to solve, e.g. handling long-lived streams? In this article Omri Cohen walk us through an excellent tutorial about how to design gRPC long-lived streaming. Take a look: https://dev.bitolog.com/grpc-long-lived-streaming/

Introduction to generics from “Learn Go with tests”: A nice tutorial that takes a step approach to teach generics starting from duplicating code for types, then to interface{}, and finally to generics. And you can run it all in the go2go playground. https://quii.gitbook.io/learn-go-with-tests/meta/intro-to-generics

How to work with context.Context: an official blog post. The documentation for context states: “Contexts should not be stored inside a struct type, but instead passed to each function that needs it.” This article expands on that advice with reasons and examples describing why it's important to pass Context rather than store it in another type. https://blog.golang.org/context-and-structs