Orthogonality now!
At some point in the history of software development, we decided that spaghetti
code after all wasn't a good thing. We have since then learned to write code
that doesn't look like a fur ball when its control flow is represented
graphically
Despite this knowledge, the Italian cuisine influence is present in surprisingly many software projects of the third millennium, although in a slightly different way. We seem to have moved the pasta from the code to the design.
When I look at the design of systems I come across, more often than not I find software module dependencies that don't make sense. Whatever small part of the system you try to use will require you to include just about every other module, no matter how unrelated it may be. It's like the idea of designing modules to be as orthogonal as possible either didn't occur to the designers in the first place, or was lost in some iteration.
The most probable reason for this is a long overdue need for refactoring. Your system evolves, but every time you need a hitherto unforeseen reference in one module, you create a dependency that solves your specific problem instead of refactoring the design to reflect the new whole picture. Refactoring can restore orthogonality, but most developers lack the courage (or worse, the ambition) to refactor code.
The greatest promise of aspect-oriented programming is perhaps that it may impose orthogonality as a natural habit in future generations of developers.