• 0 Posts
  • 16 Comments
Joined 2 years ago
cake
Cake day: May 10th, 2024

help-circle



  • Where do I complain “the quality” of my opponent? I am trying to understand their viewpoint with regard to non-segregated sports.

    I’ve spoken to some athletes about this before – women and men – and I found the opinion that sports should be gender-segregated and that the decision of where trans-athletes should be able to participate in should depend on the specific sport in question.

    In my mind good sportsmanship includes fairness and I want to figure out what is “fair” in this situation. Many reasonable people disagree in that regard I think.




  • Well if you don’t do the segregation you will find that in some sports almost no afab people will ever reach the top.

    Some sports are of course worse than others in this regard.

    And even if there is no physical barrier, historically male dominated sports struggle to find female athletes/players. See for example chess.

    How would you solve this?




  • weker01@sh.itjust.workstoProgrammer Humor@programming.devC++
    link
    fedilink
    arrow-up
    4
    ·
    edit-2
    11 months ago

    The only way to make Rust segfault is by performing unsafe operations.

    Challange accepted. The following Rust code technically segfaults:

    fn stackover(a : i64) -> i64 {
        return stackover(a);
    }
    
    
    fn main() {
        println!("{}", stackover(100));
    }
    

    A stack overflow is technically a segmentation violation. At least on linux the program recives the SIGSEGV signal. This compiles and I am no rust dev but this does not use unsafe code, right?

    While the compiler shows a warning, the error message the program prints when run is not very helpfull IMHO:

    thread 'main' has overflowed its stack
    fatal runtime error: stack overflow
    [1]    45211 IOT instruction (core dumped)  ../target/debug/rust
    

    Edit: Even the compiler warning can be tricked by making it do recusion in pairs:

    fn stackover_a(a : i64) -> i64 {
        return stackover_b(a);
    }
    
    fn stackover_b(a : i64) -> i64 {
        return stackover_a(a);
    }
    
    fn main() {
        println!("{}", stackover_a(100));
    }