He couldn’t get back in 27, he’s at 2 consecutive terms right now. Unless they change the laws…

here’s the recording: https://youtu.be/RI4D62MVvCA

“Direct Action” oh, look, they have the same name as the far right terrorists in France. What a surprise.

Not sure what the underlying software is/are, but I’m pretty sure this what they’re referring to: https://docs.forge.apps.education.fr/

The wood paneling/shielding and old-style canon are almost quaint enough to make me not see the prototype for WW1 that this is. Ominous.

“With respect to content that is already on the open web, the social contract of that content since the 90s has been that it is fair use. Anyone can copy it, recreate with it, reproduce with it. That has been freeware, if you like. That’s been the understanding,” said Suleyman.

Ugh. Social contract, free use, freeware - those all mean very different things. I don’t think the head of a department like that should be blabbing to the public if they’re going to mix up terms like that. Do they not have PR and legal departments that are versed in anything beyond Microsoft’s historical business methods (lie, steal, and fearmonger about open source)?

Not to mention that in some places, you cannot give up the IP rights over code you write.

Not to mention “fair use” is primarily for artistic endeavors.

Not to mention “freeware” is for programs, not written word blog posts or images.

etc…

The French political system, casually referred to as the “Republic of Friends,”

Where does the author get this? I’m French and have never heard of our system called as such - especially not by a French person.

Bit of both, I suppose. Along with my own experience trying to deal with prototypes in JavaScript and how Python handles methods vs “bare” functions internally in terms of v-tables and “where” things exist in memory.

I imagine the fact that both of those are interpreted languages plays somewhat heavily into it.

With regards to being able to write MyStruct::my_method(&my_var), it’s the one-two punch of “I can use that specific syntax to differentiate between ‘inherited’ methods that have the same name” and that the compiler doesn’t treat .method() calls any differently and just rewrites them as such when doing it’s job.

Lol. What, are we going to be installing Candy Crush on our robots? Expecting to be able to project recurring revenue from a humanoid robot based on smartphone numbers is a new kind of ignorance.

An important part of that process that needs mentioning is that when the mothers are convinced by Nestle to feed their babies formula instead of their breast milk, their bodies will stop producing the milk before the baby is weaned from it.

So Nestle literally endangers babies’ lives just to sell more baby formula.

I’m sure there are a bunch of patterns that emerge out of this (anyone with some wisdom here?) …

The classical one is something that looks like the following:

struct LoggedOut;
struct User {name: String};
struct Admin {name: String};

impl LoggedOut {
  fn login(self, name: String, password: String) -> User {
    User { name }
  }
  fn admin_login(self, name: String) -> Admin {
    Admin { name }
  }
}

impl User {
  fn log_out(self) -> LoggedOut {
    LoggedOut {}
  }
}

impl Admin {
  fn log_out(self) -> LoggedOut {
    LoggedOut {}
  }
}

fn fetch_user_preferences(user: User) { /*...*/ }

fn do_admin_action(admin_account: Admin) { /* ... */ }

fn main() {
  let mut user_session = LoggedOut {};
  /* (get user input) */
  match input {
    "login" => {
        user_session = user_session.login(name, password);
    }
    "admin" => {
       user_session = user_session.admin_login(name);
    }
  }
}

This would prevent you from writing code that uses the user’s info / session “object” after they have logged out (and/or before they have logged in). On its own it’s naive and a bit encumbering - I expect an enum would make more sense but then you can’t restrict via types which user session values can and can’t be passed to specific functions. In any case, when you are building a whole system around it it can be very useful to have the compiler enforcing these sorts of things “in the background”.

This is basically what Gary Bernhardt is talking about in the talk you linked.

I want to highlight one of the more subtle-yet-important clarifications made in these 2 chapters: associated functions vs methods, and how method calls are just syntactic sugar for function calls.

Unlike in many other languages, there is no formal distinction (e.g. via separate keywords) between methods vs constructors vs property getters. The first parameter as well as the return type determine if a given associated function is “actually” a constructor or a method (etc.).

Personally, I find this incredibly elegant; it’s a form of “less is more” that gets out of my way when I’m coding while still allowing me to use all of the existing patterns that I know from elsewhere.

We read from the intro to chapter 7 all the way through section 7.3 (Paths for Referring to an item in the Module Tree).

Here’s the recording: https://youtu.be/pUqVmPRLhNE

Je crois que tu penses à “the narcissist’s prayer” (dont l’Internet me dit que c’est Dayna Craig l’auteur) :

That didn’t happen.

And if it did, it wasn’t that bad.

And if it was, that’s not a big deal.

And if it is, that’s not my fault.

And if it was, I didn’t mean it.

And if I did, you deserved it.

In case the “dim” comment isn’t a joke, as I recall it’s short for “dimension”, as in you are specifying each variable’s dimension in the computer’s memory. Source: some “intro to programming with vb6” book I read like 15 years ago at this point.

I just got back from a trip to a substantially less developed country, and really living in a country, even for a little bit, where I could see how many lives that money could improve, all being poured down the Microsoft Fabric drain, it just grinds my gears like you wouldn’t believe. I swear to God, I am going to study, write, network, and otherwise apply force to the problem until those resources are going to a place where they’ll accomplish something for society instead of some grinning clown’s wallet.

Amen. We always need more insiders who are ready to take up the cause of not doing stupid shit with the ungodly accumulation of resources our society has permitted, especially when we are currently leaving so much of the world to play catch-up while we continue to leech them dry.

Here’s the recording: https://youtu.be/W1fjxCwtwfM

We managed to get through the rest of the entire chapter! Next session will start chapter 7 (on packages, crates, and modules).

Microsoft is pivoting its company culture

Oh yes, the thing they’re well known for succeeding at.