 Trade In this Item for up to £14.10
Trade in Build Your Own .NET Language & Compiler (Expert's Voice) for an Amazon.co.uk gift card of up to £14.10, which you can then spend on millions of items across the site. Plus, get an extra £5 when you trade in books worth £10 or more until June 30, 2012. Trade-in values may vary (terms apply). Find more products eligible for trade-in.
|
Frequently Bought Together
Product details
|
More About the Author
Product Description
Product Description
All software developers use languages, which are the fundamental tool of the trade. Despite curiosity about how languages work, few developers actually understand how. Unfortunately, most texts on language and compiler development are hard to digest, written from academic platforms for use in college-level computer science programs. On the other hand, Build Your Own .NET Language and Compiler demystifies compiler and language development, and makes the subjects palatable for all programmers.
This practical book presents techniques that you can apply to everyday work. You’ll learn to add scripts and macro languages to your applications, add runtime expression evaluation to their applications, and generate code immediately. Further, you will learn parsing techniques, which are essential to extract information from any structured form of datalike text files, user input, XML, or HTML. As a bonus, the book includes a complete QuickBasic compatible compiler with source code that works. The compiler illustrates the books techniques and acts as a versatile .NET language.
About the Author
Edward G. Nilges - Edward G. Nilges has been developing software since 1970. He worked on debugging an early Fortran compiler in 1972 and made it available to a university community. While at Bell-Northern Research, the research arm of Nortel Networks in 1981, Nilges worked on compiler development and developed the SL-1XT compiler for voice and data PBX programming, as well as a firmware assembler that was compiled automatically from the firmware reference manual.
In 1993, Nilges began developing with VB3 and has developed a variety of projects in Basic. Edward also assisted mathematician John Nash (the real-life protagonist of the movie "A Beautiful Mind") with C during a critical period in which Dr. Nash was being considered for the 1993 Nobel Prize. In 1999 Edward developed his vbExpression2Value VB-6 technology to parse and interpret SQL Server and VB expressions for his classes at DeVry. In 2001, acting upon a suggestion from a student colleague at Princeton, Nilges used his beta copy of VB. NET to write the fully OO quickBasicEngine.
In 1993, Nilges began developing with VB3 and has developed a variety of projects in Basic. Edward also assisted mathematician John Nash (the real-life protagonist of the movie "A Beautiful Mind") with C during a critical period in which Dr. Nash was being considered for the 1993 Nobel Prize. In 1999 Edward developed his vbExpression2Value VB-6 technology to parse and interpret SQL Server and VB expressions for his classes at DeVry. In 2001, acting upon a suggestion from a student colleague at Princeton, Nilges used his beta copy of VB. NET to write the fully OO quickBasicEngine.
Nilges currently consults on the use of compiler technology in the real world to parse and interpret complex business rules in industries such as mortgage lending and credit evaluation. He finds that compiler optimization can be used to verify the consistency and completeness of business rule sets.
Inside This Book
(Learn More)
Tag this product(What's this?)Think of a tag as a keyword or label you consider is strongly related to this product.
Tags will help all customers organise and find favourite items. |
Sell a Digital Version of This Book in the Kindle Store
If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store.
Learn more
What Other Items Do Customers Buy After Viewing This Item?
Customer Reviews
Most Helpful Customer Reviews
3 of 3 people found the following review helpful
Format:Paperback
I bought this book because I wanted to know more about making a compiler FOR the .NET framework (as per the title). Instead of teaching you ANYTHING about generating MSIL code, this books teaches you the very basics of how to make a Basic interpreter in Basic. As if a more idiotic project could be dreamed up. I feel ripped off for $49.99 - this book should have been a free, gratis project at www.codeproject.com or something like that. It should never have been a book that people can buy because it is not worth it!
1 of 10 people found the following review helpful
Format:Paperback
This is Edward G. Nilges, the author of this book, rather shamelessly giving himself five stars. I gave myself four stars on the US site when the book came out, but such humility merely attracted abusive posts. So, the devil take humility.
This book is a walk over the terrain of basic compiler development that is much easier to comprehend than the standard textbook on the subject (Aho/Sethi/Ullman). I have written in it in a light-hearted and amusing way.
It includes a compiler/interepreter of 26000 lines.
It's been in print and steadily selling at moderate levels since 2004.
I am working on a new, C Sharp version of the compiler, and the book contains information on signing up for this new release when and if it is available.
This book is a walk over the terrain of basic compiler development that is much easier to comprehend than the standard textbook on the subject (Aho/Sethi/Ullman). I have written in it in a light-hearted and amusing way.
It includes a compiler/interepreter of 26000 lines.
It's been in print and steadily selling at moderate levels since 2004.
I am working on a new, C Sharp version of the compiler, and the book contains information on signing up for this new release when and if it is available.
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com:
16 reviews
59 of 61 people found the following review helpful
Waste of time
21 May 2004
Format:Paperback
I have been waiting for a book like this for quite awhile. I've read John Gough's book and although that was too much Pascal for me; it was certainly closer to the topic than this book. This book is both incomplete and off the mark. One of the tools, a BNF Analyzer, is written (poorly) in Visual Basic 6. The downloaded source for the programs don't compile "out of the box" either. This was a rush job or done poorly in someone's spare time. Some of the code is from 1998.
Here's the kicker. The author talks about how to write BNF and analyze it, but he actually doesn't use it in his sample compiler. He wrote the compiler manually "in a few days". Then, he talks about producing MSIL, but doesn't, opting for his own opcode syntax with an interpreter. There is no information in this book about producing a compiler that will create .NET code.
This was a lazy and deceitful attempt and the author should be ashamed for not taking the time to do it properly using BNF to create the compiler engine and then producing MSIL, which is the whole point of the title "Build Your Own .NET Language and Compiler".
He clearly knows what he's talking about, but he tried to throw together a bunch of his compiler knowledge in hopes of making a quick buck. Sadly, I was suckered into it, but hopefully, you'll read this and skip it entirely.
46 of 50 people found the following review helpful
Okay for the novice, I guess...
9 Nov 2004
Format:Paperback|Amazon Verified Purchase
I preordered the book and I forced to admit that I was disappointed in the end product. The title implies that a compiler is created for .NET, but it does not create a MSIL compiler (such as C# or VB.NET). The provided code while it is written in a .NET language does not produce MSIL which is what the title of the book implies, instead the compiler runs it's own p-code. There is no partially correct statement as a previous review states, either it is or it is not and this is *not* a .NET compiler.
The fact that the author writes excuses for the book in his own review of the book should tip you off that something is not what you would think it is at face value. If you read the book you will find that he also makes such a statement that the code may not be what you were expecting in the book itself. Nilges knows that something is wrong.
That being said, if you have no background in writing compilers then this book may be of some value to you as an introductory text on the subject but don't expect to find anything here of any real use to your own work. If you think that you might enjoy the book then buy it used.
The fact that the author writes excuses for the book in his own review of the book should tip you off that something is not what you would think it is at face value. If you read the book you will find that he also makes such a statement that the code may not be what you were expecting in the book itself. Nilges knows that something is wrong.
That being said, if you have no background in writing compilers then this book may be of some value to you as an introductory text on the subject but don't expect to find anything here of any real use to your own work. If you think that you might enjoy the book then buy it used.
30 of 33 people found the following review helpful
Great BNF coverage; but gets off subject too often
4 July 2005
Format:Paperback
The book starts out explaing the standard notational language
used to define the syntax of a language: BNF (and extended BNF).
The authors VB6 EBNF-to-doc compiler "compiles" an EBNF
grammer into a documentation file! This is a novel idea
and it helps to show how EBNF relates to the syntax of the
language in question.
Although his presentation of EBNF is masterful, he didn't
use EBNF to generate the parser for his compiler. I expected
him to use a parser generator like ANTLR or coco/R to generate
a scanner and recursive decent parser automatically from
the grammer. Instead, he chose to "roll his own" scanner
and parser.
His scanner seems very good, and his discussion of
the scanner is thorough.
His parser is harder to judge by reading the book since he
kept getting off the main subject and he didn't really
explain the parsing code.
His code generator discussion has some nuggets of wisdom,
but is poorly organized.
One overriding concern with this author is that he
doesn't use terminology consistant with other
authors. He doesn't use common terms like p-code,
intermediate language, virtual machine, or the like.
His non-standard use of the word "assembling" is really
just a step that removes comments from his p-code!
The authors presentation can get off track frequently.
Its hard to find 5 pages in a row that stay on
subject completely. He also likes to quote famous people,
often out of context to the subject at hand.
His runtime interpreter (which some might call a virtual
machine) is called the "Nutty Professor Interpreter". The
heavy objects used in his design make for a terribly
inefficent runtime. His use of collections to implement
array elements is very elegant, but completely impractical
from a performance standpoint.
I like the author's concept of integrated testing, but
he seems to have left out the most important piece of the
testing architecture - a suite of test programs in the
target language.
I would have preferred these changes to the book:
1) a suite of test programs in basic.
2) compiler should save the pseudo-code into a file on
disk. His runtime "nutty professor" interpreter should
read from that pseudo-code file and execute the
program. This helps to separate the tiers.
3) his runtime architecture should have focused more
on efficiency. It's perhaps 100 times slower than any
other BASIC interpreter (maybe 1000 - I didn't
actually time it). And it should be faster than simple
interpreters because this uses a compiler in the
front-end - the runtime interpreter doesn't need to
analyze the syntax so it should be very fast.
4) he should NOT have implemented variants or user-defined
types. These took a lot of thought and effort which should
have been directed on the first 3 items instead.
used to define the syntax of a language: BNF (and extended BNF).
The authors VB6 EBNF-to-doc compiler "compiles" an EBNF
grammer into a documentation file! This is a novel idea
and it helps to show how EBNF relates to the syntax of the
language in question.
Although his presentation of EBNF is masterful, he didn't
use EBNF to generate the parser for his compiler. I expected
him to use a parser generator like ANTLR or coco/R to generate
a scanner and recursive decent parser automatically from
the grammer. Instead, he chose to "roll his own" scanner
and parser.
His scanner seems very good, and his discussion of
the scanner is thorough.
His parser is harder to judge by reading the book since he
kept getting off the main subject and he didn't really
explain the parsing code.
His code generator discussion has some nuggets of wisdom,
but is poorly organized.
One overriding concern with this author is that he
doesn't use terminology consistant with other
authors. He doesn't use common terms like p-code,
intermediate language, virtual machine, or the like.
His non-standard use of the word "assembling" is really
just a step that removes comments from his p-code!
The authors presentation can get off track frequently.
Its hard to find 5 pages in a row that stay on
subject completely. He also likes to quote famous people,
often out of context to the subject at hand.
His runtime interpreter (which some might call a virtual
machine) is called the "Nutty Professor Interpreter". The
heavy objects used in his design make for a terribly
inefficent runtime. His use of collections to implement
array elements is very elegant, but completely impractical
from a performance standpoint.
I like the author's concept of integrated testing, but
he seems to have left out the most important piece of the
testing architecture - a suite of test programs in the
target language.
I would have preferred these changes to the book:
1) a suite of test programs in basic.
2) compiler should save the pseudo-code into a file on
disk. His runtime "nutty professor" interpreter should
read from that pseudo-code file and execute the
program. This helps to separate the tiers.
3) his runtime architecture should have focused more
on efficiency. It's perhaps 100 times slower than any
other BASIC interpreter (maybe 1000 - I didn't
actually time it). And it should be faster than simple
interpreters because this uses a compiler in the
front-end - the runtime interpreter doesn't need to
analyze the syntax so it should be very fast.
4) he should NOT have implemented variants or user-defined
types. These took a lot of thought and effort which should
have been directed on the first 3 items instead.
Were these reviews helpful?
Let us know
Listmania!
Look for similar items by category
- Books > Computing & Internet > Digital Lifestyle > Online Shopping > Amazon
- Books > Computing & Internet > Programming > Compilers
- Books > Computing & Internet > Programming > Languages & Tools
- Books > Computing & Internet > Programming > Languages > C#
- Books > Computing & Internet > Programming > Microsoft Windows > .Net
- Books > Computing & Internet > Software & Graphics
Look for similar items by subject
Feedback
- Would you like to update product info or give feedback on images?
- I am the Author, and I want to comment on my book.
- I am the Publisher, and I want to comment on this book.
|
