This fake “simplicity” runs deep in the Go ecosystem. Rust has the opposite problem - things look scary at first, but it’s for a good reason. The problems tackled have inherent complexity, and it takes some effort to model them appropriately.
Here we have a language, like Go, who's marketed as simple and beginner friendly (which it is, it's not a lie) and by its design and its choices inevitably has to hide some complexity. What happens, according to the author and other people he links to, is that some of these choices are made at the expense of correctness.
Is simplicity even achievable if we decide that complexity is inevitable? I think this is why language design is so hard. Software itself is an attempt of managing complexity while trying to solve a problem.
If we say that Go's designer did a terrific work at hiding complexity (and they did, I'm not disputing that), is Go's blanket too short or at least not big enough for stuff to crash and burn when you start exploring those borders?
If you're familiar with Go, the entire discussion around error handling and interface management vs generics is a discussion around simplicity of usage vs complexity of domain.
Adding this thought from a proper rant: I want off Mr. Golang's Wild Ride:
Here we have a language, like Go, who's marketed as simple and beginner friendly (which it is, it's not a lie) and by its design and its choices inevitably has to hide some complexity. What happens, according to the author and other people he links to, is that some of these choices are made at the expense of correctness.
Is simplicity even achievable if we decide that complexity is inevitable? I think this is why language design is so hard. Software itself is an attempt of managing complexity while trying to solve a problem.
If we say that Go's designer did a terrific work at hiding complexity (and they did, I'm not disputing that), is Go's blanket too short or at least not big enough for stuff to crash and burn when you start exploring those borders?
If you're familiar with Go, the entire discussion around error handling and interface management vs generics is a discussion around simplicity of usage vs complexity of domain.
It takes a few lines of code in Go to make a concurrent program, but it takes roughly the same amount of code to make an incorrect concurrent program.
Where does the real issue lie here?