If you prepare an installation USB stick, so-called “Live-USB”, and select in the BIOS that it should boot from that, then you can test-drive Linux before you install it.
There is more details involved, like you may need to turn off Secure Boot in the BIOS, but yeah, point is, you don’t have to commit to Linux to try it.
Yeah, my current software project at work was basically half a year of feature development and since then, we’ve purely tried to get it into the real world, which meant evaluating use-cases to see where it falls flat and what needs stabilizing, as well as figuring out people’s needs and how our software can assist with that, then setting up a demo and hoping they find money somewhere…
My problem was that “Albert Heijn” is a dude’s name. It does not exactly scream “we’re talking about a real physical building”.
For all I knew, the impossible problem we’re solving could’ve been on a mathematical plane, named after mathematician Albert Heijn. “Sweeping” just as well can be used in an abstract sense.
Obviously, I did think of physically sweeping a physical floor first and foremost, but especially with the rest of the blog post being so entirely abstract, I had doubts on that for far too long, which did not make it easier to understand.
Probably could’ve mentioned at some point in that whole article that Albert Heijn is a supermarket chain: https://en.wikipedia.org/wiki/Albert_Heijn
Pretty sure, people drawing for commissions would typically use a drawing tablet… ^^’
In many cases, you don’t need an equivalent to finally, because the cleanup is automatically handled via the Drop trait, which runs cleanup code when the object is freed from memory (similar to “destructors” in some other languages).
Because of Rust’s whole ownership thingamabob, it’s generally entirely deterministic when this code will run (at the closing brace for the scope in which the object is defined, unless you pass that object outside of that scope).
In other cases, you don’t need a finally, because nothing forces you to bubble up errors instantly. You can make a call which fails, store the error in a variable, run your cleanup steps and then return the error at the end of you function.
Sometimes, however, you do want to bubble up errors right away (via ? or early return), typically so you can group them together and handle them all the same.
In that case, you can run the cleanup code in the calling function. If you don’t to want to make it the responsibility of the caller, then pull out a small function within your function, so that you become the caller of that small function and can do the cleanup steps at the end of your function, while you do the bubbling within the smaller function.
There’s also ways to make that less invasive via closures (which also serve as a boundary to which you can bubble errors), but those are somewhat complex in Rust, due to the whole ownership thingamabob.
I will say, I do sometimes feel like Rust could use a better way to handle doing something before the error bubbles up. But generally speaking, I don’t feel like a finally is missing.
You can use the anyhow crate for something quite similar to exceptions: https://crates.io/crates/anyhow
In terms of how it actually fits into Rust, you want to use anyhow for application code. If you’re writing a library, then anyhow is a no-go, because users cannot match on different error classes with it. (Much like you would want custom exception classes, so that users can catch them in different catch branches and handle them differently.)
Every so often, you will also need matchable error classes within your application code, then you would have to replace anyhow with a custom error type there, too, of course.
I will also say, IMHO it is fine to use anyhow even while you’re learning Rust. It is so easy that you kind of skip learning error handling, which you will need to learn at some point, but you can still do that when you actually need it.
I’m guessing, those people are worried that it will be removed. It’s already somewhat on the line since Wayland started replacing X11, because individual desktop environments can now decide to implement it or not.
Ah, I think, I know what you mean, that the format is supposed to be written with foolish oversimplifications that are borderline incorrect, whereas “secured by TLS” just sounds like a normal statement from an expert…
I’m guessing that was supposed to be “secured by a thin layer of TLS”…
We deployed a client software in a Docker container on Windows 10. It could not connect to the backend, even though we saw SYN packages originating from it.
So, we ran WireShark on the Windows host and saw that the SYN-ACK packages from the backend were arriving there, too, but no ACK came through to complete the TCP handshake.
Eventually, we rolled out a network debugging container on that Windows host and then could see in the tcpdump, that the SYN-ACK packages, which arrived on the Windows host, just did not show up in the container. Hyper-V or something was quietly dropping them.
Other network connections were working fine, just the SYN-ACK from our backend triggered this.
I like not being particularly recognizable. Treat me like everyone else that you don’t know.
Ah, I thought there would be a male bird involved still, but I guess that example just explains ovulation. Still quite optimistic that everyone shares the same understanding here, though…
This post made me realize, I’ve only ever heard “the birds and the bees” referenced, but never actually how it’s applied during sex ed.
But uh, turns out this does not make any sense in that context either. It’s just two separate examples to explain sexuality, so bees pollinating flowers and birds laying eggs. They’re just used as examples, because they’re visible in nature and somewhat resemble the mechanics of sex.
My thinking was that bees are the ones that pollinate, so male.
But they certainly don’t pollinate birds, so I don’t know where that was going either. 🫠
I feel like this isn’t really a new development. Back when LAN parties and local multiplayer were still a thing, games like TeeWorlds, Worms etc. were popular, because they ran on potatoes and you could often get them for free.
The actual fun then came from dicking around with or competing against your friends. The game itself does not need to be ground-breaking for that.
Hell, it technically started even earlier than that, with physical card games and board games and such. Just play them with friends and it’s fun.
I have caught myself genuinely thinking that management needs to unearth more budget, if they so desperately want us to use these AI tools, so that we can onboard another person to compensate for the productivity hit.
Unfortunately, they believe the opposite to be true, that we just need to use AI tools and then our productivity will be through the roof…
I have not looked into these myself yet, but Apertus is supposed to be fully open: https://programming.dev/post/36791696
And I recently heard of StarCoder, which was also said to be like that and which is optimized for coding assistance: https://github.com/bigcode-project/starcoder
Gotta love Linux newbies talking about their first experiences and they’ve already tried 3 distros that I have barely on my radar. A few months in, I hardly knew what SystemD was and this guy’s already on a distro that explicitly removes it.