News for hackers. Stuff that matters.
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.