<< 1 >>
Rating: 
Summary: The value of most critics can not be calculated
Review: As I read this book I had to wonder what planet the people that trashed it were from. I couldn't speak better of it and I think the author did a FANTASTIC job of making it entertaining and informative. It's very direct and to the point and I didn't get left hanging on one area. The code works the way he says it does and it's plenty to work with. Oh gee, it's not an 1200 page textbook covering every dark nuance of compiler theory. Somehow I figured that out before I openened it up. Hell I think the footnotes and quotes alone justify the price of the book. Everyone is entitled to their opinion but I think the people trashing it are either nuts or have some ax to grind in general. I have yet to come across an APress title on .NET that wasn't at a minimum a 3 and everyone I can think of off of the top of my head is a 4 or 5 (weighted heavily to 5). If you want a fun, interesting and just all around cool book to help you start in the world of writing your own .NET Compiler - this book is it.
Rating: 
Summary: waste of paper and $$$
Review: I have to agree with the "waste of time" review below. This book reads like a C-student's CS notes on compiler technology. Having created compilers for other platforms, I hoped that this book would shed some light on compiling to MSIL. Unfortunately, coverage on this and other key topics is quite sparse. In the book, the author refers to Aho, Sethi and Ullman's classic - "Compilers: Principles, Techniques and Tools" (The "dragon book"). Especially if you're new to compilers, do yourself a favor - forget this second-rate knockoff and get the real thing. Shame on APress's editors and reviewers for letting this one out the door. Shame on me for per-ordering this mess.
Rating: 
Summary: Okay for the novice, I guess...
Review: 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.
Rating:
Summary: Major disappointment
Review: I really thought this book was going to help me learn more about the subject, but it's really a fairly transparent attempt by the author to make a quick buck or two off of the .NET mania. The writing is painful, to say the least, with a heavy dose of hand-waving thrown in. A lot of claims about proper compiler development which are not followed up in the so-called compiler he developed. It doesn't actually generate proper .NET code, so the whole thing is a fraud, and should be recalled. Don't waste your money on this thing, it should be recalled. Apress used to have a reputation for doing better than this charlatan.
Rating:
Summary: To the One Star Reviewers of this Book, and Potential Buyers
Review: It appears to me that these reviewers did not read the book or download and work with the code. I'd like to add my voice to other reviewers who have wondered what planet these people are from.
Nilges provided 26000 lines of code which is far more code, of higher quality than most programming books. Furthermore, the code works as he describes in the book, presenting a consistent and attractive GUI. The book is simply written and an excellent way to get started on a difficult topic.
Rating:
Summary: Just what I needed
Review: Looking at all the reviews, I felt that I definitely had to add my own two-cents.
When I read the first couple chapters of this book, I was a bit underwhelmed. I read through the compiler flyover and thought, "well, that is cool, building a calculator." I then went to the next step and actually took the code that he included and began to write my own C# port of the integer calculator. At this point, I really started to get the gist of what was great about this book: the code isn't there to support the book, instead the book is there to support the code. So many books that I read have contrived examples in the code to supplement the words. With this book, you should start with the code and use the book as a reference to understand what the code is doing.
I'm actually working on a voice-enabled home automation project on my (ever-so-geeky) spare time, and this book had EXACTLY what I needed at EXACTLY the level that I needed it to further my project. Sure, it isn't a graduate-level book on compiler theory, but I don't think that is what it is meant for. On the other hand, this book doesn't pander to the reader by re-explaining what an if-statement is.
The world needs more intermediate/advanced-level books on .Net techniques, and I've found that APress is the major source for this level of books.
Additionally, I started writing about my experiences with this book on my blog, and Edward showed up and has been actively commenting on my ideas, lending his expertise to my learning. After looking around a bit, I've noticed that he is doing this regularly on people's blogs. That, in itself, is impressive to me, and I'm thankful that he has been willing to be part of the community.
Rating: 
Summary: Excellent
Review: Mr. Nilges presents the subject matter in a clearly understandable text. This book lays the foundation for a .NET compiler design. He clearly has a strong understanding of the subject matter.
Rating:
Summary: Intriguing potential?!
Review: 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.
<< 1 >>
| 
