tuetuopay

It’s quite easy to anycast an IP to multiple physical datacenters. Their DC nomenclature is probably a relic from when they really had a single datacenter for each region.

On the other hand, it wouldn’t shock me if they had no site redundancy. It’s a free service, it’s not like there’s SLA agreements you paid for on signup.

I’ve followed yeet from the inception phase (the creator luks in the Aya Discord, a library to write eBPF using Rust). They’re very skilled, and the project started a few years ago well before LLM coding was up to par for such code.

Nowadays I’d expect them to do AI assisted coding, but the underlying skill set is sound. A shame such good projects delegate blogposts to Claude.

One thing that would be interesting is whether they explored running their automaton in multiple steps, sharing the state across XDP probe invocations, instead of offloading the work to a JS userspace app.

I agree, and I don't remember whether I had the blinker. I, however, also respectfully disagree as in all fairness we should drive 100% perfectly 100% of the time, but we're humans. Expecting 100% driving all the times is the worst as it puts strain on the driver (I say that as someone that's pretty strict on blinkers).

What is special is one time it was a one way lane next to the tram with a concrete stub down. I wouldn't be surprised if the anti-collision kicked in and applied lane assist even with the blinker.

At any rate, the principle of least surprise still applies: heavy machinery must not jerk unexpectedly to the side. Never ever ever.

I almost slammed bicycles in Paris on a few occasions because of that crap. Shift a bit to the left to overtake them, get lane assist slam me back right. Thankfully those were close calls, but only thanks to the cyclist being used to traffic in Paris and having good reflexes.

Any dangerous machine (like a car) must not do anything unexpected out of the driver's control. A lane assist that resists the wheel when trying to get out? Why not, but dangerous. A lane assist that slam you back in the lane? Criminal. (same with anti-collision braking that triggers too strong too early and surprises drivers behind you)

I'm definitely of the opinion that all those features reduce security. The alarm fatigue is real, because the car always finds something to beep at you. Heck, even your hands not being a perfect 10-2 o'clock on the wheel is reason enough on some cars. You quickly ignore the beeps because there are so many reasons for the car to beep it's hard to even understand why.

Definitely. If bitwarden does not shows a little "1" icon I'm basically lolnope'ing out.

Still, it pains me to see that practices from the early keylogger era are still "good practices".

It's a bank, and a rather old at that. I fully expect them to store the password in cleartext. (hence the security theatre qualification)

Banks are notorious for taking security as a strict cost/savings measure. I would not be surprised if they enforce weak passwords stored in cleartext on purpose to save on support agents for the people that forget/lose their password. Imagine the customer service reviews: "they were able to find my password back, 5/5". Probably enough savings to offset the cost of refunding people that got their account pwnd. Cost of doing business.

That's without considering a lot of banks have non-textual inputs for their passwords. Man they love their scrambled virtual keyboard!

I think the worst I ever had was HSBC that asked me for fragments of my password, like characters 4, 6, 7, 11, and 12. Absolute bonkers of a security theatre.

So much this. The rule of thumb is: avoid SFP-RJ45 converters at all costs, you'll be burned by them (literally and figuratively).

They all are little snowflakes. Compatibility is hit-or-miss. They run hot. They eat more power. They're finnicky. Heck, they plain out lie about what they are (I've got some that pretend to be fibre with 3m of copper, sure).

So yeah, DAC it is for patch, fibre for anything more.

Yeah a bit like I’ll be impressed by a humanoid robot that can fold a shirt from a freeform state (i.e. thrown as a ball on the laundry chair, or straight out of the dryer). Just like repeatable movements an balance are the easy(er) parts of robotics, text processing is the easy part of AI.

Yes, it's in the platform options. You can specify --platform linux/amd64/v3 for a v3 image.

They've made a lot of progress in the recent years, and the last two major releases downright feel snappy compared to GitHub (really, browsing a repo tree is literally snappy). Oh, and their SPA implementation actually works, the back button is not broken 90% of the time like it is on GH.

And mind you, that's on a small 4 core VM on 2019 mid-range Xeons, which I would not consider to be a huge amount of compute (granted, not Raspberry Pi level, but I'd expect the SD card to be much more of an issue).

So yeah, along with the sane(r) way to do CI pipelines, and usable review tools, it's a net improvement over GitHub.

Nitpick: you definitely can do loops as long as the verifier can prove they're bounded.

At my previous job, I've written production eBPF exclusively in Rust using Aya (mentioned by a sibling comment), and it's been a blast. Being able to share the type definitions between the kernel-space and the user-space code is a blessing to avoid subtle issues when going through the maps. And, at least in Rust, you can re-use crates and types that make you gain time. As a (simple) example, being able to use the standard library's IpAddr types or the ipnet crate to not have to roll your own IP and network manipulation libraries is a (small) timesave. It's main value is not needing to onboard new developers.

The Rust type system is a good helper in keeping the verifier happy. Slices, iterators, match statements, etc are very good in my experience (e.g. Option is a godsend to ensure you stay withing the bounds of the input packet, esp. slice::split_at when parsing headers).

But you're right that reading C is non-negotiatable, especially since pretty much all example code on the internet is in C.

The difference is, unwrap will stick out like a sore thumb, and it’s opt-in. You explicitly tell "this may panic".

As for error handling, this kind of enrichment is usually left to the caller (that is, the end application), with error libraries like anyhow where you can add arbitrary string contexts to an error. You would end up writing `Config::load(path).with_context(|| format!("Failed to load configuration file {path}"))?`.

As for the specific issue: it does not exist in Zig, because Zig does not have ownership.

In a nutshell, the LLM created abstractions that allow you to write unsound code in safe rust, which is squarely against the language.

To be specific: the abstraction takes a (shared) reference and uses unsafe to wrap it in an owned object, completely erasing le lifetime. In practice, this means users of the abstraction think they own the underlying memory: they choose when to free it. However, it just wraps a pointer that’s owned by someone else (it was a shared reference, remember?), thus it will be freed when you don’t expect it.

So why does it not exist in Zig: it’s a false contract about what it is. The Zig pointer is a pointer with no added lifetime information. You can hold a Zig pointer wrong, but you will hold a lying abstraction wrong. You will misuse it because it doesn’t do what’s written on the tin. You will write bugs with it.

And, LLMs will too. If they do not have the abstraction definition in their context, they also have no way to know the contract is lying.

Well, it is a good thing to get control of your own hardware, when the vendor decides that no you won't do what you want with it.

Give a shot to the SAC305 mix. It’s a low temperature lead-free alloy, and it’s the one that made me ditch leaded solder definitively. Use more flux and a bit more iron temperature and you’ll never touch leaded solder again. Oh, and it’s available both as a hand-soldering wire reel and solder paste.

I interpret it as "in practice", "now". Non-native English speaker here, so I may have missed your meaning.

If you meant they’re now better at mimicking compilers, sure, but they’re only mimicks.

Which is how to keep shareholders and product managers happy /s

They’re not, and will never be in their current form and architecture.

Compilers are mechanical and engineered to produce a correct output. A compiler emitting incorrect machine code is exceedingly rare, and considered a bug. They have heuristics and probabilities in them, but those are to pick between a set of known-good outputs.

An AI is a bag of weights outputting a probability of the most plausible token that follows [1]. It is inherently probabilistic in nature and its output is organic (by design, they’re designed to mimic human speech), as opposed to mechanical like a compiler.

A compiler follows hard rules. An AI does its best.

And to be fair, AIs are no better than human in this regard: humans are pretty bad at generating correct code without mechanical tools to keep them in line (compilers, linters, formatters). It’s not a wonder we use the same tools to keep LLM output in line as we do humans. (And, to be fair, LLMs are better than humans at oneshotting valid code).

[1]: to those that tell me this vision of an LLM is outdated: nope. The heavy lifting is done in the probability generation. Debates about understanding are not relevant here, and the net output of an LLM is a probability vector over raw tokens. This basic description can be contrasted to a compiler whose output is a glorified Jinja template.

Wow I never thought about that, but it makes complete sense. I just tried shifting my hands "as if" the nubs were on D and K and wow, it should have been this way.

Oh well, just like caps lock can be remapped, so can my keycaps be swapped (perks of blank keyboards I guess), though it'd be even harder to use a keyboard that's not mine I guess.

Yeah but, even ones that don't use literal tab characters use the tab key to write code, right? RIGHT? Like, does he hit space N times?

I somewhat get the argument, but if you're writing code in the HN textarea you're doing something wrong (for code where tab/space matters anyways). Like, any code editor will use the tab key properly.

Though, it sills maddens me there's no somewhat universal tab-entry in OSes like we have with enter (somewhat because there's a mix of shift+enter, alt+enter and cmd+enter). All of shift/alt/ctrl tab are usually also hijacked.

Its whole purpose is to be remapped as CTRL, as god intended.

Huh, thanks, I failed to see it on my phone. Down the trash the article goes then.

The issue is, there’s not a lot of meat in this article. Anyone who’s done any amount of SRE can perfectly articulate alert fatigue in way less words.

Yet the article doesn’t tackle at all the hard part: making alerts that are actually meaningful. They handwave it instead of giving actual advice. This post is a good intro, but I didn’t "walk away" with anything useful.

This is why, in this case, AI is important. Someone puts in an effort to write a short article (if a bit wordy) that can be used by e.g. beginners or managers? Good! I’m not the target audience. But if it’s the output of AI, what’s the intent?

That is the crux of the issue: the detection of whether the changes came from copilot or not is buggy, thus all changes are flagged as coming from copilot, thus the title is correct.

I don't know if it's been tested in court, but that's the rationale behind the Signed-off-by lines the kernel requires in all patches sent. It's a way to tell the (legal) ownership of a piece of code.

Well I'd argue it'd help you to make designs that don't require perfect pixel alignments to look good, the same way developers should run crappy 10 year old computers. But that's the sadistic way. Anything graphics-related does require 1:1 display.

However, to be fair, that's only at lower DPIs smudging's an issue. Anything retina-ish and integer scaling loses all meaning. I'm typing this on a 15" 4K laptop on 1.75 scaling with HN set to 120% zoom. At those DPIs, it does not matter at all. I adjust most websites zoom level because a lot of them think the content must breathe, while I think I should not fiddle with my scroll to read a paragraph.

As a heavy fractional scaling user, as long as the display has enough DPI, it's a non-issue. At my last job I was happily running 1.35 scaling, and I run my TV at 1.5 scaling. Make sure you're using a sane compositor, which excludes DWM; most Wayland compositors should run just fine.

Dammit that’s why I could never get it to not try to one shot answers, it’s in the god damn system prompt… and it explains why no amount of user "system" prompt could fix this behavior.

The requests would be a dimension-less quantity. There are a few examples of what those are and how they fit in:

- The frames in frames per second are dimensionless, thus the SI unit for FPS is frames/s. When the frames are periodic, such as monitor refresh rates are, the unit is Hz.

- Percentages are dimensionless quantities too, produced by divinding two quantities of the same dimension (ie unit). CPU%? That’s "busy second per second", which is dimensionless, and expressed as a percentage.

A dimensionless quantities don’t have any physical backing reality in terms of the, well, dimension in which you could measure it. Time, space, mass, etc.

Fun fact: angles are dimensionless! Both degrees and radians are just shorthands as divisions of the unit circle.