[0]: https://www.amazon.com/Language-Implementation-Patterns-Doma...
[1]: https://www.amazon.com/Compilers-Principles-Techniques-Tools...
Learning the basics of writing compilers will be surprisingly helpful for all kinds of programming tasks. The Dragon Book is the best:
https://www.amazon.com/Compilers-Principles-Techniques-Tools...
Too bad the prices are so high for it. The original version is much cheaper:
https://www.amazon.com/Principles-Compiler-Addison-Wesley-in...
Learning calculus is a great way to train your mind to think better.
Don't start off with YACC/Bison as they hide a lot of stuff under the hood. It's cool learning things from scratch. The most commonly-suggested book on compilers is known as the Dragon Book[2] and if you want to take this endeavour seriously, you should really get a copy.
[1] https://code.google.com/archive/p/zeded/
[2] https://www.amazon.com/Compilers-Principles-Techniques-Tools...
That proof isn't a problem in the book; it's mentioned, with a hint for those inclined to derive it themselves, in the running text.
But if what you are after is insight into how a computer works I found that I had my 'ah-ha' moment while learning C, Assembly (intel), and writing a compiler. I did have to have a slight basis in computer architecture, but that compiler project I worked on made everything click.
(side note on writing a compiler. Read, Decode, Execute. There are no short cuts around those series of steps).
If you are looking for a book I would recommend the 'Dragon Book'
http://www.amazon.com/Compilers-Principles-Techniques-Tools-...
I found a paper copy of the international version for cheap (like $10 US if I remember) that was amazing.
http://www.amazon.com/Compilers-Principles-Techniques-Tools-...
I highly recommend it, but it's heavy stuff. There are probably simpler guides out there that just cover the basics.
http://www.amazon.com/Compilers-Principles-Techniques-Tools-...
You can also use http://lmgtfy.com/?q=sicp for a deeper understanding of interpreted languages and language structure.
If not, doing a good portion of the exercises in some books on [compilers](http://www.amazon.com/Compilers-Principles-Techniques-Tools-...), [DFAs/State Machines](http://www.amazon.com/Introduction-Theory-Computation-Michae...), Algorithms (http://www.amazon.com/Introduction-Algorithms-Thomas-H-Corme...) and theoretical programming (https://mitpress.mit.edu/sicp/full-text/book/book.html) can give you some common foundational lenses with which to see these articles
2> Learning the history of your field
Nothing informs the current state of the field more than how we got here! Learn the foundation of your field from people who lived it. The podcast [Debug](http://www.imore.com/debug) is Guy English (Creator of Napkin and other apps) along with Rene Ritchie interviewing people about the history of Cocoa and CocoaTouch
I found [this episode about AutoLayout and Key Ferry illuminating](http://www.imore.com/debug-33-ken-ferry-auto-layout-passbook...).
3> Go through early versions. Few systems START complex. Look at OLD books for EARLY versions of systems, and why old php made such silly choices is obvious (hint, they weren't that silly for what it was doing). Read books and commentary through the timeline. Understand the history of what's happening to the language, then you'll understand why you are where you are.
4> Go DOWN the stack. Understand the bottom of Objective C by reading [the open source implementation of Core Foundation and more](http://www.gnustep.org/). Also available elsewhere (and I think somewhere on Apple's Site still).
5> Do what you shouldn't! Don't ship it, but really use those implementation details to do something awesome and amazing. You'll learn tons about what's happening.
PS: To the mods, those aren't affiliate links
https://en.wikipedia.org/wiki/Shift-reduce_parsing
https://en.wikipedia.org/wiki/LALR_parser
If you want lots of detail, there is always this:
http://www.amazon.com/Compilers-Principles-Techniques-Tools-...
https://www.amazon.com/Compilers-Principles-Techniques-Tools...
It has 11 sub-sections, 2 of which are about type checking
6.3 - Types and Declarations, pages 370-378
6.5 - Type Checking - pages 386 - 398
So that's about 20 pages out of 993 pages. A fraction of a chapter!
---
What I was referring to is the appendix "A Complete Front End", which contains a lexer and parser, but not a type checker! Doesn't sound complete to me.
I guess they have a pass to create the three-address code, and type checking is only in service of that. But they don't give you the source code!
---
Also weirdly, when you look at the intro chapter "The structure of a compiler", it goes
1.2.2 Syntax Analysis
1.2.3 Semantic Analysis (3 paragraphs that mentions type checking and coercions)
1.2.4 Intermediate Code Generation
But when you look at the chapters, there's NO semantic analysis chapter! It goes from (4) Syntax analysis, (5) Syntax-directed translation, to (6) intermediate code generation.
I think there's a missing chapter! (or two)