Comment by zac23or

Great article!

I like Go and Rust, but sometimes I feel like they lack tools that other languages have just because they WANT to be different, without any real benefit.

Whenever I read Go code, I see a lot more error handling code than usual because the language doesn't have exceptions...

And sometimes Go/Rust code is more complex because it also lacks some OOP tools, and there are no tools to replace them.

So, Go/Rust has a lot more boilerplate code than I would expect from modern languages.

For example, in Delphi, an interface can be implemented by a property:

  type
  TMyClass = class(TInterfacedObject, IMyInterface)
  private
    FMyInterfaceImpl: TMyInterfaceImplementation; // A  field containing the actual implementation
   public
     constructor Create;
     destructor Destroy; override;
     property MyInterface: IMyInterface read  FMyInterfaceImpl implements IMyInterface;
   end;

This isn't possible in Go/Rust. And the Go documentation I read strongly recommended using Composition, without good tools for that.

This "new way is the best way, period ignore good things of the past" is common.

When MySQL didn't have transactions, the documentation said "perform operations atomically" without saying exactly how.

MongoDB didn't have transactions until version 4.0. They said it wasn't important.

When Go didn't have generics, there were a bunch of "patterns" to replace generics... which in practice did not replace.

The lack of inheritance in Go/Rust leaves me with the same impression. The new patterns do not replace the inheritance or other tools.

"We don't have this tool in the language because people used it wrong in the old languages." Don't worry, people will use the new tools wrong too!