1 comments about Common Information Model: Implementing the Object Model for Enterprise Management.

1. I bought the book in order to learn faster about the following: (a) How can (should) I use existing CIM schemas in order to develop CIM schema for my company devices. (b) How to represent all these concepts in XML (c) Relation of CIM to network management and DEN.

   I expected to find some examples how all that look and work in real life. This, however, is not a book that I needed. It gives you some background in OO modeling that I did not like and actually did not need at all. I also suspect that somebody without previous OO knowledge might be confused. For example, on page 41, Properties, it is written: "A property is a value used to denote a characteristic of a class; it can be thought of as a pair of functions, one to set the property value and one to return the property value." Property access methods are confused with a property itself !

   XML part is very short and general so I still have to go somewhere else to figure out how to implement XML part. Almost the same can be said about DEN - CIM relation.

   The authors are obviously knowledgeable in the areas of OOA/OOD, Patterns and Enterprise management. I do not like their presentation but it may happen that I am not a part of their 'target group' for which they wrote the book. That is why I gave the book 3 stars. As far as I am concerned, I have to go to DMTF web site to learn hard way from documents. This book did not help me to do my job more efficiently.

5 comments about Semantics in Business Systems: The Savvy Manager's Guide (The Savvy Manager's Guides).

1. I thoroughly enjoyed this book. I was skeptical that the book would be relevant to a small company's projects, but I got lots of good ideas that we can start implementing right away. Because the world of the semantic web is still so new, even our small company has a chance to contribute to a lot of the ontologies that will be used in our industry for years to come.



2. This book does a tremendous job of covering some important issues -- rarely does a technical author provide comprehensive analysis of the role of semantics. McComb addresses high-level issues while also providing solid, hands-on, specific information.
   
   Having myself been involved in complex integration projects, it's refreshing to see someone discussing the problem (and potential business value) of getting meaning out of unstructured information -- without promoting a particular technology. Even more impressive is that he does this using an extremely readable style.



3. I bought this book based on the "5 star" reviews out here - unfortunately after seeing it, I am having to send it back. It covers some *very* basic stuff. Not at all useful.



4. McComb explains a challenging idea of semantics and why this matters in business. He shows that it can be a vital way to efficiently encode your business's rules in a framework of Web Services and servers. This involves understanding different approaches to encoding these rules. Procedural, declarative (like SQL), model based and rule based.
   
   The book goes into how XML is the base standard of representing data or rules in a Web Service context. It takes a lot of the mystery and hype out of what Web Services are or could be. A sober counterpoint to much speculation elsewhere. But one that still clearly shows its potential.



5. Highly recommended. I rather liked this book, learned from it, and even quoted it. Insightful & well organized. Best book I've read in this general subject area. Should replace most of the fluffy business strategy books I've been suckered into buying.

5 comments about Programming Language Pragmatics.

1. Every good programmer should know more than one programming language, that much is almost a consensus. But more than that, every programmer should educate himself about programming languages in general, what they mean and how they work. It's important to know at least the major programming paradigms, because they form the "mental model" of computation that is available to a programmer in a language from that paradigm.
   
   And then it's always illustrative to know about the differences in many common languages, to see where different decisions have been made and what are the consequences. To know that certain legacy languages (e.g. C, Fortran) have features that were not designed because they were the "best" option (for some definition of best), but because the design was constrained by what technology was currently available.
   
   This knowledge is not only required of compiler writers. It should be required of every good programmer. Compiler writers, of course, must know this, and probably in more detail. But Scott's book is a good resource about programming languages, in a level of detail that I believe adequate for all programmers.
   
   There are two main kinds of books on programming languages: they are "survey" and "implementation".
   
   Survey books show how things work in a lot of languages, comparing them along the way. Often the comparison gets down to small details that can affect the meaning, or semantics, of similar programs written in these languages. These books contain one individual chapter for every major topic, and inside such a chapter all languages are compared in relation to the topic. For example, one such chapter covers "subroutines" and then compare a host of different languages on how they implement subroutines.
   
   Implementation books are different: they show how to implement many language features, usually by presenting code for interpreters and compilers. The reader doesn't learn that Ada permits nested subroutines, but instead how nested subroutines really work and how to implement them in a language, for example. A very good book of this kind is "Essentials of Programming Languages" by Friedman, Wand & Haynes.
   
   I normally prefer the implementation books. I'm not really interested if Standard Pascal permits functions to be passed as parameters or not; if I do need to write a Standard Pascal compiler I'll look for a reference manual. I much prefer to know how to implement functions as parameters, and be done with it. Comparing minutiae about extant programming languages can sometimes be very enlightening, and sometimes be mostly dull.
   
   Scott's book, however, really shines because it mixes feature descriptions and implementation details in the presentation. It does the usual routine of comparing a lot of different languages, most of the time the more popular ones like C++ and Java, but it then shows how the implementations differ because of differences in features. The book strikes a good balance between "language design" and "implementation" approaches, although it is clearly slanted towards design, and so more of a traditional "survey" book.
   
   It wins over other survey books by including implementation information about almost every topic, and by the clear writing and style. Also, most survey books concentrate on mainstream imperative languages (nowadays C++, Java, C#) and leave other paradigms to chapters at the end. Scott's book is a bit better in this respect: the presentation often includes Common Lisp, Scheme and Standard ML in the comparisons. There are separate chapters about functional and logic programming too, but considerations about functional programming are spread in the whole book. This is important because paradigms change, and a good programmer must be able to adapt.
   
   It's a good reference for language implementors and good education for most programmers. I look forward to the next editions.



2. As a software engineer, I tend to be picky about my books, but this one is very in depth and a good read. You will learn a lot about different programming languages, and why certain languages are better than others for solving different types of prroblems.



3. This is among my favorite computer science books. I read the first edition straight through from cover to cover, even though I had some prior knowledge of the subject. I have since purchased the second edition, which exceeds the high standards set by the first edition. Scott's book would have made the programming languages course I took as an undergraduate much more enlightening, had it existed at the time.



4. Overall, "Programming Language Pragmatics" (PLP) is a very good book. According to the Preface:
   
   "It aims, quite simply, to be the most comprehensive and accurate languages text available, in a style that is engaging and accessible to the typical undergraduate....
   
   At its core, PLP is a book about how programming languages work. Rather than enumerate the details of many different languages, it focuses on concepts that underlie all the languages the student is likely to encounter, illustrating those concepts with a variety of concrete examples, and exploring the tradeoffs that explain why different languages were designed in different ways."
   
   I'm not knowledgeable enough to pass judgment on "the most comprehensive and accurate" part. But, I'm pretty happy about the book meeting the rest of those goals. I read through the book on my own and have only a few significant gripes:
   
   - Chapters 2 (Programming Language Syntax) and 4 (Semantic Analysis) are tough to get through. They're basically trying to teach enough about Alphabets, Languages, Regular Expressions, Context-Free Grammars, Finite Automata and Push-Down Automata for the reader to understand what the rest of the book is based on. I've read Cohen's Introduction to Computer Theory, which is dedicated solely to this material and I still had some trouble. With an instructor in a class to walk through the things, it should be doable. But, for a person reading the book on his own, ugh.
   
   - All of Section III: Alternative Programming Models, seems to depart from the format of the rest of the book (as noted in the Preface) where the author talks about the concepts and then how the different languages implement them. Instead, he focuses on the languages themselves and almost seems to be trying to cram a primer into his text. Since the section seems to be a special case, it wouldn't be so bad except that the languages covered are a bit out of the mainstream and so that degree of depth gets pretty unreadable at times. Again, with a professor around, things would be better.
   
   - At a more pedagogical level, the author has a tendency to merely explain what his example Figures are doing in general terms. The problem is that a lot of the code/pseudocode involves fairly advanced structures in several languages (many of which most people won't have run across). It would have made things a lot easier if he had walked his way through each of those Figures line-by-line and explained what each line did. Once again, this wouldn't be that much of a problem in a normal teaching environment since a professor could do it.
   
   Other than those three things, this is a very good and readable book. I rate it at four stars out of five.



5. Programming Language Pragmatics 2nd Edition (PLP2e) is a fantastic book that covers a great deal of information. It starts with explaining lexing and parsing, and then goes into scope, target machine instructions, control flow, data structures, a number of paradigms, and building a runnable program. It touches on pretty much every aspect of computer programming, and with deep and insightful knowledge.
   
   While it's not as specific as some other books (language specific references, compiler construction texts, etc), it is a great beginning and reference for a wide range of topics. The bibliography of this book is incredible. I have marked a large number of papers/books from the bib that I now want to read in full.
   
   The bonus information on the CD is also very good, including all the source code from the book, extra sections, and links to other resources.

5 comments about Web Services: A Manager's Guide (Addison-Wesley Information Technology Series).

1. This book overpromotes certain vendor web services offerings. This is more than likely caused by the authors day job as an industry analyst where they get paid to write nice things about vendors who offer suboptimal solutions.

   I would encourage managers wanting to learn about web services to purchase a book targeted towards developers and only read the first several chapters. Developing Web Services and Java Web Services Architecture are two good books that fill this need.




2. This book should be required reading for all IT/MIS managers getting involved with Web services. It clearly explains the past, present, and likely future value of Web services, putting key concepts in clear context, and cutting through the hype to explain:
   1. How Web services relate to earlier distributed computing and enterprise application integration models -- lineage, Web services advantages, and integration considerations
   2. What's practical with today's Web services tools and standards -- criteria for determining which applications to start with, as well as Web services product evaluation criteria and overviews (ranging from .NET and the Java platform to specialized/niche offerings)
   3. Why and how Web services and the XML-based service-oriented architecture will productively impact most application development endeavors over time
   4. Which of the myriad Web services-related standards initiatives are most significant

   Anne Thomas Manes has a unique industry-insider perspective on the subject domain, having worked on pioneering distributed computing products, as an industry analyst, and as an influential contributor in many standards-related initiatives. She's also an excellent writer who can demystify complex technology topics and present pragmatic advice for readers seeking to understand and exploit new technologies.




3. I am so glad that this is the first book that I chose to read on Web Services. In our ever-changing world of IT, new technology and new terms pass by at dizzying speeds. We latch onto some and let others go in our attempt to stay current and relevant. The area of integration will be foundational for the new business models of the 21st century and Web Services is at the starting blocks to making it happen. As a technologist for one of the main players in IT Consulting & Services, I was looking for an unbiased (non company-oriented) and comprehensive view of the components, applications and issues surrounding Web Services. I found it in this book. Like one of the other reviewers, this was one of the most enjoyable business technology books that I have read and it exceeded my expectations. I also agree with the comment that this book should not be limited to managers. Even those who work deep in the details need to have a good understanding of the big picture from a business viewpoint to create the kind of value required. My thanks to Addison-Wesley and Anne Thomas Manes.



4. I have been involved into web services technology for a while. When I picked this book...expected an unbiased high-level outlook on Web services. But it does not help at all...the author is more biased to define all of the pieces of web services technology. With that said, this was a difficult book to read because the writing style is very abrupt, does not flow, and reads like an product brochure trying to impress some vendor and confuse others. I've read more high-level technical books that were easier to understand because they explain their subjects in more natural prose.



5. This book is incredibly clear and dense at the same time. Anne Manes accomplishes to show in a vendor neutral way an entire market of products in an emerging industry. I am thoroughly impressed.
   
   This book is not for the faint of heart. It does not contain source code, but still requires a lot of technical understanding from the reader. An excellent book also for developers.

No comments about ASP.NET MVC Framework Beta Preview.

5 comments about UML Weekend Crash Course.

1. The name "UML Weekend Crash Course" is misleading. I don't think anyone can read and understand it in one weekend, unless of course he is reading about six times faster than me. This book has long and obscure sentences and too much of unnecessary information. The chapter on Object-Oriented principles is written so badly, that I doubt in the authors competence. It mentions two major OO postulates "encapsulation" and "inheritance" but leaves out the third one "polymorphism". But he rumbles on for pages about some unrelated stuff. Also, this book was published before the UML-2 standard came out, so it is somewhat outdated. I would recommend "UML Distilled" by Martin Fowler instead of this book.



2. For the most part, it is a pretty good book. I agree it would be difficult to finish in a weekend. Some annoying mistakes in a few places. For example, on p198-200 the figures are full of mistakes and don't follow along with the text. They are not too hard to correct, but you should not have to do so when you are trying to learn something new. I like this type of format for a book where you pace yourself and then have a review and quiz after a short session. Not too bad, but could be better.



3. The book uses simple and direct language to explain the elements of UML. The examples clearly reveal the key concepts critical for understanding the modeling elements. The book has a perfect level of detail. Unlike other books I have started reading about UML, this book does not go into long commentaries or sidebars about UML, design, and standards. As a result the book allows one to work through the material quickly and will serve as an excellent long-term reference.



4. A number of books have been written about the "Unified Modeling Language" (UML), but few are as easy to understand as the 2002 book "UML Weekend Crash Course" by Thomas A. Pender. Intended to be read over the course of a weekend (beginning on a Friday evening and ending on the following Sunday afternoon), the book is divided into six parts based upon time: Friday evening, Saturday morning, Saturday afternoon, Saturday evening, Sunday morning and Sunday afternoon. Now, just because the author intended that someone would be able to completely read the book over the course of a single weekend doesn't obligate any reader to do that. However, the reader should expect to obtain at least a basic understanding of the fundamental diagrams used in UML: use case diagrams, activity diagrams, class diagrams, object diagrams, sequence diagrams, collaboration diagrams, package diagrams, component diagrams and deployment diagrams. Of these, probably the most important are the use case diagrams, activity diagrams, class diagrams, sequence diagrams and package diagrams.
   
   Though the author points out that UML diagrams can be done by hand, anyone who needs to use UML diagrams should use a software package to simplify their construction and storage because UML diagrams can become rather complex and may require periodic changes, especially when being used to design a new software application. Though there are a number of commercial applications available for UML design, there are also free UML design packages available for download from the Internet, including a few that are used interactively within software IDE's. (The latter may also have auto-code generation.)
   
   As with any software language or modeling tool, it takes time to learn UML. In my opinion, the book "UML Weekend Crash Course" will accelerate that learning process, but you will no doubt require other UML resources (books & software), as well as experience. If you need to learn UML quickly, then I highly recommend this book, which I rate with 5 out of 5 stars. As an experienced software engineer, this book was an invaluable tool for learning UML and continues to be a useful reference.



5. I think the book was good but the title is misleading. The author fails to engage the reader with "lab work" that would truley be needed to be a weekend course. It simply has text and review queestions wich is not enough interaction to keep a person engaged in the material. So what happend to me was that by Saturday morning I wasn't involved enough to continue. Now I just pick up the book during down time at work and read a chapter here and there. I think it is an easy read but I wish I was actually applying the information as I learn it.

4 comments about Introducing Microsoft Silverlight(TM) 1.0 (PRO-Developer).

1. I do recommend Silverlight 1.0 Unleashed as the best Silverlight reference so far. However, Introducting Silverlight does have a couple things that I haven't seen in other books:
   
   - A whole chapter--albeit a very short one--is devoted to Silverlight ink support. It has a useful sample to pull together concepts from the SDK.
   
   - The author also showed a little of his developer evangelist motivations by including a quick look at integrating Silverlight into non-Microsoft platforms: Java (JSP) and PHP with MySQL. The example was basic, but it did add a welcome extra dimension to the book--and quite interesting to see the ease/portability of Silverlight.
   
   This book probably won't be your end-all reference for Silverlight 1.0 (I do prefer the free SDK over this title), but it does make a for a good read-it-and-resell-it book.



2. This book has a great introduction of Silverlight 1.0, and had a nice flow of documentation that made the book a fun read. The book covered the silverlight platform well, and illustrated a few examples of how Silverlight can work in conjunction with a few other technologies like Asp.net and PHP.
   
   The book had very good code samples to illustrate specific points of Silverlight 1.0 technology, and additionally included a good primer on the upcoming Silverlight 1.1. Overall I think this book is a great resource to get up and running on Silverlight in a short period of time.



3. 
   This review refers to the beta 2 version of the book. This book is exactly what the title says - it is a good, solid introduction to programming Silverlight 2 beta 2 in C#.
   
   Laurence does a good job of covering all of the basics of writing Silverlight applications - his web site has a good table of contents (http://blogs.msdn.com/webnext/) which clearly describes the books contents.
   
   One of the features of the book that I especially like is the valuable information about how to run Silverlight from a Linux system and also information about using Silverlight with PHP, Java, MySQL, JavaScript, AJAX, Ruby, and IronPython.
   
   Laurence has been very responsive in helping to resolve any issue with the code that I have had. The book's code is Silverlight 2 beta 2; however, there has been one minor upgrade and I am sure that there will be more so having good response from the author is very important when dealing with beta software.
   
   I do highly recommend this book as a basic introduction to writing Silverlight 2 beta 2 code in C#.
   
   David Roh



4. Well written book. Laurence gives great advice along with examples. I'm a nooby at Silverlight and this definitively helps.

5 comments about Definitive Guide to Excel VBA, Second Edition.

1. This is a great book for the intermediate to advanced Excel VBA user. It covers many fine details missed by other Excel VBA texts. This does NOT make this text better than others that focus on basic skills for VBA Application programming. Beginners may get lost in the depth of the details but experienced users will be very happy with the depth of knowledge that makes the difference between a good application and a great application. Buy this book after you master the fundamentals. Highly recommended.



2. This is an excellent guide to Excel VBA. I have programmed in VB for 12+ years, but have barely dabbled in VBA. I needed to develop some tools for Excel using VBA. I asked expert friends on Experts-Exchange (www.experts-exchange.com) and Open IT (pub21.ezboard.com/bopenitforum) and they gave me three highly recommended books. I look on Amazon and came up with about five to consider, include those three previously recommended. I looked at copies of those and others and chose this book as the one most likely to fit my needs. So far, I am not disappointed.



3. If you only plan to buy one book on Excel VBA (and trust me, one may be enough for most people!), then this is it. Mr. Kofler gives a comprehensive treatment of the subject matter that is structured in a logical and progressive manner. New, intermediate, and even advanced programmers are sure to find nuggets of valuable information in these 900+ pages.
   
   Several chapters are directly related to database applications within Excel which is a strong plus for me. I haven't found another book that covers Excel databases so it was a welcome addition.



4. I like to break programming into two different categories: scripting and application development.
   
   These categories have little to do with the programming language, and more to do with the intent and style. "Scripts" generally aren't very robust: they have minimal error handling, they don't cleanly fail when unexpected data is encountered, etc. "Applications" are supposed to be more robust.
   
   All of the VBA programs (and programming books) I've seen are mostly focused on getting the programmer from Point A to Point B without regard to any problems that may be created along the way.
   
   This book goes into great detail about how to automate Excel, but it does not teach you how to make an Excel "Application," nor does it provide the necessary deep details about how VBA behaves for a programmer to be able to figure it out without turning to other references, and mostly experimentation.
   
   In short, this book teaches you how to effectively create reams of unmaintainable spaghetti code.



5. This book was originally published in Germany. Kudos to Apress for picking it up and translating it. The translation is the reason many have called this book cryptic. But make no mistake, this is a fantastic book that covers many things that others do not. This is a great addition to any Excel library.

5 comments about AppleScript: A Comprehensive Guide to Scripting and Automation on Mac OS X.

1. Prior to getting this book as a gift I read every printed book and pdf on AppleScript written in the last 10 years, and still my progress hit a wall that I couldn't get past. Seeing as I've only been scripting for a year, that's part of the problem. Most AppleScript books are either severely outdated, poorly written, or both. This book breathed new life into a subject that really needed a fresh perspective. This book is an extremely thorough reference, a challenging and inspiring workbook and a treasure trove of ready-to-use scripts and tools that you can take and make your own in the real world.
   
   Don't expect:
   "This is a subroutine, here is what it does. This is a variable, this is what it does."
   
   Instead, expect stuff like this:
   "Here is a common problem, here are four ways to solve it. Here is why the first three work. Here is why the last one might not be a great idea. Here is how you can put this to use in the real world."
   
   This book is low on fluff and useless graphics and high on useful tools. It is important to maintain a rhythm and mood when trying to get an audience to make it through 800 pages and Hanaan succeeds in keeping the content fresh and throws in just the right amount of humor. And unlike just about every other technical book I've read, the jokes are actually funny.
   
   And you'll find that the approach to solving a problem doesn't focus on right or wrong, or the good or bad way of doing things. Rather, it shows the better or best way of doing something and backs it up with real world scenarios and in plain english. I could go on and on about this book and how much it has helped me and my business. Bottom line, if you use AppleScript then by this book now and keep it close by.



2. Easy to read and very complete, until with the least details (How to implement a debug mode, how to name subroutines, good practices to write the code, etc.)



3. this book suitable for beginner (as me) and advanced user. It start with basic AppleScript skill. And the best thing if the language it use is simple and interesting. You will not feel boring (like other training books) when read it.



4. A Mac aficionado, I began knowing nothing of Applescript but a burning need to tweak Filemaker and its interactions with the Finder. Specifically I wanted to incorporate files (or more particularly their pointers) to a Filemaker Database and then move these files to different locations on the network as part of a document storage system.
   
   With this book I have achieved my goals. In addition to freestanding (Finder based) scripts I have used Filemaker's ability to embed Applescript within its own scripts to better integrate my solution.
   
   Of course it is impossible for a single text to cover such a vast topic completely, but together with available web help, Mr Rosenthal's book has allowed me to feel I have at least a nodding acquaintance with Applescript.
   
   I would recommend this text to anyone needing to understand Applescript and its potential. The layout is simple and logical and the index useful. Like other reviewers I thought the "powerwrap" at the end of each chapter was very helpful.
   
   I found the PDF version of the book particularly useful. The example scripts are downloadable which also a great boon.
   
   I continue to use the text on nearly a daily basis as a reference document and look forward to the next edition.



5. Exactly what I was looking for! Finally, a book about Apple Scripting that doesn't teach you how to write a script that e-mails your friends when you upload new tracks to your iTunes library!
   Mr. Rosenthal has broken down Scripting to a basic level but the book can also be used by a proficient scripter too. My boss was borrowing it so often she went out and bought a copy of her own.

2 comments about Structural, Civil and Pipe Drafting for CAD technicians (Delmar Learning Drafting Series).

1. A few changes recommended before (ever) reprinting this book.
   
   -Hiring an Editor who reads drawings is imperative!
   
   -The illustrations for exercises are difficult to read in many cases due to the stylized lettering & smallness of type. Details are difficult to see without a magnifying glass for some people. A suggestion - include an electronic copy of the illustrations on the included cd for easy review. Since most drawings are done on CAD now, get rid of the hand lettering or please make it all caps instead of lowercase.
   
   -Before putting in a hand drawn drawing for an exercise, draw it in CAD first. There were many math errors in dimnesions & missing dimensions. One drawing even had some dimensions that evidently "moved" to where it was referencing nothing. Several drawings that were supposed to work together had discrepancies between them.
   
   -The Appendix is missing the Angle Channel references page stated in the Appendix Contents.
   
   -The chapter on Pre-Engineered Metal Bldgs should be thrown out. It was very frustrating to try and gather enough information from the book to do anything but guess - that is not where you want a student or teacher to be. Get rid of all the pictures of the outside of the buildings - we've all seen them before - and include pictures of the inside & detailed pictures of how they are put together. That is where we really need to see the details. This chapter had the feel that the author thought it should be included but didn't really wanted to spend the time or effort to write it well.
   
   -I'm sorry to say that I don't trust what information is in this book because of all the errors I found. I am not the teacher -I AM A STUDENT. I have been drafting for many years but am new to the Civil & Structural field. Most of the errors were basic drafting & omitted or conflicting information. Unfortunately my teacher doesn't trust the book now either. THIS COULD HAVE BEEN AVOIDED WITH CAREFUL EDITING & MAKING SURE ALL INFO NEEDED WAS INCLUDED IN THE TEXT & EASILY READ.
   
   I am disappointed that textbooks are now soft cover, can contain many errors, and yet still have a list price that boggles the mind.



2. Excellent condition, highly recommend this seller, timely delivery