Hello 👋 Recently I've stumbled upon the blog post about //go:embed directive usage: a new feature introduced in Go 1.16,

>> that allows you to include the contents of arbitrary files and directories in your Go application.

Looks quite interesting, have a look:
https://blog.carlmjohnson.net/post/2021/how-to-use-go-embed/

Generic programming proposal has got accepted ✅

https://github.com/golang/go/issues/43651

The Go Wiki includes a slice trick on filtering slices without allocating.

filtered := items[:0]
for _, x := range items {
if condition(x) {
filtered = append(filtered, x)
}
}

This post will attempt to explain how that works: https://abhinavg.net/posts/zero-alloc-slice-filter/

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

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

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/

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

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/

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

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

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/

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

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

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

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!

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

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! 🤩

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

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