Hi there! 👋 After that Jetbrains report I’ve decided to make a quiz and ask you about GoLang frameworks 😀 So, which HTTP framework do you use or recommend for usage?
public poll

Gin – 278
👍👍👍👍👍👍👍 54%

Other – 82
👍👍 16%

Echo – 65
👍👍 13%

FastHTTP – 38
👍 7%

Iris – 27
👍 5%

Beego – 23
👍 4%

Martini – 6
▫️ 1%

👥 519 people voted so far.

Generally I don’t like aliases but in some cases they might be helpful 😀

#development #basics

https://codeburst.io/learn-how-to-create-custom-bash-commands-in-less-than-4-minutes-6d4ceadd9590

Hi there 👋 How to increase your GoLang application performance to more than 20x? Here is a list of tips, tricks and hacks which have been used for a 23x performance power! Within this article you will know more about:

- benchmarks and tracing;
- sometimes parallelism is not a perfect solution for each case;
- how to tune your app step-by-step and other interesting topics 🙂
Just open it and deep into GoLang performance refactoring!

https://medium.com/@val_deleplace/go-code-refactoring-the-23x-performance-hunt-156746b522f7?source=linkShare-b636419a57de-1532816321

A good reading list with a knowledge base about Golang, based on blog posts and Golang books. Inside of the link:
- 3 categories of stages: Beginner, Intermediate, Advanced;
- Common questions like “Why should you learn Go?” and “How to Write Go Code”
- Web, Concurrency, Code style, Testing and other GoLang related topics.

#language #development #basics

Add to bookmarks and enjoy the reading!

https://github.com/enocom/gopher-reading-list

100 lines of Go code for … HTTP(S) proxy! Take a look at fast and graceful proxy service based on standard Go http server and client packages 🙂

#development #practice

https://medium.com/@mlowicki/http-s-proxy-in-golang-in-less-than-100-lines-of-code-6a51c2f2c38c

Hello, there! One GoLang feature proposal about immutability is here 🙂
It’s a really interesting idea with pros and cons inside, it has a good explanation, use cases and examples for the following proposed changes: fields, arguments, variables, return values, methods reference types (Pointers, slices, maps, channels). This approach merits attention if you are interested in paths of GoLang development, so, have a good reading! 😉

#language #development

https://github.com/romshark/Go-1-2-Proposal---Immutability

Hello, there! I would like to share with you one good comment about time.Sleep function and how it works in the Go Runtime:
https://github.com/golang/go/issues/25471#issuecomment-391906366

Ok, I’m online again so Happy New Year for everyone 🎈
The first article that I want to share this year is about channels design in GoLang, their structure and internal operations. Enjoy the reading!

#development #language

https://codeburst.io/diving-deep-into-the-golang-channels-549fd4ed21a8

Hello, channel 👋
Did you know how DNS cache works? And did you know you can store your data there? A couple of days ago I found an article how DNS resolvers become cloud-based file storage 💾for you and would like to share it, so the article is here:

DNSFS. Store your files in others DNS resolver caches

#networks

https://blog.benjojo.co.uk/post/dns-filesystem-true-cloud-storage-dnsfs

Hi all, we are hiring!
#relocation #fulltime
As you may have noticed, I’m a GoLang developer and this time I want to share new opportunities in my team and our company https://www.digitalgoodie.com 🙂
We’re growing up, and looking for new GoLang talents (actually, not only Go, we’re looking for Ruby and Frontend devs as well).

Location: Helsinki, Finland 🇫🇮
Position: Senior Backend/Fullstack developer
Salary: €4,000-5,000 before taxes (it’s a general range, depends on individual negotiation)
+ Relocation package (residence permit fees, tickets, etc)


We expect you to:
- Have a say when making tooling and architecture choices
- Help, coach and mentor your peers with your skills and expertise
- Know and understand the technologies you will be working on:
Golang, for the greatest and latest Microservices
Ruby, for understanding where we are coming from
React, Node and JSON at the level to be able to discuss with the front end developers
CI/CD principles, using Jenkins
K8S and Containers, at the level, to be able to do NoOps, with little or no assistance from Site Reliability Engineering
- Be experienced with at least a couple of backend, or full stack solutions and architectures

If you’re interested in, ping me @denniselite

Errors in Go:
From denial to acceptance

Learn how to stop worrying and love error handling in Go. Author of Overmind and imgproxy describes his journey through all five stages of Kübler-Ross model—from denial to acceptance—as he went deeper into the language, and shares his favorite patterns for dealing with errors in Go code.

#development #language

https://evilmartians.com/chronicles/errors-in-go-from-denial-to-acceptance

One more introduction to Go: Why and how to write good Go code.
Author: Francesc Campoy,
VP of Product & Developer Relations
Developer Advocate at Google, Go team, Google Cloud platform
https://speakerdeck.com/campoy/an-introduction-to-go-cern

Hello, channel. Recently I’ve played with concurrency data processing in go: let’s say how to split a bunch of data to 1,2...N pieces and process it concurrently and then once everything is done continue normal execution. For those types of issues I used `channels` before and tried to design my own solution every time. But somehow, suddenly, I found a good explanation of how to use `sync.WaitGroup` and it looks like a charm! It’s not a new feature, really easy to use, but by some reason I’ve never tried to use it for some reason 😀 So here is an article:
https://tutorialedge.net/golang/go-waitgroup-tutorial/
and a short example of how it could be ▶️ https://gist.github.com/denniselite/b9c62ee0366d3f63f9f6015a68af1db3

If you feel like you mastered Go, you might want to expand your skillset. Guys from @thefrontend share a lot of useful tips and tricks, inspirational UI/UX, news and throw occasional quizzes around web and mobile dev for you to participate!

Have a quick look🔥

t.iss.one/thefrontend

A quite interesting proposal was raised last month regarding error handling in Go:
The try built-in function takes n+1 arguments (where n may be zero) where the last argument must be of type error. It returns the first n arguments (if any) if the (final) error argument is nil, otherwise it returns from the enclosing function with that error. For instance, code such as

f, err := os.Open(filename)
if err != nil {
 return …, err  // zero values for other results, if any
}

can be simplified to

f := try(os.Open(filename))

Check it out:
https://github.com/golang/go/issues/32437
Full proposal description is located here: https://github.com/golang/proposal/blob/master/design/32437-try-builtin.md

https://www.digitalgoodie.com/senior-backend-developer-2/

We’re hiring!

Unrelated to GoLang but it’s still interesting to get familiar with https://link.medium.com/60H2RCl8OY

Golang 1.13 has been released last week! 🚀
Feel free to check the updates by the link:
https://blog.golang.org/go1.13
In short, there is a list of major changes:
- The go command now downloads and authenticates modules using the Go module mirror and Go checksum database by default
- Improvements to number literals
- Error wrapping
- TLS 1.3 on by default
- Improved modules support

PS In my point of view, Error handling is one of the most important syntax changes, so I’d just want to highlight it here:
The error wrapping support follows the initial proposal described https://go.googlesource.com/proposal/+/master/design/29934-error-values.md, it adds a new Wrapper() interface:

An error that wraps another error should implement Wrapper by defining an Unwrap method.

type Wrapper interface {
        // Unwrap returns the next error in the error chain.
        // If there is no next error, Unwrap returns nil.
        Unwrap() error
}

Also, to support wrapping, fmt.Errorf now has a %w verb for creating wrapped errors, and three new functions in the errors package ( errors.Unwrap, errors.Is and errors.As ) simplify unwrapping and inspecting wrapped errors.

Thanks for your attention 🙂

PPS Given the summer is gone, I’ll try to post more news and interesting things to the channel in the future 🙂

Quite interesting reading about versioning principles in Go and how the team came up with Go modules in the end: https://research.swtch.com/vgo-principles

>>> This blog post is about how we added package versioning to Go, in the form of Go modules, and the reasons we made the choices we did. It is adapted and updated from a talk I gave at GopherCon Singapore in 2018

Serverless tech stack is becoming more and more popular, so, in case you never tried AWS Lambda functions together with Go 💙 I’d suggest you take a look at the article: this quite simple reading allows you to get the idea of the technology.
https://read.acloud.guru/serverless-golang-api-with-aws-lambda-34e442385a6a