hurril

But they don't do the exact same thing at all. One comes preloaded with apps you didn't choose and news or ads right on the task bar. Apple does none of that.

I'm relatively new to Rust. I use panic (and cousins) in fn main only. As in: I'll expect(), unwrap() or similarly handle missing bootstrapping circumstances. Outside of main, I'll never ever use any of them. Even when I "know" that a condition is Impossible(tm).

Of course not. They would move countries to the currently best option.

Downvote it all you want. I've spent the last decade writing in this style and to me it's second nature. Starting Rust I've had to basically relearn solving problems with loops and iterators. Solving problems with loops is not the way I think.

Never once thought negatively of Rust for this.

Safe isn't the best word to describe it with. But it does mean that any expression or statement always has two possible control flows. You have the "surface flow" as well as the exceptional flow, so there's an added complexity.

I never felt this was a problem when I did Java though (despite their awkwardness - basically forcing coders to not use checked exceptions.)

Rust's control flow syntax for Results and Options are very similar to this but with an added benefit: you don't have to use the ?-operator.

panics is different, however. They are more akin to the way any Java program will happily OutOfMemoryError or NoClassDefFoundError given circumstances not (always) in your control.

After a few weeks, I am disappointed in not being an expert at $new_thing. $new_thing bad!

How much taxes will be paid in the EU when the giants leave? Ireland is making a judgement here, one where they understand that they have more to gain this way. That is: unless you are trying to make the claim that they have been bribed by Apple.

It's weirder that they are not able to decide for themselves what goes on in Ireland.

Apple does not need another defence lawyer so I am not one.

But the point so many of you seem to miss, is that for the people that don't want the upgrade, their kit is cheaper. They're letting the upgraders pay for the standard piece of kit. Same goes for the ridiculous price for the monitor stand(s).

All of Apples stuff costs $$$ because we still choose to pay for _it_ instead of going for the alternatives. So a lot of us consider it _better value_ that way; as in: we think that this is the cheaper deal.

You might not understand this, or say that people that buy from Apple are delusional or agreeing to being over charged. But would not be correct. I'm not forced to buy it, I simply participate in a market place where I exchange enough money to get enough value.

So in effect, I'm then also saying that the competing offers are actually too expensive. I would not pay more than $500 for a fully kitted PC laptop because they are simply that shitty.

This is not right. This is a desktop and I use it to write programs which implies invoking a compiler. Having a snappy UI is important but short compile times can be importanter(!) once a baseline latency has been achieved.

I know! And it was not under Apple's control in any sense. This is my point!

Why has this been downvoted? Who is upset by this?

Apple doesn't have (tight) control over the whole software stack. This is something people say and probably believe.

They don't write Haskell, Postgres, Rust, Java, Scala, Firefox, Spotify, VS Code, Postico or any number of the other software that I run.

They (Apple) released _their_ software and the necessary tools to make it possible for all the software vendors to port all their code in their time, basically. But it all ran (runs!) on both Intel and ARM, still.

It's not even that, it's a call to enter a never-ending recursion. How is it that that god is permitted to exist without reason where the hydrogen atoms somehow needs an origin?

Please assemble your god or accept my eternal hydrogen.

This post, more than anything, comes across as you being a C zealot.

I'm new to properly native languages, but having worked with Rust for 6 months, I've yet to encounter a single crash that wasn't on part of my error handling.

I _love_ C and I've written one C program every year for the last decade or two. I generally write something really stupid, but there's going to be crashes that "prints the stack pants." As in: I'll fudge up returning the stack from a function, basically.

This proves nothing, of course. But Rust won't even let me fudge things up that way. This means that I have more time to spend fixing those other classes of bugs and that is the win!

This is a silly argument. Making a language _memory safe_ protects against one class of bugs and that has merit in and of itself. The fact that there are more classes does not negate the value of that. To borrow(lol!) your own analogy here: it makes $language Safer. Not safe.

Very much so. I've gotten better at simply dealing with the fact that I don't undertand wtf I'm doing, and to just accept that at the outset. Now, this is in no way unique and I'm no snowflake. But there's a definite cost.

I can definitely say that I am a mapper and not a packer. But I can also say that I am pretty much _all_ mapper and no packer. This means that it takes me forever to understand a lot of things that presumed packers (or more balanced individuals) would get in a jiffy. This is not intended as a humble brag! For the longest time on some projects I just don't f**ing get it, I start to feel dumb and in way: out of place. The imposter syndrome makes itself heard. It's genuinely uncomfortable.

But then I start to get it and finally do get it. The packers are now "experts" at their acquired knowledge and seem to have a hard time changing opinion where they should.

Back in school I had real problems getting good enough in subjects that required learning pieces of fact that don't quite go together or display some inherent system. My friends didn't. Things that have a system or are "logical" in the wider sense, easy peasy.

EDIT: I would call myself a decently accomplished programmer and engineer at this point after 25 years or so working with it.

I always thought the perspectives of this question is weird. Are people asking to be paid more than they work, or is someone forcing them to work full time?

I totally understand the urge (and suggestion) to not work too much on the other hand.

The literal minded of you perhaps were not there when Google arrived at the scene. And as you admit: you don't really know if there is a difference. Yet hearing about others that perceive difference makes you very tired.

I was there. We used Altavista and Yahoo and they rocked. Until we tried Google.

Your tiredness is of course both relevant and substantiated.

Why is that a bad example? It's proof that implementing From does not solve the problem.

Then what does this mean?

let x: u8 = E::Rest(0).into();

let y: E = x.into();

How are they measuring that Java is trending?

We need to differentiate a little more here. Instead of me having to watch another f*ing viagra ad, since I'm male and above 40, we should instead talk about substituting ads with getting actual fecal matter thrown at us. Your argument still applies. I should accept this because it is in my interest to support advertisers, since, really, I work for one. (In that I work for a private company that also pays for ads.)

Now before you dismiss this as childish and/ or obnoxious: please consider the point. We cannot gloss over _what_ we "have" to watch and not just that it's an ad.

It is true that things have to be paid for and I am 100% for this. But if you want me to basically degrade myself in order for me to get to watch your content, then wtf?

Moral hazard and inflation. If I know that I will be bailed out with a certain probability, then my actual cost of capital is much lower (since I am not expected to pay the entire volume of interest.)

For instance: why not make the investors whole again instead by giving them the "printed money" instead of going through the middle-man of propping up these failed giants?

Diffs come with column offset coordinates, though, so perhaps it's your diff editor that needs some more muscle?

Nice! Thank you! I'd forgotten about that technique - think I read about it in a ancient compiler book (by french authors no less!)

EDIT: this was a really interesting read!

I figured as much but was unsure. So the gain is that you still take heap allocations, but you do it in a "novelty" heap allocator that you will probably dipose of entirely at some point?