This is already happening.

https://alpha.school/

https://m.youtube.com/watch?v=QptwxcByzTI&pp=0gcJCa4KAYcqIYzv

She’s an ape, not a monkey, have some respect.

It’s not a branch, it’s the trunk

Don’t take career advice from Joe Piscopo.

FYI, Tidal is approximately the same price as Spotify and there are several tools floating around on GitHub which will allow you to download high quality flac files from that service.

Let me clarify: I did not mean ‘accecpt’ as in ‘accept and merge changes into the code’, but as ‘accept mail at this address’.

Often yes, but not necessarily. The GPL requires you to distribute the source code. But I’m not aware of any requirements to accept changes from anyone else.

Not quite correct. The GPL (any other free software license I’m aware of) doesn’t require you to accept changes from anyway. You can develop a piece of software and release it under the GPL without accepting public pull requests.

Free software licenses protect your rights to do certain things with the source code (the distinction from ‘source available’ software being exactly what is explicitly protected), but it doesn’t require you to accept or entertain changes from anyone who wants to make them–essentially you can force them to fork the project in those cases.

In my neighborhood there was a bike lane separated from the motor traffic with concrete bollards.

They removed the concrete bollards and replaced them with these shitty plastic ones… because people kept driving their cars into them.

Even not considering asylum. Many countries make harder, or impossible, for folks with certain medical conditions to immigrate through traditional/legal means under the rationale that they might be a drain on the public medical system.

Emperor Shōwa

Not really, because rust doesn’t have exceptions. Instead you are encouraged to handle every possible case with pattern matching. For example:

fn maybe_add_one(number: Option<u8>) -> u8 {
    match number {
        None => 0,
        Some(i) => i + 1,
    }
}

Option<u8> is a type which can either be some 8bit unsigned integer, or none. It’s conceptually similar to a Nullable<int> in C#.

In C# you could correctly implement this like:

public int MaybeAddOne(int? number)
{
    if (number.HasValue)
    {
        return number.Value + 1;
    }

    return 0;
} 

In rust, you can call Unwrap on an option to get the underlying value, but it will panic if the value is None (because None isn’t a u8):

fn maybe_add_one(number: Option<u8>) -> u8 {
    number.unwrap() + 1
}

In some cases unwrap could be useful if you don’t care about a panic or if you know the value can’t be None. Sometimes it’s just used as a shortcut. You can likewise do this in C#:

public int MaybeAddOne(int? number)
{
    return number.Value + 1;
} 

But this throws an exception if number is null.

A panic isn’t the same as an exception though, you can’t ‘catch’ a panic, it’s unrecoverable and the program will terminate more-or-less immediately.

Rust provides a generic type Result<T, E>, T being a successful result and E being some error type, which you are encouraged to use along with pattern matching to make sure all cases are handled.

Yes it is. Typically you’d do some pattern matching to handle every possible case, but Unwrap is often used as a shortcut.

It’s more like a method that can throw an exception. Rust doesn’t really have exceptions, but if you have a Result<T> or Option<T> type you can Unwrap it to get just the T. But if there’s no T to get (in the case of an Error type for Result for None for Option) the call panics.

Remember, the alligator wants to eat the bigger number

Leto II Atreides

I don’t know why, but if I had to guess, because it was easier to get the amendment to the city charter passed if they excluded the general election. Once they prove it works maybe it will be easier to expand the scope.

I haven’t heard him mention it, but I bet he would be in favor of it.

Only in the primary, not in the general election.

You’re off by a couple decimal places. 5% of 212 million is 10.6 million.

98,000 is 0.05% of 212 million.