C is many things, but elegant really isn't one of them.
C has always been part of the "worse is better"/New Jersey school of thinking. The ultimate goal is simplicity. Particularly simplicity of language implementation, even if that makes programs written in that language more complex or error prone. It's historically been a very successful approach.
Rust, on the other hand, is part of "The Right Thing"/MIT approach. Simplicity is good, but it's more important to be correct and complete even if it complicates things a bit.
I don't really think of void* and ubiquitous nulls, for example, as the hallmark of elegance, but as pretty simple, kludgey solutions.
Rust, on the other hand, brings a lot of really elegant solutions from ML- family languages to a systems language. So you get algebraic data types, pattern matching, non-nullable references by default, closures, typeclasses, expression-oriented syntax, etc.
Just like walking doesn't really compete, like at all, with flying in an aircraft, Functional and Object Oriented Programming are at their best when you use whichever approach makes sense for a given situation and in any reasonably complex software that means your code should be full of both.
I'm not really sure sure that's true.
In FP languages like Haskell, you get tools like algebraic data types, typeclasses, and pattern matching.
FP is really opposed to imperative programming, while objects are opposed to algebraic data types.
You can write OO code that's 100% fully functional, and you can write code in Haskell or rust where you barely notice you never once used an object.
Yeah, OO and FP aren't really opposed. FP is opposed to imperative programming.
That said, most FP languages give you a slightly different set of tools to use. Algebraic data types and typeclasses are really, really nice.
Honestly, working in Haskell or rust, you don't really miss the fact that you have to jump through hoops to get traditional OO objects. There's just not really many cases where you need them.
The main problem is just that getting a product from a one-off in a lab to a cost-competitive mass-market product is hard and can take a lot of time, to say the least.
It's less that these breakthroughs are bullshit, and more that commercializing these things is hard. The articles about the breakthroughs are often bullshit, though, or at least way too rosy.
The first seasons were 30 years ago, but the ending is only about 25 years ago.
BSG, though, finished in 1979. If someone says "thirty years ago" and your first thought is the 70s, you might be old. BSG ended 45 years ago. It's 20 years older than the finale of DS9.
Edit: if someone asks you "who was president 30 years ago", do you instantly think of Jimmy Carter? Because BSG came out basically in the middle of his presidency. If your first thought was Bush or Reagan, you associate the Sci Fi of 30 years ago with reruns of BSG.
Basically, the mischievous youth think that their dead chief rabbi is coming back soon as the messiah and they have to prepare for his return by expanding his synagogue.
It sounds bizarre because honestly it is pretty bizarre.
From what I understand, it's part of triggering the return of the messiah, the late head rabbi of that synagogue. He apparently said something about expanding the building before he died, but there's been no movement on it for assorted reasons like the court cases over the building's ownership.
So the idea was apparently that finishing the expansion would be the easier option once they already tunneled it out.
He said something about expanding the building before he died, and his messianic followers think that part of triggering the messianic age is fulfilling that. But due to the court cases, that's been impossible.
So the idea the yeshiva students apparently had is that if they hollowed out the basement expansion, the easiest solution would be for the synagogue to just finish constructing it.
In other words, the tunnel isn't really practical. The point of it is just to trigger the messianic age.
Trump's lawyers argument is that presidents are immune from criminal prosecution on any official act, even if that official act is illegal or unconstitutional; that the only remedy is impeachment.
The judge brought up ordering seal team 6 to assinate a rival as an example of an obviously illegal official act. Trump's lawyers response was "obviously he'd be impeached, but yeah, I guess if he weren't he'd be immune from prosecution".
Shooting Trump at the debate would be a prosecutable private action, according to Trump's lawyer. What Biden would have to do is to tell seal team 6 "If Trump gets on this stage, shoot him".
I mean, it's not something he himself said, so they don't even really need to do that.
Basically, what happened was his lawyer was arguing that the only remedy for official actions taken by a president is impeachment; they can't be prosecuted in court aside from that.
The judge said "a president ordering seal team 6 to assassinate a rival is an official act, yes?" Trump's lawyer said "He'd quickly be impeached for that!", then when pressed more, something about Marbury v Madson presupposing something or other, then finally when pressed for a yes or no as to whether he'd be immune from prosecution, said "qualified yes".
The whole exchange is pretty bad and worth a listen.
That's not really how counting infinite sets works.
Suppose you have the set {1,2,3} and another set {2,4,6}. We say that both sets are of equal cardinality because you can map each element in the first set to a unique element in the second set (the mapping is "one to one"/injective), and every element has something mapped to it (the mapping is onto/surjective).
Compare the number of integers to the number of even integers. While it intuitively seems like there should be more integers than even integers, that's not actually the case. If you map 1 to 2, 2 to 4, 3 to 6, 4 to 8, ..., n to 2n, then you'll see both sets actually have the same number of things in them because that mapping is one to one and onto.
There's similarly the same number of real numbers as numbers between 0 and 1.
It's not just car-centric Euclidean zoning and suburban sprawl.
The US also builds really dangerous stroads that you don't really see in most other countries.
5+ lanes of 55mph traffic next to a sidewalk and tons of driveways for businesses is inherently unsafe.
It's also interesting to note that the biggest spike in fatalities was during the pandemic.
The best explanation I've heard is that bumper-to-bumper rush hour traffic essentially disappeared with the switch to WFH during the pandemic. Streets artificially looked safer pre-pandemic due to drivers getting stuck in traffic at peak periods. The pandemic just revealed how inherently unsafe American stroads are.
I mean, you also see that in the US with bike path design in general.
Bike paths around me in the US mostly go along creeks and railroads. There's one in the suburbs that's an abandoned rail line out into farmland. They're mostly designed as places for suburbanites to drive to for exercise. They're more of a park than a piece of transportation infrastructure.
Oulu, on the other hand, has bike paths that go through the center of town, out to the suburbs. There's over 300 bike underpasses on the main bike paths. It's designed for commuters, for people running errands, and for kindergarteners to bike to school. They're a practical bit of transportation infrastructure.
C is many things, but elegant really isn't one of them.
C has always been part of the "worse is better"/New Jersey school of thinking. The ultimate goal is simplicity. Particularly simplicity of language implementation, even if that makes programs written in that language more complex or error prone. It's historically been a very successful approach.
Rust, on the other hand, is part of "The Right Thing"/MIT approach. Simplicity is good, but it's more important to be correct and complete even if it complicates things a bit.
I don't really think of void* and ubiquitous nulls, for example, as the hallmark of elegance, but as pretty simple, kludgey solutions.
Rust, on the other hand, brings a lot of really elegant solutions from ML- family languages to a systems language. So you get algebraic data types, pattern matching, non-nullable references by default, closures, typeclasses, expression-oriented syntax, etc.