Lev Alexandrovich N.

This section needs to be more accurate. Compiled or not compiled has nothing to do with maintainability, but a robust type system does. Dynamic typing introduces additional friction when refactoring aspects of the code base, which is often necessary as the complexity scales. Another aspect not mentioned here is language popularity and how easy it is to hire people who know the language and do not need to learn it on the job. Finally, I would like to suggest Kotlin as a great language since it works on top of Java, and is easy to learn by Java programmers. Additionally, Kotlin has a much cleaner and less verbose syntax, but is still strictly typed.

Scaling software with respect to a number of features and the number of people working on it is an essential aspect of maintainability. As companies and products grow, a single repository may find itself being worked on by multiple teams or even multiple organizations.

One thing to consider here is that a lot of popular language have popular standard libraries full of existing data structures and interfaces for them. If your data structure can fit the "mold" such as List, set, map, iterable, collections, etc. interface, then you should ensure that your implementation implements these interfaces. This will ensure that your data structure can be "dropped" into existing code which takes in interface types of these data structure as arguments. For example, if your data structure is iterable, then you can implement iterator interfaces for this, and any algorithm that just needs to iterate linearly will be able to work with your implementation.

Prevent bugs from shipping to production via testing! Testing should be part of shipping code and deployment process. Code reviews that break existing tests should be prevented from being merged. You can also add code cov requirement for new code added in the change, such that review is not mergable until x% of new code lines are covered by testing. When deploying to production, consider a round of automated pulse tests. Canary deployment can also be useful to minimize impact of potential issues while also testing with production traffic.

Maybe there is something here about the separation of concerns, divide and conquer, black boxes, and links to some books about design patterns.

I would add a caveat about not shipping debug logs to production unless its a highly experimental feature and there is no other good way to get the same information. Another pointer I would add is to configure a chosen logging framework/library to format the log lines in uniform way and to show information which beginners sometimes omit - Time stamp - Level - Logger name. A whole section could be written on how to manage logger names. - Version of code being run, such as git sha. - file name and line number from where the message was emitted.