3 ms·
I do wonder if some issures (especially about composability) are actually caused a layer deeper, in the programming languages. For example, java has some very
by xg15 10y ago
I do wonder if some issures (especially about composability) are actually caused a layer deeper, in the programming languages.
For example, java has some very peculiar ideas about typing and metaprogramming that encourage a "plugin" approach an tie your codeto 3rd party libs stronger than would be necessary.
Some examples:
- Classes that implement an interface now have it as a dependency: If the interface class is not present, your class won't compile. This even though the interface class usually doesn't contain any additional information (exception being "extends" clauses)
- the same is even true for annotations - even if those annotations don't even end up in the compiled class at all.
- the language itself offers an extensive range of tools to package your code into discrete units with well-defined inputs and outputs. It offers significantly less tools to wire those units together and actually make then into a complete piece of software. In the end, if you roll your own solution, you often get to choose between "bowl of spaghetty" or "needlessly complicated". Frameworks stepped in to solve that problem (or at least make it look as if all the complexity were justified).
- the reflection API encourages adding your own semantics to java language constructs and in a way extending the language - except there is no way to coordinate reflection usage by different frameworks.