Composability: A tremendous amount of time engineers spend on gluing things together. Once you can consider all controlflow patterns as natural transformations designing and refactoring programs become straightforward.
Openness: In contrast of encapsulation, Я encourages you to use open interfaces. In my opinion one of the main source of complexity is actually the habit to hide things from users. Instead we shoud see how objects are related to each other in order to come with an idea redefining things in a more suitable way.
Compactness: Complexity exists in every system, you can either distribute it by smaller chunks or concentrate at one place. Я would prefer the latter.
It’s all sounds cool, but it’s sometimes better to state not what we do but rather what we don’t:
No explicit recursion! We have all tools to stop writing code that requires running interpreter in our head manually, especially on jumping between goto operators. All recursive behaviour is wired in within individual natural transformation so you may forget about it.
No type declarations! It’s okay to use it during development just to align your reasoning with type system, but most of the time it’s either obvious or takes too much attention. You can give hints both to compiler and your potential code reader using visible type applications.
No custom datatypes! In order to provide extreme composability we should abandon a habit to create new datatypes (with data keyword) in our programs. Use core primitives instead.