Arcuru

What's crazy is that the landing page doesn't even mention Mac at all.

I'm getting very annoyed by things that don't mention they only work on Mac until you go to install them.

The highest density hard drives have 10 platters[1], storing about 2.2TB each. So if they're talking density in terms of bytes per square cm, 24 is probably reasonable. HDD platters are certainly smaller than DVD-size, and the 24x claim would be true if they were ~25% the size of a DVD which seems about right.

[1] https://blocksandfiles.com/2023/04/13/seagate-22tb-disk-capa...

The only downside is that fish has no way to allow atuin to override the autosuggestions as you type. We can get that in zsh but fish doesn't expose that.

If you're comfortable with shell scripting, you can get that today. There's code for a number of shells in this issue https://github.com/atuinsh/atuin/issues/798

Adding it to Atuin will take a bit of work to keep it from being too brittle, so it hasn't yet been done.

I've now explained in that issue why it's broken, why it's probably unfixable for atuin, but why replacing fc with an equivalent feature in atuin sounds pretty doable.

Feel free to open a feature request before I do.

No. That's not how that works.

https://github.com/kellyjonbrazil/jc - "CLI tool and python library that converts the output of popular command-line tools, file-types, and common strings to JSON, YAML, or Dictionaries. This allows piping of output to tools like jq and simplifying automation scripts."

I used to use this, but it won't work if you want to share the script with someone who doesn't use Nix. My preferred option recently has been to detect the presence of Nix in the shell script, and if so just rerun the script with the deps installed. That way it still works for anybody not using Nix, but also has pinned versioning for Nix users.

I haven't used this for anything complex, so it may need a little bit of tweaking.

[0] - https://jackson.dev/post/a-portable-nix-shell-shebang/

In most shells, you can just add those entries as shell completions to `cd` or `z`.

In fish for example, it's as easy as the following (using zoxide query)

    complete -c z -f -k -a "(zoxide query -l)"

That's how the article above does it for some reason, so it is consistent but I agree it makes no sense.

+1 to this recommendation. Everyone likes to point to ‘just’ as a makefile replacement, but having tried both I slightly prefer Task.

There are quite a few issues that they've stopped fixing in the Element app in favor of doing it in Element X, the one I've been following is where the iOS app causes a breakage in E2EE when you use the share extension, so they just disabled the share extension entirely and said they'd fix in X - https://github.com/vector-im/element-ios/issues/7618

But X requires Sliding Sync on the server, which is still a separate service to run alongside the homeserver and doesn't have a stable API. I am increasingly disappointed with how centralized Matrix is becoming, since AFAIK there isn't really an alternate client close to the same level of quality as Element.

I probably would've made all of the same decisions myself though, so I don't blame them I'm just a bit disappointed in how it's shaking out.

I know it's off-topic, but I can't help noticing Financial Times pricing model. It's $1 for 4 weeks, $69 a month for digital, but also $99 a year for print and digital? That's a wild pricing model.

I long for the day that I can just pay XX cents to read a single article with minimal fuss, but at this point I don't see that happening.

I agree, I used a high end Chromebook/Chromebox for several years as my local dev machine (for corp work) and it worked flawlessly. It was one of the sleekest developer experiences I've ever had.

I use an obnoxiously custom Linux setup for my personal devices, but I still try to push anyone who will listen to try a Chromebook.

The clock does wrap around at the top, but the problem comes about when the smallest hand gets to the bottom (the value 0x80). Flipping it would be confusing as that would make the 0x00000000 position be at the bottom.

The 2038 problem comes about because of overflow in a 32bit signed int, so the top byte (smallest clock hand in this case) effectively only has 7 bits instead of 8, when it goes above 0x7F is when the int is interpreted as negative.

The easiest 'fix', if it's even necessary, would be to make the smallest hand go all the way around in 128 ticks instead of 256. But really this micro blog post could just use an explanation of that to aid the visualization.

Green threads sort of pretend to be threads, they aren't really the same thing. So the short answer is yes there is a fundamental limitation.

The largest performance difference is probably that real threads must have a larger startup cost, as they will need their own copies of some resources (like stack space) that green threads can share. There's not really a way around that without changing how you define a platform thread.

Because the Github post is the original source. The HN submission should be to the original source and a link to the "interesting comment(er)s" on Twitter could be in the comments here.

There is, but it's only in unstable. It hasn't been backported to 23.05.

Wow, that's really annoying.

I pay for a year at a time for ease of use since they wouldn't save payment info when using port forwarding. And now since I last bought a years worth in May they turned off port forwarding and now make me drop the next 8 months of prepaid time if I'd want to use this feature (that I've been waiting for for years).

Excellent, I'm finally able to retire the NixOS module I wrote to replace Tailscale to fix this exact problem [1]. It was certainly imperfect and overengineered, but it has worked for my use cases pretty well.

I'm still not sure if I like the login situation for Tailscale (allowing only 3rd party auth) but I understand why they do it.

EDIT: Turns out I can't use it yet since you have to buy Mullvad through Tailscale. I bought a year of Mullvad in May (they can't save payment info for port forwarding) and in the 4 months since they've removed port forwarding[2] and won't let me use my remaining credit for this integration.

[1] https://jackson.dev/post/replacing-tailscale-with-nixos/

[2] https://news.ycombinator.com/item?id=36113215

Is Steam capable of delivering aarch64 native games? For instance, is it correct to assume that a game developer can upload both an x86 and aarch64 version?

I think Apple's current strategy makes perfect sense, bundling the (mostly non-upgradeable) computer and the display is perfectly reasonable for most consumers but breaks down for professional use cases.

Consumers will likely keep these devices for many years and want to just upgrade the whole thing at once, and the fact that both the display and computer are on the cheaper side makes this feasible to make the usability tradeoff worth it. A pro use case would want to be able to upgrade the very expensive display and the very expensive computer at different rates. The upgrade cycles don't really line up.

TFA talks about how that doesn't exist anymore.

You can always just toggle the vertical tab view per window, so you don't lose any horizontal screen real estate unless you need them. And at least in Firefox you can remove the existing horizontal tabs using userChrome[1].

[1]: https://www.pcworld.com/article/823939/vertical-tabs-in-fire...

Zoxide is basically the 'Rust Rewrite' version of the 'Z' tool and is actively maintained, I haven't had any issues with it: https://github.com/ajeetdsouza/zoxide

You can still seed/download without port forwarding setup, however the other person you're connected to needs to have port forwarding. Basically either side of the P2P connection needs to be reachable from the open internet, but not both.

So you can still seed, it just won't be as usable.

I think the most interesting part about Vector implementations is that some impls never actually copy data around on a push. They just use the huge virtual memory space to be initially allocated in an empty area and then just grow in place, requesting new physical pages as necessary.

The CS101 explanation of a Vector that copies values around whenever it exceeds its capacity is incorrect in many cases.

When I worked on perf at Windows, I vaguely recall someone telling me that the Windows impl doesn't do that for some reason. I'm curious if Raymond will cover why.

It's possible that Google has chosen to take the brunt of the complaints to shield the creators.

Several media players will do that in the background for you, 'mpv' and 'vlc' come to mind. 'mpv' even has a sponsorblock script that will skip the sponsored segments if you so chose.

I occasionally use this for convenience, even though I pay for YT Premium.

It's easier to make something small and quiet if it's power efficient. It will need to dissipate less heat.