Build Your Own .NET Language and Compiler Softcover reprint of the original 1st ed. Edition

by Edward G. Nilges (Author)

17 ratings

ISBN-13: 978-1590591345

ISBN-10: 1590591348

Why is ISBN important?

Have one to sell?

Sell on Amazon

Paperback

$26.69 - $39.58

Other Sellers

from

Other Sellers

See all 6 versions

Used: Very Good | Details

Sold by ThriftBooks-Portland

Access codes and supplements are not guaranteed with used items.

10 used from $26.69

& FREE Shipping

FREE delivery: May 6 - 12

Fastest delivery: April 30 - May 4

In Stock.

Ships from and sold by Amazon.com.

Available at a lower price from other sellers that may not offer free Prime shipping.

List Price: $59.99 Details

Save: $20.41 (34%)

10 new from $31.71

FREE delivery: Wednesday, May 5 Details

Available at a lower price from other sellers that may not offer free Prime shipping.

* Includes a complete QuickBasic compiler with source code. We cannot overstress that this is a huge marketing hook. Virtually every experienced programmer today started out with some version of Basic or QuickBasic and has at some point in their career wondered how it worked. The sheer nostalgia alone will generate sales. The idea of having QuickBasic for them to play with (or let their kids play with) will generate sales.

* One of a kind book – nothing else comes close to this book.

* Demystifies compiler technology for ordinary programmers – this is a subject usually covered by academic books in a manner too advanced for most developers. This book is pitched at a level accessible to all but beginners.

* Teaches skills used in many other types of programming from creation of macro/scripting languages to file parsing.

Customers who viewed this item also viewed

Page 1 of 1 Start overPage 1 of 1

Terence Parr
90
Paperback
$25.09
In Stock.
Michael Scott
57
Paperback
$68.89
Only 2 left in stock - order soon.

Special offers and product promotions

Amazon Business: Make the most of your Amazon Business account with exclusive tools and savings. Login now
Amazon Business : For business-only pricing, quantity discounts and FREE Shipping. Register a free business account

Editorial Reviews

About the Author

strongEdward G. Nilges/strong 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. pIn 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 Mindem"/em) 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. /p pEdward 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./p

Product details

Publisher : Apress; Softcover reprint of the original 1st ed. edition (May 13, 2004)
Language : English
Paperback : 423 pages
ISBN-10 : 1590591348
ISBN-13 : 978-1590591345
Item Weight : 1.71 pounds
Dimensions : 6.94 x 0.93 x 9.26 inches

Best Sellers Rank: #2,319,879 in Books (See Top 100 in Books)
- #184 in Compiler Design
- #586 in Software Programming Compilers
- #710 in C# Programming (Books)

Customer Reviews:
17 ratings

Customer reviews

5 star		35%
4 star		20%
3 star		22%
2 star		14%
1 star		9%

How are ratings calculated?

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Brian Dormer

An even odder duck

Reviewed in the United States on September 2, 2016

Verified Purchase

You can learn concepts in this book that are not really well explained in many other places - which is this books saving grace.

This book is a bit of an odd duck (amongst many programming texts which are themselves odd ducks). The complete source code isn't in the text, or included on a CD - you have to go download it from the publisher (its a free download). Then you can (maybe) run the programs. If you want to recompile everything - you'll be fiddling around with the code quite a bit - Visual Studio 2010 or 2012 won't compile it out of the box. Once you get things working - then you have the descriptions in the book of how it's supposed to work - and the running program to compare to.

The text is full of asides, political rants and alot of non-programming "stuff". It's not as dry as some programming books. But it rambles far too much. The author is obviously intelligent and experienced. He's also opinionated - and perhaps the book would be better of without as many opinions being expressed and more focus on the technical aspects.

The code is, to be kind, grossly inefficient (I've written a few compilers, so I feel justified in this evaluation) While it's fine as a teaching tool - it runs far too slow to be useful in any production environment.

Lastly, there is only a small portion of the ultimate project of the book (a QuickBASIC compiler) that actually deals with compiling to a .NET assembly. Full QuickBasic programs can be run in the authors virtual machine, however, all you can do is have the compiler produce .NET assemblies that perform simple expressions (like 2+5 ) - the .NET compiler is more of an afterthought. This makes the books title somewhat misleading. Still - if you want to see "how it's done", then this is at least a step in the right direction.

Helpful

R. Balsover

Okay for the novice, I guess...

Reviewed in the United States on November 9, 2004

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.

52 people found this helpful

Helpful

William McColl

Four Stars

Reviewed in the United States on April 7, 2015

Verified Purchase

great book

Helpful

Ignacio E. Menendez

Five Stars

Reviewed in the United States on February 24, 2015

Verified Purchase

Excellent, thanks

Helpful

intriguing potential

Reviewed in the United States on June 10, 2004

When Microsoft introduced .NET, one highly touted advantage (implicitly over Java) was that you could write in .NET-aware versions of languages like Visual Basic, C# or Pascal, compile these into .NET binaries and link and run these as one executable. There are all sorts of small details to attend to, but this seems to be the gist.

Well, Nilges has taken this one logical step further. He uses an example of writing a compiler in VB.NET. This is striking for two reasons. Firstly, quite aside from .NET, most people who might write a compiler would surely not choose VB, but instead a higher level language like C.

But the second example is more important. As he makes clear, you can generalise the book's example into writing a compiler for a new language that you have invented. Of course, the amount of effort needed for your compiler may be far greater than his example.

Step back a moment and consider what Nilges has given you. He shows that .NET can be used as a test bed for experimenting with languages. A level beyond most programmers, who write in languages, not write them. Also, by making your compiler in .NET, you get a chance to integrate your language's programs with those of the existing mainstream languages supported by .NET.

The promise is there. Though a harder question is how big the potential audience is for this book. He wrote his example in VB instead of C# to maximise this. But ultimately, it may only be researchers in computer science. A select but small bunch.

One person found this helpful

Helpful