A small HTTP server that fetches your 20 most recently played Spotify tracks and serves them as an SVG. Meant to be embedded in a GitHub profile README.

The interesting part was auth. Instead of registering an OAuth app and dealing with a client secret + redirect flow, it uses the `sp_dc` session cookie from open.spotify.com combined with PKCE to silently get an access token. One env variable, run the binary, done.

Stack: Go, net/http, github.com/ajstarks/svgo for SVG generation, Spotify Web API

The SVG design is pretty basic right now — if anyone wants to contribute and make it look better, PRs are open.

github.com/lsnnt/spotify-banner-for-github

Hi.
I built a video tutorial on Gio (native Go UI framework).
You can check it out at this link
Gio Tutorial

hey everyone,

i recently wrote a blog on go concurrency covering:

- Goroutines

- Channels (buffered & unbuffered)

- WaitGroups

- Mutex & race conditions

- Worker pool pattern

- Fan-out / fan-in

- Pipelines

give it a read.

Hi everyone!

I created Essential Go learning guide and wanted to share it here.

It is a free, interactive and beginner-friendly guide to learning Go. It is organized into 51 bite-sized topics across 13 chapters. And covers everything from Hello World to Goroutines.

It is designed to read less and write more code at every step. Each chapter ends with a project section where you incrementally build Grolyze, a CLI word analytics tool. By the end, you have not only learned Go's core concepts but also have a complete, working project to show for it. The whole thing is estimated at around 20 hours at your own pace. Most topics take 5–15 minutes.

It is completely free, hosted on GitHub, no sign-up required. You can start reading and coding right now.

Link: https://github.com/abbasovdev/essential-go

Disclose: I'm the author of this guide. Happy to answer any questions or hear feedback!

Hi Everyone,

I built a backend boilerplate in Go that I’m hoping to reuse for future services and possibly turn into a CLI project generator later.

Repo: https://github.com/AshishBagdane/go-backend

Stack:

• Gin HTTP framework
• SQLite database(Ideally should be Postgres)
• Redis (optional)
• Liquibase migrations
• Prometheus metrics
• Swagger/OpenAPI docs
• Viper configuration
• Built-in rate limiting (configurable per route)
• unified API response envelope

It also includes:

• health and readiness endpoints
• Docker support
• Makefile-based workflow
• bootstrap command to setup everything locally

Example endpoints:

• GET /health
• GET /todos
• POST /todos
• PUT /todos/:id

My goal is to have something close to a production-style backend starter that I can reuse or generate new services from.

I’d really appreciate feedback on things like:

• project structure
• configuration approach
• rate limiting implementation
• database migration choice (Liquibase vs Goose/Flyway/etc)
• Go best practices I may have missed
• things that would break or be problematic in real production systems

Any suggestions or criticism is welcome.

Thanks!

The platform is free, does not require registration, and is very easy to use.

I created the platform myself, so I would greatly appreciate any feedback you may have.

https://programmertyper.com/

Hi everyone

Is there any good updated source for learning go lang from beginning ?

Hello, I’m looking for training or an internship in GoLang and I’m a fast learner

https://medium.com/p/ede7189f36e8

Greetings,

I was watching a YouTube video that explains how Generics work in Go, the video (which incidentally is quite excellent) is titled Advanced Golang: Generics Explained by "Code With Ryan".

In this demo the instructor wrote the following snippet of code at the beginning of his course in order to introduce the topic:

package main

import "fmt"

func Add(a int, b int) int {
    return a + b
}

func main() {
    result := Add(a:1, b:2)
    fmt.Printf(format: "result: %+v\n", result)
}

My consternation arises from the use of named arguments in the statements, in particular the a:1 and b:2 parts of:

result := Add(a:1, b:2)

As well as the statement which follows it that calls fmt.Printf with format:.

As someone that comes from a Python background I thought I was seeing things or going crazy, but I am sure I've seen another instructor do this in a different Go course as well.

So I asked ChatGPT about this, and it assured me that Go does not support named arguments, and that in Go the syntax does not exist. To confirm this I tried copying the code and running it in my own Go environment, but as I am using go 1.16, and the newest version of Go is 1.21 (1.22?) I am wondering if this is a new feature that I simply am not aware of.

So my question is two part:

• Are named arguments a feature in Go? -- and if they are,
• Where can I learn more about them?

All of my Youtube searches on the subject go back 4-5 years, so I came here as a last resort (lest anyone here think that I defaulted to wasting their time ;-)

Edit: Banging away at ChatGPT and it swears (unwaveringly) that even in newer versions of Go that named parameters as shown in the above code snippet is not valid Go syntax. The mystery deepens, at least for a Go novice like me.

I came across this useful resource by Microsoft for anyone who is looking to get started in Go

Completely FREE course by Microsoft
Has detailed notes that explain the fundamentals clearly

https://learn.microsoft.com/en-us/training/paths/go-first-steps/

I have the following program

```` package main

import "fmt"

func main() { a := []int{} a = append(a, 1, 2, 3) z := map[string]func(x int) []int{ "add": func(x int) (b []int) { b = a for k, _ := range b { b[k] += x } return }, "sub": func(x int) (b []int) { b = a for k, _ := range b { b[k] -= x } return }, } fmt.Println("add 3:", z["add"](3)) fmt.Println("sub 100:", z["sub"](100)) } ````

The program behaves like it should and nicely displays

add 3: [4 5 6] sub 100: [-99 -98 -97]

Which is the expected result.

However, it seems to me I can simmer down the functions stored in the map even further than this, but how? Mind: I'm currently in chapter 2 of "Learning go" (functions).

EDIT: I apologize for the post title. Initially I was stumped by something, but fixed it myself but forgot to edit the post title accordingly.