I consider myself fortunate to have written enough C++ to learn coupling and cohesion. When you screw these up in C++, you pay for it, over and over, through increased compile times and link times.
I think there are other factor at work here:
- The size of the project. I think most code written today is in the context of tiny systems, e.g. a bit of Javascript that goes with a single web page or some trivial backend code within an existing framework.
- The life cycle of the project. Most software projects have a short life time. This is for various reasons, some of them technical, some of them business related.
- You pay for bad design much farther down the road so it's harder for people to see the causation.
- The investment of individual engineers. If you move from one startup to the other every year you may not care that much about principles that will affect maintainability. You should but a lot of people don't. By the time coupling matters you'll already be hacking somewhere else. Being disconnected from the results of your work creates a difficulty in understanding design principles.
- Not Invented Here. People generally aren't open to receiving lessons from other people's experience. Learning often has to happen through individual experience.
I don't think there are many successful, large, long term, software projects where everything is a jumbled mess with no design intent and everything coupled with everything.
Its no wonder people either tend to discard them or to apply them incorrectly.
15 years later I've written enough software to understand the principles but no amount of study got me there, just lots of practice and fixing my own mistakes.
The GoF book does a decent job balancing context with theory, IMO.
I think such information will be received with great interest - it would be like receiving a shot of condensed experience in readable form. Not exactly the same with actual experience of course, but way better than just abstract principles that leave me unconvinced.
Given that data, its easy for a developer to extrapolate (more general) principles that may apply for their own concrete situations and problems, if any.
If you do the extrapolation of the principle yourself but hide the data that caused you to arrive to that principle, nobody will learn anything.
I have no idea why software architects do this. I guess because they're so used to abstracting all the details away in software, they start thinking it also applies to teaching/writing. It does not.
But I can't give that to you in something that you can read in an hour, or even a day. I might be able to give it to you in something you could read in a month (of 8-hour days reading). It's really hard to show in a one-page example.
GoF almost managed to do it, except they removed the real system context. One can almost learn something from that book :)
This is too vague to be a "principle", and only causes confusion. It is about as precise, and as useful, as the "write good code" principle.