Here we present an example where Go’sinterfacesmade it easy to refactor some existing code to make it more flexible and extensible.Originally, the standard library’sRPC packageused a custom wire format calledgob.For a particular application, we wanted to useJSONas an alternate wire format.

We first defined a pair of interfaces to describe the functionality of theexisting wire format,one for the client, and one for the server (depicted below).

type ServerCodec interface { ReadRequestHeader(*Request) error ReadRequestBody(interface{}) error WriteResponse(*Response, interface{}) error Close() error}

On the server side, we then changed two internal function signatures toaccept theServerCodec interface instead of our existinggob.Encoder. Here’s one of them:

func sendResponse(sending *sync.Mutex, req *Request, reply interface{}, enc *gob.Encoder, errmsg string)

became

func sendResponse(sending *sync.Mutex, req *Request,  reply interface{}, enc ServerCodec, errmsg string)

We then wrote a trivialgobServerCodec wrapper to reproduce the original functionality.From there it is simple to build ajsonServerCodec.

After some similar changes to the client side,this was the full extent of the work we needed to do on the RPC package.This whole exercise took about 20 minutes!After tidying up and testing the new code,thefinal changeset was submitted.

In an inheritance-oriented language like Java or C++,the obvious path would be to generalize the RPC class,and create JsonRPC and GobRPC subclasses.However, this approach becomes tricky if you want to make a further generalizationorthogonal to that hierarchy.(For example, if you were to implement an alternate RPC standard).In our Go package, we took a route that is both conceptually simpler andrequires less code be written or changed.

A vital quality for any codebase is maintainability.As needs change, it is essential to adapt your code easily and cleanly,lest it become unwieldy to work with.We believe Go’s lightweight, composition-oriented type system provides ameans of structuring code that scales.