I don't have experience with using Julia in really large code bases but my intuition has always been that the combination of these design characteristics in one language:
- easy unrestricted composability
- lack of well-defined interfaces
- lack of an effective way to use the strong typing system to validate correctness
I think Julia (mostly meaning pervasive multiple dispatch, which is unprecedented at that scale Julia has it) unlocks a new way to organize programs.
Some formalized notion of "interface" is certainly important, but it seems no clear formulation has emerged.
I think it's fairly consistent with the dynamic nature of Julia and fairly inconsistent with the static nature of Julia. I don't know what a good solution to the interface problem is.
I think one can get pretty far with writing tests to check interfaces. If you are a library that expects user-defined types, you can expose an interface to these tests so that a user can check if they've implemented everything.
This is a very generic approach, and aside from the key limitation of only giving results at runtime, is much more powerful.
Testing is certainly general but it's high-effort and it's easy to miss corner cases. I think type checking + some testing is going to beat testing alone in most scenarios.
- easy unrestricted composability
- lack of well-defined interfaces
- lack of an effective way to use the strong typing system to validate correctness
is not a very good idea.