sleep_deprived @ sleep_deprived @lemmy.world

Posts

0

Comments

70

Joined

2 yr. ago

Having made the choice to use GTK for a Rust project years ago - before a lot of the more Rust-friendly frameworks were around - this is exactly why I chose it. Nothing to do with DEs or any of that, just looking for a better coding experience. Now I'd probably choose one of the several Rust-focused solutions that have popped up though.

That's good for handwriting, but digitally I prefer 𝟶. Either is acceptable though.

Watch out, Jedi code didn't work too well for Anakin

At sea? Chance in a million!

As an American this is how I feel. I don't mind Fahrenheit but for absolutely everything else I desperately wish we'd switch.

It's very well documented that machine learning will have the same biases its training set does. Years ago this was a big deal when Google tried to use ML for hiring but it kept ending up racist.

I learned that after reading this xkcd and then the list. Which was concerningly recently.

I guess on the bright side it was the only misconception on the list that I had.

The issue is not just that a bad update went out. Freak accidents can happen. Software is complicated and you can never be 100% sure. The problem is the specifics. A fat finger should never be able to push a bad update to a system in customers' hands, forget a system easily capable of killing people in a multitude of ways. I'm not quite as critical as the above commentor but this is a serious issue that should raise major questions about their culture and procedures.

This isn't just some website where a fat finger at worst means the site is down for a while (assuming you do the bare minimum and back up your db). This is a vehicle. That's what they meant about the CAN bus - not that that's really a concern when the infotainment system just gets bricked, but that they have such lax procedures around software that touches a safety-critical system.

Having systems in place to ensure only tested, known good builds are pushed is pretty damn basic safety practice. Swiss cheese model. If they can't even handle the basics, what other bad practices do they have?

Again, not that I think this is necessarily as bad as the other person - perhaps this is the only mistake they've made in their safety procedures and otherwise they're industry leaders - we don't know that yet. But this is extremely concerning and until proven otherwise should be investigated and treated as a very serious safety violation. Safety first.

I mean yeah, we should absolutely be replacing as much fossil fuel use as we can with existing renewable energy tech. But there's no reason we shouldn't also be investing in fusion research, at least as far as I'm aware

For reference, OTV stands for "orbital transfer vehicle", basically something that can change its orbit via onboard propulsion. And Tom Mueller is the guy behind Merlin and Raptor. Almost certainly SpaceX wouldn't be anywhere near what it is today without him.

Currying is converting a function with n parameters to n functions that each have one parameter. This is done automatically in most primarily functional languages. Then, partial application is when you supply less than n arguments to a curried function. In short, currying happens at the function definition and partial application happens at the function call.

Currently the type of test_increment is (int, int) -> unit -> unit. What we want is int -> int -> unit -> unit. The more idiomatic way would have this function definition:

    
let test_increment new_value original_value () =

  

Which would require this change in the callers:

    
test_case "blah" `Quick (test_increment 1 0);

  

See, in most primarily functional languages you don't put parentheses around function parameters/arguments, nor commas between them - in this case, only around and between members of tuples.

I'm not an OCaml person but I do know other functional languages. I looked into Alcotest and it looks like the function after "Quick" has to be unit -> unit. Because OCaml has currying, and I think test_increment already returns unit, all you should have to do is add an extra parameter of type unit. I believe that would be done like this:

 OCaml

    
let test_increment (new_value, original_value) () =

  

Now the expression test_increment (1, 0) returns a function that must be passed a unit to run its body. That means you can change the lambdas to e.g. this:

 OCaml

    
test_case "blah" `Quick (test_increment (1, 0))

  

I don't know OCaml precedence rules so the enclosing parentheses here may not be necessary.

I'd also note that taking new_value and original_value as a tuple would probably be considered not idiomatic unless it makes sense for the structure of the rest of your code, especially because it limits currying like we did with the unit being able to be passed later. Partial application/currying is a big part of the flexibility of functional languages.

Edit: if you're getting into functional programming you may also consider calling increment_by_one "succ" or "successor" which is the typical terminology in functional land.

I certainly do, thanks for the correction!

The China thing is stupid but the review after the failure of the pad and the FTS isn't really what this is about. I'm sure SpaceX would be happy if they could talk congress into relaxing that type of thing too, the reality is that by all accounts both parties are happy with the way the safety review has gone, and with this type of thing the FAA works very closely with SpaceX (though I suspect Elon will be upset if the Fish and Wildlife Service consult takes long given his impressive record of stupidity). In fact, given the wording the SpaceX rep used, I'd bet his mentioning Starship and the Moon is because Artemis is very important to a lot of people in Congress for several reasons - if this were about Elon's ego and disregard for safety, I expect they'd instead mention Mars and China's growing economic, not scientific, rivalry with the US. But that's besides the point.

The real issue at hand for the FAA, and the reason for this hearing, lies in the fact that starting with the Falcon 9, commercial space launches are becoming more and more routine, and they're only going to keep picking up the pace as Starship, Vulcan, Proton and others enter service. And while at the moment the FAA is managing to keep most things running, they're critically understaffed for the workload to begin with before you even take into account the pace at which the space scene is changing. And most of what was said in the article lines up with what the FAA says, which is basically "sorry guys, we're doing the best we can, but we don't have enough people". I think this quote from SpaceX does a much better job than the crap they have to tell senators:

"Our concern is even today Falcon and Dragon are sometimes competing for FAA resources with Starship, and the FAA can’t handle those three activities together. So let alone what's coming next year, or maybe even later this year, we just don't think the FAA is staffed ready to support that."

They also recommend that the FAA be allowed to use NASA's and the Space Force's resources, which sounds like a great idea worth exploring to me. It should also be mentioned that these complaints are almost exclusively targeted at unmanned space flight, and that manned space flight is a different story entirely and not really relevant to this hearing.

So really a better non-sensational title would be "FAA understaffed for space boom even with doubling of staff, says space companies" or something along those lines.

Fantastic, thank you for that

No, and the above commentor is a little mixed up. While we originally thought the benefit of RISC CPUs was their smaller instruction set - hence the name - it's turned out that the gains really come from a couple other things common to RISC architectures. In x86 pretty much every instruction can reference memory directly, but in RISC architectures you can only do it from a few specific instructions. Modern RISC architectures actually tend to have a lot of instructions, so RISC means something more like "load/store architecture" nowadays.

Another big part of RISC architectures is they try to make instruction fetch+decode as easy as possible. x86 instructions are a nightmare to decode and that adds a lot of complexity and somewhat limits optimization opportunities. There's some more to it, like how RISC thinks about the job of the compiler, but in my experience load/store and ease of fetch+decode are the main differentiators for RISC.

More towards your question, a lot of the issues with running x86 programs on ARM (really running any program on a different architecture than it was compiled for) is that it will likely depend on very specific behaviors that may not be the same across architectures and may be computationally expensive to emulate. For some great write-ups about that kind of thing check out the Dolphin (Wii emulator) blog posts.

I think the point is that since it's open source, there's not as much worry of Microsoft ruining a good thing.

Excuse me but I have it from a very reputable source that the saying goes "fool me once...

Shame on... Shame on you.

Fool me-- can't get fooled again"

I've heard of lots of people that have won against the ceiling. The trick is to go from the attic and just jump down onto it!

Eh, I'll take assembly over like Perl any day. I may be biased since I like to reverse engineer though.