RGBCube

Agreed, it's not intuitive at all, but at least it's there...

You can just paste the number into the "start new chat" search input and start a chat from there. You don't need any of this.

I like the Google Calculator, but don't use Google services and the Google Calculator can't work without Play Services for some reason. So I've tried all the popular open source ones and found https://github.com/sadellie/unitto to be the closest in experience (material design) and accuracy (the tan(355/226) test works). It also has conversions for other units, and even currency using https://github.com/fawazahmed0/exchange-api that is accurate enough for a rough estimate if you let it have Internet access.

> This is hacker news, not drama queen news

Same thing.

The C++ that have the humility to realize are using Rust.

That's actually one of the best parts.

Stop using awk, use a real programming language+shell instead, with structured data instead of bytestream wrangling:

  > ls -l | get user

  ┌────┬──────┐
  │  0 │ cube │
  │  1 │ cube │
  │  2 │ cube │
  │  3 │ cube │
  │  4 │ cube │
  │  5 │ cube │
  │  6 │ cube │
  │  7 │ cube │
  │  8 │ cube │
  │  9 │ cube │
  │ 10 │ cube │
  │ 11 │ cube │
  │ 12 │ cube │
  │ 13 │ cube │
  │ 14 │ cube │
  │ 15 │ cube │
  └────┴──────┘

You don't need to memorize bad tools' quirks. You can just use good tools.

https://nushell.sh - try Nushell now! It's like PowerShell, if it was good.

Finally, a modern VR headset that doesn't hate you.

Mozilla.

AI slop.

Even if they made it Source Available it wouldn't hurt them much, because Minecraft is very easy to pirate and the reason anyone pays for anything at all is because you need an account in Mojang's authentication servers (which people do not want to move off of for various reasons).

Hell, they could even make it Open Source with a clause preventing other companies from using to code to make a profit. It's too big to fail.

It is much more complex than C, sure. But it's so much simpler than C++ and you won't find yourself digging through the reference, or standard, or whatever to understand the code you are writing. It's very close to the sweet spot of "not complex enough to make you bald, not simple enough to make your code complex" while also making correctness the default.

What I love about this is that it removes the need for anything suid completely, removing more Unix, thus making our systems more secure and overall better.

I'm actually working on my own OS agnostic package collection + system management software, and I've found https://radicle.xyz great for this. All repos depended on by the official package collection t will be on the radicle network.

The linked GitHub isssue links to that page, too.

This won't affect most users as they will be using the cache.nixos.org substituter and haven't modified any package that pulls repo.or.cz repositories, but it's still amusing.

There's no Virtual Terminal, aka TTY / VT, so the kernel is smaller and the insecure VT impl in the Kernel is not compiled in. In general, you get less moving parts and a more solid system.

The functionality of the VT as a fallback can be handled by cage+foot/whatever or kmscon.

See the reddit post explaining a lot here: https://reddit.com/r/linux/comments/1dpeqay/config_vtn_in_20...

Coming to a distro near you, probably!

You need to enable the option-key-as-alt config option (I recommend only doing it for left option) as alt and option aren't actually the same thing. The name of the config key may be different but it exists

Currently Linux and I think BSD, and the creator has said he wants to support MacOS and Windows, though those will only be included in the paid product.

On Linux and BSD, it supports Wayland and X11, though Wayland is better supported.

ie, Quickshell will forever stay completely free for free operating sysems.

Radicle.xyz fixes this with COBs (Collaborative Objects). They're stored inside your git repo as normal objects, and benefit from its p2p mechanism as well. It's the true sovereign forge.

Sorry, I meant `&Vec<T, dyn Allocator>`.

And no, it is possible. Here is an example that does it with BufReader, which has T: ?Sized and uses it as a field: https://play.rust-lang.org/?version=stable&mode=debug&editio...

Though it comes with a caveat that you can't take self by value, which is perfectly fine for this use case & is what a normal allocator-aware language does anyway.

If the `A` generic parameters were changed to be ?Sized, it would still be possible to make `read_to_end` support custom allocators by changing the signature to `read_to_end(&mut dyn Vec<u8, Allocator>)`

Not sure if that is a breaking change though, it probably is because of a small detail, I'm not a rustc dev.

That's more of a distro thing than "Linux being a few screws loose".

I vastly prefer the OpenBSD kernel too, but if you use a distro that does things properly such as NixOS, the BSDs are the ones that feel wonky.

Holy slop.

This does reflect my experience with Claude Code too. It just writes TOO MUCH damn code. It's never able to understand the tiny change that would make the software actually be better without guidance, and at that point I'd rather write it myself.

It's fine for gruntwork though.

This whole rant is uninformed & it seems like the author is completely ignorant of anything happening outside his well.

But I'll bite the Rust rant anyway.

> Where's your SSL?

Right here: https://www.memorysafety.org/blog/rustls-server-perf/

It's an order of magnitude faster than OpenSSL, and almost double the speed of BoringSSL.

> Where's your operating system?

There are lots of OSes written in Rust, but nobody expects them to replace a well-established piece of software like Linux (and _even Linux_ is integrating Rust, because you can't RIIR the kernel overnight). That's why it's shining in the embedded sector, with stuff such as Tock: https://github.com/tock/tock, or many, many other OSes available today. Oxide Computers uses Rust, Volvo writes a lot of their systems in Rust. I also know a few unnamed MIC companies in Turkey using Rust for their software. Anduril also uses Rust.

Rust also runs the Internet, Cloudflare is primarily Rust and AWS is one of the biggest users of Rust. So many more examples but these are the biggest.

Half my environment is Rust: Helix/Zed my editors, my version control system (jj), my shell (nushell), my Window Manager (niri), the build system I'm working on in Rust to build it all, Firefox which is partially Rust, and I actually enjoy using these greatly, because they're fast, well designed and secure.

Has the author written anything in his life that's not games or toys?

Hello

They're still not enough. Even with those, it's really easy for stuff to slip in.

You should just pick the nearly exhaustive option instead

Many such cases.

Nushell fixes this: https://nushell.sh/

I've been using it as my shell for 2-3 years, and it has improved a LOT since then. The interactive experience is great, and it's wonderful assembling scripts in its REPL. I can use my editor to edit the bufferline too using ctrl+o.

The best thing about it is that's it's self-contained. You don't have to assume anything about the users environment, as Nushell has almost everything you'd need fot common tasks built-in.

Some example scripts I've written:

- Link all files in a dir & deduplicate based on hash, in parallel, handling all cases: https://github.com/RGBCube/random-scripts/blob/master/linear... - A simple github->forgejo migration/live mirroring script: https://github.com/RGBCube/GitHub2Forgejo/blob/master/github...

All of these only need nushell, and not even coreutils.

I also use 3 spaces myself, because 4 spaces is too damn wide and 2 spaces is a little bit too small. I would use tabs instead, but rustfmt doesn't handle it well at all in some of the nightly options, I've had it use spaces where it should use tabs a lot.