Reddit mentions of Domain-Specific Languages (Addison-Wesley Signature Series (Fowler))

I cannot think of any examples of books which approach design in this manner. Aside from end examples of such programs like Vim and its related reimplementations, Sam/Wiley/Acme, the Acid debugger and a lot of Plan9/Inferno, I think practicing implementing parsers, lexers, and other programming language tools will provide how to achieve this concept. The closest literature which presents these ideas abstractly are those targeting DSLs; some example texts which are high quality are: Domain-Specific Languages, DSLs in Action, Language IMplementation Pattern, and DSL Engineering. Although they obviously cannot ensure that the resulting pattern enables thinking in terms of the relevant semantic level easier.

The primary advantage to designing programs in this manner is that it enables the interfaces to result in a composability that is consistent in its means of interaction; from an implementation and maintainability perspective it is beneficial as well due to the components being decoupled from one another more easily and also how to make use of it in other contexts as well being more obvious.

An example of this being the case is comparing evil-mode to other implementations of the same features within emacs, there is a lot of reduplication of effort to implement features that are instead only requiring adding a new text object or motion in evil-mode which is very nice; relatedly we can compare the same implementation in Vim's code base which is implemented in C which has poor to none metaprogramming tools available and implementing the same idea in emacs which has excellent metaprogramming faculties and thus can trivially be extended to new language contexts soundly. The end result is the implementations being much more trivial to accomplish and reasoning about them being much easier. Discretely the magnitude of source code required is much smaller also.

It also reduces the necessary grey matter to understand the application as well which is the most advantageous part of these designs, instead of rote memorization being required, the person simply has to understand its grammar. Ideally this grammar is shared by other programs so that the effort is less duplicated, but even if it is just that individual program it is worthwhile.

Language Implementation Patterns is a good read, written by the author of ANTLR and StringTemplate. Also Martin Fowler's Domain Specific Languages book.