I used reddit under a normal username that I used everywhere for like 10 years. I didn’t ever do anything, but did start to feel uncomfortable with the amount of data available to anyone interested. Discord was so much worse for me, I had years of chat logs with like thousands and thousands of messages. Modern governments have the potential to have so much information on people compared to before 1970. Like, there’s a very big difference between getting a subponea for 100,000 messages in chat logs for 2010-2020 and having to talk to acquaintances of the person in the ways that investigations happened before the internet.

I don’t know, I somewhat think there should be shorter time limits for how long chat logs can be used in courts.

My threat model is company tracking. I feel like I stand out like a bright red target with a random letter username, but it’s just so companies using tools like Sherlock will struggle to connect my other accounts. I found it exhausting to create new usernames that I liked for every service.

I’ve actually been wanting to create a normal fediverse account self hosted with my own domain, but I haven’t done it yet because I haven’t completely determined what I want to do yet.

I had commented something similar to stating it was possible to pass the inference problem to the struct if the goal was to support more types, but I removed it because I didn’t think my example was easy to understand when reading it later. I made a better example though

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=8651fa6121840658b4b6249399f693c7

I made an edit.

There’s not anything stopping it from supporting Option<&str> though. This would be the implementation

impl OptionUpgrade for Option<&str> {
    fn upgrade(self) -> Option<String> {
        self.map(|v| v.into())
    }
}

It’s also possible to just make it generic over Option types

impl<A: ToString> OptionUpgrade for Option<A> {
    fn upgrade(self) -> Option<String> {
        self.map(|v| v.to_string())
    }
}

Two of your macro rules are not used 😉 (expand to see which ones).

The macro rules are all used. (Macros are matched from top to bottom by the declared match types. The ident/expressions can’t match until after the more text based Option matching.)

let _foo = Span { line: 1, column: 1, file_path: None };
let _bar = Span { line: 1, column: 1, file_path: "file.txt".upgrade() };
let _baz = Span { line: 1, column: 1, file_path: Some("file.txt".to_string()) };
let _baz = Span { line: 1, column: 1, file_path: None };
let _baz = Span { line: 1, column: 1, file_path: borrowed.upgrade() };
let _baz = Span { line: 1, column: 1, file_path: owned.upgrade() };

This doesn’t support Option<&str>. If it did, we would lose literal None support 😉

I didn’t make Option<&str> an option because the struct is for type Option<String>. It does support Option<String> though.

impl OptionUpgrade for Option<String> {
    fn upgrade(self) -> Option<String> {
        self
    }
}

It looks like the following, and uses the last match case.

let opt: Option<String> = Some("text".into());
let opt = span!(1, 1, opt);

With macro expansion

let opt: Option<String> = Some("text".into());
let opt = Span { line: 1, column: 1, file_path: opt.upgrade() };

There’s not anything stopping it from supporting Option<&str> though. This would be the implementation

impl OptionUpgrade for Option<&str> {
    fn upgrade(self) -> Option<String> {
        self.map(|v| v.into())
    }
}

One option to OP’s problem is to use an auxiliary trait implemented on both string and Option<string>

This looks something like the following

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=aa68fe540dbd09821ecc482423227b46

I clearly didn’t read it. It makes sense, if users aren’t visiting the API then it really doesn’t matter that it’s not redirected on insecure connections.

I disagree.

You shouldn’t serve anything over http. (The article argues that there’s risk of leaking user data) Whatever you’re using for a webserver should always catch it. A 301/308 redirect is also cached by browsers, so if the mistake is made again, the browser will correct it itself.

If you make it fail, you’re just going to result in user confusion. Did they visit the right website? Is their internet down? etc.

deleted by creator

It should be possible to ping him to a post or comment though. (or for him to comment or post here)

removed

those devs understand why their assets are so large. but if you ask a js dev why they webpack instead of compiling they just start crying and run away

I think all 3 are likely detectable.

AdNauseam is my favorite though, and probably currently the least detectable. It purposefully costs advertisers the money they bid against each other for clicks. Though, if abuse of it becomes too high, I think Google would very likely separate out users they have detected as likely bots. Though, for people who do not browse the internet very often, there might not be very much data to be confident they’re a bot.

I really don’t like that modern advertising is based on highly invasive spying. A billboard is a nuisance, but someone watching everything I do online is a stalker.

edit: It’s about making predictions about behavior worse. An issue is that advertising has conversions or sales, which most fake clicks will not become conversions… but part of it is just creating data that might cause predictions against other people for content they don’t desire. (resulting in less impactful advertising)

/c/thelinuxexperiment_channel@tilvids.com

I also really like the Bitcoin block number. It will likely be one of the most provable records of time passing, but not as convienent for tracking or converting time.

Unix is the easiest format I’ve used. It’s easy to parse, it’s consistent, there’s not usually competing unix like formats, it converts perfectly to other time formats, most file explorers can immediately sort it correctly, and it’s clearly the date from which the universe spawned into existence.

deleted by creator