[0xdeadb00f]

To say go's simplicity is a lie, then to go and and say this;

> This function signatures tells us a lot already. It returns a Result, which means, not only do we know this can fail, we have to handle it. Either by panicking on error, with .unwrap() or .expect(), or by matching it against Result::Ok / Result::Err, or by bubbling it up with the ? operator.

What the hell? I'm not a rust dev. I have no idea what half of this means. "bubbling up"? What the fuck even is that?

[miloignis]

What's your argument? The point the article is making is that Go says it's simple, but isn't, while Rust doesn't say that it's simple, and uses its complexity to solve the complex problem.

Bubbling up means returning the error to the caller, and is general error handling jargon.

[shadowgovt]

And the reason Go keeps a toe-hold in the ecosystem is that file-handling is simple for most people, most of the time.

Rust is expressing the full complexity of a twisty maze of corner-cases built up from decades of filesystem features being slapped on with no care for each others' existence. Go just says "Sure, but you won't need most of that most of the time; here's a subset that usually works." So it solves most people's problem most of the time with far less words (with the trade-off that if you get burned, you get burned).

[0xdeadb00f]

Just because Go doesn't have a consistent API for file stuff, does not make it 'not simple' it makes it inconsistent. It is still simpler, and easier for me to understand ALL of the Go code on screen, than it was for me to understand just that rust function signature, and all the stuff in the paragraph I posted.

[joelfolksy]

I hear you. People keep saying Spanish is an easier language than English, but yesterday I pulled up an article written in Spanish and I couldn't even read the first word.

[mcronce]

"Bubbling up" is common parlance for "exit this function early and return the error we got from our callee" (or "wrap the error we got from our callee and return that")

In Go, this looks like

   thing, err := call()
   if err != nil {
       return nil, er
   }

In Rust, this looks like

   let thing = call()?;

[0xdeadb00f]

People keep telling me this is common nomenclature but I have never heard of it until today.

[NavinF]

https://xkcd.com/1053/

[dralley]

>"bubbling up"? What the fuck even is that?

When you throw an error and don't catch it, you just let the error immediately propagate up to the calling function. Think "return err"

>> Either by panicking on error, with .unwrap() or .expect()

This means fatally terminating the program immediately when an error is encountered in this spot.

>> or by matching it against Result::Ok / Result::Err

Result is an enum can be one of either Ok<T> or Err<E>. Pattern matching is one way of finding out which, and running code depending on which variant it is. It's just a fancy and convenient if statement, if that helps.

[0xdeadb00f]

Thanks. The point of my comment was not to actually ask someone to explain it to me, but again, thank you for explaining it, I appreciate it.

[Rygian]

"Bubbling up" is the default in C++, when the code you call throws an exception and you don't have a try/catch for it.

[taneq]

Do C++ people actually call it "bubbling up"? I don't think I've used a language where this isn't the default behaviour so I'm not sure I've ever heard it given an actual name, it's just what happens when you don't catch the exception - it keeps going until someone does catch it, or it hits the runtime and demolishes your program.

[dgritsko]

I've heard "propagating" the exception used as well.

[taneq]

Now that you mention it, I think this is the term I've heard for it when it has been mentioned. The exception propagates upwards.

[NavinF]

Yes, but not just in C++. Bubbling up errors is a common phrase in Java and Python.

[mynameisash]

I often use and hear "bubbling up" in non-tech discussions, too. It's not at all uncommon, IMO.

[jeroenhd]

I've heard this term more often in JS contexts than in C++ contexts, to be honest. I don't think C++ programmers use the term all that often, though the reference to error propagation will probably be understood anyway.

[metadat]

Bubbling is what my guts do when they're unhappy. Not a great programming term.