The tradeoff is, historically, that you're going to have to hire a team of seven developers, three business analysts, and a project manager to do what is, honestly speaking, two decent engineers worth of work if they were working in e.g. Rails. This is a worthwhile tradeoff for many enterprises, as they care about risk much, much, much more than the salary bill.
(I spent several years in the Big Freaking Enterprise Java Web Applications salt mines. These days I generally work in Rails, and vastly prefer it for aesthetic and productivity reasons, but I'm at least intellectually capable of appreciating the advantages that the Java stack is sold as bringing to users. You can certainly ship enterprise apps in Rails, too, but "the enterprise" has a process which works for shipping Java apps and applying the same development methodology to e.g. a Rails app would result in a highly effective gatling gun for shooting oneself in the foot.)
Also, ADA is _a bit_ popular, but not too much. Most of the code is still done in C because of the conformism. Object oriented programming is still considered like a dangerously modern move. The rules here are pretty hard and it's easier to fuck up the regulation than the code... (cough A330 Neo cough)
organizations which design systems ... are constrained to produce designs which are copies of the communication structures of these organizations
I had to re-read your comment twice as I thought that there exists an OTS ERP for salt production.
PS. The company I work for actually grows salt.
I remember (vaguely) the beginnings of Java, but not how it did end up in Enterprise and why it was loved so much there.
Then, when the web exploded, people found out that developing against a virtual machine could be safer and more predictable than developing against the operating system, so web-app servers were born. J2EE provided a certain degree of consistency, which other platforms did not have.
As platforms evolved, they tried to generalise their use-cases, which introduced a number of abstractions and forced decoupling; and because Java2 lacked support for a lot of introspection/metaprogramming features, you had to explicitly cover a lot of cases, leading to interfaces multiplying.
It didn't help that at the time, the "Pattern" movement was popularised and their tools (which are all about decoupling and introducing further levels of abstractions) became overused.