Writing Compilers and Interpreters und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr


oder
Loggen Sie sich ein, um 1-Click® einzuschalten.
oder
Mit kostenloser Probeteilnahme bei Amazon Prime. Melden Sie sich während des Bestellvorgangs an.
Jetzt eintauschen
und EUR 4,75 Gutschein erhalten
Eintausch
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Beginnen Sie mit dem Lesen von Writing Compilers and Interpreters auf Ihrem Kindle in weniger als einer Minute.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Writing Compilers and Interpreters: A Software Engineering Approach [Englisch] [Taschenbuch]

Ronald Mak
4.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
Preis: EUR 59,60 kostenlose Lieferung. Siehe Details.
  Alle Preisangaben inkl. MwSt.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Montag, 28. Juli: Wählen Sie an der Kasse Morning-Express. Siehe Details.

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Kindle Edition EUR 41,72  
Taschenbuch EUR 59,60  

Kurzbeschreibung

25. September 2009
Long-awaited revision to a unique guide that covers both compilers and interpreters Revised, updated, and now focusing on Java instead of C++, this long-awaited, latest edition of this popular book teaches programmers and software engineering students how to write compilers and interpreters using Java. You'll write compilers and interpreters as case studies, generating general assembly code for a Java Virtual Machine that takes advantage of the Java Collections Framework to shorten and simplify the code. In addition, coverage includes Java Collections Framework, UML modeling, object-oriented programming with design patterns, working with XML intermediate code, and more.

Hinweise und Aktionen

  • Amazon Trade-In: Tauschen Sie Ihre gebrauchten Bücher gegen einen Amazon.de Gutschein ein - wir übernehmen die Versandkosten. Mehr erfahren


Kunden, die diesen Artikel angesehen haben, haben auch angesehen


Produktinformation

  • Taschenbuch: 864 Seiten
  • Verlag: John Wiley & Sons; Auflage: 3. Auflage (25. September 2009)
  • Sprache: Englisch
  • ISBN-10: 0470177071
  • ISBN-13: 978-0470177075
  • Größe und/oder Gewicht: 23 x 19 x 5 cm
  • Durchschnittliche Kundenbewertung: 4.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 262.462 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Produktbeschreibungen

Synopsis

This third edition emphasizes modern software engineering practices in writing compilers and interpreters. Although its primary goal remains teaching these skills, the book can also be viewed as a modern software engineering book that uses writing compilers and interpreters as case studies. This edition keeps the same basic chapter organization as the second edition. The major changes includes new coverage of the Java Collections Framework and the Java Virtual Machine, UML, object-oriented programming, and XML and XML transformation tools. This is the definitive, up-to-date resource for IT professionals.

Buchrückseite

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

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


Kundenrezensionen

5 Sterne
0
3 Sterne
0
2 Sterne
0
1 Sterne
0
4.0 von 5 Sternen
4.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
Format:Taschenbuch|Verifizierter Kauf
This book is really nice to have as a reference. It shows an object-oriented approach for writing compilers and interpreters. I had learnt some basics about compilers and interpreters and their internal design before I’ve bought this book. I’ve always started in a procedural programming style and later tried to pour the code into classes and/or modules depending on the language I was using.
This was the first time that I’ve really considered a more modern approach and this book has showed me in great detail how that could look like. I had no problem to follow the book with the help of its UML and Syntax Diagrams.

It is also a good (but time consuming) idea to implement the compiler/interpreter while reading the book. In that way you learn a lot about pitfalls, possible spots for bugs, and why which design decision has been made.

I think this book expects some basic knowledge if you want to start right away. There is also an awful lot of code in there. You will hardly find a page without code and listings but that’s the kind of details that let you peek behind the scene.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 4.6 von 5 Sternen  5 Rezensionen
29 von 29 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen An excellent book for learning how to implement an interpreter/compiler 11. Februar 2010
Von A. Papadimitriou - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
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.
3 von 3 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Truly a great textbook 4. Januar 2013
Von Stan Tackett - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
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 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen This book is one of the most practical examinations of writing a compiler that I have read. 16. August 2013
Von Robert Thunelius - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
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.
5.0 von 5 Sternen Gets right into the thick of things 6. Juli 2013
Von Bruce Baker - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
Mak makes it clear at the beginning what the book is attempting to accomplish; and then proceeds to do exactly that.
2 von 6 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Same Design Patterns as Previous Book 6. September 2012
Von Scott Mccain - Veröffentlicht auf Amazon.com
Format:Kindle Edition|Verifizierter Kauf
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.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar