> But again we are facing this dilemma when there are literally thousands of different tools and ecosystems and you just simply cannot be an EXPERT or even ADVANCED in most of them.
Though there are only a handful of ideas and principles, and all of these
thousands of different tools are just reimplementations of some of them, and
usually not too fancy at that.
Of course you don't, but those nuances and specifics are usually superficial
and don't change how you approach your environment. You think there is that
much of a difference between running Puppet, CFEngine, or Chef?
They are not superficial and they definitely change how you approach your environment.
I have worked extensively with both CFEngine and Puppet and I can assure you that they have enough differences especially when you consider large heterogenous environments that in no way you can consider using one as a substitute for the other.
Yes, but this also doesn't mean that one person trained in one tool can't learn the other in fairly short order, provided they understand the core principles behind it and haven't been 'brainwashed' into thinking 'this is how things work'
And how these affect operator's workflow? That is, the ways an operator
interacts with the tools?
The facts that Java is garbage collected or that it runs on virtual machine
don't fundamentally change how programmers write code in it compared to e.g.
C++. It's the same type of tool ("paradigm"). Erlang, however, is
substantially different.
You are comparing apples to oranges (in my opinion of course).
I would say it's often hardly about just "operating" the machine. You need to know how the machine works how it can affect other machines and what can you do if parts of the machine break.
Not only that but also how many operators you can find, how many additional modules (libs) are there and how often you need to oil the wheels.
Sure the implementation of the known algorithms will be similar in Java and C++ but the overall usage and how it connects with everything (aka the workflow) will be very different.
> I would say it's often hardly about just "operating" the machine. You need to know how the machine works how it can affect other machines and what can you do if parts of the machine break.
So, in terms from programming analogy, you need how your runtime operates, how
it can affect neighbour processes/services, and what can you do when the
runtime breaks down. This still does not affect how you structure your code
(at least usually, when you don't work closely with the OS, which I bet is
majority of code in the wild).
> Not only that but also how many operators you can find, how many additional modules (libs) are there and how often you need to oil the wheels.
How does workforce availability affect the way you work with your system?
How does availability of libraries affect the way you work with your system,
apart from amount of code for you to write (libraries have to come from
somewhere)?
The architecture and strategies stay exactly the same. With this regard,
there's very little difference between CFEngine, Puppet, and Chef.
> Sure the implementation of the known algorithms will be similar in Java and C++ but the overall usage and how it connects with everything (aka the workflow) will be very different.
It will hardly affect how you think about the system and how you approach it.
It will only affect where you get your code from. Unless you think about
yourself as a guy who only puts together different libraries/modules and never
ever writes own code, then of course it's a new paradigm, but I don't think
you had this scenario in mind.
> So, in terms from programming analogy, you need how your runtime operates, how it can affect neighbour processes/services, and what can you do when the runtime breaks down. This still does not affect how you structure your code (at least usually, when you don't work closely with the OS, which I bet is majority of code in the wild).
Working with CFEngine's "DSL" v2 was very different from using Puppet mainly due to its limitations and lack of features. This really affects the way you structure your code.
There were / are many nuances in CFEngine that make it different from puppet. And this is also about availability and complexity that is what I meant.
> Working with CFEngine's "DSL" v2 was very different from using Puppet mainly due to its limitations and lack of features. This really affects the way you structure your code.
In this case it only affected where you put which part of the code, not how
you managed your servers with the tool.
Note that the analogy with programming languages is <how you manage servers>
=~ <how you structure code>, not <how you structure code> =~ <how you
structure code>, what you're trying to put into use here. For judging the
approach, it's irrelevant whether you write a shell script or use somebody's
Ruby plugin to detect mounted filesystems or something like that. It doesn't
change fundamentally how you structure maintenance of your environment.
> There were / are many nuances in CFEngine that make it different from puppet.
Of course, starting with their languages' syntax. Though both use the same
underlying ideas, even if they call them differently, and both operate in
similar way. If you know how one works, it's a knowledge that's easy to
transfer to the other.
Though there are only a handful of ideas and principles, and all of these thousands of different tools are just reimplementations of some of them, and usually not too fancy at that.