mcronce

> Rust didn't protect me from that, and those are the kind of vulnerabilities that we'll continue seeing regardless of language.

It didn't on its own, but it is worth noting that with type-safe languages, you can protect yourself from this by encoding that invariant into the type system.

Using Rust as an example, take a &std::path::Path (or &camino::Utf8Path or whatever) in your public API; have custom InternalPathBuf and InternalPath types that perform validation to ensure they aren't using relative paths to "break out" during construction, and then pass those around in your internal API. Bingo bango, now there's no way (short of transmuting, an `unsafe` operation) to pass invalid paths to the functions that hit the filesystem without a compile error. No redundant runtime checks required, and no need for you as the developer to keep track of which codepaths have already validated a Path and which haven't.

I'm sure you already know this, and I would imagine that Java can do the same, but it's a big step above languages like Python where you can do whatever you want to anything you want.

EDIT: lol while I was typing this you made a post about the same thing below.

If you're using the app, that might explain the difference. I'm using the mobile web interface and it's so slow that they've lost sales from me before - not because I got frustrated and stopped, but because it took 10+ minutes to put together an order and the restaurant stopped taking orders before I could get it in. This has happened multiple times.

The desktop web interface is slow enough to be irritating but not so slow it's unusable.

Finding open restaurants with Google Maps is pretty easy. They have a specific option for "is currently open", and menus are frequently linked right from the business's listing.

Absolutely not, that wouldn't be nearly as effective as clickbait

Doordash doesn't even do a good job at it. The tech is awful. The website is slow; on mobile, it's so slow it's unusable. Payment issues require you to open dev tools to see actual actionable errors returned by the server.

Strongly agreed that these gig companies, at least in their current form, can die as quick a death as possible.

It probably does help that both Python and Rust treat FFI as first-class in terms of importance. That said, yeah, PyO3 is a pretty awesome suite to work with.

In the process of electric swapping our 5-speed Baja. It will be keeping the manual gearbox.

My understanding isn't that you _can't_, but that you _aren't allowed to_ by kernel policy. (The risk being that the kernel will panic on OOM, which is not an acceptable way for the kernel to deal with OOM conditions.)

If this is out of tree, AFAIK you can use these all you want. Whether or not you _should_ is obviously a different matter.

ASML depends on lenses from a relatively small company. That company does not have interest in ramping production any more than they already have. They don't care how much money they're offered.

Nobody else can get the job done. So, as they say, it is what it is.

"Them" is TSA employees, as the other user explained. The rest of this is a lot of pretty aggressive assumptions about me that are entirely unfounded.

My sample size is two - one departing flight each from LHR and DUB - but they were way less painful experiences than any airport I've flown out of in the US.

It'd be better than UBI if they weren't making everybody's lives worse in the process.

I'd rather just provide UBI. Pay them to do nothing instead of paying them to make everybody else's lives worse.

It's detailed here - https://docs.rs/anyhow/1.0.66/anyhow/struct.Error.html - the list is short but IMO significant

I always use actix-web. warp comes pretty highly recommended as well, although I haven't personally tried it.

I came from PHP, Python, and Go (in that order) with very limited experience in both C and C++ and now use Rust for everything with one exception - a scraper for mint.com that uses https://github.com/mintapi/mintapi. That has a lot going on, including spinning up a headless browser, and my code is virtually trivial, so the benefits of porting it to Rust are limited, and the work would be pretty significant.

As far as things I typically make, database-backed HTTP APIs are probably the most common, and influxdb collectors second most common.

Generics are a language feature to reduce the need to copy and paste in an editor. For that matter, functions are a language feature to reduce the need to copy and paste in an editor.

Yeah - it's almost better to think of GATs as less of a feature and more of a weird restriction being removed. That's obviously super reductive knowing the amount of work that went into it, but from an end developer standpoint, it's an explanation that helped make it make sense to me.

Something something MAGA something something

It's worth reinventing the wheel for the purpose of learning those low-level bits, if that's something you want to learn. For example, I feel like every week I see a new NES or Gameboy emulator posted on /r/rust

The nice thing about well-solved problems in libraries is that you don't have to learn how to write those things if you don't want to

OK? That doesn't really change any of the facts I posted.

This is my experience as well (in a similar situation to you). I also found Svelte far easier to grok, as someone who is generally not a web developer, than alternatives. Not having to bundle a huge runtime and deal with all the virtual DOM cruft is a nice bonus for performance, but the reality is that it's probably not a measurable difference for anything I'm doing on the front end.

Not entirely. With Skylake, there was a clock speed penalty for "heavy" 256b instructions and "light" 512b instructions, and a steep clock speed penalty for "heavy" 512b instructions. With Ice Lake, there is a very small single-core clock speed penalty for 512b instructions. There is no clock speed penalty after Ice Lake. (Which, for non-server CPUs, is currently a list containing one generation: Rocket Lake.)

> I get it, Crate & Barrel sees this as an opportunity to monetize their brand without having to do all that much. Unfortunately it leaves me with a lot less trust for a brand that used to represent a quality and reputation.

It's essentially converting reputation to cash

> The greatest performance gains are actually at the lowest TDPs, where the 7950X saw a 74% increase in Cinebench R23 MT performance. These advantages actually decreased as TDPs went up, dropping to 37% at 105W, and finally 35% at 170W.

My money is on the new I/O die being the source of most of the improvement in the low TDP range. That thing was pretty power hungry on 12nm GloFo; 6nm TSMC is a pretty sizeable leap.

Obviously there are improvements everywhere in the V/F curve, implying that the CCDs have also had solid improvements, but since I/O die power draw doesn't change much with CCD frequency, it's a bigger slice of the pie (so to speak) at lower clocks.

Ontario is also twice the size of France and 1/4 the population; they're at least in the same order of magnitude. I'd call it a reasonable comparison.

Administrating the storage pool.

The worst that comes to mind for me was a node failure in the middle of a major version upgrade. Not likely a big deal for proper deployments, but I don't have enough nodes to tolerate complete node failure for most of my data.

Grabbed a new root/boot SSD, reinstalled the OS, reinstalled the OSDs on each disk, told Ceph what OSD ID each one had previously (not actually sure if that was required), and....voila, they just rejoined the cluster and started serving their data like nothing ever happened.

You can get M.2 to PCI-E add-in-card adapters, yeah - as long as it's an M.2 slot that supports NVMe, not SATA only

Ceph is fantastic. I use it as the storage layer in my homelab. I've done some things that I can only concisely describe as super fucked up to this Ceph cluster, and every single time I've come out the other side with zero data loss, not having to restore a backup.

This is what people don't seem to get...with a set of physical buttons, you can find what you're looking for just by feel, glance down briefly when it's safe to do so to make sure it's the button you want, then press it.

With a touchscreen, in contrast, you have to hover over approximately the location you think you want to press, and either hope you don't hit a bump before you have a chance to look down and make sure it's the right spot or look down immediately.

I put a touchscreen head unit in my car in 2016. If I drove more often I'd dump the touchscreen in a heartbeat.

If I'm understanding correctly, it's OCI compatible in the other direction - it consumes OCI compatible images, but it doesn't expose an OCI compatible layer on top for orchestration.

kube-virt[1] is a thing, though, that provides k8s orchestration for VMs. I don't see why you couldn't use krunvm microvms with that

[1] https://github.com/kubevirt/kubevirt