Are there principles, such that, if they were followed, they would yield software that is guaranteed to be easy to understand and maintain, at least to some minimal degree or level? What if each module was limited to a small number of inter-related conceptual elements, and written in care carefully English (or whatever human language it uses) in such a way that someone could get to understand and grasp it within a few minutes?

The one I can think of is the "growing a language" tradition of lisp and forth, were you start with a small foundation and build layers of the domain, each layer can only use language in its level or the one inmediately below

Thanks for the video & book references.

by dsl I don't mean actual languages, just sets of types and operations

lppp m

the y combinator is not very easy to understand, even though it is very short, has no dependencies or fancy features, and is not written in an intentionally obfuscated manner

modularity, small pieces with few dependencies does guarantee better results than the tangled mess that is OOP. Compare two large programs, one written in Modula-2 versus Java, and you will see a huge difference. Clarity as to where a computation is being performed, nicely controlled visibility, tons of compile-time and run-time checks that catch stupid errors quickly also add to its advantages. No operator overloading or ambiguity created by too-clever programmers helps. But it is also true that as a system grows its overall complexity to a maintainer also grows.

I really need to understand the y-combinator!

this is a good explanation:

I think the dependency tree is super important, since my last job involved a mesh of several large classes where everything depended on everything else, and it was awful. If A depends on B and B depends on C and C depends on A, the three together can be thought of as a single unit.