[papaf]

How do we allow our culture to be so lazy that people resist using one of the basic tools because "oh its hard I gotta remember 5 commands" and we find it OK? No wonder the plane is burning.

Its probably a rhetorical question but I think its worth answering anyway.

Experienced developers had the luxury of learning git, say, over a 10 year period. I certainly know a lot more git than 10 years ago.

If you are a new developer thrown into your first real project and Intellij handles git for you so that you can concentrate on being productive then learning command line git takes a back seat.

I see this in many aspects of programming. One thing I am struggling with currently, is that JHipster generates applications in a user friendly way. JHipster is highly productive and seems like the future of programming BUT it means that there will be a generation of programmers that do not understand the MB of Spring Java code that is casually puked out by the code generator.

Its depressing to say it, but I think not understanding the tools is only natural and is probably the new normal in this age of complexity.

[thecupisblue]

>Experienced developers had the luxury of learning git, say, over a 10 year period. I certainly know a lot more git than 10 years ago.

The depressing thing is I'm not talking just about off-the-shelf newbies, I'm also talking about experienced devs.

>Its depressing to say it, but I think not understanding the tools is only natural and is probably the new normal in this age of complexity.

Yes, unfortunately, this is becoming the new normal. But what is the next "new normal" after this? More complexity and obscurity? How long can we keep building that house of cards before it collapses upon us?

[quickthrower2]

I don’t know about most people but i have to relearn stuff if I don’t use it.

I use the basic git commands a lot but the wider set not very often.

So maybe I should learn Git from first principles every year? Like a cop would practice at the firing range?

But I’m doing that on my own time. But then what about the 1000 other things from Dockerfiles, to Relational database query plan optimisation, to the latest azure cloud offerings, to the newest React library for managing state, etc. etc.

[joseluis]

the solution I believe would be to focus on creating simpler tools, and by that I mean tools with at least the same usefulness/as powerful as the ones we have now, but with much less cognitive burden, with better interoperability and composability by using simple standard data interchange formats.

[PaulDavisThe1st]

If you really believe this, then I don't believe that you understand what the job of a powerful revision control system is.

The "cognitive burden" of git comes as much from the tasks that it is occasionally required to make possible than anything else.

If the only git commands you ever use are push, pull, commit and checkout then its a very simple system with very little cognitive burden. But one day, you may need to perform a truly complex task with git that a simpler system with much less cognitive burden would just not allow.

I do not understand how "data interchange formats" are an issue here. What do you want to inter-operate with?

[wutbrodo]

I generally agree with you that much of git's conceptual complexity is irreducible if you want to retain git's power. But there's plenty of examples of poor-quality and inconsistent porcelain that provide no extra power. Indeed, these "UI smells" mostly offer no benefit at all.

Note that we're specifically discussing the theoretical reason for git's usability woes. The costs of actually fixing them in git aren't trivial, of course.

[Lutger]

Most of the experienced developers you mention probably also don't know really know assembly - unless they are specialists, something which the generation before them think shows their lack of understanding. Assembly used to be canon, now it's a speciality. I don't know a single developer in my company who is able to write it.

We'll see if JHipster and their ilk are really the new building blocks. A lot of the older RAD development tools have also gone the way of the dinosaur. For sure the new primitives will be higher level and allow us to build more complex applications, it's just a matter of time before we'll find our which ones have to most expressive power and ergonomics, and which turn out to be giant hairballs.