TehPers

Some thoughts on the comments on Discord:

I can understand most of the arguments against Discord, and there are some problematic communies on it of course, but I’m not sure I understand how using Discord over an alternative puts someone more at risk of exposure to those communities. People are free to join and leave servers at will, so is the issue that these servers built around FOSS projects have toxic communities? If so, how would being on any other platform solve this?

Speaking from experience, just about all the servers I’m in have some kind of “no politics” rule, a very inclusive “be nice” rule, and a pronoun selector. Maybe it’s just the servers I join, but hate speech gets people banned pretty quickly.

Anyway, there are plenty of arguments that can be made about discoverability, lack of control, privacy, and the non-FOSS nature of the platform to justify its presence on that list.

As a man, I diasagree. We are also allowed to be hungry and horny.

Grief, in my opinion, was a mistake. It should really be banned in all formats (except those where it’s normal to restrict instead). In the right deck, it’s a 1-drop 3/2 menace that double/triple thoughtsiezes before your opponent can drop a land into play.

But hey, they fixed that problem by banning Fury in modern, right?

As for the “no changes” B&R, I wish they were a little more willing to unban cards. For example, I wonder if Invoke Despair could come back to standard at this point (despite it rotating out soon anyway). Anyway, I guess I’m just looking forward to rotation to change up standard since it feels mostly solved (a lot of the same decks have been on top for a while now, with minor changes each new set).

Ignoring the rest, just some thoughts about the list of proposed features:

A capture trait for automatic cheap clones

Automatic implicit cloning would be useful for high level developers, but not ideal at all for low level or performance-sensitive code. It’s not the case that anyone using a shared pointer wants to clone it all the time. The high level usecase doesn’t justify the cost assumed by the low level users.

Instead, being able to wrap those types with some kind of custom “clone automatically” type feels like a middle ground. It could be a trait like mentioned, or a special type in the standard library. Suppose we call it Autoclone[T] or something (using brackets because Lemmy nonsense). Autoclone[Rc[T]] could function like the article mentioned.

Automatic partial borrows for private methods

Having “private” and non-“private” methods function differently feels like confusing behavior that should be avoided if possible. Also, “private” I assume refers to pub(self) methods (the default if unspecified), which is “module-level” methods (so accessible within the module it’s defined in). Anyway, there are years of discussion around this so I’ll just defer to that as to why it’s not in yet.

I agree with the urge to make it happen though. Some method of doing partial borrows for methods would be nice.

Named and optional function parameters

This is what prompted me to even comment. What “every language” does for complex constructors is different per language. C#, for example, supports both named and optional parameters, but construction usually uses an object initializer:

var jake = new Person("Jake")
{
    Age = 30,
    // ...
};

This is similar to Rust’s initializers:

let jake = Person {
    age: 30,
    ...Person::new("Jake")
};

Where it gets tricky is around required parameters. Optional ones don’t really matter since you can use the syntax above if you want, or chain methods like with the builder style.

As for the overhead of writing builders, there’s already libraries that let you slap #[derive(Builder)] on types and get a builder type automatically.

As for optional parameters, how those are implemented differs between languages. In C#, default values must be constant values. In Python, default values are basically “global” values and this nonsense is possible:

def count_calls(count=[]):
    # if unset, count is a global list
    count.push(0)
    return len(count)

Anyway, all this is to say that the value of optional parameters isn’t obvious.

Named parameters is more of a personal choice thing, but falls apart when your parameter has no name and is actually a pattern:

async fn get_foo(_: u32) {}

Also, traits often use names prefixed with underscores in their default fn impls to indicate a parameter an implementer has access to, but the trait doesn’t use by default. Do you use that name, or the name the implementer defined? I assume the former since you don’t always know the concrete type.

Faster unwrap syntax

We have that, it’s called the try operator.

Okay I know it’s different, and I know everyone’s use case is different, but I’ve been coding long enough to know that enabling easy unwraps means people will use it everywhere despite proper error handling being pretty dang important in a production environment.

Thinking of my coworkers alone, if we were to start writing Rust, they’d use that operator everywhere because that’s what they’re familiar with coming from other languages. Then comes the inevitable “how do I add a try-catch block?” caused by later needing to handle an error.

Anyway, I prefer the extra syntax since it guides devs away from using that method over propagating the error upwards. For the most part, you can just use anyhow::Result and get most error types converted automatically.

Try trait

Yes please.

Specialization

Yes please.

Stabilizing async read/write traits to standardize on an executor API

I’d want input from runtime devs on this, but if possible, yes please.

Allowing compilation of builds that fail typechecking

???

How is the compiler going to know how to compile the code if it doesn’t know the types? This isn’t Python. The compiler needs to know things like how much memory to allocate, and there’s a ton of potential unsound behavior that can occur from treating one type as another, even if they’re the same size.

Anyway I’ll save the rest for later since I’m out of time.

Speaking as someone with a MTF close friend and NB spouse, but the term used in the article is the term everyone around me used when I was growing up. That term may be obsolete now, and if so, the author simply needs to be informed. There’s no need to assume they meant harm by it.

If they knowingly used a term that may offend, then that’s of course a separate issue.

I was mostly looking for something more composable, similar to how jest works. Some ideas that I’ve been working on are assertions like:

expect!([1, 2, 3])
    .all()
    .to_be_less_than(5);

I also have some ideas around futures that I’d like to play with.

Felt like making an assertions library since I can’t seem to find something quite what I’m looking for.

I’m sure Lockheed Martin wouldn’t mind it too much, but I can’t see Washington being interested in actually entering a conflict (given the situation with Ukraine), and I’m sure even the suits at Lockheed are hesitant about that major of a war.

In addition to 1:many, many:many, and many:1 (which is just 1:many but looking at it in the other direction), you also occasionally see 1:1, for example if you want to augment a table with additional data. This might be done by having your foreign key also be your primary key in the augmenting table, since that would also enforce a uniqueness constraint on the FK as a result.

Also, probably unnecessary to mention, but you can also have “0 or 1” relationship (meaning one side is optional but capped at 1). These are technically separated from “1” relationships usually when you get into all the theory. An example of this might be a “0:1” relationship using the above augment table, but where the augmenting table isn’t required to have a row for every row in the augmented table. (A 1:1 constraint can be enforced, for example, by having an additional FK in the augmented table pointing to the augmenting table.)

To add - blocking the main thread on a long running task in the browser can make the page unresponsive. There’s not really a way, as far as I know, to “block until a promise completes”, which might be the source of the frustration. It seems to me that was intentional by the ones who designed this function.

Personally I don’t eat whole bananas. I peel them first. I guess that means I’m “safe”?

The Royal Scions have two planeswalker types to make up for The Wanderer having none. (They were later split into individial cards, Will and Rowan)

Rule 10 might also not apply since the companion mechanic is a special action. Still, it’s a bit confusing because “Companion” is itself a keyword ability (702.139), so my guess is that while the companion ability allows you to take a special action to put the card into your hand, it itself doesn’t put the card in your hand, so it doesn’t apply. Companions are weird.

My understanding with commander is that players don’t have sideboards, so they are unable to bring any cards from outside the game into the game. 903.11 may be referring specifically to companions, which for some weird reason, are legal in commander.

In casual commander, you can of course do what you want as long as the play group is okay with it.

(Also, I don’t play a lot of commander, so my rules knowledge for it may be incorrect.)

We have infused AI into every layer of Windows

I sure hope not. I don’t want Windows to just decide to delete my hard drive because it feels like it.

We are introducing Windows Semantic Index, a new OS capability which redefines search on Windows and powers new experiences like Recall.

You could also improve Windows search by contracting with voidtools and integrating Everything. While you’re at it, maybe ditch the bing searches, and other useless search results?

Anyway, the rest of the article seems to go into actual dev-oriented details, and there’s some interesting bits like enabling certain AI acceleration features on the web (probably only in Edge though…), for what that’s worth.

Not quite a “gaming PC” since, at least if they’re using something like Nvidia’s Hopper GPUs (or relying on another service that does), they’re not designed for gaming (and in the price range of $10k-$100kish), buuut if you ignore the finer details then fundamentally it’s basically like that. They’d send the image to their “very expensive gaming PC server” where the inferencing would be done.

Feels like we could have both by ditching tenure and allowing professors to express their opinions (so long as it doesn’t interfere with teaching, of course).

Anecdotally, my business ethics professor in college was a very open libertarian. I’ll never agree with his politics, but despite that, he was an excellent teacher, and one of the better ones I had at the school overall. On the other hand, none of the classes I had that were run by tenured professors were any good, with one professor even giving us the wrong exam once and having us complete it anyway, even though it had material we weren’t even expected to know.

I feel like I see this question come up now and then across the communities I’m in, and there’s always a debate over search engines lol. Anyway, to answer the question, I use Kagi for its custom rankings (and, more recently, Wolfram|Alpha integration, which I’ve found more useful than I expected it to be).

Duff’s device takes this to a whole new level.

In C# at least, goto can take you between case labels in a switch statement (rather than using fallthrough), which I don’t view as being nearly as bad. For example, you can do goto case 1 or goto default to jump to another case.

The only other use of goto I find remotely tolerable is when paired with a labelled loop statement (like putting a label right before a for loop), but honestly Rust handles that far better with labelled loops (and labelled block expressions).