5 comments about Programming SQL Server 2005.

1. As a new student to the field of SQL Server 2005, I was hoping to obtain a book learning the various methods of programming in SQL Server 2005. I was initially hearted by the first paragraph in the preface:
   
   "You don't need to be an experienced SQL Server 2005 programmer to use this book..."
   
   which is indeed the case if you intend to use it as a paper weight.
   
   The book suspiciously looks like the syntax guide found in most MS products: the procedure name and inputs followed by a description of the inputs. It is not for the beginner/intermediate learner and is somewhat of a disappointment comming from the O'Reilly range ("SQL on SQL Server 2005" is an excellent counter point to the book being reviewed from the same publisher). This book serves mainly as a reference (which on page 7, it clearly states that it is not a reference) to new doctrine in the SQL Server evolution.



2. This is definitely one of my best SQL programming books. It covers the newer programming concepts; such as XML storage and handling in SQL 2005, very well.
   
   I would definitely recommend this book to anyone who is serious about SQL Server 2005 programming.
   
   It also covers CLR programming in SQL Server. Good book.



3. User does not have to be experience SQL Server 2005 programmer to use this book; as it is designed for users of all levels. This book also suggests that user does not have to be experienced with SQL Server 2000. However, I disagree with that. This book only covers new features of SQL Server 2005. Understanding of fundamental relational database concepts is helpful to digest and accept the concepts introduced in this book.
   
   This book covers following perspective of SQL Server 2005 new features.
   * Tools and utilities
   * Data types
   * T-SQL enhancements
   * Programmability enhancements
   * XML support
   * Native XML web services
   * SQL Management Objects
   * SQL Server Integration Services
   * SQL Server Reporting Services
   * SQL Server Notification Services
   * SQL Server Service Broker
   * Replication Management Objects
   * SQL Server Agent
   * SQL Server Mobile Edition
   
   The code used in the book is available for download on O'Reilly web site. I always like this as I really do not like to retype examples from the book. Most of the examples of this book use C# code and Visual Studio 2005. One good thing about this book is it uses AdventureWorks sample database, I always prefer book which uses samples database which comes along the SQL Server, this makes it easily useable by developer. This book is also Safari enabled.
   
   Appendix of this book has in depth explanation of the ADO.NET 2.0, which can be quite useful to users interested in the topic. There are very few good books which covers this topic such in depth.
   
   Rating: 4 stars
   
   Summary: This book is quite good for new learning; I enjoy reading it and learning new concepts from this book.
   
   Pinal Dave
   Principal Database Administrator
   (blog.sqlauthority.com)



4. This book is very inaccessible, not because it is too complex, but because it is poorly written. If you'd like to actually learn SQL Server programming I'd recommend Professional SQL Server 2005 Programming (Programmer to Programmer).



5. This book covers nearly all topics on SQL Server programming. It begins with the differences between the SQL Server 2000 and 2005. 2005 has new tools (SSMS, Profiler, BIDS, command line), data types, xml support, and .NET integration. Chapters 1-4 go over these topics in turn. The next series shows the reader how to program using the Visual Studio IDE, deal with XML programming, and web services (Chaptes 5-8). Chapters 9-14 are on programming SQL Server management and reporting tools plus interfacing with the objects exposed by SQL Server through .NET. The remaining chapters are on programming services: SS agent, intergrations services, broker, notification services, and analysis services.
   
   The book is quite thourough and has a large number of examples, code, and pictures for each topic. The book is generally easy to read and well indexed. Programmers will feel right at home with all the extra help provided by the book.
   
   Folks who have no programming experience of any kind will likely struggle with the information in the book. Basic SQL is shown but not explained. It is clear the book is meant for people programming and/or automating SQL Server topics rather than just running basic queries. That being said, the chapter on XML was very helpful even from just a querying point of view. Using XML as a bulk load technique was particuarly useful and turned out to be very fast when loading text based data to the server. Querying XML data was covered by using both FOR XML statements and using XQuery type statements. The chapter sovering SSIS was also very useful as there is not much material on SSIS yet.
   
   This book is a must have for SQL Server DBAs, programmers, and professionals.

5 comments about Java Development with Ant.

1. Ant to me was just a build script, nothing more or less. I got curious about what you can do with ant and figured, how could you make a full book with this topic. I am floored with all the aspects of this tool. How easy it is to make a build, deploy it to any number of servers, then test to make sure your install is complete. And that is still a small portion of what is possible with ant. If you are an experienced java developer looking for an easy way to automate your daily routine this is the book and topic for you.



2. Best of genre - don't waste your money on that junk by A.T. Bell - buy this instead.



3. Ant is a great tool that lets you pretty much automate any process- whether Java build-related or not. This book is then THE one-and-only book to buy - it serves as a tutorial AND a reference. The author's breadth of knowledge on Ant is amazing and the examples he presents are wonderful.
   
   The key areas I found the book very helpful on were
   1) JUnit integration & report creation (using XDoclet /JUnitReport)
   2) Deployment-related activities
   3) Breaking out commonly used Ant targets for reuse
   
   But there is so much more - my edition has been well thumbed
   and has many yellow post-it notes for quick lookup.
   
   Based on what I've learned in this book I've been able to quickly and easily integrate the following components into my build process
   1) Checkstyle (syntax checker)
   2) PMD ("bad practice" checker)
   3) JUnit & Clover (code coverage)
   4) JDepend (Class interdependcy reporting)
   5) Javadoc
   6) An automated nightly build of the code and deployment to WebSphere
   
   I can't say enough about this book - but I would be lost without it and thus am loathe to lend it. If you use Ant or WANT to use Ant then buy this book.



4. Sorry for the short review...
   
   I was completely new to Ant before buying this book, now I feel like an expert. It's a very well structured book. If you want to know what Ant is all about, just read the first part of the book. If you want to know how to do some more advanced stuff, this book covers it all.
   
   I'm going to now be using Ant as my deployment tool in development and production, dealing with static content, CVS, Struts, and more.



5. I read the first 4 chapters of this book to get a basic understanding of Ant. Since my employer already uses Ant, the skills that I need is to understand an Ant build file and how to modify it to satisfy new requirements. Using this book as my only Ant's reference, I could find a solution for any requirement that I was asked to implement. Maybe it's not the best solution, but it works.

5 comments about Agile Development with ICONIX Process: People, Process, and Pragmatism.

1. I was totally shocked at how horrible the "Refactored" book was written. That book was loaded with unsubstaintiated anecdotal claims written by anonymous "informants?" versus actual and highly selective quotes from XP practitioners lifted from usenet postings with misspellings included that struck me as character assassination. It was opinion disguised as analysis and pseudo-scolarship.
   
   This book seems a bit more measured. It seems like the authors finally embrace the core tenets of Agility but they are still (I think unfairly) knocking some of the things that XP in particular touts, based on some strange assumptions. One assumption that runs through the Iconix folks writings is that robustness and responsiveness are opposing forces. They are not, or at least need not be. I know this becuase I've seen a highly robust and highly responsive XP team at work. The root of this thinking is in the belief that developing software is like any manufacturing endeavor, where quality and cost are also trade offs. Oddly, with Agility in general (and XP in particular), increasing the quality actually is shown to reduce cost. Also, I know this because I've seen this. And XP doesn't mean that there are no documents and no diagrams. It just means that they aren't as valuable as executing code. I still can hardly recognize the thinly-disguised invective of the last book as coming from the same authors as this book. I would say the authors have grown up a bit.
   
   I think the Iconix people's departure with XP originates in Pair Programming. My in-the-trenches experience with pairing is that if you've never really done it, ie, given it a real chance not killed the baby with preconceived notions, you won't ever get it. Most anti-XP people are simply against pairing because they don't understand how it actually works in practice.
   
   One example of how pairing works is to hear my friend tell what it was like to program PROM / PAL code as an embedded-systems programmer way back. They ALWAYS pair programmed because you can't afford to screw up a couple of PROMs a day, that would be blowing $400 or so. The same holds true today with an IT developer coding off a cliff alone on his workstation, blowing several hundreds or even thousands of bucks a day because nobody is reviewing his code BEFORE he checks it in.



2. About two years ago, I reviewed Doug's books and contacted him to help me on a new software development effort I was directing. I had low expectations because my team was just learning professional software methods period. Doug came in and taught the five main diagraming techniques, including robustness diagrams. After the class, he pitched-in to help with documenting all of our use-cases and thoroughly disambiguating our problem domain. This was the most successfull software project in the history of the company. As a direct result of Doug's methodology and consulting, we delivered a reliable and re-usable core product line. Because of this, we have been able to consistently deliver great software based on the original core time-after-time.



3. I'm a big fan of Doug's methodology and books, so I'm biased. I'm a fan because I know his process works... I've used it in a number of medical device projects. In the area of safety critical or mission critical systems, you can't throw out requirments and process; it isn't an option. I would argue that it is also not smart.
   
   This book does a great job of explaining how to achieve the core ideals of agile without sacrificing the up-front work (requirements and modeling) that are necessary to achieve a high quality system within a reasonable schedule and cost. I love the fact that the book harkens back to core software engineering principles and shows how this process enforces those principles while encouraging just the right amount of agility to react in a timely manner to mid-course corrections that every project (accept the very small) experience.
   
   The book demonstrates an important aspect that I have used in my own projects; the core process is robust to the needs of different projects. For example, adding a release plan for scheduling the implementation of individual or groups of use-cases or expanding use-cases using interaction design. Extensibility is the mark of a solid, well thought-out core design; whether it be a process or software.
   
   The approach was very balanced in light of the fact that Doug and Matt have been some of the most vocal detractors of the Agile/XP neuvo processes. It takes someone from outside the religion to bring balance; they have done that with this book. Their "sweet spot" is within reach!
   
   Best!



4. First beware that books with almost the same titles have been written by the same author and some of his fellows between 1999 and 2007:
   
   1999: "Use Case Driven Object Modeling with UML: A Practical Approach": This is the "reference" book although it seems ICONIX has evolved since if we consider later books and various articles online. I am considering acquiring this one after disapointments about "Agile Development with ICONIX Process."
   
   2001: "Applying Use Case Driven Object Modeling with UML : An Annotated e-Commerce Example": This seems to have been written to illustrate the first book with a web example.
   
   2005: "Agile Development with ICONIX Process, People, Process and Pragmatism": This is the book we are talking about here. I bought it because of its relative recentness and was quite disapointed: a bigger part of the book is dedicated to defend the ICONIX process on one hand (this is what many other comments denounce about the 1999 book), and to explore new extensions that obviously have not yet stabilized.
   
   2006 and 2007: Two new books published only a few monthes apart, from two different editors, and especially with almost identical titles: "Use Case Driven Object Modeling with UML - ICONIX Process in Theory and Practice" (Addison-Wesley, jun. 2006) and "Use Case Driven Object Modeling with UML - Theory and Practice", (Apress, jan. 2007). The first is unavailable at this time on Amazon and is very expensive ($160). Given the titles, these two new (and identical ?) books might be a rewrite of the 1999 reference.
   
   What I liked in the book:
   
   1. The process is explained quite clearly
   
   2. Whether you adhere to ICONIX or not (I do), the messages it carries is worth it: use a small and consistent subset of UML and the rest when only needed. It also helps to understand the "why's" of diffrent diagrams, that are not necessarily well explained by quality books such as UML Distilled.
   
   3. For those who did some reading beforehand, the book shows what have been the minor evolutions (and the presistent doubts) in the process compared to what Rosenberg and Scott wrote online around 2001 (DrDobb's and InformIT.
   
   2. An example is given (web), with som code, stressing the explorations around the robustness diagrams.
   
   What I disliked about the book (this the three stars):
   
   1. It is not a reference book :a) Robustness diagram rules aren't even exposed/reminded. b) Almost nothing is said about the milestones leaving (thus the need to consider buying the other books)
   
   2. It is to some extent a too much propaganda book: The book is divided in three parts and only one is about the core process. The first part is ICONIX propaganda and the third part is about forrays into new [and probably immature] extensions.
   
   3. There is a persistent ambiguity about whether use case text should be written as they are identified (before requirements review) or should these be left for the Analysis & Preliminary design phase (and checked at the preliminary design review).
   
   
   Conclusion: If you'd consider buying a book about the ICONIX process, I'd advise you to buy the 1999 book or one of the two new ones. They most probably would contain precise guidelines on how the method works than this 2005 volume. You should buy this book only as a second read for 1999 or as complement for 2006 or 2007 if needed.



5. This Text is a very well targeted book for the novice as well as a reference for experts in agile software development. This book when combined with "Use Case Driven Object Modeling with UML: Theory and Practice" creates an excellent package if both documents can be obtained for use simultaneously.

4 comments about Microsoft Visual C# .NET Programming: From Problem Analysis to Program Design.

1. Here's why you should avoid this book:
   
   1) This book fails to provide clear, step-by-step instructions on how to create the different applications.
   
   * A perfect example of this can be seen (starting with) Chapter 8 -- the programming Windows Apps section. The author shows a picture of an application that you [the reader] will be creating. After showing you the picture, she [the author] then describes a few of the features that the program will have. When finished with that, she then lets you know that you should be done writting your program and that you should be all done with it. Remember, this is all done without any guidance or help from the author. NOT THE WAY TO TEACH PROGRAMMING!!
   
   2) This book is NOT worth $75 dollars.
   
   * The first seven chapters are strictly dedicated to teaching one how to create old MS-DOS applications.
   
   * Only two chapters talk about the *basics* of creating MS Windows applications. (Remember, no instructions provided on how to create them here.)
   
   3) The teaching style seems to somewhat change throughout the book.
   
   * For example, in the beginning of the book, the author assumes that you are using MS Visual Studio to create your software applications. Later on, in the horrible Windows Development App section, the author somehow forgets this fact and then provides code samples that one needs to type in when using their favorite, *NON*-VISUAL STUDIO code editors.
   
   Normally, I like to give books a good review. However, this is one that I honestly cannot give more than one star. If zero stars were possible, it would deserve it.



2. If you are looking for a textbook for a beginning class in C# where you do not expect the students to write large programs, then this one will satisfy your needs. Nearly all of the programs are very simple, very little more than a page of text. All of the fundamental concepts such as variables, arithmetic, comparison and logical operators; control constructs such as if-then, switch and the different types of loops. The basics of Windows form programming with the standard GUI control objects and event handling are also introduced. Object-oriented concepts such as encapsulation, inheritance and overloading are covered, with a chapter devoted to exceptions and another that introduces web pages and ASP.NET.
   The problem I have with the book is that nothing is covered in depth. Even the programming exercises tend to be rather light and are often vaguely written. For example, at the end of chapter 11 (page 688), "Handling Exceptions and Stored Data", the following programming exercises are given.
   
   4. Write a program that stores your name, address and local phone number in a text file. Surround your phone number with asterisks. Include appropriate exception-handling techniques in your solution.
   
   5. Place the following values in a text file: 86, 97, 144, 26. To simplify the problem, the values can each be placed on separate lines. Write a C# program to retrieve the values from the text file and print the average of the values formatted with two decimal places.
   
   In both problems, there is no mention of whether a console or form based application is to be created. In problem number 4, there is no context to the exception-handling techniques that are to be used. My assumption was that it should be a form-based application with labeled input boxes. The exception handling would then be to verify that the inputs have the appropriate structure. The level of difficulty of both problems is also much less than I would expect of a programming student near the end of the class.
   If you are an experienced programmer and interested in a quick, effective overview of the C# language for self-study, then this book is a good choice. For everyone else, I consider the coverage too light to be worth using.



3. This book was the prescribed textbook for the programming subject which I completed this year. C# is my first programming language, so I will be reviewing this book from the perspective of someone who does not know any programming languages.
   
   I believe it was an excellent introduction to writing code. I have taken out many other books on C# which were nowhere near as a helpful as Doyle's book. The book does a really good job explaining how the language works and how code can be structured. It tended to go a little bit deeper with its explanations than many books, thus fostering a deeper understanding of how everything fits together. However, it does not go so deep as to completely baffle or confuse the beginner.
   
   Another really good aspect of this book is that, at the end of nearly every chapter, a case study is presented and worked through. I found these case studies invaluable in that they demonstrated how a programmer should break down and analyse a problem and how to work through the problem, right through to writing the code. This is so much more helpful than the isolated code snippets that most text books run through. What good is knowing how to write a "for" loop if you have no idea how it can be applied in a real application? i.e. how it can be used as a tool to achieve a desired functionality.
   
   This book is not so good if your focus will be on learning about graphical applications. It does provide a pretty good introduction into the visual stuff, but that's all it really is (a cursory introduction).
   
   Having said that, I believe that people learning how to write code should not even be contemplating GUI applications until they have a good, solid understanding of types and object oriented programming. It is that which this book will provide.



4. What a mess. I cannot express how disappointed I was in this book.
   
   Firstly the book is oversimplifies concepts to the point where the author actually starts to become inaccurate about the precise nature of certain constructs and processes.
   
   Secondly the book is out of touch with more modern design and development methods such as agile development techniques, test based coding etc. It also fails to deliver on its title with almost no detail on problem analysis and no real world practical program design.
   
   Shame on colleges that use this book in their curriculum, this book has almost no application to real world application development

5 comments about Pro ASP.NET 2.0 in VB 2005 (Expert's Voice in .Net).

1. I was looking for a solid, comprehensive, yet approachable ASP.NET 2.0 book for a long time when I stumbled across Pro ASP.NET 2.0. I flipped through it and quickly realized that it is both the learning and reference tool I was wanting. Since getting the book, I have not swayed from that position. This book is a great way to get started and to keep going in your ASP.NET development efforts.
   
   Although large (it weighs in at over 1200 pages), it is well organized and easily accessible. The material builds on itself in such a way that you don't need to read the first 900 pages to effectively use the later chapters. Additionally, the content is organized in a practical approach so you can get started relatively quickly. I find this technique helpful in that it I have more information when it comes time to answer specific questions. I never found myself "wishing" I know more in order to understand a concept.
   
   On the down-side, there are some glaring typographical errors throughout the text. It is pretty obvious in some places that there is a copy/paste error from the C# version to the VB version. None of the errata detracts from the book for me. In fact, in some cases, the little research I did to clarify something actually helped.
   
   All told, I have and continue to highly recommend this book to colleagues and clients alike. It is both an excellent learning tool and a great reference. The fact that one person wrote the entire text and in two programming languages amazes me. The author has an easy writing style that promotes absorbing the information quickly. I anticipate this book becoming tattered quite quickly!



2. I am very pleased with this book. After a couple of failed attempts to find a good ASP.NET 2.0 book I finally found this book. They really did a great job at covering a vast quantity of topics with enough substance that one can actually understand and apply to real life programming situations.
   
   There are some typographical errors and very few examples that don't work but in sight of the great volume of information and examples given, I'd say it is acceptable.
   
   I think I hit a jackpot with this book and I am looking for other books by the same authors that cover more specific topics and I doubt I'll be disappointed.



3. Although this book is only an introduction, the structure and depth are more than fine. After all, to discuss every single thing ASP.NET 2.0 has to offer would require several volume of HUGE books. I would suggest this book to anyone wants to learn ASP.NET 2.0, even with background other than VB.
   
   To the authors, you did a great job!!!



4. I have bought several other books on 2.0 and wish I had discoverd this one first. In each of the different categories, this book is written in order and style to learn and use as a reference. For me, a person with vb6 and asp classic experience this one hit the nail on the head.



5. I am reading this book now for some time. I have worked through the first 5 chapters and I am now in middle of the sixth. The content might be pretty accurate and maybe even comprehensive but there are 4 MAJOR problems which overshadow anything else. They are what I wrote in the title:
   
   A) MISSING: The author almost never starts by stating "add a new class and name it whatever" or "add three textboxes and one label". just throws you something like "heres the complete code" now from the snapshot i am able to figure out how he named the webform, which controls did he add how he named those controls etc. the source code on the Apress site is a must, cuz otherwise you'll be guessing you're head off on every page. Every 2 minutes I'm asking myself:
   should i add a module now? no? maybe soon?
   is this a new namespace?
   do i add that to the previous web form? or is it a replacement?
   is that a table, or div tags?
   other than that he also usually forgets to tell you when a namespace needs to be "imports"ed. probably to leave a challenge to the user why the editor is underlining all the object types.
   
   B) INCONSISTENT: most snippets of code that are more than a few lines will always have some naming conflicts. in line 1 the button is name cmdSave in line 10 it might be cmdSubmit. I mean this didn't happen once or twice it is a constant problem. As i type, i'm indebted to the VB editor in VWD for cathing these booboos.
   
   C) OVERDONE: this might not be a real problem. but as i am not yet such a seasoned ASP.NET 2.0 developer, i find reading pages upon pages of Http pipelines, ASP.NET providers, multiple comparison charts of State management options and custom tracing capabilities before even teaching how to put up a simple data-driven website with simple user and group options, extremely overdone and over comprehensive. if the author wanted to show how much he knows about asp.net 2.0 he could have done so in the preface.
   
   D) THEORETICAL: Everything taught is immediately followed by some code snippet which you could try and figure out where to plug it in and see if it works. he never (so far) builds upon something already done. I am now in the sixth chapter and have a mumble-jumble of techniques to accomplish a variety of odd and end functionality. I haven't the slightest idea of how to build a real world site.
   
   Again, I'm in the sixth chapter only. I'm still hoping to find some useful information in the remaining ones. Just felt I should let people know about it to save them from aggravation.

No comments about Domino 7 Lotus Notes Application Development.

No comments about Using C++: An Introduction to Programming, Second Edition.

5 comments about Essentials of Systems Analysis and Design, Second Edition.

1. I was forced to use this book for a class. I find the text very unclear and hard to understand with quite a few errors. The layout of the pages is poor and the author seems to get lost in his/her own words. The problems found at the end of each chapter never give enough information to tell you what you are supposed to be doing and they often ask for information that is not found in the text. For what you get this book is extremely overpriced. I may even sell this book back.



2. I purchased this text for a college course,that I was required to take. Simply put this is one of the worst textbooks I have ever seen. The author does not clearly explain the concepts in the book, he uses the most vauge definitions I've ever seen. I reccomend to any students taking a course with this book,appeal to the proffeser to get a diffrent text, and to any proffesors considering using it for their course, please reconsider.



3. This textbook is incomplete, inaccurate, and invalid as a tool for teaching students about current System Analysis and Design concepts. Beg your instructor to choose a different textbook.



4. The other reviews of this text amaze me! Yes there are some errors, and some of the end-of-chapter exercises do require a little thought - that is probably why one reviewer couldn't answer them. It is a short concise, very straightfoward to use text, I use support material for the lectures and my own materials for the tutorials, but this book is very good at highlighting the key points. It is up to your lecturer to make it more interesting I'm afraid. Overall I think this is a very good Systems Analysis text for 1st year MIS students.



5. This book is atrocious in its implementation of its text AND of its review questions at the end of the chapter. Many times there will be questions asked which no way of being answered given what is presented in the text. This book was a requirement for a college, otherwise it is useless as a learning tool.

5 comments about Building Web Services with Java: Making Sense of XML, SOAP, WSDL, and UDDI (2nd Edition) (Developer's Library).

1. I am still wondering why the authors don't provide all the code, since the book describes an application and that should have been tested and the code is there. Just a few wsdl files don't help very much.



2. The writers either do not understand the topics, or they want to confuse the readers intentionally. You will find their writing style extremly annoying. They use the Skatestown(??) example to mislead the readers whenever they need to explain something. I dont know how such a bad written book can make it out to the book stores. If you buy this book, it will be the biggest waste of money.



3. This book has helped me immensely in implementing some really intense production quality data interchange across systems using web services.
   
   This book will quickly help you understand the entire XML stack of technologies that you will need for Web Services.
   
   The authors have uniquely enabled the readers to develop an understanding of the underlying technologies that make up the web services. Certainly expect to put in some effort in understanding the content.



4. The problem with Learning Web Services is just one - there is too much happening..the technology has grappled everyone's attention and a lot of Organizations are on it..
   A beginner to web services just doesn't know where to look..strong foundations give 'empire estates', this book does just that
   The primer on XML was one of the best i ever read anywhere and i am a big fan of Dr.Google, the clarity of the authors on WSDL Element model is very informative. All in all - if you need a book to trace Web Service concepts and build your foundations - i would strongly refer this book.
   
   If you are looking for a quick reference/book to get started in implementation you should look elsewhere..Sam's 'Teach Yourself Web Services in 24 Hours' is a good choice..but then i believe that this book is definitely worth a reference because it goes a distance conceptually.
   Kudos to the authors



5. Without a doubt one of the worst computer books I have ever bought. The intent of buying a book about programming is to actually learn programming. I have fought the XML section until I have a screaming headache with very little accomplished. So far I have found it impossible to get the so-called examples to run. The source code is not available from the publisher in spite of what others may tell you. Yes, there is a file to be downloaded. However, it has almost none of the source code in it. For example, it only contains the source code for one .jsp file for the entire 2nd chapter. The writing style is practically incomprehensible, jumping around all over the place without ever finishing anything. There are nine authors listed on the cover. Perhaps that is why this book is such a clusterf#@k. How did this thing get to a 2nd printing? STAY AWAY FROM THIS BOOK. I cannot stress that enough.

5 comments about Advanced Compiler Design and Implementation.

1. Ok, let's be fair. This book provides a broad coverage of useful optimizations and it will be useful in case you work writing compilers AND have some experience.
   
   However, for learning the concepts, it is a very bad material. At the end you end up confused under a pile of thousands of lines of pseudocode in a weird notation (invented by the author) called "I CAN" (yes you can write a very bad book Mr. Muchnick) instead of reading useful explanations of the topics. The author also assumes that you already know some concepts and that's why he does not explain them as he should. If you want to really understand this book, first review Chapter 10 of the Dragon Book. I thought that the Dragon book was not so good because you have to re read some things in order to fully understand, but with Muchnick's book that is not always possible.
   
   You can also take a look at Morgan's book (unfortunately, out of print) or just read the papers (as the first reviewer suggested). This book is not enough, and sadly, a lot of "teachers" think of it as a kind of "bible" and as a very bad excuse to teach very poorly. Some of them even don't master all the concepts presented there and have to use other books (their "dirty little secret") but they don't tell you which ones and continue praising this bad piece of work. If you are a CS student who really wants to learn, be warned that this book is not for you (it has at least three erratas and still has errors!)



2. I've seen chapter 14 of this book referenced (by a university professor giving suggestion to his students, not by a random guy) as:
   
   "Another conventional approach to strength reduction. 35 pages of the same kind of confusing crap we've all come to expect from this book."
   
   This could not sum it up better. A confusing book at best, presenting basic material so as to make it look "advanced", and without any covering of even relatively new techniques. A good source of references to papers that you should read, but not at all a valid reference on its own.



3. Compiler development is more of a craft than a science, although there's plenty of science involved. It involves huge numbers of tradeoffs in features, optimizations, and use of the underlying processor. But, as long as people keep coming up with new computing platforms (and not just instruction set processors), new languages, and new performance demands there will always be need for new compiler developers. If you can't apprentice yourself to masters of the craft, or even if you can, this book is a great introduction 2000-era compiler development.
   
   Muchnik does a clear, thorough job of laying out the basics, starting with the intermediate representation used. (If you get that wrong, nothing else is going to work.) He then moves on to the basics of symbol table structure - an issue that can get immensely complicated in systems like Microsoft's CLR. He also discusses run time support briefly. Although that discussion is good as far as it goes, it skips past a lot of the complexities of dynamic loading, debug symbol tables, simulation support, and related issues. They aren't strictly part of the compiled, executable code, but responsibilities of the compiler developer nonetheless. Next comes a brief description of code generation, crucial in normal environments but tangential to my own needs.
   
   That's just the first quarter of the book, though. The rest is the real meat of the topic: code analysis and optimization techniques, over 600 pages of discussion. It's way too much to summarize here, but even that just an introduction to a huge technology. Still, you have to start somewhere.
   
   By this point, you may be asking "But what about tokens, lexemes, and grammars? Isn't that what compilers do?" Well, yes, but it's done. Tool developers have made lexical analysis a commodity. The easily automated tasks are not where modern compiler distinguishes itself. This book addresses the semantic levels, getting the reader into the shallow end of the industry's huge pool of specialized compilation knowledge.
   
   If you have to self-teach compiler development - good luck. Start here, though, and luck will have a lot less to do with the outcome.
   
   //wiredweird



4. It's the bible of compiler data-flow analysis. The author had the experience of building an industrial strength compiler. One tip: skip books authored by those who haven't implemented an industrial strength compiler by themself.



5. This is a very good intermediate/advanced text for codegen & optimization.
   
   Having spent nearly 15 years working on compiler development, with most of it spent on codegen & optimization in compiler backends, I was very happy to see this book published ten years ago when I was relatively new to the field and hungry for more information.
   
   The good: Coverage of many important topics, and a better discussion of the phase ordering issues than I've seen in other texts.
   
   The bad: The writing style is okay, but not great. Little insight is typically given for the problems discussed. A very annoying aspect of the book is that the author sometimes goes into great detail about one technique, and then later mentions another (often superior, IMO) way to solve the problem at hand, without going into much detail. As a working compiler writer, I would have preferred it be the other way around.
   
   The very very bad: The ICAN notation used throughout the book is verbose, unintuitive, and ultimately takes away from the presentation. Compare the complicated detail-filled ICAN listings in this book to the simple, elegant algorithms in the Dragon Book or Cooper/Torczon's text.