Mastering Go Application Design: HTTP Servers (Part 1)

Part 1 , Part 2 Go is an excellent choice for writing your next http service. It supports multithreaded request handling with the standard library and many other convenient features that makes creating a new application a breeze. Here is an example of a http service that returns the current time as json. Playground: https://go.dev/play/p/gZGKLEhHkPR

Mastering Go Concurrency: Running Background Tasks with Goroutines (Part 5)

Part 1 , Part 2 , Part 3 , Part 4 , Part 5 Goroutines can be used to start independent long running task. These tasks can be entire microservices, which is very useful for creating a single application with multiple system responsibilities. The select statement will block and wait for a channel to be ready for reading, then after reading from the channel the code will be executed. Playground: https://go....

Mastering Concurrency in Go: Decoupling Data Transfer With Buffered Channels (Part 4)

Part 1 , Part 2 , Part 3 , Part 4 , Part 5 Buffered Channels in Go are similar to unbuffered channels, but they allow a writer to write without blocking if the channel is not full, which can be useful for concurrent data processing where the reader needs to be decoupled. However, using buffered channels can consume memory even when the buffer is empty, so they should be used with care....

Debugging like a Pro: Lessons from My Time at Spotify

#debugging #automation #softwareengineering Useful Logging Logs are one of the most basic and vital sources of information when debugging an application. Here are a few tips to make your logs more useful: Aggregation is a must. In a distributed system, logs must be aggregated into a single location so that they can be queried. Related logs should be linked by a unique, queryable identifier. Logs that originate from a single HTTP request should all have the same ID so that the flow of logic and data can be easily queried....

Golang Anti-Pattern: Why You Shouldn't Return Interfaces

Returning an interface in Golang will reduce type safety and increase complexity of your code. Instead of returning an interface, you should return a concrete type and pass it directly to a function that accepts an interface your concrete type implements.