
Experiment, Simplify, Ship - stablemap
https://blog.golang.org/experiment
======
Sytten
I personally think they missed one big pain point of Go: the logging. The
standard logging should be an interface for structured logs that can be
implemented by various vendors instead of the current really basic logger.
This is especially bad for third party libraries that either force you to use
one logging library (logrus, zap, etc) or built their own custom interface
which you then have to implement yourself for your logger. That is something
they should have stolen from Java...

~~~
xyzzy_plugh
Libraries generally shouldn't depend on concrete loggers. Plumbing a logging
interface throughout is a marginal improvement, but really they should provide
a a structured tracing interface to let callers decide what events they care
about, and how to act on that information.

For example, the httptrace package provides a set of hooks you can opt in to
for various http events.

That being said I've only ever experienced a lot of pain when libraries use a
global logger. Otherwise it's usually pretty painless to adapt one logging
library to another.

------
frou_dh
This was an exhausting read because Rich Hickeys "Simple Made Easy"
presentation from years ago transmitted a mind-virus to me where I have to
stop and have an internal conflict every time I read simpl(e|ify) in a
programming context.

It's notable how so many independent programming communities seem enamored
with Simple being the goal, yet probably don't even agree on the definition of
the term.

~~~
vizzier
Is that this?
[https://www.youtube.com/watch?v=34_L7t7fD_U](https://www.youtube.com/watch?v=34_L7t7fD_U)

~~~
frou_dh
Here's the original location that has synced slides:
[https://www.infoq.com/presentations/Simple-Made-
Easy/](https://www.infoq.com/presentations/Simple-Made-Easy/)

------
coldtea
There's an eerily condescending tone throughout the piece. It's addressed to
programmers and discusses topics like error handling and generics, but talks
up trivial concepts as if they're unique, or as if the Go team has thought of
them first, or something...

"Experiment, simplify, ship"? Yeah, who would have thought of that! Surely
other language teams never do the same...

It's doubly annoying when the whole process involves trivial issues, long ago
solved to satisfaction in tons of similar languages... (e.g. Optionals for
error handling).

~~~
ehnto
This tone has been prevalent in tech writing for years. It's like we all
learned to write by listening to TED talks. When I first started coming across
the tone as I was learning to be a developer, it was all really fresh and
exciting. Everything was so aspirational.

I try to just gloss over it now and let it be, because you never know who
might be getting motivated by it like I was, and I would hate to think I
ruined their excitement by being jaded about it. But it is still pretty
annoying to read.

