That's only true since 2017. Prior to then, lots of folks itemized. Post-2017, with itemized deductions for regular people limited to the charitable deduction, the (capped) mortgage interest deduction, and the (heavily capped, to punish blue states, and not adjusted for inflation so it's less useful each year) SALT deduction, yeah, basically only singles with new mortgages or those who earn and donate a lot of money get anything from itemizing, but that isn't a permanent and automatic state of affairs. It could happen next year if the One Big Beautiful Bill fails, because all the changes to deductions and the standard deduction were officially temporary, and failing to extend them means the old deduction regime returns.

At the same time he was talking about "undoing some mistakes", he was also talking about gutting the regulations, and regulatory agencies, that fixed those mistakes of the past. A phrase that rings true is "Every regulation is written in blood." No, it's not 100% true, but it's the case for many, many regs. The regulations on food safety, water quality, removing lead from the environment, etc., are all there because people died. When you say "I want to cut regulations (in general)" as opposed to "I oppose these specific regulations as being poorly targeted and in need of improvement", you're saying "It's okay if we kill some people if it saves money." And that's exactly what we're getting.

Capital-L Libertarians lately haven't been all that distinct from Republicans. Sure, they tend to be more marijuana friendly. And they claim to want to cut spending or balance the budget, but so does almost every Republican, and 95% of them, given the right environment, e.g. single party control of all branches of gov't, immediately unbalance the budget further, barely cutting spending, if at all, and handing out even more unsustainable tax cuts. And you'd think, given the whole "personal autonomy as guiding principle" thing in little-l libertarianism, they'd be pro-choice, or at least "we may dislike it personally, but the gov't has no business getting involved". But basically every prominent Libertarian politician and thinker either is vocally anti-choice, or, even if they claim to be pro-choice, glaringly avoids criticizing massive steps towards anti-choice policies at both federal and state level.

I'll take the Libertarian party more seriously the moment they clearly decide that bodily autonomy, the single most basic human right, trumps (rather newly invented; within the last 100 years, most churches tended to go by quickening, not conception, as beginning of life) religious beliefs about non-conscious entities. For now, they're basically NRINO (Not Republican In Name Only).

Gaming via VPN sounds like a lag clusterfuck. You could do it, but for real time games, you'd be at a huge disadvantage.

Have you used it in the last, say, three years? They made massive improvements. I run with uBlock Origin, uMatrix (probably not for most folks, but I'm a paranoid OCD control freak), Greasemonkey with a dozen installed scripts, and Facebook Container, and it's lightning fast. They went through a bad spot 5-10 years ago, but for the last several years it's been as fast as Chrome for me, and unlike Chrome, doesn't constantly try to break ad-blocking extensions.

Except the house still won. The jackpot got this big from many rounds of play with no winner. They were eventually going to pay out, and now that they have, they've locked in the winnings from this round of suckers, perhaps slightly less than they'd have received otherwise, but still profitable for the lottery.

That's a weird way to spell "Humans murdered the shit out of megafauna more and more efficiently as they moved to areas where local megafauna didn't have time to evolve even behavioral defenses against human predation." Climate change moved roughly in sync across the globe, human arrival did not, and guess which one is more tightly correlated with mass extinctions selectively targeting megafauna?

Yeah, that's exactly it. A huge percentage of the kernel level exploits and bluescreens in Windows stemmed from insecure device drivers, because there are far more devices that need drivers than there are programmers capable of writing bulletproof kernel mode C code. The Windows solution was to make it much easier to write user-mode drivers, but they're still in C, so they're still buggy as hell, they just don't bluescreen the box when they go down (and as a bonus, they're easier to debug, which makes it somewhat easier to find and fix bugs when they do go down). I've written code for Windows myself (years ago, for Windows 7/WS2008), and the internal development rules at Microsoft do make it harder to make stupid mistakes with buffer overruns and the like, but it's still C, the moment you start indexing an array all it takes is one mistake to introduce a critical vulnerability.

I think the only reason you see Rust advocated for in this space so often is because, in the systems programming space, there just aren't a lot of options:

• C: Secure entirely by convention and discipline (read: All it takes is one lousy night's sleep and a less than perfect code review to introduce a serious bug).
• C++: Offers more options for opt-in safety, but Linus hates it (for more or less valid reasons), and again, it's opt-in safety, the gain is limited.
• Zig: Even newer than Rust, not stable enough for 1.0 release.
• Swift: Made by Apple, for Apple, don't want to anchor yourself to a language with a major corporation calling all the shots (sure, there open source contributors, no, Apple won't do a thing that hurts Apple products to improve the language for non-Apple product usage). Not sufficiently memory-safe either.
• Go: Finally, memory-safety! Except oops, garbage-collected; can't stop the world in the kernel, no sir.

Whatever you think of Rust, it's got the best memory-safety story of any reasonably mature, not-tied-to-a-single-corporate-overlord language here that gets roughly bare-metal performance and doesn't involve non-deterministic garbage collectors. That's really it. It has other nice-to-have features (e.g. decent standard library; built-in, reasonably well-done package management with a lively package ecosystem), but at kernel level, "memory-safe-by-default systems programming language" is the selling point. Adding interfaces to make it easy for multiple Rust-based device drivers to maintain that safety through a common interface rather than each of them individually wrapping the interface with FFI in a more-or-less safe way doesn't seem wildly unreasonable.

All forms of English are primarily short scale at this point, just like the U.S., even if they were historically long scale. The term "thousand million" still survives as an historical curiosity, but it's synonymous with billion in most usage nowadays. It's Continental Europe (excluding Russia/Turkey) that favors the long scale. Like British/American English, Russian favors short scale, luckily for Google (not that they'd pay either version of a decillion, in either dollars or rubles).

Only 18%? Around where I live (central MD area), the only reason someone isn't going at least 5 MPH over the speed limit on the highway, usually 7-15 over, is because the traffic has slowed everything to a crawl. And in that case, everyone is going too slow for a fatal accident. I can't imagine fatal accidents occurring around here without someone involved speeding, unless both drivers were high and driving slower as a result.

Please, tell me which languages lack program-wide ownership checking and lifetime analysis that cannot be accidentally omitted, and a framework adds all of that? That adds type-inferencing (there's a reason C++ repurposed auto; it's a convenience feature, but without it, complex use of templates/generics to get maximum performance and correctness is the ugliest thing in the universe)? That adds RAII in a way that works across function calls in disparate libraries, so ownership of a single unique object can be passed along efficiently and cleanup is guaranteed to occur even in the presence of exceptional circumstances, many-way branching code, etc.? You could add new iterator paradigms, but without language support, they're going to either make everything slower (because the compiler doesn't know when the accesses are definitionally safe, vs. runtime checks being needed), or be unsafe unless used carefully. I did say some of that can be added in backwards compatible ways (C++ added a few of these things), but the fundamental things that make Rust safe-by-default and performant-by-default, as opposed to merely providing convenient libraries, are language-level features. C is a great high-level replacement for assembly, but it's so incredibly fragile/insecure-by-default that any attempts to make it memory-safe, type-safe, race-safe, etc. when written by a median skill programmer, or even a 90th percentile programmer, would require fundamental changes to the language that would render existing code unusable (because if it wasn't unusable, it would remain the giant security holes in any new code that used it).

How many fad-and-fade languages have you seen with meaningful uptake lasting more than five years, including uptake in the major software development corporations? I'm serious here. I've been programming professionally for a couple decades, and as an amateur for a decade before that, and the closest I've seen to this was Go, which started rising around the same time as Rust, but faded quite a bit when it became clear it was too opinionated (no operator overloading means no drop-in replacements for language features like integers, collections, etc.), sort of badly straddled the boundary between a productive language and a performant language (it got marketed as a faster Python and a more expressive C/C++, but AFAICT, all the uptake was high-level developers looking for something faster, it just didn't provide what systems programmers needed).

And Rust has a lot going for it simply in terms of uptake (ignoring all merits of the language, just how far it's spread). When Microsoft is integrating it into their core products, and Linux is integrating it into the kernel, that's well-beyond where any fad language I've ever seen has gotten.

Are you joking? You have to be joking. If you put even a tiny fraction of the security and stability features of Rust, things that are desirable even before we get into functional improvements, you'd be porting some form of:

1. Automatic bounds-checking, with iterators to remove the need for most bounds-checking in the first place
2. Protections against accessing arbitrary memory
3. Automatic resource cleanup in various forms (RAII for most objects, with reference-counted types, both for single and multi-threaded usage for more complex scenarios)
4. Compiler-enforced lifetime and ownership analysis to forbid accidental use-after-free, or multi-threaded race conditions
5. Type-inferencing
6. Destructuring assignment

And to be clear, some of that is tractable. C++ started with RAII, and in the past decade or so added built-in reference-counted memory management with partial thread-safety (the reference count itself is managed atomically, but the data it points to is 100% unprotected), type-inferencing, and limited forms of destructuring assignment. It also has a concept of iterators, though it's a concept that doesn't fundamentally make them any safer if you're using them manually, rather than via a foreach-style loop. But any attempt to add the safety and security features of Rust to C in a way that was opt-out rather than opt-in (and no, opt-in isn't good enough, because the people who need to do so the most, don't) would break every existing C program, and involve introducing so much new syntax to C that it would be a brand new language.

C++ itself has made historical decisions that mean it can't do a lot of this either. They can introduce better ways to work with iterators, but the underlying protocol is fundamentally unsafe with the standard library types (vector's iterators are glorified pointers; they can't be made safe without undoing much of the performance benefits they rely on, or restricting operations like arbitrary incrementing and decrementing that existing code needs. They can introduces new things, e.g. ranges and company, but they're hamstrung when it comes to removing old, inherently unsafe things.

Sure, you could add a bunch of useful collections types, better threading tools, strings that aren't terrible hacks around simple arrays with a handful of more-or-less insecure APIs to manipulate, etc. Those are nice quality of life improvements. Somehow C hasn't managed to do more than the most basic threading for decades, and it doesn't look like it's even trying. And it lacks any sort of package ecosystem, along with any standard build tooling that might support it (things Rust already has). But none of that is impossible in theory (even if history suggests its impossible in practice). What is impossible is making C any more secure or stable than it is without making into a completely new language.

None of this is to say that Rust is the one and only answer. I readily admit it's hard for beginners to pick up, precisely because of those ownership rules and lifetime issues that are the core selling point for Rust as a secure replacement for C (I know, I've been learning it recently). But I don't know of any competition that is suitable for general systems programming tasks (provides deterministic resource management, low-level access when necessary, high performance, etc.) that isn't C or C++, and the security story for both of those languages is "Don't make mistakes in the first place", a strategy that I'd trust maybe 1% of coders to manage (have you read the CERT Secure Coding Standard for C? I have, I'm a very good C programmer, and even I have trouble remembering to cover every possibility in there), and that's a very optimistic estimate.

My very first test of any of the modern LLMs was asking Bing's Copilot to write me a D&D adventure, just to see what it came up with. What it came up with was a summary of the Light of Xaryxis, the published adventure from the 5E Spelljammer Box Set. No creativity at all, it just regurgitated an outline of the exact adventure that had been published a year or so ago. Not exactly a great source of ideas if it mostly just paraphrases stuff you already wrote.

At least one of the articles talks about a proponent of this bill who divested from stocks and put their money in a blind trust (which presumably invests without their involvement), so presumably that's allowed. I suspect broad-based mutual funds would also be allowed. Among other things, legislators have access to the TSP, the federal equivalent of a 401(k), where the primary investments include an S&P 500 tracking fund, a small-medium cap U.S. stock fund, and an international stock index. They're all so broad that it's pretty rare you could use inside knowledge to help (notable exception: the legislators with privileged early info on the COVID pandemic dumping stock before the news leaked), and even when you can, the TSP has contribution limits that mean it's generally not going to be a source of massive wealth (in similar 401(k)s, it would take close to 20 years of maxed out contributions to reach ~$1M in retirement savings).