There are different qualities of salt. Some contain additives, sea salt contains plastic particles. I eat plenty of salt, as much as I feel like; but it's all mineral salt without additives.
Everyone likes to pretend they can predict the future for a while, to the point where they will stop at nothing to make it conform to their predictions. Then comes the part where they will defend their choices to death, no matter how much evidence to the contrary is piling up. Once you start seeing the entire chain of consequences, it becomes easier to discipline yourself; it's a process of growing up and taking responsibility.
The whole discussion is a side track, the essence of who we are is and always was immortal. Do you honestly believe in a universe that would throw away the results of the experiment?
There's no proof either way, but it seems the least likely alternative to me. As to Buddha, Gandhi, Tesla, Einstein and many more otherwise respectable thinkers.
Examine what you're not supposed to think, what is collectively ridiculed; that's where truth is hiding in plain sight.
And since composition is seamless, and they're relatively trivial to implement; they make great glue/DSL/process description languages. Take off as in replace C++ or Java, probably not. I see them more as a complement to existing languages, a more convenient way to glue the pieces together. Even wrote my own [0] to see how far it's possible to push that idea in C.
I get what you're saying, and I get the same feeling from most modern languages. They lack conceptual integrity. It's sort of spreading like a virus, even C++ fell into the same trap lately. Whole system design is difficult, really difficult, tear your hair out difficult. Accumulating features is a Sunday walk in the park in comparison; until the pile tips over, that is.
It sort of makes sense in an engineering/programming context, but life in general doesn't really lend itself to that level of control.
Did you ever try thinking about how they might turn out for the best instead to compare results? Energy follows thought, the more you focus on it the more likely it is to happen from my experience. And the only place and time you're ever going to stop failure from happening is here and now using up to date local knowledge.
Two words, nested functions. They should have been in the C standard a long time ago, solving the same problems without them is a major pain. And even though Clang supports most of the rest of the GCC extensions, they stubbornly refuse to touch nested functions. That and the code of conduct social justice warrior bullshit they've been pulling lately keeps me away from Clang these days.
I lived through Microsoft's dark ages, when the victory of open source was still hanging by a thread. The reason we're seeing a softer Microsoft is that they lost, they were forced to change. And the open question is what they learned in the process.
On the other hand, they're producing pretty decent software these days; dotNet Core, TypeScript & VSCode just to name a few solid projects. Open source, no less; imagine that back when monkey boy was running the show, literally.
But then I keep hearing about shady Linux licensing deals and endless privacy intrusions over in Windows land.
Tricky indeed, I think I'm going to leave my code in there for now and give them a chance to redeem themselves.
There are as many kinds of nils as programming languages.
Cixl [0] doesn't derive nil from every other type, instead Nil and most other types derive Opt; which means that user code may specify Opt to accept nil or any other type to have them automatically trapped by function dispatch. I find this to be a nice compromise between wrapped optionals and shooting from the hip.
While I'm all for more options, and against deprecating commonly used functionality; the results I'm getting say that first class context switching support isn't really as important as we like to pretend.
If you're serious about writing code; I strongly recommend learning some C, Forth & Common Lisp to get an idea of what's possible. Once you have those under your belt, appearances matter less and Cixl will look less crazy banana.
I hear you; I'm not overly excited with CMake either, or the C build system story in general.
I spent several years trying to bend regular make into something I was happy with; then I spent several years on top of that using Rake, since at least it allowed me to say what I mean in a sane language. Compared to Rake, CMake is at least semi-standard, provides some kind of macro for most things I want to do, and mostly stays out of my way.
But you definitely have a point when it comes to simplicity and project fit. If someone would be willing to step up and help translate the makefile into something that doesn't look horrible, I'd be more than happy to let it go. Otherwise we'll have to wait until I get enough round tuits, which could take a while given how much remains to be done in Cixl.
Sweet memories from a more playful online experience, and probably part of the reason I turned vegan.
[0] http://www.stinkymeat.net/stinkymeat/day1/