606 karma · joined February 20, 2023
Partially, but after seeing the Jordan Hubbard connection, there's a lot of layers to this. May have reinforced my biases, but it's definitely non-trivial according to my hippie-tier anarchist baseline. Oops. Worst case scenario of answering your own question.
But your reply does give me actually contradicting evidence. It wouldn't surprise me that distance has grown to the point of total atrophy, given the general trajectory Apple has been on since 2012 or so. This is why I ask these questions, because the people on the ground give the most informative answers.
As Ptahhotep advises circa ~2300BCE:
> Fine words are more sought after than greenstone, but can be found with the women at the grindstone.
The only thing I've ever heard from FreeBSD-land, not paying attention to users, but the maintainers and the tools. Apple comes up. In the same manner that RedHat and others come up for Linux. How to explain? It's an abstract pattern. Transparent, understandable.
I mentioned somewhere about the connection through ix systems. And honestly to project, if I was a maintainer of something used between Netflix and Apple, I'd prioritize Apple. Apple has outlived IBM. If you know your history, you know how serious that is. If you've got authority over something as large as FreeBSD? Yeah, you don't ignore that kind of actual power especially when it's personal. Like I say, all based on guesses. But some things are hard to mistake.
I understand the former. But with how Apple operates, it's really hard to believe they'd pull downstream from something they don't have some kind of soft power over. They do still pull downstream AFAIK? Maybe that's changed?
>Ix systems
I did some reading and saw a FreeBSD contributor ended up going to Apple until 2013 before he founded this company. https://www.ixsystems.com/clients/ Apple is listed here. Six degrees of separation and all, but probably not a coincidence. Nothing wrong with that, business is a social structure. This is how they work. We make and keep friends, even if only professionally. Backchannels are where real deals are made. But this to me is not nothing. No corporate influence means there's a lot of nice things you don't get. You just can't afford the manpower. It looks more like 9 Front than a BSD that has some serious billion-dollar problems under its belt.
That sounds harsh, not a judgement. Just very deep skepticism of the assertion of no influence. I'm realizing there's not a lot that can be done to sway that intentionally.
> This is a huge difference to Linux
This I'm well aware of. I just like having a perspective across the fence. These days they're starting to get a little too aggressive for my tastes. FreeBSD seems fine in comparison.
I'm genuinely actually curious. FreeBSD exists in kind of a shadow realm for me where I've never been quite able to pin down the soul that keeps it chugging, but I know it exists somewhere in there.
particularly when the language you're replacing was explicitly designed for your domain, and the language you're replacing it with is an entropic event horizon from which no coherent thoughtform can escape.
[1] - https://www.dote.osd.mil/Portals/97/pub/reports/FY2024/other...
I disagree. Having to juggle two type systems and two languages simultaneously is inherently unclean, to say nothing of how noisy and unergonomic templates end up being. For anything non-trivial they're a mess. Imagine I handed you a codebase with a few hundred templated structures, averaging about 50 parameters each, many of which are variadic, many of which are nesting as parameters within each other. As you climb through this pile, you end up in a totally different layer, where these more complicated templated structures are passing around and working on a much larger collection of simpler templated structures and constexpr. You're not going to have a fun time, no matter how comfortable you are with templates.
> I can’t remember the last time I saw a compiler crash
How long of a parameter pack do you think it will take to cause a crash? Of course eventually the compiler has no more memory to spare, and that'll be a crash. Clang will helpfully complain:
warning: stack nearly exhausted; compilation time may suffer, and crashes due to stack overflow are likely
But I assure you, the compiler will crash long before it runs out of memory. If you're in the domain of non-trivial meta-templates, these packs can explode to ludicrous sizes from recursive concatenation, and especially if you have a logic error somewhere that generates and concatenates packs you didn't want. And that's just the obviously intuitive example. Now contextualize this in the codebase I describe above.The more you push templates as a turing-complete language to their maximum potential, the more compiler issues you run into. Templates are probably the most rigid and unstable metaprogramming facility I've experienced, honestly. GCC and cl.exe are the worst for it.
> it lives closer to the abstraction level of Java.
That's interesting, because Java isn't very abstracted over the JVM. It's that extra layer of the JVM being an abstraction over another CPU architecture that makes Java abstract. C and C++ are arguably more abstracted, because they have to be. But just like Rust, they provide good general semantics for any register machine that the abstractions can mostly be compiled away.
> the rigid ownership/lifetime model doesn’t play nicely with fairly standard systems-y things like DMA
Choosing references as your default is insane, honestly. Safe Rust is akin to writing formally verified software in the mental and ergonomic overhead it incurs. That's not coincidental. I've come to the conclusion one of the biggest mistakes of the community is not pushing pointer-only Rust harder, given they want it to be taken seriously as a systems language.
Rust's safety is irrelevant as far as I'm concerned. It's nice that it has it, but I (and everybody else working in C++) is used to working without it and don't really miss it when it's gone.
> and the code is always runs slower for some inexplicable reason.
As you come to understand Rust as a set of assembler macros and rewrite rules applied over them, I've found they're neither more or less granular than the C/C++ ones. They're just a different family, and it stems from a different style of assembly programming (of which there are many). If you've ever translated a lisp with manual memory management onto a register machine, it's similar to that way of thinking about how to compose LOAD/STORE/JUMP + arithmetic, which it got from the ISWIM/ML heritage. Just like with C/C++, everything else is syntax sugar and metaprogramming. At the core of it, you should still be able to translate your Rust code into your target's machine code in your head relatively trivially.
Not really. Rust, ATS, D, and some implementations of Lisp and even Haskell if you slay the dragon of actually learning GHC. Modern C++ is honestly overrated in my opinion as an extensive user of the language with 300k lines in a modern dialect alone. It's a pain in the ass to step through in a visual debugger and core dumps may as well be useless no matter the platform. It's extremely grating to read and to write. Compilers have a tendency to crash like crazy if you get too cute. There's still no compile-time (or runtime) reflection. I would literally rather be writing proofs for a dependent type system than deal with heavy template metaprogramming.
GHC, which is without a doubt the smartest compiler you can get your grubby mitts on, is still an extremely stupid git that can't be trusted to do basic optimizations. Which is exactly why it exposes so many special intrinsic functions. The "sufficiently smart compiler" myth was thoroughly discounted over 20 years ago.
Actually I do, and I include the inertia and momentum of every piece of the drive-train as well, and the current location of the center of gravity. I'm thinking about all of these things through the next predicted 5 seconds or so at any given time. It comes naturally and subconsciously. To say nothing of how you really aren't going to be driving a standard transmission without that mental model.
Your analogy is appropriate for your standard American whose only experience with driving a car is the 20 minute commute to work in an automatic, and thus more like a hobbyist programmer or a sysadmin than someone whose actual craft is programming. Do you really think truckers don't know in their gut what their fuel burn rate is based on how far they've depressed the pedal?
Thus I've cut through a laundry list of silver and golden age cRPGs (and other genres, of course) with cute copy protection and complex manuals. Often times the relevant information was included as a text file (maybe not in the same format it came in), sometimes the copy protection was patched right out of the game (the Scene in the 20th century was just that crazy.) I never particularly cared. I was there for the game, not the auxiliary accoutrements. To some degree I understand the sentimentality and attachment if you grew up with the tactile materials accompanying the game. That being said, I don't feel like my experience of Ultima 3 was lessened because I lacked the cloth map any more than I feel like my experience of Wasteland was ruined because I could ctrl+f the copy protection challenges.
And for that matter, if you're concerned about minute granular details of visual media being an integral component of the meaning and essence of that media, you should be far more concerned with whether or not the cultural context is one that's even accessible to you in a meaningful capacity, because most are not. The whimsy of the Mona Lisa in person isn't actually all that deep.
Perhaps not modern C++, but I would absolutely place it in the same weightclass as CFront and C++98 (albeit with less bugs and more ergonomics than those). I know you've placed the language adjacent to gamedev, so an appropriate metaphor, I feel like Odin is up to the task of making something with the complexity of a Goldsrc game, or a Dreamcast game. I feel like I could churn out half a million lines of high density soft real-time code quite happily.
Excited to see how it evolves through the years. Keep up the good work!
It detracts from the thing-itself, like a showroom car that travels everywhere in a hermetically sealed container. That's not a car anymore, it's waste. Just because it gets driven 5 miles a year doesn't change shit. If someones spending money to preserve my games, I'd rather it'd just be a tarball in a well maintained magnetic tape vault available on-line than some aristocratic funko pop collection for a tiny amount of people to pog at in person.
You can find odds and ends of these things in other Pascal successors like Delphi, Oberon and Object Pascal. Truth is though, I never found these languages compelling. Why? Because none of them were anywhere close to being the same kind of simplicity as Pascal, and they were too wrapped up in flashy, trendy things that went out of style. Where Odin wins out is that it distinctly lacks the 90's OO craze hangover, and it never feels particularly more complicated or bloated. It's an audaciously tasteful proposition for a language. A C replacement? No, not really. But as a C++ programmer who's fed up with the lack of things like structure introspection and ergonomic sum types, I'm keeping a very close eye on Odin.
[1] - https://c3-lang.org/
[2] - https://harelang.org/
For anyone unfamiliar with Odin that might misinterpret this, Odin has structs and parametric polymorphism for those structs. What it does not have is operator overloading or methods (which also means no constructors or destructors). In this sense, its product types are like ocaml's, only without methods too. Odin is not object oriented.
IMO AST Macros are an even bigger problem than text substitution. Debugging metaprogramming of any kind past a certain point of complexity is a royal pain in the ass (even in a Lisp, Forth or Prolog), but AST explorers are next to useless for complicated logic problems that involve needle in a haystack searches of side effects. If you're dealing with a large AoS of heterogeneous SoAs which influence each other to shuffle around, and most of the related code and the structures themselves are generated via AST macros, you better be really comfortable with assembly analysis and debugger scripting.
> Are there cases where you didn't "obviously" cheat where it's "wrong" to use it?
In particular, it prevents us from adapting the proof to non-binary valued logics full stop.
> I see ¬¬P => P as a "cast" from an opaque function type to specifically be a closure {f => f(p)} for some p: P.
Now this is an interesting thought.