Explore >> Select a destination

You are here

 kokada.dev
My coding experience with LLM - kokada
| | kokada.capivaras.dev
An unordered list of things I miss in Go - kokada
6.5 parsecs away

Travel
| |
| | willhaley.com
Migrate Markdown Engine from Hugo - Will Haley
15.2 parsecs away

Travel
| | I recently decided to migrate my blog platform from Hugo to my own home-grown solution. Hugo's great, but I want something simpler and under my control. My own blogging platform/generator is only ~300 lines of code and I intend to keep it that way. One snag with my change is that, even though my source markdown/frontmatter files weren't changing, the generated HTML would. The reason is that markdown processors and rendering/templating engines can generate subtle (or not-so-subtle) different outputs from the same source markdown.
| | konradreiche.com
Context is for goroutine cancellation
16.5 parsecs away

Travel
| | Starting a goroutine is as easy as adding the go keyword in front of a method, but managing the lifecycle of a goroutine is not. If you only need to start a few goroutines and wait for their completion, you are off the hook thanks to sync.WaitGroup. However, what if a goroutine has to run for a specific duration or repeatatly in a loop until the initiating code terminates? Does it matter? After all, if the main goroutine terminates, any other goroutine will also stop. It does matter, because depending on what the goroutines are doing, it might leave your system in an inconsistent or invalid state. Channels are a commonly used to signal to a goroutine that it can shut down, but I often see the use of a signaling channel, for example chan bool or chan struct{}.
| | threedots.tech
How to implement Clean Architecture in Go (Golang) | Three Dots Labs blog
100.1 parsecs away

Travel
| In this guide, we share our pragmatic approach to Clean Architecture in Go, refined through years of real-world experimentation. We demonstrate refactoring techniques on a live project, showing how to extract application logic, define interfaces, and improve testability. You'll learn how to apply Clean Architecture principles in an idiomatic Go way, balancing theory with practical implementation. Our battle-tested methods help you create loosely coupled, highly cohesive code that's easier to maintain and extend over time.