811 karma · joined July 14, 2014
https://www.chibios.org/dokuwiki/doku.php?id=chibios:licensi...
Edit: missed the part about JS ecosystem. You can move DRM prime descriptors between processes, but I assume you can’t do this from the ffmpeg CLI and would need to write your own little C wrapper around libavcodec
It would feel weird for Vulkan to become the standard API for encode/decode given that (as you say) video accelerators aren't necessarily tied to the GPU (although not necessarily weirder than doing it through an extension of the webcam API).
That said, I still think sparing use of this is justified, especially with an editor which can show types on mouseover.
In contrast, you can build a very simple encoder using very few of the format features and still have it be usable/useful (albeit with poor quality/compression ratio).
I read some of Effective Modern C++ but it seemed to be more a list of footguns and poor design decisions in the later C++ editions.
For simplicity, let’s say that all quantum interactions have two possible outcomes, 0 or 1.
The first point is that we can only talk about what interactions appear to have done in the past in our worldline/universe, which is randomly distribute themselves between 0 and 1. If we happened to be on a worldline where all interactions had always resulted in 0 for the whole history of the universe then that universe almost certainly wouldn’t support complex life. So perhaps there’s an observership bias here: if quantum interactions hadn’t decently distributed themselves between 0 and 1 then we wouldn’t be asking this question (just like the values of all the other fundamental constants).
As far as I can tell there’s nothing in current theories which would rule out all future interactions happening to result in a 0. Let’s hope our consciousness don’t end up on that worldline (unless you believe in quantum invulnerability).
In terms of checking over the code, cargo dependencies should result in less duplication and so fewer lines of code for the same level of functionality, and having it split into crates doesn’t obviously make it harder to review and Cargo.lock means the dependencies won’t change unexpectedly.
I do agree that there is a question about whether easy access to pulling in dependencies means libraries are more inclined to bloat and unnecessary complexity. But not having cargo dependencies at all would seem like a very big hammer to solve that problem. I’d much prefer to grow an ecosystem of minimal/simple libraries which don’t try to do everything and which limit their dependencies.
Cargo letting libraries easily have their own dependencies means that many Rust libraries are very rich and fully featured. This has plenty of advantages, but the big dependency tree can be a problem in some circumstances. Crate features can sometimes help but usually not much in my experience.
I’ve seen libraries appearing in Rust which are specifically very simple and minimise dependencies (ureq is an example I like). This gives the developer the choice whether they want libraries which just do a small basic job or whether they are okay with including lots of dependencies in exchange for rich functionality. There’s a risk of segmenting the ecosystem (see also async/tokio) but it seems to be working pretty well to me.
It would be cool if kernel Rust could implement a panic handler which just killed the offending module, but I’m assuming from the discussion around panics that this isn’t possible.
But the multiocular O really does seem like one monk got bored one time and did some doodling.
To me it the race to the bottom of clickbait video titles/thumbnails feels dishonest and harmful but it’s hard to see what to do about it other than manual curation and/or alternative platforms which don’t use recommendations to exponentially amplify click rates.
This hits the nail on the head for me with Python. The standard libraries take a very “batteries included” approach but the language constructs don’t, and that means people use the flexibility of the language to do things their own way. I find that really increases my mental workload when reading other people’s software (how have they done this) and when writing my own (which way should I do this).