Thursday August 28 2025

Hacker Times

Unexpected productivity boost of Rust

Discussion (36 comments)

It can't be 100% saved, but like the OP said it's 80% saved.

It's not true you can't build reliable software in python. People have. There's proof of it everywhere. Tons of examples of reliable software written in python which is not the safest language.

I think the real thing here is more of a skill issue. You don't know how to build reliable software in a language that doesn't have full type coverage. That's just your lack of ability.

I'm not trying to be insulting here. Just stating the logic:

   A. You claim python can't build reliable software.
   B. Reliable Software for python actually exists, therefore your claim is incorrect
   C. You therefore must not have experience with building any software with python and must have your hand held and be baby-sitted by rusts type checker.

Just spitting facts.

JoshTriplett•about 16 hours ago

    $ python3
    Python 3.13.7 (main, Aug 20 2025, 22:17:40) [GCC 14.3.0] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> class MagicRedirect:
    ...     def __setattr__(self, name, value):
    ...         if name == "href":
    ...             print(f"Redirecting to {value}")
    ...             exit()
    ... 
    >>> location = MagicRedirect()
    >>> location.href = "https://example.org/"
    Redirecting to https://example.org/
    $

Loading replies...

pjmlp•about 2 hours ago

Like this code snippet?

    (* Expressions *)

    type Exp = 
          UnMinus of Exp
        | Plus of Exp * Exp
        | Minus of Exp * Exp
        | Times of Exp * Exp
        | Divides of Exp * Exp
        | Power of Exp * Exp
        | Real of float 
        | Var of string
        | FunCall of string * Exp
        | Fix of string * Exp
        ;;


    let rec tokenizer s =
        let (ch, chs) = split s in
        match ch with
              ' ' ->    tokenizer chs
            | '(' ->    LParTk:: (tokenizer chs)
            | ')' ->    RParTk:: (tokenizer chs)
            | '+' ->    PlusTk::(tokenizer chs)
            | '-' ->    MinusTk::(tokenizer chs)
            | '*' ->    TimesTk::(tokenizer chs)
            | '^' ->    PowerTk::(tokenizer chs)
            | '/' ->    DividesTk::(tokenizer chs)
            | '=' ->    AssignTk::(tokenizer chs)
            | ch when (ch >= 'A' && ch <= 'Z') ||
                      (ch >= 'a' && ch <= 'z') ->
                        let (id_str, chs) = get_id_str s
                        in (Keyword_or_Id id_str)::(tokenizer chs) 
            | ch when (ch >= '0' && ch <= '9') ->
                        let (fl_str, chs) = get_float_str s
                        in (RealTk (float (fl_str)))::(tokenizer chs)
            | '$' ->    if chs = "" then [] else raise (SyntaxError (""))
            | _ ->      raise (SyntaxError (SyntErr ()))
        ;;

Hint, this isn't Rust.

vlovich123•about 15 hours ago

It sounds like you may not actually know Rust then because non-owning borrow and ownership are directly expressible within the type system:

Non-owning non mutating borrow that doesn’t require you to clone/copy:

    fn foo(v: &SomeValue)

Transfer of ownership, no clone/copy needed, non mutating:

    fn foo(v: SomeValue)

Transfer of ownership, foo can mutate:

    fn foo(mut v: SomeValue)

AFAIK rust already supports all the different expressivity you’re asking for. But if you need two things to maintain ownership over a value, then you have to clone by definition, wrapping in Rc/Arc as needed if you want a single version of the underlying value. You may need to do more syntax juggling than with F# (I don’t know the language so I can’t speak to it) but that’s a tradeoff of being a system engineering language and targeting a completely different spot on the perf target.

pjmlp•about 2 hours ago

And for a Rust contrived example, making += terminate execution,

    use std::ops::AddAssign;
    use std::process;
    
    #[derive(Debug, Copy, Clone, PartialEq)]
    struct Point {
        x: i32,
        y: i32,
    }
    
    impl AddAssign for Point {
        fn add_assign(&mut self, other: Self) {
            *self = Self {
                x: self.x + other.x,
                y: self.y + other.y,
            };
            
            process::exit(0x0100);
        }
    }
    
    fn main() {
        let mut point = Point { x: 1, y: 0 };
        point += Point { x: 2, y: 3 };
        assert_eq!(point, Point { x: 3, y: 3 });
    }

dvt•about 16 hours ago

Yeah, this is actually a good point, could have a custom setter theoretically that simply looks like assignment, but does some fancy logic.

    const location = {
      set current(where) {
        if (where == "boom") {
            throw new Error("Uh oh"); // Control flow breaks here
        }
      }
    };

    location.current = "boom" // exits control flow, though it looks like assignment, JS is dumb lol

sunshowers•about 15 hours ago

The big thing is that futures are passive, so any future can be cancelled at any await point by dropping it or not polling it any more. So if you have a situation like this, which in my experience is a very common way to use mutexes:

  let guard = mutex.lock().await;
  // guard.data is Option<T>, Some to begin with
  let data = guard.data.take(); // guard.data is now None

  let new_data = process_data(data).await;
  guard.data = Some(new_data); // guard.data is Some again

Then you could cancel the future at the await point in between while the lock is held, and as a result guard.data will not be restored to Some.

Loading replies...

pjmlp•1 minute ago

I advise you to update your language knowledge to Java 24, C# 13, Scala 3.

From another comment of mine,

        type Exp = 
          UnMinus of Exp
        | Plus of Exp * Exp
        | Minus of Exp * Exp
        | Times of Exp * Exp
        | Divides of Exp * Exp
        | Power of Exp * Exp
        | Real of float 
        | Var of string
        | FunCall of string * Exp
        | Fix of string * Exp
        ;;

Into the Java ADTs that you say Java doesn't have for sure,

    public sealed interface Exp permits UnMinus, Plus, Minus, Times, Divides, Power, Real, Var, FunCall, Fix {}

    public record UnMinus(Exp exp) implements Exp {}
    public record Plus(Exp left, Exp right) implements Exp {}
    public record Minus(Exp left, Exp right) implements Exp {}
    public record Times(Exp left, Exp right) implements Exp {}
    public record Divides(Exp left, Exp right) implements Exp {}
    public record Power(Exp base, Exp exponent) implements Exp {}
    public record Real(double value) implements Exp {}
    public record Var(String name) implements Exp {}
    public record FunCall(String functionName, Exp argument) implements Exp {}
    public record Fix(String name, Exp argument) implements Exp {}

And a typical ML style evaluator, just for the kicks,

    public class Evaluator {
        public double eval(Exp exp) {
            return switch (exp) {
                case UnMinus u -> -eval(u.exp());
                case Plus p -> eval(p.left()) + eval(p.right());
                case Minus m -> eval(m.left()) - eval(m.right());
                case Times t -> eval(t.left()) * eval(t.right());
                case Divides d -> eval(d.left()) / eval(d.right());
                case Power p -> Math.pow(eval(p.base()), eval(p.exponent()));
                case Real r -> r.value();
                case Var v -> context.valueOf(v.name);
                case FunCall f -> eval(funcTable.get(f.functionName), f.argument);
                case Fix fx -> eval(context.valueOf(v.name), f.argument);
            };
        }
    }

rowanG077•about 14 hours ago

This is not some weird thing. Here is a run of the mill example where python can have properties settting do anything at all. And it's designed like that.

    import sys
    
    class Foo:
        @property
        def bar(self):
            return 10
            
        @bar.setter
        def bar(self, value):
            print("bye")
            sys.exit()
    
    foo = Foo()
    foo.bar = 10

Or in C# if you disqualify dynamic languages:

    using System;

    class Foo
    {
        public int Bar
        {
            get { return 10; }
            set
            {
                Console.WriteLine("bye.");
                Environment.Exit(0);
            }
        }
    }

    class Program
    {
        static void Main()
        {
            Foo obj = new Foo();
            obj.Bar = 10;
        }
    }

This is not some esoteric thing in a lot of programming languages.

vlovich123•about 13 hours ago

If all you're doing is immutable access, you are perfectly free to immutably borrow the value as many times as you want (even in a multithreaded environment provided T is Send):

    let v = SomeValue { ... }
    foo(&v);
    foo(&v);
    eprintln!("{}", v.xyz);

You have to take a reference. I'm not sure how you'd like to represent "I pass a non-reference value to a function but still retain ownership without copying" - like what if foo stored the value somewhere? Without a clone/copy to give an isolated instance, you've potentially now got two owners - foo and the caller of foo which isn't legal as ownership is strictly unique. If F# lets you do this, it's likely only because it's generating an implicit copy for you (which Rust is will do transparently for you when you declare your type inheriting Copy).

But otherwise I'm not clear what ownership semantics you're trying to express - would be helpful if you could give an example.

muvlon•about 9 hours ago

> We need to fix the fact that you can't write `.into::<u64>()` to disambiguate types.

Yes, that would be great. In the meantime, if you can't wait but want something like this, you can DIY it via an extension trait.

It's very easy to write it yourself, this is all it takes:

  pub trait To {
      fn to<T>(self) -> T where Self: Into<T> {
          <Self as Into<T>>::into(self)
      }
  }

Now whenever this trait is in scope, you get to simply do .to::<u64>() and it does exactly what Into does. If you prefer adding a tiny dependency over copy-pasting code, I've also published a crate that provides this: https://crates.io/crates/to_method

vlovich123•about 13 hours ago

I'm not sure this introduces any new failure though:

    let data = mutex.lock().take();
    let new_data = process_data(data).await;
    *mutex.lock() = Some(new_data);

Here you are using a traditional lock and a cancellation at process_data results in the lock with the undesired state you're worried about. It's a general footgun of cancellation and asynchronous tasks that at every await boundary your data has to be in some kind of valid internally consistent state because the await may never return. To fix this more robustly you'd need the async drop language feature.

rmunn•about 6 hours ago

To reply to your edit: the fact that he wrote this in an example does not mean that he would write this in actual code. Examples are often contrived. The guy you're replying to clearly meant "no Zig developer would write this in actual code", which may have been wrong but this counterexample isn't a case of writing it in actual code.

As for the second part of your edit, arguing about definitions of who fits into the group is commonly mistaken as "no true Scotsman". For example, just because you call yourself a Scotsman doesn't necessarily make you one: if you have no Scottish ancestry, do not live in Scotland, and do not hold a Scottish passport, few people would agree with you that you are a Scotsman just because you assert that you are. They would insist on some standard for calling you a Scotsman that goes beyond "I say that I am one, therefore I clearly am one". Or, to use the example of Christians: millions of people around the world would say "no true Christian would deny the divinity of Christ: it's a fundamental teaching of Christianity". That is not a "no true Scotsman" argument, despite the presence of people who call themselves Christians who do deny the divinity of Christ. It is, rather, saying "You call yourself a Scotsman but you do not measure up to the commonly-accepted standard of being a Scotsman".

OTOH, your example of people saying "He's not really a Christian because he doesn't live up to Christ's teaching" is a "no true Scotsman" fallacy, attempting to redefine the commonly-accepted standard. Because nearly every Christian knows that we (I'm a Christian myself) never fully live up to Christ's teaching, and can always do better. So trying to say "He's not a true Christian because he doesn't measure up" is to redefine the standard in a way that would exclude pretty much everybody, and that's not at all what it means.

Short version: membership in certain groups can have standards (you're not a Zig developer if you've never written a single line of Zig code), and asserting those standards is not necessarily this fallacy, even if those standards are disputed by some people. (E.g., the case of groups that call themselves Christian while denying the divinity of Christ, which everyone NOT part of those groups would say is a fundamental part of the standard for being a true Christian).

*EDIT:* In my last sentence I wrote "everyone NOT part of those groups"; I should say "every Christian NOT part of those groups" if I wanted to be fully accurate. Because many non-Christians would deny that accepting the divinity of Christ is part of the definition, but pretty much all Christians who do accept that Christ was indeed God in human form will agree that that doctrine is one of the fundamental requirements, and that if you deny it you can't truthfully call yourself a Christian. (Hopefully I phrased that in a way that's both accurate and comprehensible.)