A bunch of abreviations, like etc., eg., and some others like quid pro quo

I understand. Thank you!

Thanks for answering! I was more wondering what kind of issue DNS solved and why it was solved that way. Also if anyone thought of another solution.

I also read the history here (https://cyber.harvard.edu/icann/pressingissues2000/briefingbook/dnshistory.html), and it still seems pretty sketchy to me that the concern of website names being inaccessible to small businesses and such was solved with the ICANN. Didn’t this just make domain names into stuff you could speculate with? I may be tweaking rn, but I don’t think it’s necessarily right.

I’ve seen the crypto scams, unfortunately, which is basically what brought me to ask this question.

Is there a reason why they decided that domain names should be owned? Cause it kinda sounds like the metaverse, but older (like buying digital land and stuff). And idk, it just leaves a bad taste for me at least.

I meant more like did it have to be a central agreement for it to scale up to what it is now?

But why did everyone agree to that? Couldn’t domains be determined by user, or at least a bit more decentralized? (ex: google.com leads to IP address 1.1.1.1)

1. You’re replying to someone from db0

2. Lemmy.ml is not the only place that believes the US isn’t a democracy.

3. The US is an oligarchy. It’s one of the things agreed by philosophers, including my teacher. The current controversy in the left surrounding the elections obviously proves this point.

You’re defending an IDF soldier who was proud of doing their job, on a radical Marxist-leninist forum. Call it trolling or whatever, but that’s kinda on you.

Same but with being fluent in english.

Like nobody is “dumb” for not being an expert at speaking English, let alone just speaking 😭

Thanks a lot man! After debuggin for a while it worked!

I was also wondering, where do you learn that kind of stuff? I’m currently learning and would like to be as resourceful as possible.

Here’s the main function

fn main() {
    let mut main_terminal = terminal::new_terminal(caps::Capabilities::new_from_env().unwrap()).unwrap();

    terminal::Terminal::set_raw_mode(&mut main_terminal);

    App::new()
        .insert_non_send_resource(main_terminal)
        .init_resource::<TextDuration>()
        .add_systems(Startup, enter_name)
        .run();
}

And here are the function enter name and flush_sdin

fn enter_name(duration: Res<TextDuration>, main_terminal: NonSendMut<terminal::SystemTerminal>){
    print_text(&duration, Speeds::Default, String::from("Please enter your name: "));
    flush_stdin();
    terminal::Terminal::set_cooked_mode(main_terminal.into_inner());
    let mut name = String::new();
    io::stdin().read_line(&mut name);
    print_text(&duration, Speeds::Default, String::from(format!("Hello, {}!\n", name.trim().green())));

}

fn flush_stdin(){
    let mut clean_buffer = [0; 4];
    let _ =io::stdin().read(&mut clean_buffer[..]);
}

When I use flush_stdin, I have to press a key before submitting the actual input

Edit: I forgot to mention, the print_text function is just something I used to make print_typed! use different speeds and stuff. I haven’t finished the different speeds for now, but that’s not important

fn print_text(duration: &Res<TextDuration>, speed: Speeds, text: String){
    match speed {
        Speeds::Default => print_typed!((duration.default), "{}", text),
        
    }
}

Took me a while to get it to work because of bevy stuff, but it works a lot better! Is there a way to flush stdin without requiring the user to press a key?

Thanks a lot!

Thanks! So far it kinda works, but since I’m using print_typewriter, the characters that I’m printing are printed one by one, and user input can slip in between them. I’m not sure how to prevent them from showing up in the first place, and not make them appear in stdin.

Or maybe in this case I shouldn’t use the terminal, right?

This is so cool!

Hey you’re that guy from that other post!

I hope this is O(n!)

No I am the greatest person alive I don’t need water to sustain myself /s

That’s kind of like saying if 1 is 0 + 1 or 2 - 1

Based ❤️

No but like something being bread like doesn’t mean that it is bread, just similar to bread.