One of the oldest and most persistent complaints about Go concerns the verbosity of error handling. Despite the efforts of the Go team to address this issue, the problem persists.

The Problem with Error Handling

The issue lies in the way error handling is implemented in Go. The traditional approach involves checking for errors using a long chain of if statements, which can become cumbersome and difficult to read.

• The test if err!= nil can be so pervasive that it drowns out the rest of the code.
• Programs that do a lot of API calls often rely on this pattern, making error handling rudimentary.

This code pattern has been a source of frustration for many Go developers:

“`go

x, err := strconv.Atoi(a) if err!= nil { return err } y, err := strconv.Atoi(b) if err!= nil { return err } fmt.Println(“result:”, x + y) return nil

“`

This code is not only verbose but also hard to read and maintain. The Go team has tried to address this issue with several proposals, but none have gained sufficient traction.

A Proposed Solution

In 2018, the Go team proposed a solution based on a check and handle mechanism. The proposal was based on a draft design by Marcel van Lohuizen and was intended to provide a more comprehensive approach to error handling.

The proposed solution involved using a check and handle mechanism to handle errors. The check pseudo-keyword was intended to be used to identify errors, while the handle part would provide a way to handle them.

The proposal was deemed too complicated and was later simplified to the try proposal in 2019. However, the try proposal was also met with criticism and was eventually abandoned.

Current State of Error Handling

The current state of error handling in Go is that there is no single, widely accepted solution. The Go team has proposed several solutions, but none have gained sufficient traction.

1. The check and handle mechanism proposal was deemed too complicated.
2. The try proposal was simplified but also met with criticism.
3. The? operator proposal was also met with criticism.

The Go team has decided to stop pursuing syntactic language changes for error handling and will close all open and incoming proposals that concern themselves primarily with the syntax of error handling.

Why Not Change the Language?

The Go team has decided not to change the language to address the issue of error handling because the proposal process is not conducive to reaching a consensus.

• The proposal process is not conducive to reaching a consensus.
• Changing the language is expensive and requires a concerted effort.

The Go team believes that the current state of error handling is not a problem that needs to be solved through a language change. Instead, they recommend focusing on improving error handling practices and providing better tools and support for developers.

Conclusion

The issue of error handling in Go is a complex one, and the Go team has tried several approaches to address it.