What programming language design patterns are most common in Go software engineering?

1 Functional options

One of the challenges of writing Go code is to deal with optional parameters and configuration. Go does not have default values, named arguments, or variadic parameters, which are common features in other languages to handle this issue. Instead, Go developers use a pattern called functional options, which allows them to pass functions as arguments to modify the behavior of a function or a struct. For example, instead of having multiple constructors for a struct with different parameters, you can have one constructor that accepts functional options to customize the struct. This way, you can avoid creating complex and confusing signatures, and make your code more readable and flexible.

2 Interface segregation

Another challenge of writing Go code is to design interfaces that are clear and concise. Go does not have inheritance or generics, which are common ways to abstract and reuse code in other languages. Instead, Go developers use a pattern called interface segregation, which means defining small and specific interfaces that capture the essence of a behavior or a role. For example, instead of having a large and complex interface that defines all the methods of a service, you can have multiple smaller interfaces that define the different aspects of the service, such as logging, caching, or authentication. This way, you can reduce the coupling and dependency between your components, and make your code more modular and testable.

3 Error wrapping

Another challenge of writing Go code is to handle errors gracefully and consistently. Go does not have exceptions or try-catch blocks, which are common ways to propagate and handle errors in other languages. Instead, Go developers use a pattern called error wrapping, which means adding context and information to an error before returning it to the caller. For example, instead of returning a plain error value from a function, you can wrap it with a message, a stack trace, or a custom type that implements the error interface. This way, you can provide more details and insights about the error, and make it easier to debug and recover from it.

4 Dependency injection

Another challenge of writing Go code is to manage dependencies and resources efficiently and securely. Go does not have constructors or destructors, which are common ways to initialize and finalize objects in other languages. Instead, Go developers use a pattern called dependency injection, which means passing dependencies and resources as arguments to functions or structs, instead of creating them inside the function or struct. For example, instead of opening a database connection inside a function that performs a query, you can pass the connection as an argument to the function. This way, you can decouple your code from the concrete implementation of the dependency or resource, and make it more flexible and testable.

5 Context propagation

Another challenge of writing Go code is to handle concurrent and distributed operations effectively and reliably. Go has a powerful feature called goroutines, which are lightweight threads that can run multiple tasks in parallel. However, goroutines can also create problems such as leaks, timeouts, or cancellation. To solve these problems, Go developers use a pattern called context propagation, which means passing a context value along the call chain of goroutines, and using it to control and communicate the state of the operation. For example, instead of using a global variable or a channel to signal the cancellation of a goroutine, you can use a context value that carries a cancel function, and call it when you want to stop the goroutine. This way, you can handle concurrent and distributed operations more gracefully and consistently.

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?