Show and share letter q

 package main import "log" type Container struct { Items[]int32 } func (c *Container) Inspect() { log.Printf("We have %v items", len(c.Items)) } func main() { var c Container c.Inspect() } 2009/11/10 23:00:00 We have 0 items program exited. 

That's good! After all, the []int32 slice is indeed a reference type, and its null value is nil , and len(nil) simply returns zero because, "obviously", the null slice is empty.

And sometimes is not good, because zero values ​​can mean something completely different from what you think:

 package main type Container struct { Itemsmap[string]int32 } func (c *Container) Insert(key string, value int32) { c.Items[key] = value } func main() { var c Container c.Insert("number", 32) } panic: assignment to entry in nil map goroutine 1 [running]: main.(*Container).Insert(...) /tmp/sandbox115204525/prog.go:8 main.main() /tmp/sandbox115204525/prog.go:13 +0x2e program exited. 

In this case, you would first initialize the dictionary ( by the way , which is also a reference type) with make or a dictionary literal.

This alone can already provoke incidents and failures, due to which someone has to be woken up at night, but things can really get worse quickly, given how the channel axioms are revealed in this context:

• Send to channel operation nil permanently blocked

• Operation Operation from the channel Nil is blocked forever

9000 , this option was chosen. It's good that there is such a pprof thing that helps to find deadlocks!

And since there is no way to “go beyond” the values, it should make sense to both receive from closed channels and send to them, because even after you close such channels, you can still interact with them .

(At the same time, in languages ​​like Rust, a channel closes as soon as its Sender is discarded, which happens only when no one can touch it again after - just . The same probably applies to to C++, and to a number of other languages, this is not a new phenomenon).

The wording "zero values ​​make sense" is simplistic and definitely wrong when you consider input... of almost any kind. There are so many situations in which values ​​need to be “one of these known options and nothing else” that sum-types (in Rust, these are enums) were born for such cases.

And in Go, the answer to this problem is "just be careful." The same answer was given in C.

Just don't access the returned value unless you've checked to see if it's an error. Keep half a dozen people carefully reviewing even the most trivial code change to make sure that nothing, zero, or an empty string leaks out of the code everywhere (and to the very depths of your system).

Just one more thing to keep an eye on.

Which, in any case, will not save you from all problems.

That's right! There are always a lot of things to keep an eye on - and even the simplest operations, like downloading a file to disk... are not easy at all! Generally!

Moreover, in almost any language, you can write code with logical errors. And if you try - then, be sure, you can rush the locomotive right into the tree. Moreover, a car.

In this case, there is such a delusion: since it is impossible to solve all problems , don't even try to solve some of them . Following the same logic, you should not financially support anyone individually, because in this case you still won’t help other people who make ends meet.

This is another self-defence tactic: to refuse to consider any version of the thesis other than taken to extremes, while pointing out how absurd it is (ignoring the fact that no one advocates this ridiculous extreme).

Let's discuss this thesis.

Rust is perfect, and you are all fools

How I wish I had those feelings, since it would be so much easier to explain them.

This artificial version is also very easy to break. “How did you end up working with Linux then? It's also written in C. “Rust is insecure, so writing it correctly is incredibly difficult, how do you like this fact?”

Go's success is largely due to the fact that it is "all-inclusive", and there are also hard defaults.

The success of Rust is that it is easy to take in pieces and how gets along well with other languages ​​ .

Both these stories are about success, but these success stories are very different.

If you believe in the conspiracy theory “Rust is a lure”, then why doesn’t everyone immediately discard everything old, choosing “The Only Good Language That Exists”?

Such a position is so far from actual events that it is even tragic.

The Firefox code base is written primarily in C++, but several critical components are written in Rust. The Android project recently reimplemented the entire Bluetooth stack in Rust. Rust crypto code has been able to take hold in Python, HTTP Rust code has found a place in curl (as one of the many backends out there), and Rust patches for the Linux kernel are looking better with each iteration.

All this was not done without complications, and no one involved in these developments denies that, yes, there were problems. But all the work was done progressively and pragmatically, and some elements were ported step by step to a safer language in cases where it was appropriate to do so .

We are very far from the "throw the baby out" approach. The code generation backend for Rust, which literally everyone uses, is a mountain of code written in C ++ (LLVM). It is impossible to recognize any alternatives as its competitors, no matter how hard you strain your imagination - the only exception can be, perhaps, only one more mountain of C ++ code.

Rust's most hardened users are the loudest yelling about issues like how long builds take, the lack of certain features in the language (just give me a GAT!) and all the other shortcomings that just about everyone else talks about.

In addition, it is they who, before everyone else, look out for other, new languages ​​that approach the same problems, but in which problems are solved even better than .

But just like the position “whether to double-check your passport”, it doesn't matter . The current trends may be similar to the propaganda of dangerous bullshit, and we literally have no worthy alternative. It doesn't matter who raises the question!

Inventing false dichotomies, we will not get any closer to solving any of the problems identified.

People who develop an allergy to "big chunks of mutable state without type-sums" tend to gravitate toward languages ​​that are easy to control mutability, lifetimes, and build abstractions. It doesn’t matter that such a language often turns out to be Go and Rust. Sometimes C and Haskell take their place. Still in some cases - ECMAScript and Elixir. I can't speak for them with certainty, but there are such languages.

You don't have to choose between "go fast" and "model the problem space in literally every detail." Also, if you choose Go or Rust, you don't have to "stay true" to one of those languages.

With a lot of effort and care, you can write neat Go code that doesn't come close to strongly typed values, and checks for invariants all the time - just be aware that you won't get any help from the compiler.

Also, you can easily and naturally not bother with many things when writing Rust code. For example, if you're not writing a low-level command-line utility like ls, you can only look after paths that are full UTF-8 strings, which is what camino is for.

An extremely common practice in error handling is to list a few options that we really care about, provide a special handling procedure for them, and sweep everything else into the category “other”, “internal” or “unknown”. These categories can always be broken down later, if necessary, depending on what log analysis reveals.

The "correct" way to assume that an optional value is set is to say it is, and otherwise not use it. This is the difference between call json.Unmarshal and cross your fingers - and call unwrap() on Option .

And getting it all right is much easier if the type system allows you to "announce the whole list" of options - even if they are as simple as "ok" and "not ok".

Which brings us to the next argument, which is (by a margin) the most reasonable in the bunch.

Go is a prototype/seed language

Now we've reached the fifth stage: acceptance .

Good . I'm willing to agree that Go is not good for production services unless your guild is all Go experts (Tailscale) or if you can't spend as much money on engineering costs (Google).

But Go definitely has its own niche.

After all, Go is an easy language to migrate to (because it's so small, right)? There are already a lot of those who have learned it, so it's easy to recruit Go developers, so why not stock up on them for a reasonable price and – uhh! – to prototype a couple of systems?

And then later, when things get more complicated (it always happens with scaling), we either rewrite the code in other languages, or bring in experts, or come up with something.

Everything would be fine, but there is no such thing as a "junk code".

Every tech organization that I know EXCLUSIVELY doesn't like to rewrite anything, and for good reason! It takes time to organize a smooth transition, details are lost in the hustle, new features are slowed down, and employees have to be retrained so that they follow the new track as efficiently as the old one, etc.

Lots of good, good reasons.

Therefore, very few things end up being rewritten. As more and more components are written in Go, there are more and more reasons to continue in the same spirit: not because it suits you well, but because it is always so difficult to interact with existing code bases literally from where anything from outside (except over the network, but even then - see the "Go is an island" section above).

So, basically, nothing ever changes for the better. All the go traps, all those things that you will not be helped to prevent language and compiler are common problems, they affect both beginners and experienced ones. The linter helps to some extent, but it will never do as much as the compiler does in languages ​​where these problems are taken seriously. As a result, such languages ​​only slow down development, although they are promoted precisely as a means for "rapid development".

All the complexity that doesn't live in the language now lives in your code base. All the invariants that you don't have to say when using types now have to be said at the code level. The noise-to-signal ratio in your (very large) code bases will be very unsightly.

After all, it has long been decided that abstractions are for nerds and fools, but what you really need is slices, dictionaries, channels, functions, structures; but in this case it becomes very difficult to trace what the high-level structure of the program is. After all, wherever you look, you will drown in a quagmire of imperative code that performs trivial operations on data or propagates errors.

Because function signatures don't tell you much (does it change data? Does it hold data? Is it okay to have a null value here? Does this code run a goroutine? Can this channel be null? What types can actually be passed for this parameter? interface{}?), you have to rely on documentation that is expensive to update, and not updating is even more expensive - because then more and more bugs will appear.

The reason I don't consider Go a "beginner's language" is precisely this: the compiler accepts so much code that it's almost guaranteed to make mistakes.

It takes a lot of experience in all aspects around the language, everything that Go leaves the programmer to "practice" in order to learn how to write at least relatively good code in Go, and even then, in my opinion, this result is not worth the effort required.

The “worse, the better” argument is never about people seeking to feel their own superiority, for which they are ready to heap unnecessary complexity and then master it.

Quite the contrary, it is an admission that people are bad at maintaining invariants. Everyone. But we know how to make tools that help with this. And focusing on this approach to development requires you to invest well in advance, but such expenses pay off very well.

I thought that we had long ago outlived the belief that "programming is typing", but when I read again and again: "you can write a lot of Go quickly!" - such confidence is lost.

The inherent complexity isn't going away by simply closing your eyes.

Having decided for yourself not to reduce the complexity, you simply shift it onto the shoulders of other developers, your boss, admins, clients, someone else . Now and will have to bend around your assumptions in order to ensure that all elements of the system work smoothly.

Nowadays, I often find myself as someone and I'm already tired of it.

Because at first glance Go is so easy to like, because it's so easy to switch to it - but hard to get off. And because the price paid for choosing Go is slowly realized, cumulative, and only becomes unbearable when it's too late. Our industry is such that we simply cannot afford to gloss over this issue.

Until we begin to demand the best tools for the job, we are waiting for wake-up nights again and again, because some nil value has crept in where it should not be.

This is a Billion Dollar Mistake, yet another.

Let's sum it up

So here's what we stubbornly lie to ourselves by continuing to use Golang: elite 9" just be careful” or add extra linters/watchful eyes

• Since Go is easy to write, it’s easy to develop production software on it

• Since the language is simple, all other things related to it are also simple

• Go can be taken only a little, or just to start, and then we can easily switch from it to another

• Then you can always rewrite.