What is the reasoning behind making Mathematica and the Wolfram Language purposefully non-modular?
Currently, every new function goes into the same context, System`, and every function appears loaded at all times. It seems to be done this way on purpose. There is also no clear dependency structure between the components of the system.
I was wondering what advantages WRI sees in this. Modularity, and building larger systems from smaller components, is one of the key principles of engineering that allows us to build complex systems and machines that we can still maintain, understand, and keep extending in the long term. All other programming languages embrace modularity. Mathematica seems to be the only one going straight against it.
Consider, for example, the design of Graph. It just doesn't play well with edge attributes.. If the system were modular, the whole framework could be switched out to a better-designed one in the future, the same way as Combinatorica (a separate module!) was replaced with the built-in Graph (abandoning modularity). The old and the new frameworks could be used concurrently for a while, then the old one could be phased out. If other parts of Mathematica depend on the old Graph, they could be gradually updated to use the new framework, until finally all dependencies on the old one are removed.
With the current design of WL, there can never be another System`Graph. Once a new name is added, it can never be replaced or changed without breaking existing code. The lack of modularity implies the lack of flexibility, maintainability, and extensibility.
I admit that I am not a programmer. I did not formally study the subject and I do not have professional experience with it (other than personal projects). Perhaps someone more knowledgeable can explain how the current direction can benefit Mathematica and its users in the long term, and why the several advantages of modularity (and disadvantages of the lack of modularity) that I mentioned above do not apply.
From my point of view, it would seem that Wolfram is slowly backing themselves into a corner of broken design until it will be too late and they won't be able to get out anymore.
Note: Graph was used only as an example, but the argument applies to any other part of Mathematica. I am wondering why a modular design is being purposefully avoided, and worrying that this may prove very problematic in the long run, especially with the current rate of adding new functionality. I believe others have brought up the same question, but I can't find if/where it was answered.