Compilers: Principles, Techniques, and Tools

Customer Reviews:

The best for getting the theoretical foundation of compilers.......2007-06-13

This is the classical reference book for compiler design. This is not an easy text because of its heavy use of mathematical notation and the algorithms are presented only in pseudo code but you will not find a more complete collection of compiler related algorithms than in this book.

Warmed over ghost of past excellence.......2007-05-19

I spent some serious quality time with the first edition (the "red dragon book"), in three main episodes over the past dozen years: 1) undergraduate compilers class, 2) industry project, and 3) parser generator implementation. During all three episodes, I was disappointed in various ways, though there is no denying that the book contains a wealth of information. As an undergraduate, I found the book somewhat impenetrable. When in industry, I found the book too abstract. When implementing a parser generator, I discovered that the book excludes important research results with regard to LR parser generation. It is the last disappointment that I will focus on.

The book presents parser generation in layers of increasing complexity, from SLR to LR to LALR, where LALR is presented as the penultimate algorithm, though LALR parsers can only handle a subset of the grammars that LR can handle. The justification for this is that the original Knuth LR algorithm is intractable for large grammars. However, an efficient, fully correct, approach for LR parser generation was published in 1977, and on top of that it appears easier to implement than efficient LALR parser generation! The red dragon book's original authors simply cannot have been unaware of this research result, but I suspect that they elected to warm over the "green dragon book" (published in 1977) rather than incorporate the state of the art as of 1986 into the "red dragon book". Now here we are another 20 years later, and as near as I can tell from reading through available online information, the "purple dragon book" is perpetuating this omission. The result of the red dragon book is that we have an entire generation of computer scientists who have been mislead to think that LALR is somehow superior to LR, and the purple dragon book is setting things up for yet another generation to be mislead.

The new cover is awesome! Long live the Purple Dragon!.......2007-05-04

The CGI cover looks great! I only wish it stretched along the spine of the book like in the previous editions.

Useful book.......2007-02-20

I'm a computer engineering student and I purchased the book for my programming languages and compilers course. At present I still haven't completed the course, but I've already found this book pretty useful so far. The concepts are clearly and well explained, so that I could better understand some points that I found rather obscure during the lessons. It's being of great help, so I'm very satisfied of this purchase.

Great book but...........2007-02-15

This is the numero uno among compiler books. But whoever designed the new cover out to be have their sketch pens stuffed down their throat. Why change the cover! The previous book was called the dragon book and was a red dragon. No one ever changed Feynman's lecture books by painting the cover blue, did they? Addison Wesley should take their new edition cover design and stuff it.

Average customer rating:

Great book!
Great Study resource
Excelente libro para el autoestudio
I CAN'T STAND LIBERAL FEMINISTS
Great Resource

CISSP All-in-One Exam Guide
Shon Harris
Manufacturer: Osborne/McGraw-Hill
ProductGroup: Book
Binding: Hardcover

General | Certification Central | Computers & Internet | Subjects | Books

Network Security | Networking | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

Look Inside Business Books | Trip | Specialty Stores | Books

jp-unknown1 | Specialty Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Business & Investing | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

ASIN: 0072193530

Book Description

All-in-One is all you need! This authoritative reference offers complete coverage of all material on the Certified Information Systems Security Practitioner (CISSP) exam. You'll find exam objectives at the beginning of each chapter, helpful exam tips, end-of-chapter practice questions, and photographs and illustrations. The bonus CD-ROM contains practice tests and hundreds of questions. This comprehensive guide not only helps you pass this challenging certification exam, but will also serve as an invaluable on-the-job reference.

Customer Reviews:

Great book!.......2007-10-04

This book was excellent in helping me study for the CISSP exam. Good luck.

Great Study resource.......2007-09-25

I just passed the test. I used the Passport, this book, and the Official Guide to the (ISC)2 CBK to study along with practice tests, etc. I thought this was the best study guide out of them. The CBK guide gives more information on the various topics but this gives you a lot of the information you need and I would highly recommend anyone taking the exam to read this book. The Passport was also useful as a brief study guide. It gives a good overview to read first and to read through again to refresh for the test. The practice questions on the CD were also very helpful in preparation. I have never been disappointed with any of the books in the All in One series that i have read.

Excelente libro para el autoestudio.......2007-09-11

Para preparar el examen CISSP es el mejor apoyo con el que puedes contar, este libro explica en un lenguaje simple y directo, a diferencia de otros libros del mercado.
Recomiendo leer este libro a todas las persona que quieren obtener la certificación.

I CAN'T STAND LIBERAL FEMINISTS.......2007-09-08

If you're like me and annoyed by morons that can't keep their mouths shut about politics (ya know, the kind of people that think everyone wants to hear their liberal ranting and complaining "I hate all men", feminist whining) you may NOT want to venture into this book.

If you read quite a few of the following reviews, you'll find MANY others that tried to warn me about this FEMINIST author NOT being able to keep her mouth shut about politics and hatred of men while YOU "attempt" to learn and/or prepare to take the CISSP, this liberal femy is sounding off throughout the book.

This is why I can't stand liberals (especially liberal feminist women). I picture the author with very short hair, wearing all black, sitting at a Mac, typing her feminist book while sipping Starbucks she picked up in her VW.

The world would be such a better place if these types could CONTROL themselves enough to leave their politics at home, especially when the subject at hand is IT Security.

Great Resource .......2007-08-22

I took the CISSP exam on August 12, 2007 and just received word on yesterday that I've passed. I can't express enough how important this book was in helping me prepare for the exam. This book was my primary resource for studying for the exam along with www.cccure.org. I also took a week long class which kind of helped. The reason I say 'kind of' is because I had pretty much read the book and the class was more of a review for me. I think that between this book and www.cccure.org the exam can be passed. Great resource for the exam.

Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science)

Average customer rating:

Mind-changing
from a student who use the book for a course
A Computer Science grand tour
Great Texbook
This should be on your bookshelf

Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science)
Harold Abelson , and Gerald Jay Sussman
Manufacturer: The MIT Press
ProductGroup: Book
Binding: Hardcover

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Databases | Computers & Internet | Subjects | Books

Programming Languages | Computer Science & Information Systems | New & Used Textbooks | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books

Look Inside Computer Books | Trip | Specialty Stores | Books
Similar Items:

ASIN: 0262011530

Amazon.com

Abelson and Sussman's classic Structure and Interpretation of Computer Programs teaches readers how to program by employing the tools of abstraction and modularity. The authors' central philosophy is that programming is the task of breaking large problems into small ones. The book spends a great deal of time considering both this decomposition and the process of knitting the smaller pieces back together.

The authors employ this philosophy in their writing technique. The text asks the broad question "What is programming?" Having come to the conclusion that programming consists of procedures and data, the authors set off to explore the related questions of "What is data?" and "What is a procedure?"

The authors build up the simple notion of a procedure to dizzying complexity. The discussion culminates in the description of the code behind the programming language Scheme. The authors finish with examples of how to implement some of the book's concepts on a register machine. Through this journey, the reader not only learns how to program, but also how to think about programming.

Book Description

Structure and Interpretation of Computer Programs has had a dramatic impact on computer science curricula over the past decade. This long-awaited revision contains changes throughout the text.

There are new implementations of most of the major programming systems in the book, including the interpreters and compilers, and the authors have incorporated many small changes that reflect their experience teaching the course at MIT since the first edition was published.

A new theme has been introduced that emphasizes the central role played by different approaches to dealing with time in computational models: objects with state, concurrent programming, functional programming and lazy evaluation, and nondeterministic programming. There are new example sections on higher-order procedures in graphics and on applications of stream processing in numerical programming, and many new exercises.

In addition, all the programs have been reworked to run in any Scheme implementation that adheres to the IEEE standard.

Customer Reviews:

Mind-changing.......2007-07-16

This is the best book on programming I have ever met in my life and, most probably, will ever meet.
It not only surprised me and made me think "Oh my god, how come I didn't think this way/about these so incredibly important things before?" dozens of times in every single chapter during every of my 3(in a row) readings of it but it actually changed the way I think about programs and the way I write them.
The authors have a perfect sense of balance between complexity and importance: they never skip important things silently and they never dig too deep into dull subtleties, instead they point out the really meaningful points and either invent a solution before the reader's eyes or give clues that inspire the reader to work out the solution himself.

The book does not teach most of the basic algorithms and data structures, like quicksort of graph path finding (except for several examples that fit well for the purpose of a particular chapter), it is not a programming reference: it is a manual on methods of computation: exactly what the title says. So, in case you have a pragmatic problem you can't just take the book and find a solution: I guess this is the reason for low ratings. But if you read the book thoroughly, you will definitely become an order of magnitude better programmer and that is much more important than knowing concrete algorithms.

I also extremely highly recommend the same-named video course by the same authors at http://swiss.csail.mit.edu/classes/6.001/abelson-sussman-lectures/ : I first was intrigued and shocked with it and only afterwards saw and immediately bought the book. It is a pity I have not yet had time to watch all the lectures (I watched about a half).

from a student who use the book for a course .......2007-05-04

I'm an undergrad who is currently taking an introductory class in C.S using the book as the primary textbook (actually, the only textbook). Sadly, I'm taking it with another class in computer architecture with heavy emphasis on system programming (a la C, MIPS). Like one of the reviewers having pointed out, the excessive zeal of pedantic and theoretical C.S has left the students clueless about the connection between reality and fundamental ideas presented in the book. The authors enforces a grand vision of solving problems independent of programming language. Sadly, this is not the case in practice (I have been trying to port some algorithms in the book into C, oh boy, what a frustrating experience). This vision has left me a very bad impression on Scheme (a good-for-nothing language invented by geeks to impress other geeks).

Some people have said they liked the book. At the beginning of semester. I liked the book too, since programming in functional style is completely new to me (who major in C.S wouldn't delight at learning new thing). HOWEVER, the more I delved into the book while taking a computer architecture course at the same time (in which I have to design a complete 8-bit CPU from ground up, as well as doing a lot of low-level programming), the more I feel there are some fundamental issues with using Scheme (or any other functional languages for that matter) as a tool to interpret and design machines and programs. It just struck me as very odd to design a computer "recursively". How ironic that the book is called "STRUCTURE and INTERPRETATION of computer programs".

I agree with some reviewers in here who bashed C in favor of Scheme. C is not a very good language, but C deserves praises. There are reasons why it has been around forever (both in academic and in industry), and at this rate, I don't see how any functional languages would emerge out of academics as replacement for C. The authors in book braggs that only Fortran has been surviving longer than Scheme, but besides surviving in the this textbook (which has been pushed down my throat by my school), I haven't seen Scheme anywhere else.

This textbook reminds me of the Feynman series in Physics. A series which everyone talks about, but when it comes to reality, it's just best used as a supplementary to look up for reference and self-congratulate as being "smart" rather than the one used to teach and learn from.

A Computer Science grand tour.......2007-03-17

I discovered this text, I believe, while browsing The Aerospace Corp Library in '90. I was immediately taken with it, wishing my own undergraduate program in CS had incorporated its use. The first two chapters on procedural and data abstraction are much better CS preparation than learning Java or C++ or Ada or Pascal. Abstraction and specificiation in software development are absolutely necessary if software "art" is ever to become a "science."

I used this text last year to teach a one year introduction to computer science to some rather advanced homeschooled high school students. Scheme is a much better choice for a teaching language than C++ or Java. There is no need to deal with memory management issues as with C++ and the development model is simpler than with Java. And scheme makes many things easier to achieve than with other languages: higher-order procedures (chapter 1) and hierarchical data (chapter 2).

For my own enjoyment and personal enrichment I have used chapters 4 and 5 as a basis for my own explicit control evaluator for scheme in C++.

A classic. Every CS graduate should do remedial work now and read this text, if they have not done so already.

Great Texbook.......2007-03-15

I purchased this texbook for my first computer class since it was required. It's a great book, but I'm glad we did not cover it entirely. Too much material, and Scheme is not that popular of a language. Price was right though!

This should be on your bookshelf.......2007-03-02

This is a 'must have' book for anyone wishing to practice the craft of programming. It is enigmatic in that it requires little background in programming, but leads swiftly and easily into non-trivial concepts. Of course one must do the exercises, which are varied and practical, the most they ask of the reader is that they understand basic mathematics of Leibniz and Newton. This book will not teach you a collection of tricks, it will give you a way to think about programming. There are a set of lectures by Abelson and Sussman based on the book available at no cost on the Web. Even though they were produced over a decade ago they are well worth watching, and add an interesting flavour to the text. All the software you need to use this text is available for free for a number of platforms. If you are an experienced programmer this is a fun read, if your intention is to learn the art of computer programming, start with SICP, and add Knuth to your bookshelf for reference.

Average customer rating:

Depends on what you want
If you are a beginner...Do not buy it
A great starter guide to writing a compiler
Terrible for Starters
Super compiler text!

Engineering a Compiler
Keith Cooper , and Linda Torczon
Manufacturer: Morgan Kaufmann
ProductGroup: Book
Binding: Hardcover

General | Architecture | Professional & Technical | Subjects | Books

General | Hardware | Computers & Internet | Subjects | Books

Design & Architecture | Hardware | Computers & Internet | Subjects | Books

Systems Analysis & Design | Computer Science | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General & Reference | Technology | Science | Subjects | Books

General | Arts & Photography | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Look Inside Science Books | Trip | Specialty Stores | Books

All Amazon Upgrade | Amazon Upgrade | Stores | Books

Arts & Photography | Amazon Upgrade | Stores | Books

Computers & Internet | Amazon Upgrade | Stores | Books

Professional & Technical | Amazon Upgrade | Stores | Books

Science | Amazon Upgrade | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Arts & Photography | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books

Science | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

ASIN: 155860698X

Book Description

The proliferation of processors, environments, and constraints on systems has cast compiler technology into a wider variety of settings, changing the compiler and compiler writer's role. No longer is execution speed the sole criterion for judging compiled code. Today, code might be judged on how small it is, how much power it consumes, how well it compresses, or how many page faults it generates. In this evolving environment, the task of building a successful compiler relies upon the compiler writer's ability to balance and blend algorithms, engineering insights, and careful planning. Today's compiler writer must choose a path through a design space that is filled with diverse alternatives, each with distinct costs, advantages, and complexities.

Engineering a Compiler explores this design space by presenting some of the ways these problems have been solved, and the constraints that made each of those solutions attractive. By understanding the parameters of the problem and their impact on compiler design, the authors hope to convey both the depth of the problems and the breadth of possible solutions. Their goal is to cover a broad enough selection of material to show readers that real tradeoffs exist, and that the impact of those choices can be both subtle and far-reaching.

Authors Keith Cooper and Linda Torczon convey both the art and the science of compiler construction and show best practice algorithms for the major passes of a compiler. Their text re-balances the curriculum for an introductory course in compiler construction to reflect the issues that arise in current practice.

·Focuses on the back end of the compilerreflecting the focus of research and development over the last decade.
·Uses the well-developed theory from scanning and parsing to introduce concepts that play a critical role in optimization and code generation.
·Introduces the student to optimization through data-flow analysis, SSA form, and a selection of scalar optimizations.
·Builds on this background to teach modern methods in code generation: instruction selection, instruction scheduling, and register allocation.
·Presents examples in several different programming languages in order to best illustrate the concept.
·Provides end-of-chapter exercises, with on-line solutions available to instructors.

Customer Reviews:

Depends on what you want.......2007-06-12

What it is: A great introduction to basic concepts in contemporary compilers.
What it's not: A handbook for someone thrown in at the deep end of commercial compiler development.

I can imagine a very good one-term course in compiler construction built around this text. After a brief introduction, it gets immediately into the classic topics of lexical scanning, parsing, and syntax analysis. These three chapters help any beginner understand the multiple levels of processing, from the character level, up through reorganizing grammars for practical parsing and table-driven techniques, to the lower levels of sematic analysis. This includes a very brief discussion of type systems and type inference - less than 20 pages, on a topic that whole books devote themselves to. These 200 pages typify what you'll see in the rest of the book: a lot of attention paid to lexical analysis, a problem largely eliminated by automated tools (lex and yacc being the best known), and thin mention of the harder problems that differ significantly across languages and applications of languages.

Chapter 5 addresses the critical issue of intermediate representation, the data structures that represent the program during analysis, optimization, and code generation. Chapter 6 is titled "The Procedure Abstraction." It deals with much more than its name suggests, including procedure activation records (generalizations of stack frames), parameter passing, stack management, symbol visibility and scoping, and scraps of symbol table organization - important stuff, but hard to understand as "procedure abstaction." The next chapter deals with "Code Shape," a grab-bag including value representations, arrays and strings, control constructs, and procedures (again). It also presents a very few pages, at the end, on object oriented language - hardly enough to scratch the surface, let alone build competence. And, for lack of a better place to stick them, I would have expected support for parallelism and exceptions to appear here, but this book seems to omit the topics altogether.

Code analysis and optimization appear in chapters 8-10. That includes a competent introduction to static single assignment notation, a staple of current compiler technology mentioned earlier, in the section on intermediate representation. This covers a range of basics, but omits all significant mention of arrays, the workhorses of performance computing. Chapters 11-13 introduce the basics of instruction selection, scheduling, and register allocation. Although it mentions some hardware effects, like out-of-order execution in superscalar architecture, discussion stays close the instruction sets of popular processors. As a result, it omits mention of SIMD, VLIW, DSP, and more exotic architectures, the ones most in need of good code generation. Compiler-specific support libraries, e.g. the kind that make up for lack of hardware divide instructions, should have appeared somewhere around here, but are oddly absent.

The authors present an adequate introduction for the beginner, someone who's still not sure what a hash table is (see appendix B). It introduces many basic topics, but doesn't go into a lot of depth in any of them. The student who finishes this book will understand most major issues of classical compiler construction. I just can't see a serious, working competence coming out of this text, though. I give it four stars as an academic introduction, but a lot less for anyone with immediate problems to solve.

-- wiredweird

If you are a beginner...Do not buy it .......2007-01-01

I read this book and really did not like it. It is a nightmare for any one new to compilers. It is difficult to read with more emphesis on the backend of the compiler.

The following texts are much better for a beginner:

1. Louden's Compiler construction --> the best text for a beginner.

2. the Dragon book

A great starter guide to writing a compiler.......2005-06-10

I recently used this book to supplement the Dragon book in a Compilers course. I found this book so much easier to read and understand. They do a great job of laying out the basics and introducing you to compiler design.

I also liked how they seemed to keep an open mind about which intermediate representation is best to use. They discuss the pros and cons of graphical IRs vs Linear IRs, and let you decide which best fits your needs.

Their open mindedness ended when it came to optimization though. I got the impression that the authors consider SSA (static single assignment) form to be the silver bullet of optimization. Almost all of the optimizations they discuss in this book rely on your IR being in SSA form! I agree that SSA form does indeed make many optimizations much easier, but there is a very high initial cost involved in converting to and from SSA form. In there defense they spend almost an entire chapter on how to do these conversions.

So to sum up, this book does a great job of introducing you to compiler design. It is well written and very easy to understand. It also does a good job of discussing different compiler design choices and their pros and cons. The only short coming of this book is that the entire optimization discussion is revolves around SSA form.

Terrible for Starters.......2005-03-22

This book was the textbook for an undergraduate course on compilers. Let me make it short: I never read it after reading the first chapter. The authors may be top experts on compilers but they shouldn't be writing books. Another book written in 1982 (compilers, principles, techniques and tools) saved my life for this class. If you are a beginner "do not buy this book".

Super compiler text!.......2005-02-22

This is really a super compiler text. It is also one of the most recent compiler books you can buy.

First of all this is a theoretical book. If you read the title 'Engineering a compiler' as 'Coding/Building a compiler' you would be disappointed! So, if you're looking for a learing-by-coding book, this is not for you (but I have some recommendations at the end of this review in the latest paragraph). The difference with most of the other theoretical books is that this book is not a dry text. It has also a nice layout. It gives plenty of examples, and all topics are well connected to each other. It's a pleasure to read for not native English people, so native English people can read it pretty fast.

This book read like a novel.. It does contain enough diagrams, tables, etc. but not too much (crowded), and everything is well explained.

You can read this book as a compiler introduction book. But I can only recommend this to B.Sc/M.Sc Computer Science students (like me). You don't need to have a M.Sc in Mathematics to understand this text, (all the math, eg. liveness graphs are well explained), but you will understand everything better if you have some background in algorithms (design), pseudocode, etc. like you gained during your B.Sc program. People without formal computer science education I would recommend to read a practical book first (see at the end of this review), because you may find else this text too theoretical.

This book focus on code optimizations. According to the authors (and me) compiler front ends (scanning/parsing/etc) are commodities today, and the backend (codegeneration) is where the difference is made nowadays. So if you're looking for a introduction text into compiler optimization this book is for you!

If you're looking for a more practical book I advice you to read 'Programming Language Processors in Java' from Watt & Brown. In that book you learn to build a nice stack virtual machine in Java with 'advanced features' like records (structs), procedures/functions, arrays and so on. That book is a good companion for 'Engineering a Compiler' to give you some practical insight. If you're looking for a Language Design book I advice you to look at 'Programming Language Pragmatics'. Both books are worth the money...

Advanced ASIC Chip Synthesis Using Synopsys® Design Compiler® Physical Compiler® and PrimeTime®

Average customer rating:

hands on guide
ok for an introduction to the tools

Advanced ASIC Chip Synthesis Using Synopsys® Design Compiler® Physical Compiler® and PrimeTime®
Himanshu Bhatnagar
Manufacturer: Springer
ProductGroup: Book
Binding: Hardcover

CAD | Graphic Design | Computers & Internet | Subjects | Books

General | Science | Subjects | Books

General | Arts & Photography | Subjects | Books

Look Inside Art Books | Trip | Specialty Stores | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Look Inside Science Books | Trip | Specialty Stores | Books

All Amazon Upgrade | Amazon Upgrade | Stores | Books

Arts & Photography | Amazon Upgrade | Stores | Books

Computers & Internet | Amazon Upgrade | Stores | Books

Engineering | Amazon Upgrade | Stores | Books

Professional & Technical | Amazon Upgrade | Stores | Books

Science | Amazon Upgrade | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Arts & Photography | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books

Science | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

Accessories:

ASIN: 0792376447

Book Description

Advanced ASIC Chip Synthesis: Using Synopsys® Design Compiler® Physical Compiler® and PrimeTime®, Second Edition describes the advanced concepts and techniques used towards ASIC chip synthesis, physical synthesis, formal verification and static timing analysis, using the Synopsys suite of tools. In addition, the entire ASIC design flow methodology targeted for VDSM (Very-Deep-Sub-Micron) technologies is covered in detail.
The emphasis of this book is on real-time application of Synopsys tools, used to combat various problems seen at VDSM geometries. Readers will be exposed to an effective design methodology for handling complex, sub-micron ASIC designs. Significance is placed on HDL coding styles, synthesis and optimization, dynamic simulation, formal verification, DFT scan insertion, links to layout, physical synthesis, and static timing analysis. At each step, problems related to each phase of the design flow are identified, with solutions and work-around described in detail. In addition, crucial issues related to layout, which includes clock tree synthesis and back-end integration (links to layout) are also discussed at length. Furthermore, the book contains in-depth discussions on the basis of Synopsys technology libraries and HDL coding styles, targeted towards optimal synthesis solution.
Target audiences for this book are practicing ASIC design engineers and masters level students undertaking advanced VLSI courses on ASIC chip design and DFT techniques.

Customer Reviews:

hands on guide.......2005-11-12

This book is geared towards the synopsys synthesis tools (as evident in the title). It gives brief explanations about vhdl and verilog coding style (which can be found in many other books).
The actual useful part was that the book explored the commonly used synthesis commands in synopsys, and also had explanations on the steps to follow to succesfully synthesize rtl. These ideas can also be used on synthesis tools from other vendors.

This book is good for people already familiar with front end rtl design and are looking into moving to backend.

ok for an introduction to the tools.......2003-03-21

This book is interesting as an introduction to these tools but needs more depth

Linkers and Loaders (The Morgan Kaufmann Series in Software Engineering and Programming)

Average customer rating:

A must-have book
too abstract
clear explanation of concepts
Helpful
not exactly what I was expecting.

Linkers and Loaders (The Morgan Kaufmann Series in Software Engineering and Programming)
John R. Levine
Manufacturer: Morgan Kaufmann
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Operating Systems | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

ASIN: 1558604960

Amazon.com

Written for any programmer who works with compiled code, Linkers and Loaders surveys today's hardware platforms with a tour of how code is linked and executed on IBM mainframes, Unix, and Windows. This handy title fills a valuable niche for anyone who wants to understand how programs are built and run on today's computing systems.

It's the cross-platform perspective that distinguishes this book. The author's wide-ranging perspective on IBM 370 mainframes, RISC platforms like the SUN SPARC and, of course, Microsoft Windows makes this book a commendable reference on the internals of linkers and program execution in each environment. There's also a digestible guide to the computer architecture (including registers, instruction formats, and memory addressing) for each platform. (Unix programmers will be pleased that the book has more information on non-Windows platforms than on Windows itself.) For C++ programmers, this text gives you a glimpse into the internals of such language features as macros, templates, and name mangling, and how linkers deal with them at build time.

The book closes with useful material on static libraries and dynamic linking, plus a short tour of Java and its class loader (which can resolve classes on the fly as they are downloaded over the Internet). Short exercises are provided for each chapter, making this a useful resource for both classroom and self-study on what is an often overlooked topic. --Richard Dragan

Topics covered: History of linkers and loaders, application binary interfaces (ABIs), computer architecture basics, big- and little-endian memory addresses, register and instruction formats for IBM 370, SPARC and Intel x86, paging and virtual memory, position independent code (PIC), Intel x86 segmentation, embedded architectures, object files for DOS COM and EXE files, Unix a.out, Unix ELF, IBM 360 object format, Microsoft Portable Executable (PE) format, Intel Object Module Format (OMF), storage allocation, linking details for C++, symbol management, name mangling, weak and strong references, debugging information, library formats, COFF and ELF formats, relocation, loading and overlays, bootstrap loading, shared libraries, dynamic linking for Unix ELF and Microsoft Windows DLLs, advanced linking techniques for C++, and linking in Java.

Book Description

Whatever your programming language, whatever your platform, you probably tap into linker and loader functions all the time. But do you know how to use them to their greatest possible advantage? Only now, with the publication of Linkers & Loaders, is there an authoritative book devoted entirely to these deep-seated compile-time and run-time processes.
The book begins with a detailed and comparative account of linking and loading that illustrates the differences among various compilers and operating systems. On top of this foundation, the author presents clear practical advice to help you create faster, cleaner code. You'll learn to avoid the pitfalls associated with Windows DLLs, take advantage of the space-saving, performance-improving techniques supported by many modern linkers, make the best use of the UNIX ELF library scheme, and much more. If you're serious about programming, you'll devour this unique guide to one of the field's least understood topics. Linkers & Loaders is also an ideal supplementary text for compiler and operating systems courses.

*Includes a linker construction project written in Perl, with project files available for download. *Covers dynamic linking in Windows, UNIX, Linux, BeOS, and other operating systems.
*Explains the Java linking model and how it figures in network applets and extensible Java code.
*Helps you write more elegant and effective code, and build applications that compile, load, and run more efficiently.

Customer Reviews:

A must-have book.......2007-09-03

As far as I'm aware, this is the only book on the market that covers this subject. Clearly this book will be of use to someone that is starting on writing a link editor (or any other tool that manipulates object files). Even for developers that aren't in that category (myself included), then there were interesting things to be learnt. For instance, prior to reading this book, I was unaware of the exact consequences of compiling PIC code for shared libraries. Now that I understand this better, I'll know the impact on performance of code that is destined for chared libraries.

too abstract.......2006-02-15

maybe it's not the book's fault and instead it's my lack of sufficient background, but this book is hard to understand because of its lack of examples.

clear explanation of concepts.......2005-10-28

Whatever the hardware and operating system you are using, Levine offers a general explanation of what a linker and loader do. If you deal just in a high level language like C++ or Java, this book can help you appreciate what goes on at a lower level. Notably, the unix ELF and Microsoft Portable Formats are expounded on.

You might also find tips to improve your code performance. Perhaps by finding that your storage allocation could be reduced. Or maybe you want to write relocatable code for dynamic linking.

All told in a style that shows ideas clearly. Without getting bogged down in the syntax of a given CPU or operating system.

Helpful.......2005-10-28

This particular book had all the information I needed to know to make a COFF standard linker.

not exactly what I was expecting........2005-01-05

For what this book is, it is good. but, for what I expected it to be, it is a little lackluster. I was expecting a book that would explain linking and loading, provide code examples, and teach the subject systematically. What this book is however, is a simple technical reference. It talks about what things are, and the particulars of all the different file formats and architectures. It provides no code (and no pseudo-code) to demonstrate any of the concepts.

The book does however provide several excercises at the end of each chapter that will test the programmer, and it also has a main project: each chapter prompts the reader to construct, and add to a sample linker, which the book claims should be written in Perl, although perl is never talked about in the book, and no perl code is ever provided. Since Perl code is never used in the problems, and no solutions in perl are provided in the book (they are on the website, however), it would work just as well for a programmer to use any language that they felt comfortable with, such as C/C++ or Java.

my feelings are mixed. on one hand this book is an excellent reference on a subject that rarely sees any light. if I may quote a passage: "But all the linker writers in the world could probably fit in one room, and half of them already have copies [of this book]." Clearly the audience for this topic isnt particularly large, and so it seems that linkers and loaders will remain a bit of a black art, even though this book does shed some light on the most basic concepts involved. However, this book only contains concepts, and it asks the reader to view external sources for the specifics, and it asks the programmer to have a firm grasp on their knowledge of programming, but also computer architecture.

I give this book 4 stars because it is one of the best (one of the only) books on the topic, but I hope that future versions of this book (or even a competing title) will shed more light, and provide more specific examples (including specific code examples) on this confusing topic.

The Definitive ANTLR Reference: Building Domain-Specific Languages (Pragmatic Programmers)

Average customer rating:

Must read for anyone planning to do anything with parsers
A Perfectly Pragmatic Guide!
Can't do without this one
Another Gem From the Pragmatic Programmers
Essential purchase for anyone starting with ANTLR

The Definitive ANTLR Reference: Building Domain-Specific Languages (Pragmatic Programmers)
Terence Parr
Manufacturer: Pragmatic Bookshelf
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Computer Science | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

ASIN: 0978739256

Book Description

ANTLR v3 is the most powerful, easy-to-use parser generator built to date, and represents the culmination of more than 15 years of research by Terence Parr. This book is the essential reference guide to using this completely rebuilt version of ANTLR, with its amazing new LL(*) parsing technology, tree construction facilities, StringTemplate code generation template engine, and sophisticated ANTLRWorks GUI development environment. Learn to use ANTLR directly from the author!

ANTLR is a parser generator-a program that generates code to translate a specified input language into a nice, tidy data structure. You might think that parser generators are only used to build compilers. But in fact, programmers usually use parser generators to build translators and interpreters for domain-specific languages such as proprietary data formats, common network protocols, text processing languages, and domain-specific programming languages.

Domain-specific languages are important to software development because they represent a more natural, high fidelity, robust, and maintainable means of encoding a problem than simply writing software in a general-purpose language. For example, NASA uses domain-specific command languages for space missions to improve reliability, reduce risk, reduce cost, and increase the speed of development. Even the first Apollo guidance control computer from the 1960s used a domain-specific language that supported vector computations.

This book is the definitive guide to using the completely rebuilt ANTLR v3 and describes all features in detail, including the amazing new LL(*) parsing technology, tree construction facilities, StringTemplate code generation template engine, and sophisticated ANTLRWorks GUI development environment. You'll learn all about ANTLR grammar syntax, resolving grammar ambiguities, parser fault tolerance and error reporting, embedding actions to interpret or translate languages, building intermediate-form trees, extracting information from trees, generating source code, and how to use the ANTLR Java API.

Customer Reviews:

Must read for anyone planning to do anything with parsers.......2007-06-19

ANTLR is pretty much the de facto tool when it comes to writing parsers. In this book Terence Parr has given a really nice and detailed guide to ANTLR 3. Usually a reference book is pretty dry, but not this one. Terence has a nice, relaxed writing style which makes this a very easy read. Also it has lots of examples to guide you along the way.

A must read for anyone planning to work with ANTLR, write parsers or just wanting to get an insight into parsing theory.

A Perfectly Pragmatic Guide!.......2007-06-12

If you have any interest in compiler design, building translators, building intelligent editors, code generation, understanding what goes into building your own computer language, or just how to use ANTLR v3 then you may want to get a copy of this book.

This book is all about ANTLR. ANTLR is a tool you can use to build compilers and interpreters for computer languages, but don't let that scare you off. With the increasing interest in domain specific languages, bulding intelligent editors, code generation, and model driven development books like this are becoming ever more important. Terence Parr has made the topic far more approachable than any other book I have read (or attempted to read) on the topic.

In the first few chapters the author walks readers through the phases of parser construction using language that is approachable and easy to understand. He explains the needed principles and demonstrates their application with well chosen examples.

This is followed by a quick tour of how one might use ANTLR. I love the approach taken in this chapter as it takes a small example and shows two different ways to approach the problem using ANTLR. This is coupled with explanations describing when you want to use one approach over another.

The middle section of the book goes into depth on the various aspects of ANTLR. This is the reference section. Don't expect to be able to read these chapters one after another in quick succession. There's just too much to take in all at once!

The text is littered with references both forward and back to other sections and topics of interest. You can tell the author has spent a lot of time working with compiler construction by the breadth and depth of information presented. I really liked the motivating examples he gives for certain ANTLR features such as the need to emit imaginary tokens when lexing python (see page 94 in chapter 4).

The first chapter of part three of the book delves into the depths of the parsing algorithm used in ANTLR since you will need to understand it when you run into parsing errors and need to make sense of them.

The remaining chapters are devoted to ways to deal with the problems you may run into when trying to parse various language constructs.

This book has left a very lasting impression on me. I can visualize what goes into an editor like eclipse more fully. I no longer feel that the topic of abstract syntax trees is above my head and I feel I am better equipped to tackle the dragon book. I also understand why lisp programmers say that lisp has no syntax (take a look at the serialized form of the AST from chapter 3 on page 62, it looks like a bunch of s-expressions!).

One more note: ANTLR itself is a domain specific language (DSL) and serves as a prime example of how a DSL can greatly increase the clarity of the solution to a problem if the solution is described in terms native to the problem domain. (I think that's what the folks in the lisp camp have been saying for a long time.) ANTLR helps show the value of having DSLs and this book shows how easy it can be to write one!

Can't do without this one.......2007-06-07

You may have decided to use the Parser Generator ANTLR because it can generate code in many different languages like CSharp, Python and of course Java.
In this case you have to get this book. The current online documentation is minimal. But beware that despite the title
there are some points that the author forgets to define (such as the EOF token, which can be important). However a more important quible is that
we are far from the quality of writing of the famous "Dragon Compiler Book".
If you are looking for pithy clear definitions like me you will be disappointed. You may waste a lot of time trying to understand error messages when they arise while generating code from a grammar.
The space devoted to Antlworks is very limited .
Hopefully this will be fixed up in future printings of this book.

Another Gem From the Pragmatic Programmers.......2007-06-07

The always-excellent Pragmatic Programmers have done it again. "The Definitive ANTLR Reference" is an important book, and not just for language designers/implementers, but for anyone who is serious about getting better at computer science/programming. I am a graduate student and a working programmer, and I know I will be using what I learn from this book to become better at both. Thanks to Dr. Terence Parr, not only for developing ANTLR, a world-class parser generator, but for motivating and teaching us how to use it with a relaxed, gently humorous writing style that makes you forget that there is some pretty hardcore computer science behind all this stuff. And thanks to the Prags (Dave Thomas and Andy Hunt) for giving Dr. Parr this forum.

Essential purchase for anyone starting with ANTLR.......2007-06-06

If you're working with ANTLR then you need "The Definitive ANTLR Reference". It's a reference work, but only in part; the vast majority of the book consists of explanations and examples rather than dry reference material. The reference material is in there, of course, but there's really not a lot of it because ANTLR itself has a very minimal design.

But despite the fact that ANTLR looks like a simple tool on the surface (the rules for building a grammar are few and simple) in reality it is fiendishly difficult to use until you get the knack for it. This book will help you through the difficult early stages of learning how to write ANTLR grammars; it really is the only resource out there that does this in a comprehensive way. Terence Parr somehow manages to take the incredibly dry subject matter of lexer and parser generation and turn it into a witty and entertaining conversation; you really feel as though Terence is speaking to you from across the table.

My only complaint about the book is that it is almost totally Java-centric (all the examples are in Java) despite the fact that ANTLR can target multiple languages (if the book had a little more information about other target languages then it would be a five-star title).

Average customer rating:

Interesting

Principles of Program Analysis
Flemming Nielson , Hanne R. Nielson , and Chris Hankin
Manufacturer: Springer
ProductGroup: Book
Binding: Hardcover

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

General | Education | Nonfiction | Subjects | Books

History of Science | History & Philosophy | Science | Subjects | Books

General | Education | Professional & Technical | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Look Inside Nonfiction Books | Trip | Specialty Stores | Books

Look Inside Science Books | Trip | Specialty Stores | Books

All Amazon Upgrade | Amazon Upgrade | Stores | Books

Computers & Internet | Amazon Upgrade | Stores | Books

Nonfiction | Amazon Upgrade | Stores | Books

Professional & Technical | Amazon Upgrade | Stores | Books

Science | Amazon Upgrade | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Science | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

Accessories:

ASIN: 3540654100

Book Description

Program analysis concerns static techniques for computing reliable approximate information about the dynamic behaviour of programs. Applications include compilers (for code improvement), software validation (for detecting errors in algorithms or breaches of security) and transformations between data representation (for solving problems such as the Y2K problem). This book is unique in giving an overview of the four major approaches to program analysis: data flow analysis, constraint based analysis, abstract interpretation, and type and effect systems. The presentation demonstrates the extensive similarities between the approaches; this will aid the reader in choosing the right approach and in enhancing it with insights from the other approaches. The book covers basic semantic properties as well as more advanced algorithmic techniques. The book is aimed at M.Sc. and Ph.D. students but will be valuable also for experienced researchers and professionals.

Customer Reviews:

Interesting.......2000-10-23

As the title suggests the book discusses various approaches to program analysis and it discusses these approaches is pretty good detail, though purely theoretical with small WHILE languages. It would have helped to have used a real live example by considering a small chunk of any of the generally used languages. It has good appendices that covers on some mathematical concepts but be warned you need know your math, the kind described in Glynn winskel or John reynolds book, before you dig into this one.

I rate it as 4 star as it gives the information on how to approach program analysis from the theoretical side. Also, reading it made my life easy when working with some code on flow analysis. I would say it definitely requires 2 readings for the info to settle inside. The appendix on Partially Ordered Sets is much more comprehendable than in Winskel.

Book Description

This textbook explains all phases of a modern compiler: lexical analysis, parsing, abstract syntax, semantic actions, intermediate representations, instruction selection via tree matching, dataflow analysis, graph-colouring register allocation with coalescing, and runtime systems. It covers current techniques in code generation and register allocation, as well as functional and object-oriented languages, which are missing from most books. The author illustrates the most accepted and successful techniques in a concise way, rather than as an exhaustive catalogue of every possible variant. Detailed descriptions of the interfaces between modules of a compiler are illustrated with actual C header files. A unique feature of the book is a well-designed compiler implementation project in C, including front-end and ‘high-tech’ back-end phases, so that students can build a complete working compiler in one semester. The textbook is meant for use in a one-semester first course for undergraduates in compiler design. Accompanying support software is available.

Customer Reviews:

Good, but error-ridden.......1998-04-02

This book provides a great overview of compiler-writing in general, with excellent discussions of issues like parsing, code generation, register allocation, and optimizations. This particular version (the C version) of the book, however, seems to contain a lot of typos in the code samples -- even without a compiler, I could see that most of them will not compile. If you can figure out what he meant, however, the algorithms are very sound.

MMIXware: A RISC Computer for the Third Millennium

Average customer rating:

MMIXware: A RISC Computer for the Third Millennium
Donald E. Knuth
Manufacturer: Springer
ProductGroup: Book
Binding: Paperback

Design & Architecture | Hardware | Computers & Internet | Subjects | Books

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Operating Systems | Computers & Internet | Subjects | Books

General | Medicine | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

All Amazon Upgrade | Amazon Upgrade | Stores | Books

Computers & Internet | Amazon Upgrade | Stores | Books

Medicine | Amazon Upgrade | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Medicine | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

ASIN: 3540669388

Book Description

MMIX is a RISC computer designed by Don Knuth to illustrate machine-level aspects of programming. In the author's book series "The Art of Computer Programming", MMIX replaces the 1960s-style machine MIX. A particular goal in the design of MMIX was to keep its machine language simple, elegant, and easy to learn. At the same time, all of the complexities needed to achieve high performance in practice are taken into account.
This book constitutes a collection of programs written in CWEB that make MMIX a virtual reality. Among other utilities, an assembler converting MMIX symbolic files to MMIX objects and two simulators executing the programs in given object files are provided. The latest version of all programs can be downloaded from MMIX's home page. The book provides a complete documentation of the MMIX computer and its assembly language. It also presents mini-indexes, which make the programs much easier to understand.

Books:

Books Index

Books Home

Recommended Books