Later, they comment:

I’ve learned today that you are sensitive to ensuring human readability over any concerns in regard to AI consumption

Their takeaway from

1. They reject with one of the reasons, and the only disclosed reason, being AI is worse at reading the form
2. Community says AI readability should not be a priority over human readability
3. That it may not even be a problem for AI to read
4. Suggest at least considering an improvement in a form that both can read well

is that the community wants to “ensure human readability over any concerns in regard to AI”.

I don’t think this is only about MS or being overworked. Yes, it was a harsh push-back. But they’re responding passive aggressively, claiming the community pushes the other/an extreme when, to me very clearly, it does not.

Maybe you can say that conclusion is also due do being overworked and not investing the time to read through the comments. But I dunno. There’s no need to reply in that passive aggressive tone and claiming unreasonable things.

404 dead link

I find that the .NET/C# documentation has great guidance for old and new concepts. There’s reference docs with remarks, there’s guidance and best practice recommendations, and there’s examples and guided work-alongs.

Personally I’ve never done the examples or video or text follow-alongs. But I greatly value the concept guidance that goes beyond mere reference docs with remarks.

While it’s somewhat specific to the .NET/C# ecosystem, I imagine it’s valuable beyond it, and maybe a good example of how a big and significant enough project can provide more relevant and condensed information than “random tech blogs and websites” or similar.

Tell me when you’re getting used to USB so I can prepare for the next switch /s 😅

I don’t see how that is relevant? You’re already familiar with C, so writing about C does not influence whether you will be outdated in a few years. Learning and writing about Rust could be something that becomes useful, but not necessarily practically - it depends on what you will do in the future.

If you feel you lost your passion, I would suggest learning and experimenting with Rust. It’s different, so may be interesting and thought provoking to learn.

Writing down what you know about C may also be worthwhile, good, or produce a good resource, but I don’t see it as much or like as sparking lost interest and passion. If that is actually your goal (you only asked about future relevancy in the end).

I did not go through those phases.

I talked to a friend of mine last week and they didn’t know of the old PS/2 mouse/keyboard cable/sockets. They’ve seen it before, but it wasn’t familiar to them. Nobody only having used USB devices will remember those.

Who has age authority? A state agency or service. Like the state issues an ID with age.

Preferable, we want the user to interact with a website, that website request age authentication, but not the website to talk to the government, but through the user.

Thus, something/somewhat like

1. State agency issues a certificate to the user
2. User assigns a password to encrypt the user certificate
3. User connects to random website A
4. Random website A creates an age verification request signed to only be resolveable by state agency but sends it to the user
5. User sends the request to a state service with their user certificate for authentication
6. State agency confirms-signs the response
7. User passes the responds along to the random website A

There may be alternative, simpler, or less verbose/complicated alternatives. But I’m sure it would be possible, and I think it lays out how “double-blind”(?) could work.

The random website A does not know the identity or age of the user - only to the degree they requested to verify - and the state agency knows only of a request, not its origin or application - to the degree the request and user pass-along includes.

You didn’t give much info on what it’s supposed to be or become, but either one of:

• Create something of value, while being open and documented enough for accepting contributions
• Write down and publish goals, approach, structure so anyone can participate, and seek out collaborators while also doing your own

• AHA - Avoid Hasty Abstractions
• WET - Write Everything Twice
• DRY - Don’t Repeat Yourself

Forge-joe

there have been physical fights between committee members

lol; committee with consensus by violence?

• https://github.com/google/oss-fuzz-gen
• https://blog.oss-fuzz.com/posts/
• https://google.github.io/clusterfuzz/

They’re not demanding anything. They’re describing how the current meaning of REST is nothing like the original one.

They’re making a point for not splitting application state and logic into client and server with shared knowledge. If you’re making that a pretext of course their argumentation won’t fit. They’re describing an alternative architecture and approach. Not an alternative protocol for the current common web application architectures.

Presentation/Lecture; bad software quality due to software stack complexity with increased separation of layers and participants

SoC (System on a Chip) hardware for embedded/smaller use cases is very common and successful.

Suggests “Direct Coding” with direct hardware access as a possible alternative approach to PC hardware interfacing. Implementing that is more about commitment than difficulty. Depends more on hardware producers than software developers. A lack of drivers could give a fairer playing field between manufacturers.

German pro basketball team relegated to lower division due to Windows update

lol

Seems like a Ruby issue and suggested improvement? Using keyword arguments does feel like introducing a type of typing.

In C# I use records for simple, naturally behaving types, I can define explicit and implicit cast operators, so I have to choice between requiring explicit casts or not (because they make sense to require or are not necessary). I can use var to define a variable without specifying a type, and it is deducted from what it gets assigned - but is still that specific type and gives me type safety.

In Rust, as far as I understand anyway, traits define shared behavior. In Go interface implementations are implicit rather than explicit. With these, there’s even less of a need of elaborate explicit typing like the post argues/gives an example of.

In general, I’ve never had considerable effort or annoyance implementing or using typing. And I know what it’s good for; explicitness, and in consequence, predictability, certainty, increased maintainability, and reduced issues and confusions. If following references or refactoring becomes unpredictable or high effort, it’d be quite annoying.

When I’m coding JavaScript adding JSDoc so the typing information gets passed along is quite cumbersome. Without it, the IDE does not give intellisense/auto-completion or argument type matching. JavaScript is better with it, I consider it worth it with IDE support, but it is quite cumbersome. (I try to evade TypeScript compiler/tooling overhead.)

A programming language can offer extensive auto-deduction while using strong typing. With appropriate conversions in place, it will only report conflicts and where it was intended to.

I’m thinking of where I enjoyed dynamic natures, which I certainly have. But I don’t think that’s a matter of typing. It’s a matter of programming language interfacing to typing. If in PHP or JS I make a change, hit F5, and get an error, that’s not any better than the IDE already showing it beforehand. And for the most part, I can program the same way with or without typing.

Man, this became a long text.

I’m just glad we didn’t end up with this one (seen in the ticket)

Damn, sad story behind the color

deleted by creator