If you want to know how computers work, learn assembly and circuit design. You can learn C without ever thinking about registers, register allocation, the program counter, etc.
Although you can learn assembly without ever learning about e.g. branch prediction. There's tons of levels of abstraction in computers, and many of the lower level ones try to pretend you've still got a computer from the 80s even though CPUs are a lot more complex than they used to be.
As an aside, I've anecdotally heard of some schools teaching Rust instead of C as a systems language in courses. Rust has a different model than C, but will still teach you about static memory vs the stack vs the heap, pointers, etc.
Honestly, if I had to write some systems software, I'd be way more confident in any Rust code I wrote than C/C++ code. Nasal demons scare me.
Right tool for the job, sure, but that evolves over time.
Like, years back carpenters didn't have access to table saws that didn't have safety features that prevent you from cutting off your fingers by stopping the blade as soon as it touches them. Now we do. Are old table saws still the "right tool for the job", or are they just a dangerous version of a modern tool that results in needless accidents?
Is C still the right tool for the job in places where Rust is a good option?
Fixing the two party system in the house can be done piecemeal by states, because states run their own house elections.
Fixing the two party system in the presidency requires either an amendment or an interstate pact.
Because what the constitution says is that if no single candidate gets a majority in the electoral college's FPTP election, then the president is whichever candidate the US house prefers.
There would have been a pretty big difference between Ford inditing Nixon after Watergate, and Nixon running again with the promise of inditing political rivals in retribution.
It's good to hold politicians accountable for their actual crimes, and bad to have a politically motivated kangaroo court.
It's really not just that Rust is new and C is old. Compare Rust with Go, for example. Go is a fairly modern example of a 'worse is better' language.
Back in 1970s when C was invented, Lisp had been around for over a decade. C came out the same year as smalltalk, a year before ML, and 3 years before Scheme.
Rust is a very modern language, yes. There's no way we could have had it in the 70s; many of its language features hadn't been invented yet. But it very much depends on MIT style research languages for its basis.
Some of the best drinks I've ever had are pure fresh-squeezed juice.
For example: pomegranate juice pressed by a street vendor? Amazing. Apples from the tree in my mom's yard? Incredible when juiced. Freshly squeezed orange juice? Sign me up.
Relatively few fruits make a juice that's not good straight. Cranberry comes to mind as being too bitter. Lemon is a bit too acidic for most.
Wyman's 100% blueberry juice is 20g sugar per 250ml. Mott's apple juice is 28g for 8 oz/240ml. So blueberry juice is about 2/3 the sugar of apple juice. It's still plenty sweet.
You don't water blueberry juice down because it's not sweet enough. You water it down because 8oz of Mott's apple juice is $1.30 at Walmart, and 8oz of wymans' blueberry juice is $7.30. Blends use apple juice because it's cheap and mild, so you can layer other flavors on top.
Juice isn't bad for you because of the extra apple sugar. It's bad because you removed all the fiber. Fiber promotes sateity.
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 lubbavitcher rebbe said a couple years before he died that he wanted his synagogue expanded.
There's been a bit of a power vacuum since he died, and expanding the building hasn't been possible due to court cases over the building's ownership.
A bunch of the students think that the rebbe is coming back as the messiah, were bored and decided that they could start the expansion by tunneling into the basement from a couple buildings over.
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.
C is not how a computer truly works.
If you want to know how computers work, learn assembly and circuit design. You can learn C without ever thinking about registers, register allocation, the program counter, etc.
Although you can learn assembly without ever learning about e.g. branch prediction. There's tons of levels of abstraction in computers, and many of the lower level ones try to pretend you've still got a computer from the 80s even though CPUs are a lot more complex than they used to be.
As an aside, I've anecdotally heard of some schools teaching Rust instead of C as a systems language in courses. Rust has a different model than C, but will still teach you about static memory vs the stack vs the heap, pointers, etc.
Honestly, if I had to write some systems software, I'd be way more confident in any Rust code I wrote than C/C++ code. Nasal demons scare me.