Its a review about this product
Other than the historic "dragons," (eg: Compilers: Principles, Techniques, and Tools (2nd Edition)), Grune and Cooper are the current "go to" texts on compilers, respectively located at: Modern Compiler Design ** and ** Engineering a Compiler, Second Edition.
This series of conference monographs from 2006 are still very up to date at this writing in 2013 when comparing to the above topical standards. In fact, calling this text a "supplement" is accurate due to its specialization in concurrent, but misleading for a 350+ page text packed with details on parallel compiler issues, from race conditions to memory management and register solutions, with numerous code (not just pseudocode) examples. It truly is a text in itself. The text was 2 years in the making, and as a conference attendee I am pleased to see that significant updates and revisions have been made to account for the fact that we readers aren't watching slides as we hear the details.
The articles vary from advanced undergrad to postgrad practicing Engineers. This is NOT the text to differentiate between scanning, parsing, optimization, intermediate states and generation, as nearly all the articles start at the end of that process and cover how the decisions at each of those stages have to be reframed when considering (often NP hard) parallel quandaries.
There is a school of thought that goes: "Compilers are a mature technology, and advances are necessarily incremental" -- meaning that millions of lines of code already have "well known" design patterns and tried and true templates and code snippets built in. Sure, we had them for Lisp and Fortran, but with Java EE, distributed processing, embedded, and now large scale parallel, the whole paradigm of considering a compiler a single "thing" is disappearing!
Java started the rush to innovation with bytecode, and smartphones, network packets, smart agents, client/server piecemeal compiler interchange sharing, cloud computing and many other applications are creating a great need for folks willing to relook at the old assumptions of (admittedly amazing) legacy compilers. OOP, with some of its recent "JIT" compiles (throw it at the wall and see which object opts to process it and allocate the memory) as well as garbage collection, have created numerous new, and even machine language/ assembly level challenges with large scale concurrent processing needs. Need I say that (ahem) some of us "assume around" some of the problems by specifying more of (today's cheap) memory, a practice that won't last forever. Seriously good programmers (unlike yours truly) can use information in this series to go a step deeper and finer in register decisions that many of us just "work around" with more memory.
Grune and Cooper cover concurrent relatively well as a summary (around 45 pages average each), but if you're seriously into parallel management issues, there is no better pedagogy to get into than compilers, even if you aren't specifically intending to modify or maintain one. This fine monograph fills out both of those seminal texts with everything you need to get up to speed on that missing link. Some of our Engineers here write their own compilers in Lisp to test parallel management issues because of the ease of checking bugs with "strawman" virtual compilers that hold a lot of other moving targets constant and allow you to see specific instancing of structural and algorithmic results on memory, process sharing between client and server, etc. Highly recommended. AND... I got it brand new for $17 from one of Amazon's third parties... SHOP this one!
