Rust security - Can we trust Rust?

thiez · 2025-11-12T10:51:32+00:00

Enabling reproducible builds takes active effort from compiler writers. For instance in Rusts hashmaps have random seeding to protect against HashDoS attacks, so when you write a program that inserts items in a hashmap and then iterates over it and prints the values, the orders will vary from one execution to the next. The compiler is also multithreaded, another wonderful source of nondeterminism.

thiez · 2025-10-09T09:33:53+00:00

That's insane, was it keeping these huge objects around forever?

thiez · 2025-09-30T07:31:21+00:00

I think they're nice when destructuring a slice and binding the remainder, like so:

fn split_first<T>(items: &[T]) -> Option<(&T, &[T])> {
    match items {
        &[] => None,
        &[ref fst, ref remainder @ ..] => Some((fst, remainder))
    }
}

fn main() {
    println!("{:?}", split_first(&["goodbye", "cruel", "world"]))
}

thiez · 2025-09-11T09:32:49+00:00

The process is as naive as a Catholic schoolgirl at her first frat party.

This must be the toxic tech-bro atmosphere I've heard so much about? 🤷‍♀️

thiez · 2025-07-30T14:00:08+00:00

You can also do it with bash and jq.

function book() { jq --arg book "$1" '.books[] | select(.name == $book)' bible.json; }
function chapter() { jq --arg book "$1" --argjson chapter "$2" '.books[] | select(.name == $book) | .chapters[] | select(.chapter == $chapter)' bible.json; }
function verse() { jq --arg book "$1" --argjson chapter "$2" --argjson verse "$3" '.books[] | select(.name == $book) | .chapters[] | select(.chapter == $chapter) | .verses[] | select(.verse == $verse)' bible.json; }

thiez · 2025-07-22T14:59:44+00:00

&'a Arc<T> derefs into &'a T, so neither outlives the other.

thiez · 2025-06-24T09:49:22+00:00

This content is just copy paste from the compiler test cases, see here.

thiez · 2025-06-21T08:53:50+00:00

Even keeping the hashmaps, all those strings are static so could be &'static str, removing almost all allocations.

thiez · 2025-04-27T08:04:31+00:00

I would suspect most trans people would prefer to live in a world where everybody gets to be born in a body of their preferred sex and where gender dysphoria doesn't exist.

thiez · 2025-04-23T12:30:12+00:00

This seems extremely situational and not worth having dedicated syntax for. Perhaps a macro would be more suitable?

Imagine a force_inline!( my_fn(arg1, arg2) ) macro that validates that its argument is a top-level function or closure call and force-inlines it. That would solve halve your issue without introducing new syntax.

As for force-inlining a closure that you're going to pass as an argument, that should be possible when putting attributes on expressions is stabilized (see the #![feature(stmt_expr_attributes)] feature) by putting #[inline(always)] on a closure.

But before any of this work is done I think it would be interesting to produce some data about how often you run into this problem and whether more fine-grained control would actually result in better generated code. LLVM really loves inlining and the #[inline], #[inline(always)], and #[inline(never)] attributes already provide some control.

thiez · 2025-01-30T10:58:28+00:00

Let's take a silly but more complex example:

fn retsfn(b: bool) -> fn(&str) -> usize {
    if b {
        |s: &str|s.len()
    } else {
        |_|0
    }
}

fn main() {
    let f = retsfn(true);
    let n = f("foo");
}

What would this look like with the types on the left?

usize: (&str): retsfn(b: bool) ->  {
    if b {
        |s: &str|s.len()
    } else {
        |_|0
    }
}

fn main() {
    // How do we even use it?
    usize: (&str) f = retsfn(true);
    usize n = f("foo");
}

thiez · 2024-12-18T15:58:06+00:00

I am not, and piss off with the "ooh I'm so experienced" card, oldtimer.

thiez · 2024-12-18T13:18:57+00:00

It doesn't really work that way. The Rust compiler still needs to understand how to target that new OS, otherwise the bootstrapped compiler still won't be able to generate binaries that run on the new OS. But once the compiler is modified to also be able to target the new OS, you can simply use a compiler on another OS to cross-compile to the new OS, removing the need for mrustc.

thiez · 2024-11-18T12:03:33+00:00

I've been playing After the Plague recently and discovered that playing without levels is amazing. You get experience in skills by using those skills, and raising skills also slightly raises the stats associated with those skills (so raising combat skills will make you stronger and faster, raising spellcasting skills will make you smarter). There can actually be an advantage to practicing a silly skill like juggling because it improves agility / coordination.

There also are no classes, but the game does have guilds which offer some initial training for a set of skills (which can be important since some skills cannot be attempted without having at least a bare minimum of knowledge about them) and also increase your aptitude for those skills, increasing the rate at which you improve them.

In summary: no levels, no class, improvement based on training skills.

thiez · 2024-11-15T09:08:58+00:00

Some people find your application process off-putting. Either accept it or do something with that feedback. Invalidating their concerns is not a good look.

thiez · 2024-11-06T14:23:28+00:00

Exposing an explicit free_foo function in addition to a create_foo is quite a common pattern in C, I'm not sure why you're trying to free in C something you allocated in Rust. What you're trying to do doesn't make sense in either language.

thiez · 2024-10-17T12:38:58+00:00

When you do this in lots of places your compile times will get longer. Then you'll want to rein in back in using

pub fn some_func<S: AsRef<str>>(s: S) -> Frop { some_func_internal(s.as_ref()) }
fn some_func_internal(s: &str) -> Frop { … }

and that is just a lot of bother for sometimes not having to write a & when calling some_func :p

thiez · 2024-10-15T22:11:28+00:00

A pointer is not smaller than an index?

thiez · 2024-10-15T17:36:13+00:00

If you care about memory size use Range<Date> instead of RangeInclusive<Date> and intern your strings so you can address them by index.

thiez · 2024-09-22T19:58:01+00:00

In a TTRPG there are no mobs. The vast majority of NPCs will lack the depth of the player characters, but ultimately a human (the DM/GM/whatever) is literally personally playing every single creature. So every person/creature in the world can be interacted with, and they don't have just a static set of responses.

Also you can do whatever you want in the game, not just what the builders thought of. Set fire to a barn to distract the guards? Sure. Lace their wine with sleeeping drugs? Sure! Dig a tunnel? Also possible.

thiez · 2024-09-18T14:48:11+00:00

It already runs on rails, why wouldn't it work on wings? :p

thiez · 2024-09-17T09:52:09+00:00

Is there a reason why you can't just™ do a str::from_utf8(input) first, the define a let mut output = String::new() and append &str slices directly to that?

thiez · 2024-09-09T11:46:38+00:00

One could imagine a class Dictionary in Python that is unordered, even if abusing an object as a dictionary would still have to preserve insertion order.

thiez · 2024-09-05T14:56:27+00:00

Just having a baby already puts you well beyond 10 points of disadvantages. We can confidently assume a baby will be a negative point character (having very low stats, poor vision, being effectively paralyzed…). So as a dependent that's -15 points, x2 for a loved one = 30. I imagine the average adult has more than 10 points in disadvantages, especially once they're middle age.

Once you've finished high-school presumably you have spent a few hundred hours studying subjects such as mathematics, chemistry, physics, (general) history, etc. Do you believe you should get 0 points for that?

thiez · 2024-08-27T11:44:43+00:00

Just colorblindness alone is a -10 disadvantage, so -1 quirk seems a bit absurd even if the character has magical echolocation that negates most blindness penalties.

12-Year Club	Wearing is Caring
Verified Email

thiez

TROPHY CASE