Buy New

Sign in to turn on 1-Click ordering.
Buy Used
Used - Very Good See details
Price: 14.09

More Buying Choices
Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Image not available

Tell the Publisher!
Id like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Build Your Own .Net Language and Compiler (Expert's Voice) [Paperback]

Edward G. Nilges
1.0 out of 5 stars  See all reviews (1 customer review)
RRP: 39.49
Price: 21.80 & FREE Delivery in the UK. Details
You Save: 17.69 (45%)
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
In stock.
Dispatched from and sold by Amazon. Gift-wrap available.
Want it tomorrow, 1 Sept.? Choose Express delivery at checkout. Details

Book Description

13 May 2004 1590591348 978-1590591345
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.

Customers Who Viewed This Item Also Viewed

Product details

  • Paperback: 412 pages
  • Publisher: Springer (13 May 2004)
  • Language: English
  • ISBN-10: 1590591348
  • ISBN-13: 978-1590591345
  • Product Dimensions: 2.2 x 17.3 x 23.1 cm
  • Average Customer Review: 1.0 out of 5 stars  See all reviews (1 customer review)
  • Amazon Bestsellers Rank: 1,659,244 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Author

Discover books, learn about writers, and more.

Product Description

About the Author

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, Edward 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, he 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 VB6 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, Edward used his beta copy of VB .NET to write the fully object-oriented quickBasicEngine.

Edward 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)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

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

Customer Reviews

5 star
4 star
3 star
2 star
1.0 out of 5 stars
1.0 out of 5 stars
Most Helpful Customer Reviews
4 of 4 people found the following review helpful
1.0 out of 5 stars This book is a shameless rip-off 31 Aug 2011
By Mikael
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 [...] or something like that. It should never have been a book that people can buy because it is not worth it!
Was this review helpful to you?
Most Helpful Customer Reviews on (beta) 2.8 out of 5 stars  17 reviews
69 of 71 people found the following review helpful
1.0 out of 5 stars Waste of time 21 May 2004
By A Customer - Published on
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.
49 of 53 people found the following review helpful
2.0 out of 5 stars Okay for the novice, I guess... 9 Nov 2004
By R. Balsover - Published on
Format:Paperback|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.
31 of 34 people found the following review helpful
3.0 out of 5 stars Great BNF coverage; but gets off subject too often 4 July 2005
By Eric W. Engler - Published on
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.
24 of 28 people found the following review helpful
2.0 out of 5 stars Mediocre Book 11 April 2005
By M. Cleary - Published on
This is a mediocre book. I probably would have given it 2.5 stars if it was allowed, but it definitely isn't worth 3.

The issues I have with the book are:

1) It just isn't very good. If you want to develop a compiler/programming language, get: Lex and Yacc (Levine, Mason, Brown), Compiler Construction: Principles and Practice (Louden), and Programming Language Pragmatics (Scott). All of them are excellent books.

2) I'm not sure what to make of the author's incessant injections of political diatribes into the book. He tries to hide it by couching it in sidebars and philosophical quotes but it really sticks out like a sore thumb. There's the quip about Nixon invading Cambodia, the quote from Carl Marx, and then the passage accusing (Dilbert creator) Scott Adams of having "mocked offshore and immigrant developers" and of "essentially exploit[ing] the ordinary working folks he left behind." Is this supposed to be a political book or a book about writing compilers?

3) The writing style is a bit longwinded. For example, take a look at the review he wrote for his own book. Admittedly, the book isn't nearly as unfocused as his rambling review, but it could've been more concise. Luckily, in the book he keeps much of his rambling contained in the footnotes.
16 of 18 people found the following review helpful
1.0 out of 5 stars Incredible it passed a technical review 25 Aug 2009
By Joaquin Jares - Published on
I hate to give any book a 1 star rating, as it's obvious that the author put a lot of work in this book. But I have to. This book is so full of technical errors and false assumptions I don't understand how it passed a technical review (and Lead Editor was Dan Appleman, so I assumed it would be good). I read this book on my commute to work and I have set up an almost daily mail for my colleagues where I tell them what I read and we all make fun of it. But sometimes it's downright depressing. I don't care if the guy has continuity problems with his writing that make him go to completely unrelated political and historical events (and he does that a lot), but the antipatterns he uses (using a collection instead of an object because "it is unnecesary to go crazy and develop a full-dress object for each and every potential object", the IsUsable pattern where he inspects objects on dispose to see if their status is consistent instead of proper testing, which "creates logistical problems in that it doubles the count of overall projects", thinking that AndAlso is something that exists at IL level, stating that declaring variables inside of a For loop has some sort of performance penalty, a naming convention where "all members that are called exclusively by a higher procedure (...) are prefixed by the name of the caller" and many, many more). I'm still not very deep in his compiler practices. What I have seen so far I didn't like, but I don't know if I'm a very good judge of that (and that's why I'm reading these books). Based on his misconceptions on much about anything else, I'm not giving him a lot of credit. Buy Gough's book. It's still the best around.
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
First post:
Prompts for sign-in

Search Customer Discussions
Search all Amazon discussions

Look for similar items by category