the more time I spend in this industry, the more I come to realize that it's a very blurry line between PROGRAMMING and CONFIGURING.

How much programming do you do these days, really? Isn't it just configuring your frameworks and libraries and engines to do what they do in the way you want?

Does it still make you programmers...?

And then what are these .conf files for your application? A declarative configuration for your... imperative configuration...?

Aren't you a sysadmin?

For those keen to argue, here's a question: is build.gradle a configuration or a program source file?

@neriald A sysadmin, a devops, a developer, a secops, a DBA, and a few more hats I'm forgetting.

Why?

@netikras I dunno what is gradle. Never used it.

@netikras because sysadmins do configuring. I still code. Not many .conf files in my life

my experience is the opposite: too many things that could and should be declarative are imperative, thanks to libraries like React but also Webpack etc. their supposed "configuration" turns out as a mixture of declarative and imperative with obscure domain specific syntax for each one of them

Knowing HOW to configure everything up and changing it according to what management says, is what makes you a programmer.

@netikras neither, build.gradle is an abomination

That might be true if you are "developing" some generic website using a CMS.

Definitely not true for all devs.

@Lensflare well.. I'm not sure about that.

I'm configuring a spring-web framework to accept requests on my preferred URLs and map body&params to my variables, which then I use to configure the JPA framework pregenerated "configuration/code" units to engage the DB and retrieve a response, which I then use to configure the spring-web framework again to return a particular response. Everything in between is just data transformations and validations to translate data from one lib/framework into a valid configuration for another lib/framework...

@netikras yeah, I agree that this kind of work is mostly configuration and not actual programming. I did that too in the past. But not all of us do that all the time.

@netikras

As @devrancid so eloquently said, Gradle is an abomination, but besides that, it's a DSL for a build system, meaning, yes, it's mostly configuration, but you have the expressive power of a real language to be able to do control flow, dynamic configuration, etc.

GitHub actions, CMake and others are similar (even if their languages are more limited than groovy), as is, say, the whole trend of infrastructure as code.

I avoid things that need configuration

and I rewrite stupid libraries that do nothing, break all the time, the maintainers are some corpos who don't care, or they're integrated in a bunch of legacy corpos stacks so they don't care about you and your needs so I make my own shit with blackjack and hookers

configuring is annoying because it isn't about what you want the computer to do but to conform to some random person's and the 100 people after that's opinions which results in mishmashed schizophrenic opinion about how things should be done and now you have to know all their subpar garbage. often, the configuration "code" ends up longer than you just writing the thing out yourself

configuration is a poor substitute for programming

It's all programming IMO. Gradle? programming. Cronjobs? programming. Plugging wires in a telephone routing board to connect totally isolated 1-1 channels that don't interact with each other? programming.

Configuration is a perspective on programming where you consider the system that does the work and the instructions given to that system. When you're writing a highly optimized stream processor in Assembly, you're configuring the CPU.

I unironically think that recording user macros in MS Word is programming.

In classic English, they mean the same thing basically. Just now that we have computers, programming has taken on a different and more romantic meaning. It’s all just writing instructions.

I'm a Drag-n-Drop engineer. Bullshit low-code and constant configuration is my job.

software was itself invented as "configuration" for machines. That is what "program" means in latin: "laid out in a table" (like in a schedule)
TBH, we are all just making sequences of assembly instructions, anyway. Just like writing is just configuring chosen words in an arbitrary sequence.

The line between them is how many « if statements » u write.
How many classes you write.

Kotlin Gradle isn't an abomination, for ex.:
```
plugins {
kotlin("jvm") version "1.9.22"
application
}

repositories {
mavenCentral()
}

application {
mainClass = "MainKt"
}
```
but at least for me: android Gradle plugin is pain to configure