I thought they meant Directed Acyclic Graph [0].

[0]: https://en.wikipedia.org/wiki/Directed_acyclic_graph

Do you have a link to some of these? I'm interested now :D

This happens all the time on a lot of platforms. Even Protonmail would sometimes flag my work MFA emails as spam.

Things like this always tend to give off a Streisand effect - I had never heard of House of Zana before this, and this article prompted me to look into it.

Solid idea. But as others have said a demo or some example screen caps would be nice.

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.

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).

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.

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.

"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()?;

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

>"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.

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.

"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.

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.

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

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.

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

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

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.

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

If Twitter is the closest thing to a global consciousness we are all doomed as a species.

How can someone even claim this? Twitter is a cesspool, I thought people on Twitter knew this. But apparently not.

That being said, it is @jack who is saying this. So I'd take it with a massive tablespoon of salt.

If Twitter is a consciousness, then it's one that's all "id":

the instinctual component of personality that is present at birth, and is the source of bodily needs and wants, emotional impulses and desires, especially aggression and the libido (sex drive).

It doesn't have even a shadow of "superego" to put in charge of moderating its wants and desires. It's an infant -- an infant that is never going to grow up.

If it's a "global consciousness", then it's a consciousness of an entity I do not wish to ever meet. It's a terrible person, and it's only getting worse.

Humanity taken as an average is also a cesspool, don't let anyone mislead you any further than right here.

Damn..

No you don't. You just join a general purpose instance that doesn't block nsfw instances. These are plentiful.

I've done this with bitmap fonts before. Fun times