I still use it. When GitHub first forced it on everyone, it broke one or two of my scripts - so I ended up just changing the default back to master out of spite, and haven't touched it since.
I'd bet five bucks some desperate Haskeller or Rustacean has implemented exactly that. You could also probably use nested functions for GCC C or lambdas in C++ to move everything inline?
This is why I can never get into microblogging/Twitter-type platforms. Character limits and one-click reposting mean that what little discourse you get is shallow, and ragebait is consistently pushed to the top.
I'm not going to say that Lemmy or (especially) Reddit completely avoid this, but you generally get much more insightful conversation and can opt-in to political communities.
There was a thread on !asklemmy@lemmy.ml recently asking people for their unpopular political opinions, and it actually wasn't a total shitshow!
I would consider language support essential for "good" sum types. AFAIK, stuff like exhaustive pattern matching can't be accomplished by a library. Perhaps you could do some cursed stuff with compiler plugins, however.
(There was a library that implemented non-exhaustive pattern matching that eventually morphed into an ISO C++ proposal... so we won't see it until 2030 at the earliest /hj)
It's a shame that sum type support is still so lacking in C++. Proper Result types (ala Haskell or Rust) are generally much nicer to deal with, especially in embedded contexts.
As is, there's only std::expected (which can and will blow up in your face if you forget to check has_value) and std::variant, which I have heard nothing but complaints about.
Yes. We have plenty of studies indicating that IQ deviation (for lack of a better measurement) is heritable.
This is even observable casually - plenty of people gossip about $LOCAL_FAMILY having a history of Darwin award attempts, or how $OTHER_FAMILY is stuffed with straight-A engineering students.
However, it's only a component, not the whole story. Intelligence can be built up like muscle - Joe Average who trains will beat out Sally Smartypants who doesn't.
I won't be using CSS or JS. I control the entire stack, so I can do a server-side check - GPTBot user agents get random garbage, everyone else gets the real deal.
Obviously this relies on OpenAI not masking their user agent, but I think webmasters would notice a conspicuous lack of hits if they did that.
Re: CSS and Javascript being obvious - I'm planning to do this entirely server side, since I control the whole stack.
Regular users (and good bots) get regular pages, but if a GPTBot user agent makes a request, they just get garbage back. (Obviously this relies on OpenAI not masking the user agent, but if they do that, hopefully bigger webmasters will notice the lack of hits and call them out.)
I like your idea with the sentence fragments. Because the LLM check would happen before I actually look up the requested resource, I think I could combine it with fake links to lead the scraper on a wild goose chase.
Cringe. Not everything needs to be offloaded to someone else's computer.
And frankly, why would I pay some sort of fee (which they will eventually charge, even if they don't right now) for the "privilege" of having rustc fight for execution time on a vCPU somewhere in California?
Every day that passes I lean further towards pursuing a career in embedded.
Too many people conflate the evils of corporatism and corruption with the general concept of "capitalism"/a market economy.
Now, I'm hardly an advocate of laissez-faire economics. But I'm not a full-on socialist either. I think the majority of problems people attribute to modern market economies can be corrected with aggressive anti-trust and pro-consumer regulation.
(The keyword here is majority. I'm sure it makes sense to socialize some things, but those details are best left to people smarter than me.)
I think the stuff with the foundation is kinda overblown by the Internet drama machine. That's not to say they haven't made mistakes, but hopefully the leadership council will fix things up.
Plus, Rust has come into widespread use, so it'll be very hard to kill.
Excellent tooling. The package/build manager (cargo) just works, the compiler's error messaging is simply unmatched and the IDE story is excellent thanks to rust-analyzer.
Rich ecosystem. There's a crate for almost anything you could need, and endless piles of learning resources.
You get the speed and low-level control (if necessary) of C/C++ without all the pain and legacy baggage.
The community tends to care a lot about correctness and API design, which is reflected in both the core language and the ecosystem. Rust doesn't try to hide complexity and pretend things are simple (like Go) - instead, it gives you the tools to manage it head-on.
Example: if a function can fail, then it returns a Result and you have to explicitly handle the possibility that something went wrong. There's no forgetting a null check and slamming face-first into a NullReferenceException or segfault in some other part of your code.
It's expressive. Iterators, generics/traits and other language features make it easy to communicate what's going on to both the machine and other humans. Even the syntax is designed to support this - you can tell a lot just by looking at a function signature.
Obviously it's not all perfect, however.
Compile times can drag you down. (rustc is always getting faster, of course, but it'll probably never be as fast as Go or JVM/NET.)
It can be difficult to read at times, especially when code starts leaning heavily into generics and lifetime annotations.
Speed and control comes at a cost. No garbage collector means that anyone coming from a managed language (which, hello, that was me) is going to have to rewire their brain to deal with lifetimes, ownership and mutability XOR aliasing. You eventually develop an intuition for how to structure your code to play nice with the compiler, but that takes time.
New language features can take a long time to be stabilized and released. The advantage is they tend to be baked all the way through from day one, but the slow pace can be infuriating, especially when big ecosystem advancements are hung up on key additions.
If it's anything like the USB protocol (which I've been working with recently) the names are probably baked into the binary. You're likely out of luck unless you can somehow flash modified firmware.
Perhaps there's a way to give devices an alias on your machine?
It's most likely originating from a relay switching inside your PSU. It's perfectly normal - my Be Quiet unit (slightly ironic, I know) does it and I've never had any issues.
I still use it. When GitHub first forced it on everyone, it broke one or two of my scripts - so I ended up just changing the default back to
masterout of spite, and haven't touched it since.