Programming Books C Java PHP Python Learn more Browse Programming Books
Writing Compilers and Interpreters and over one million other books are available for Amazon Kindle. Learn more
  • List Price: $80.00
  • Save: $53.25(67%)
Rented from apex_media
To Rent, select Shipping State from options above
Due Date: Dec 20, 2014
FREE return shipping at the end of the semester. Access codes and supplements are not guaranteed with rentals.
Condition: Used: Acceptable
Comment: Item may not include associated media. Small mark / wear on front cover. Large wrinkle / bend on front cover. Medium mark / wear on back cover. Large wrinkle / bend on back cover.
Access codes and supplements are not guaranteed with used items.
Add to Cart
Qty:1
  • List Price: $80.00
  • Save: $23.80 (30%)
Usually ships within 2 to 4 weeks.
Ships from and sold by Amazon.com.
Gift-wrap available.
Add to Cart
Trade in your item
Get a $14.49
Gift Card.
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Writing Compilers and Interpreters: A Software Engineering Approach Paperback – September 28, 2009

ISBN-13: 978-0470177075 ISBN-10: 0470177071 Edition: 3rd

Buy New
Price: $56.20
Rent
Price: $26.74 - $26.75
30 New from $52.32 22 Used from $40.17
Rent from Amazon Price New from Used from
Kindle
"Please retry"
Paperback
"Please retry"
$26.74
$56.20
$52.32 $40.17

Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student



Frequently Bought Together

Writing Compilers and Interpreters: A Software Engineering Approach + Language Implementation Patterns: Create Your Own Domain-Specific and General Programming Languages (Pragmatic Programmers) + Engineering a Compiler, Second Edition
Price for all three: $160.81

Some of these items ship sooner than the others.

Buy the selected items together

NO_CONTENT_IN_FEATURE

Save up to 90% on Textbooks
Rent textbooks, buy textbooks, or get up to 80% back when you sell us your books. Shop Now

Product Details

  • Paperback: 864 pages
  • Publisher: Wiley; 3 edition (September 28, 2009)
  • Language: English
  • ISBN-10: 0470177071
  • ISBN-13: 978-0470177075
  • Product Dimensions: 9.1 x 7.5 x 2 inches
  • Shipping Weight: 2.8 pounds (View shipping rates and policies)
  • Average Customer Review: 4.6 out of 5 stars  See all reviews (5 customer reviews)
  • Amazon Best Sellers Rank: #189,196 in Books (See Top 100 in Books)

Editorial Reviews

From the Back Cover

Master the skills you need to build your own compilers and interpreters

Compilers and interpreters are very difficult programs to write, but modern software engineering tackles the complexity. Design patterns and other object-oriented programming techniques guide you to develop well-structured code in incremental, understandable steps. Apply what you learn in this book to succeed with any complex software project.

You'll learn to:

  • Use Java to develop scanners and parsers for programming languages

  • Employ UML to model software components

  • Manage symbol tables with the Java Collections Framework

  • Use XML to represent the generated intermediate code

  • Develop an interpreter to execute programs, including a powerful interactive source-level debugger

  • Implement an integrated development environment (IDE) that animates the execution of programs

  • Use the IDE's graphical user interface to set breakpoints and single-step programs statement by statement with mouse clicks

  • Develop a code generator that emits object code for the Java Virtual Machine (JVM), and run the compiled code on multiple platforms

About the Author

Ronald Mak wrote the earlier editions of this very successful book as well as The Martian Principles for Successful Enterprise Systems: 20 Lessons Learned from NASA's Mars Exploration Rover Mission (also published by Wiley). He is also the author of Java Number Cruncher: The Java Programmer's Guide to Numerical Computing. He develops advanced software systems for organizations from startups to NASA. Currently a research staff member at the IBM Almaden Research Center, he also teaches compiler writing and software engineering at San José State University.

Customer Reviews

4.6 out of 5 stars
5 star
4
4 star
0
3 star
1
2 star
0
1 star
0
See all 5 customer reviews
Share your thoughts with other customers

Most Helpful Customer Reviews

29 of 29 people found the following review helpful By A. Papadimitriou on February 11, 2010
Format: Paperback Verified Purchase
The book of Ronald Mak is simply excellent.
It develops very clearly the techniques to build a parser,
an interpreter, a source-level debugger and a compiler for the
Java Virtual Machine, all directed for the standard Pascal language.

The design of Ronald Mak is very modular build upon robust
software engineering methodologies and the developed modules can be easily
customized (e.g. by extending the Pascal language) and can be readily
utilized in other similar application domains (e.g. implementing special
purpose languages by replacing only the Pascal scanner and parser).

The parser is a top-down one, easily understandable.
Mak produces an intermediate code representation of the program, that is Pascal
independent, and thus both the presented source-level debugger, interpreter and JVM
compiler are kept independent of the Pascal language,
since they operate on the Abstract
Syntax Tree based intermediate code representation.

The Java code of the book is very elegant and understandable.
The design of the interactive source level debugger and of the compiler targeted at the
Java Virtual Machine are also of outstanding quality.

As the author also declares, the book is more for the one who wants to
implement compilers than for the compiler theorist. For the student or engineer who
wants to realize interpreters/compilers, the book is magnificent.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
3 of 3 people found the following review helpful By Stan Tackett on January 4, 2013
Format: Paperback Verified Purchase
This book was just what I needed to refresh my fading memory of compiler design skills. And this one is cross-platform, as the code is written in Java.

The book goes step by step in developing a full Pascal interpreter and then compiler. Highly recommended!!
1 Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
Format: Paperback Verified Purchase
It is filled with actual working code, so that a practical Software engineer can see what is happening as the chapters incrementally add to what has been developed in earlier chapters.
There is not a large emphasis on theory, and while necessary at some point, it allows for a more grounded approach to learning from a working code perspective. Allowing theory to be learned after the fact, once code has been seen in action.

Well written and well structured.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
Format: Paperback Verified Purchase
Mak makes it clear at the beginning what the book is attempting to accomplish; and then proceeds to do exactly that.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
2 of 6 people found the following review helpful By Scott Mccain on September 6, 2012
Format: Kindle Edition Verified Purchase
I bought this book with high hopes that it would speed me along my current project. I enjoyed Ronald Mak's original book which was targeted to C++ folks. I read it early on in my career before I could appreciate good design with high cohesion. Mr Mak's object orient approach, while it works well for his usages, creates too many dependencies for my taste. He does abstract many things out with interfaces, but that's where he stops. For example, there is one abstract base class with about 20 different overloads for the same function (with implementation) where only the parameter signatures are different. In some cases those functions actually do very different things.

I bought this book with the high hopes that the author would use more design patterns in his implementation, but it looks like it's just a java port of his original C++ design. It's a great book for beginners to learn about compilers, definitely easier to understand than the Dragon Book, but I wouldn't rely on it for good examples of OO design, separation of concerns, or SOLID programming.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Customer Images

Search