News for hackers. Stuff that matters.
Re:Docker Is Four Things by strogonoff on Thursday August 31, 2023 @09:40AM (#37336996)
Like with functional programming, which at extremes is only declarative, there is a tendency to call “declarative” only those approaches that are perfectly declarative and incapable of imperativeness. However, not unlike purely functional programming, complete declarativeness is largely useless.

If you pretend that COPY means with these files like those files on host machine as of execution time, RUN means with this command executed at build time, etc., then even Dockerfile becomes fairly declarative. Every declaration defines a new immutable layer with its own unique hash, it’s just that some declarations can be used in ways that make the outcome vary based on the state of the entire world as of build time.

Re:Docker Is Four Things by tyingq on Thursday August 31, 2023 @10:03AM (#37337298)
I feel like "not declarative" is fair enough if you look at how the important bits work in a Dockerfile. Like what software is installed, that's not usually some structured thing...but typically shell commands out to apk or apt-get.

I get why it is the way it is, but if it were more declarative, it would be easier to manage Dockerfiles through changes, security updates, etc.

Re:Docker Is Four Things by strogonoff on Thursday August 31, 2023 @10:32AM (#37337732)
You can shell out in Nix and Haskell. If they are not “declarative” then what is [both declarative and useful, a.k.a. capable of interfacing with outside world]?

Dockerfile is intentionally bare-bones. It just gives you RUN straight up, no scary hidden option, but it’s up to you how to use it. If you want to write imperative, you can. If you don’t write imperative, pin everything to a hash, shell out only to Dhall and Prolog, it can get very declarative…

…at a cost. The fact that people do not tend to go this route means equally that 1) they are lazy, and 2) using RUN this way is pragmatic.

Re:Docker Is Four Things by tyingq on Thursday August 31, 2023 @10:42AM (#37337905)
That's what I meant by "I get why it is the way it is".

I'm not suggesting it change. I'm saying that calling it "not declarative" seems fair, based on the way that most people actually use it.

Re:Docker Is Four Things by strogonoff on Thursday August 31, 2023 @10:47AM (#37338009)
And I’m saying that it is not fair, for the same reason (as well as for another reason, which in short is “nothing can be both declarative and useful by that logic”).
Re:Docker Is Four Things by globular-toast on Thursday August 31, 2023 @10:06AM (#37337345)
Yeah, that's why I would consider a Makefile declarative even though it can contain bits saying how to do something. I can't consider a Dockerfile declarative simply because it is necessarily executed top to bottom.
Re:Docker Is Four Things by strogonoff on Thursday August 31, 2023 @10:13AM (#37337445)
An array can be declarative even if it has order. Think of the ordered list of statements in a Dockerfile as syntax sugar for a linked list of (declaration, nextDeclarationPointer) tuples.
Re:Docker Is Four Things by shawabawa3 on Thursday August 31, 2023 @10:15AM (#37337483)
Fair enough that everything is a scale, and you _can_ write dockerfiles in a more or less declarative way

But the syntax itself is conducive to imperative image definitions, and they are by far the most common

Re:Docker Is Four Things by rgoulter on Thursday August 31, 2023 @10:21AM (#37337577)
> Every declaration defines a new immutable layer with its own unique hash...

This blurs the meaning of "declarative" to the point of meaningless.

Consider the following pseudocode:

  x = 5
  print x
  x = 10
  print x
This is clearly 'imperative'.

But from the perspective of 'each line of code declares a new program', then we consider the code snippet a declaration of a program.

> Just as in Ansible you can use “declarative” YAML in a very imperative lasagna of a setup

One of the things which makes Dockerfiles imperative is the sequence of Dockerfile commands is significant; if you swap the order of a COPY, RUN to a RUN, COPY, the result changes significantly.

Re:Docker Is Four Things by strogonoff on Thursday August 31, 2023 @10:44AM (#37337953)
> This blurs the meaning of "declarative" to the point of meaningless

The alternative is to draw a clear line where there is none.

> One of the things which makes Dockerfiles imperative is the sequence of Dockerfile commands is significant; if you swap the order of a COPY, RUN to a RUN, COPY, the result changes significantly.

By that logic you can call every Nix program “imperative”. They are sequences of strings, the order of which matters. The horror!

A Docker image is a stack of layers. Every layer points to a preceding layer. It’s not a huge leap from that structure to a fairly elegant sugar of a string array, where each string is a declaration that applies to preceding layer thus describing the next one. I don’t see anything fundamentally imperative about it; it can be used in imperative ways, but anything can.

Re:Docker Is Four Things by rgoulter on Thursday August 31, 2023 @11:51AM (#37339146)
> The alternative is to draw a clear line where there is none.

I'd say that more/less "imperative" refers to describing sequences of actions that take place (especially those which might modify some state), whereas "declarative" is more about a structure of what the result should be.

I can agree that a Docker image can be considered as a structure, and that it's possible to construct one declaratively. Whereas I'd say a Dockerfile is an imperative construction of that.

Re:Docker Is Four Things by strogonoff on Saturday September 02, 2023 @05:02AM (#37359720)
Dockerfile describes a set of immutable layers. Whether you model it in your head as a sequence of commands or as a description of a set of immutable layers, is up to you.
Re:Docker Is Four Things by kdmccormick on Thursday August 31, 2023 @10:45AM (#37337976)
I also would to call Dockerfiles imperative on syntactic grounds alone, but I feel they have decalartive semantics in a way that's noteworthy.

> But from the perspective of 'each line of code declares a new program', then we consider the code snippet a declaration of a program.

The critical difference is that each line in a Dockerfile yields (declares) a filesystem state which can be referenced and recreated. In contrast, in your example, I have no way to say "give me a snapshot of the system between the third and fourth instructions".

Dockerfiles have all sorts of rules and restrictions that make these semantics possible. You cannot create loops; there is nothing like a "function", at least within the context of one Dockerfile.

> One of the things which makes Dockerfiles imperative is the sequence of Dockerfile commands is significant; if you swap the order of a COPY, RUN to a RUN, COPY, the result changes significantly.

I reject this line of reasoning, simply because decalative languages are indeed order-dependent:

    let y = f(g(x))
is different than:

    let x = g(f(x))
Much in the same way that these are different:

    FROM x AS y
    RUN g
    RUN f
   
vs

    FROM x AS y
    RUN f
    RUN g
Re:Docker Is Four Things by rgoulter on Thursday August 31, 2023 @11:57AM (#37339248)
> I reject this line of reasoning, simply because decalative languages are indeed order-dependent

Eh, I can kinda see that. -- It's possible to imagine a declaration where the order of items in a list has consequence.

Still, I'd Dockerfiles as a sequence of statements more akin to a bash script than to an SQL expression.

Re:Docker Is Four Things by strogonoff on Saturday September 02, 2023 @04:59AM (#37359698)
This is a deeply mistaken view informed by the cargo-culting devops traditions of yore. A Dockerfile is a declaration of layers that does not resist being used in imperative way, in which sense it’s no different from YAML or any functional language you can think of.
Re:Docker Is Four Things by kdmccormick on Saturday September 02, 2023 @08:55AM (#37361097)
Yeah, to pile on, I often see this line of thinking:

> Still, I'd Dockerfiles as a sequence of statements more akin to a bash script than to an SQL expression.

lead to some quite inefficient and poorly-factored Dockerfiles.

Re:Docker Is Four Things by strogonoff on Saturday September 02, 2023 @08:44AM (#37361011)
If you call things “declarative” or “imperative” on syntactic grounds, which would you call Ansible (like Docker, a devops tool, famously using pure YAML but in many cases for basically running a bunch of scripts)?

It’s just not a reasonable way of making the distinction; claiming X is “imperative” because you are using it in imperative ways is logically flawed, it is not a statement of truth about X.

Dockerfile is fundamentally declarative, as you note (that’s just how Docker works: every line describes a layer), and it has not even enough features to make it imperative (control flow? goto?).

Re:Docker Is Four Things by kdmccormick on Saturday September 02, 2023 @08:53AM (#37361079)
I think it is fair to distinguish between syntax and semantics here.

Haskell's "do" notation is frequently described as an imperative syntax for functional/declarative transformations. I would put Dockerfiles in the same boat. They behave declaratively, but users can think imperatively when they write them (to a certain extent) and this is part of what makes them more accessible to newcomers.

Ansible is a great example of the opposite. It looks declarative but, like you said, basically runs a bunch of scripts one after another on a system, with state and all.

Re:Docker Is Four Things by lolinder on Thursday August 31, 2023 @10:28AM (#37337683)
The thing is, some of the first advice you'll get about Docker is that the order matters a ton. These two Dockerfiles technically create the same result, but the difference between the two is very important:

    COPY . .
    RUN npm install
And:

    COPY package.* .
    RUN npm install
    COPY . .
The first file reruns npm install every single time any file changes in the code. The second only reruns npm install if the packages change. That can make the difference between a 5-minute build and a 5-second build, so it's not a small optimization.

Given how important the order of instructions is, it's hard for me to think of it as declarative. It fits better in my mind as a sequence of instructions, which is the very definition of imperative.

Re:Docker Is Four Things by strogonoff on Thursday August 31, 2023 @10:58AM (#37338191)
Correct.

I find Docker an interesting example of a fundamentally elegant approach that, possibly to facilitate commercialisation, was documented in a way that, instead of imposing any particular culture (such as, say, Nix or Haskell), strongly aligned with the preexisting culture of operations and system administration—the resulting ease of adoption and popularity (and, I assume, broadly deserved financial well-being of the original creators), however, could not come without a variety footguns along the lines of which you have described.