751 karma · joined May 2, 2013
I still believe you are right and wrong (which is why I put the "ish" on wrong).
"Every new major OS update introduces new bugs, that didn't exist in the previous OS, some of them horrible, and Snow Leopard was no exception" is not what folks are noticing when talking about Snow Leopard. People don't say Snow Leopard was great because it had no bugs, they say it was great because it had fewer bugs they experienced at release and converged quickly to something that was very stable, much more quickly than previous releases (and Leopard was a particularly long stabilization cycle right before it).
I do remember that bug you link, and I remember is was via migration assistant and required some convoluted steps to get in that state (IIRC it largely cropped up with people migrating their home from extremely old versions continuously, which was one of the QA tests we actually did but this issue was missed). There was much debate as to just how widespread it was (Apple didn't have telemetry at the time and had to rely on forums and apple care reports). The majority of people had no issues with SL, which was not the case with Leopard. Leopard's development internally was also more chaotic FWIW.
During that time period my team and I triaged every single Mac OS X bug coming into the company every morning. Trust me, SL was of higher quality than Leopard.
Nowadays, shipping is less of a major event due to CI, automated tests, betas, no CDs/DVDs, recovery partitions, etc. We're in a much better world!
The new version of the OS was always being developed in a branch/train, and fixes were backported to the current version as they were found. They weren't developed linearly / one after another. So yeah, if you are comparing the most stable polished/fixed/stagnant last major version with the brand new 1.0 major version branch, the newer major is going to be buggier. That would be the case with every y.0 vs x.8. But if you are comparing major OS versions, Snow Leopard was different.
Snow Leopard's stated goal internally was reducing bugs and increasing quality. If you wanted to ship a feature you had to get explicit approval. In feature releases it was bottom up "here is what we are planning to ship" and in Snow Leopard it was top down "can we ship this?".
AFAIK Snow Leopard was the first release of this kind (the first release I worked on was Jaguar or Puma), and was a direct response to taking 8 software updates to stabilize 10.5 and the severity of the bugs found during that cycle and the resulting bad press. Leopard was a HUGE feature release and with it came tons of (bad) bugs.
The Apple v1.1 software updates always fixed critical bugs, because:
1. You had to GM / freeze the software to physically create the CDs/DVDs around a month before the release. Bugs found after this process required a repress (can't remember the phrase we used), which cost money and time and scrambled effort at the last minute and added risk. This means the bar was super high, and most "bad, but not can't use your computer bad" bugs were put in v1.1...which was developed concurrently with the end of v1.0 (hence why v1.1s came out right away)
2. Testing was basically engineers, internal QA, some strategic partners like Adobe and MS, and the Apple Seed program (which was tiny). There was very little automated testing. Apple employees are not representative of the population and QA coverage is never very complete. And we sometimes held back features from seed releases when we were worried about leaks, so it wasn't even the complete OS that was being tested.
A v1.1 was always needed, though the issues they fixed became less severe over time due to larger seeds (aka betas), recovery partitions, and better / more modern development practices.
1. Bazel/Buck is not just for building, it is a task runner with built in distributed execution and caching. Which is, uh, what CI is.
2. You not finding it useful might be because you want to continue to use the same methods and tools yet get different results. Bazel/Buck supports Go and Rust and those just fine (JS is steadily improving as well, I know multiple public companies using it). Now, the DX may be different or non-standard but that's the point...different methods for different results. Of course there are tradeoffs to it not being the standard way to do things for a particular language!
3. You can run postgresql/redis/what have you into the environment with Bazel/Buck, all the companies using these tools do it. Almost everyone wires it up to https://testcontainers.com/, see https://www.docker.com/blog/revolutionize-your-ci-cd-pipelin....
4. For integrating the entire lifecycle, this is how it is set up at most companies...use Bazel/Buck for building the environment, use Bazel/Buck for building, use Bazel/Buck to trigger a deploy, etc. For example, see https://github.com/adobe/rules_gitops
Again, not trying to be rude, just drop info. Your list of pain points in the post is real, but only with certain / older systems or ways of using them. If you look into the newer systems, you'll see that they were largely created to solve those issues!
And if those don't work for you, build custom on something like Temporal.
For Rust GPU, nothing built in but there are libraries like https://github.com/rust-num/num-complex that support `no_std` and should work on the GPU. I've never used them so I don't know what (if any) the perf hit would be.
We already have a lot (we have many intrinsics and an `arch` module like `std::arch`, asm! to include raw spirv, etc). For example, here are the intrinsics: https://rust-gpu.github.io/rust-gpu/api/spirv_std/arch/index... and here is support for ray tracing (which obviously is not on every card: https://rust-gpu.github.io/rust-gpu/api/spirv_std/ray_tracin...).
Vulkan has a way to query and specify different GPU capabilities and Rust-GPU uses that.
Rust and Vulkan have many of the tools we need for progressive enhancement, we are not focused on lowest common denominator.