I wonder how much internet-argument bandwidth would be saved if we used different words for "freedom from" vs "freedom to", instead of putting both things on a single scale and then arguing over which is "more free"...
Yes - difficulty in shipping security updates to a hundred different container images, each of which is vulnerable in their own slightly-different way because they all decided to ship an OS alongside their app - is one of the top criticisms of the docker way of doing things
If it were 5 years ago I'd have the same reaction, but today it's fairly simple to setup a single node deployment with minikube or k3s, and LLM makes it very easy to maintain deployments.
If only we could somehow share libraries and configuration files across apps rather than duplicating them and having to update them for every app individually.
We could call it a "shared library" system and an "operating" system. Someone should really invent this.
I mean, even docker could maybe use a shared base image or something right? ;-)
Now make it immutable and layered, like Docker images, and you might be onto something... Ah well, sounds too good to be true. We might have to nix the idea.
What kind of psychopath ships 100 distinct container images? I mean, maybe if you’re talking about all of Netflix or something, but… I suspect even they have base images that they use as a starting point.
There’s very little actually running in a docker container. ca-certs may actually be an exceptional case though, since it’s not code that’s running but a kind of data.
It’s not like if you use an Ubuntu image for a node.js app that you get PHP too and have the PHP vulnerability present in your web app.
I think the number one thing that bites a lot of container workflows is when you have a separate "base image" build that depends on external, mutable package sources using tools that don't support locking, such as apt.
This gets worse for each additional such layer, for example if you start from ubuntu:whatever and have a system deps layer, then an application deps layer, then static assets, then your app's code. Unless you think about it upfront when designing the pipeline, it can be challenging to trace all that state backwards and figure out how to safely re-build thing-from-x-weeks ago but with a single unsafe package bumped forward.
Every shop with competent devops people present should be set up for this, but it usually doesn't come for free.
AFAIK a container build just puts files into a base image, this creates a sort of a commit chained to the base image commit. This means to update the base image you only need to rebase that commit on top of the new base image branch automatically.
I haven’t seen tooling for rebasing OCI images yet. Considering you’d still have to do this and roll it out to the server, you can just re-run the CI, which would build the image again, but also test that it works with the new base image.
You actually can sort of do this just inside a modern docker file, with COPY --link
That version of copy overlays the copied content without any knowledge of its underlay, so if the underlay changes, the hash of the layer created by COPY remains identical.
Obviously there are lots of situations this doesn't work for, but say you have a pool of Ubuntu packages (the system layer) and then you separately copy a CMake installspace or built uv project from a build stage, that project layer can be identical in hash if it's copied onto an updated system layer.
In practice, it's hard to get this to work because it's very easy in docker to accidentally trigger a rebuild for some random reason, but all the pieces are there.
Working for a few years at Facebook, and then returning to the normal world, it was like stepping back in time -- I really think that the mainstream git culture (by which I mostly mean "github") achieved a local maxima around 2012, and has been holding the industry back since :(
(Like GH finally has some support for stacks, 15 years late, with an implementation which is somehow more complicated and less powerful than the prior art...)
As someone who came to terms with dying on the mercurial hill, someone who forgot more gitisms than there are to learn in the first place because git cli's inconsistencies and poor taste hurts and neuters my memory, yeah, I relate.
Most people aren't VCS nerds, most are of a generation that only ever knew git. Learning git was a prerequisite they engaged with out of necessity, not by choice, not after exploring the problem space and pondering about different approaches. Learning git was difficult, and the more they learned the more they discovered they had more to learn, including the little things, obscure details and a plethora of paper-cuts. For them (again, I suspect they are a majority), the perspective of learning something else comes with the expectation of a similar daunting effort and steep cognitive reluctance.
That's the paradox of git as I see it: had it been a simple and easy system to pick-up, it would probably have been replaced, and/or the VCS space would be much more competitive.
> Learning git was difficult, and the more they learned the more they discovered they had more to learn, including the little things, obscure details and a plethora of paper-cuts. For them (again, I suspect they are a majority), the perspective of learning something else comes with the expectation of a similar daunting effort and steep cognitive reluctance.
You just blew my mind with this. This is shockingly profound.
(I say this as somebody who deeply loves the concepts in most functional languages, and loves the concepts in nix, but recognises that the developer-experience of both is about as pleasant as reading somebody else's code-golfed perl)
It isn’t a compliment, just a fact. Of course it all depends on what you are familiar with, but that is a fact about you, not Nix.
The concepts in functional languages are not fully realized in any multi-paradigm languages. So you can admire all you want, but don’t knock it until you’ve actually tried it.
Why is it any of your business how I do or don't describe my repos? (Genuine question, it seems like a really weird demand to impose on other people for no particular reason)
(Of my 200+ published repos, I'd say about 175 contain code I wrote purely to scratch my own itches - if other people find it useful, great! If they don't find it useful, that's also fine with me - I'm not sure why I should be obliged to go out of my way to help though?)
TBH learning git in depth was a hindrance for me learning jj - for my first few weeks I kept instinctively looking for complex solutions to simple problems and being confused, when the answer was always "use the tools you already know"
As a concrete example - git has one set of commands for managing commits, a different set of commands for managing the index, a third set of commands for managing stashes, a fourth set of commands for managing the working directory, and a fifth set of commands for managing conflicts -- in jj all of those things are a single concept with a single set of commands, equally (if not more) powerful, but also simpler
The Direct Rendering Manager is useful for any Linux user who wants to display things on a monitor (unless you're happy with like 640x480 VESA, in which case maybe you don't need it)
"sophistication" seems like a strange way to describe GitHub to me - I've found in every individual aspect (code browsing, issue tracking, code review, package management, etc), it's the worst out of all the systems I use regularly... But it's good _enough_ for most people, and it has all those features in one place, which is more convenient than wrangling 10-15 high quality but disconnected systems
reply