Reddit mentions of Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers)

I have been doing a lot of self study in compilers and interpreters recently so please take my advice with that in mind, I can't say about modern but I personally found compiler construction by Kenneth C Louden to be an excellent book, I am going through the book as part of self study. It builds a compiler for a subset of C (in the C language) and from the several books I have on the subject, this is the one which walks the line between theory and code best.

I do have the feeling this one is more of an introduction though and once I am done with it I will need to go over to a more advanced book (dragon book perhaps or Muchnik?). It is very expensive though, I was lucky to get a second hand copy.

Also another interesting book though maybe not as useful directly is language implementation patterns which goes over the topics of DSLs etc. using Java.

This book is also available at pragprog.com without the DRM.

Reminds me of reading Language Implementation Patterns, although that's geared more towards LL.

It's by the same guy behind the ANTLR parser-generator, and basically explains why certain grammar constructs lead to certain arrangements of parser-code.

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.

And it's massive enough to crack your skull in if it falls on you ;)

The dragon book has always been a bit too heavy for me. If anyone else feels that way, I encourage you to try Language Impl. Patterns. It's shorter and less comprehensive than the dragon book, but it's got everything you need to build a good compiler.

Just noticed that my 4 main languages - Python/Java/C#/C++ - are the same as yours! In answer to:

>Does there even exist an application domain where (e.g.) Haskell or Clojure are obviously the best choice?

Parsec (Haskell) is a very nice tool. I believe there are versions of it for various other languages too, however I've never used them, so can't comment and anyway I think Haskell is a natural choice for it. As for what it does, its wiki page says:

>Parsec is an industrial strength, monadic parser combinator library for Haskell. It can parse context-sensitive, infinite look-ahead grammars but it performs best on predictive (LL[1]) grammars.

Which in English means it's a tool for creating parsers. If you haven't had too much experience with parsing, I'd recommend this book, which uses Java for its code samples.

• Domain Specific Languages by Martin Fowler is a great read, focused mainly on DSLs, but it does cover Parsers and Lexers.
  
• Language Implementation Patterns is good too.

> It’s hard to consolidate databases theory without writing a good amount of code. CS 186 students add features to Spark, which is a reasonable project, but we suggest just writing a simple relational database management system from scratch. It will not be feature rich, of course, but even writing the most rudimentary version of every aspect of a typical RDBMS will be illuminating.
>
> Finally, data modeling is a neglected and poorly taught aspect of working with databases. Our suggested book on the topic is Data and Reality: A Timeless Perspective on Perceiving and Managing Information in Our Imprecise World.
>
>
>
>
>
> ### Languages and Compilers
>
> Most programmers learn languages, whereas most computer scientists learn about languages. This gives the computer scientist a distinct advantage over the programmer, even in the domain of programming! Their knowledge generalizes; they are able to understand the operation of a new language more deeply and quickly than those who have merely learnt specific languages.
>
> The canonical introductory text is Compilers: Principles, Techniques & Tools, commonly called “the Dragon Book”. Unfortunately, it’s not designed for self-study, but rather for instructors to pick out 1-2 semesters worth of topics for their courses. It’s almost essential then, that you cherrypick the topics, ideally with the help of a mentor.
>
> If you choose to use the Dragon Book for self-study, we recommend following a video lecture series for structure, then dipping into the Dragon Book as needed for more depth. Our recommended online course is Alex Aiken’s, available from Stanford’s MOOC platform Lagunita.
>
> As a potential alternative to the Dragon Book we suggest Language Implementation Patterns by Terence Parr. It is written more directly for the practicing software engineer who intends to work on small language projects like DSLs, which may make it more practical for your purposes. Of course, it sacrifices some valuable theory to do so.
>
> For project work, we suggest writing a compiler either for a simple teaching language like COOL, or for a subset of a language that interests you. Those who find such a project daunting could start with Make a Lisp, which steps you through the project.
>
>
>
> [Compilers: Principles, Techniques & Tools](https://teachyourselfcs.com//dragon.jpg) [Language Implementation Patterns](https://teachyourselfcs.com//parr.jpg)> Don’t be a boilerplate programmer. Instead, build tools for users and other programmers. Take historical note of textile and steel industries: do you want to build machines and tools, or do you want to operate those machines?
>
> — Ras Bodik at the start of his compilers course
>
>
>
>
>
> ### Distributed Systems
>
> As computers have increased in number, they have also spread. Whereas businesses would previously purchase larger and larger mainframes, it’s typical now for even very small applications to run across multiple machines. Distributed systems is the study of how to reason about the tradeoffs involved in doing so, an increasingly important skill.
>
> Our suggested textbook for self-study is Maarten van Steen and Andrew Tanenbaum’s Distributed Systems, 3rd Edition. It’s a great improvement over the previous edition, and is available for free online thanks to the generosity of its authors. Given that the distributed systems is a rapidly changing field, no textbook will serve as a trail guide, but Maarten van Steen’s is the best overview we’ve seen of well-established foundations.
>
> A good course for which some videos are online is MIT’s 6.824 (a graduate course), but unfortunately the audio quality in the recordings is poor, and it’s not clear if the recordings were authorized.
>
> No matter the choice of textbook or other secondary resources, study of distributed systems absolutely mandates reading papers. A good list is here, and we would highly encourage attending your local Papers We Love chapter.
>
>
>
> [Distributed Systems 3rd edition](https://teachyourselfcs.com//distsys.png)
>
>
>
> ## Frequently asked questions
>
> #### What about AI/graphics/pet-topic-X?
>
> We’ve tried to limit our list to computer science topics that we feel every practicing software engineer should know, irrespective of specialty or industry. With this foundation, you’ll be in a much better position to pick up textbooks or papers and learn the core concepts without much guidance. Here are our suggested starting points for a couple of common “electives”:
>
> - For artificial intelligence: do Berkeley’s intro to AI course by watching the videos and completing the excellent Pacman projects. As a textbook, use Russell and Norvig’s Artificial Intelligence: A Modern Approach.
> - For machine learning: do Andrew Ng’s Coursera course. Be patient, and make sure you understand the fundamentals before racing off to shiny new topics like deep learning.
> - For computer graphics: work through Berkeley’s CS 184 material, and use Computer Graphics: Principles and Practice as a textbook.
>
> #### How strict is the suggested sequencing?
>
> Realistically, all of these subjects have a significant amount of overlap, and refer to one another cyclically. Take for instance the relationship between discrete math and algorithms: learning math first would help you analyze and understand your algorithms in greater depth, but learning algorithms first would provide greater motivation and context for discrete math. Ideally, you’d revisit both of these topics many times throughout your career.
>
> As such, our suggested sequencing is mostly there to help you just get started… if you have a compelling reason to prefer a different sequence, then go for it. The most significant “pre-requisites” in our opinion are: computer architecture before operating systems or databases, and networking and operating systems before distributed systems.
>
> #### Who is the target audience for this guide?
>
> We have in mind that you are a self-taught software engineer, bootcamp grad or precocious high school student, or a college student looking to supplement your formal education with some self-study. The question of when to embark upon this journey is an entirely personal one, but most people tend to benefit from having some professional experience before diving too deep into CS theory. For instance, we notice that students love learning about database systems if they have already worked with databases professionally, or about computer networking if they’ve worked on a web project or two.
>
> #### How does this compare to Open Source Society or freeCodeCamp curricula?
>
> The OSS guide has too many subjects, suggests inferior resources for many of them, and provides no rationale or guidance around why or what aspects of particular courses are valuable. We strove to limit our list of courses to those which you really should know as a software engineer, irrespective of your specialty, and to help you understand why each course is included.
>
> freeCodeCamp is focused mostly on programming, not computer science. For why you might want to learn computer science, see above.
>
> #### What about language X?
>
> Learning a particular programming language is on a totally different plane to learning about an area of computer science — learning a language is much easier and much less valuable. If you already know a couple of languages, we strongly suggest simply following our guide and fitting language acquisition in the gaps, or leaving it for afterwards. If you’ve learned programming well (such as through Structure and Interpretation of Computer Programs), and especially if you have learned compilers, it should take you little more than a weekend to learn the essentials of a new language.
>
> #### What about trendy technology X?
>

> (continues in next comment)

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