5 comments about Windows Script Host (Circle).

1. I am currently reading this book and have found it to be very helpful so far. I have already read Tim's NT Shell scripting book and loved it.
   The main reason for writing this review is to tell users that YOU CAN DOWNLOAD SOURCE CODE but not from the link listed in the book. You must go to new riders website and do a search on the book. Once you find the book there is a link to download the source code.



2. As one of the other reviewers here, Ales from Slovenia, pointed out, this book is not for experienced VBscript developers! Because most of the content is not about WSH, but about VBscript. If you are an experienced developer looking for an in depth and detailed discussion of WSH, you are going to be very disappointed with this book. It's WSH coverage doesn't even surpass MSDN's. This books assumes little to no scripting experience, and as a result, the bulk of the book is an effort in teaching scripting, not WSH as the title suggests. It's also a bad reference, not that it matters, since it doesn't cover what I wanted. I'll return my copy.



3. This book was ok but was very limited in scope.

   The IIS section is incomplete and is missing scripting for a few technologies.

   IMO, this book seems to focus on scriptable methods of common GUI admin tasks. I was expecting more coverage of how to script admin tasks that are not available in the Operating System.

   A book with a reference section of common or admin related commands (or reference info like in his basic shell scripting book execellent reference by the way!) would needs to be added. Sometimes admins need to create custom solutions not available in the Operating System and this subject would be an excellent addition to this book.

   This Book is a good reference to see how the flow of given code examples are written but falls way short in the overall administration field. I'd see if there was another book on the market.




4. After scripting in Linux for some time, I have realized that I should go Windows as well, for all of our commercial servers are Windows based. So I have blindly purchased this book and it came out to be a great purchase.
   
   I'm not creating any elaborate scripts, but I have successfully created many of them that run every day without a hickup. And I took this book as my reference book. But please note, that this is no reference book, one has to find the topic and read it through in order to get some answers... But since I didn't have any WSH experience before, it was great.



5. As other reviewers have noted, this book almost exclusively focuses on using WSH with VBScript rather than a more general tour of WSH and other scripting languages (as perhaps implied by the title). Fortunately, this is exactly what I was looking for and, as a newcomer to VB, I found the book provided a good, thorough tutorial on VBScript with plenty of inline examples on the various language features and built-in WSH and VBScript objects.
   
   The book is well organized, starting with the basics(sic) and steadily working through to more advanced concepts. As a software developer, I found the book more "readable" than average for computer books and worked through most of it in a day (except for the examples in the final section, which I mostly skipped).

5 comments about Java Collections: An Introduction to Abstract Data Types, Data Structures and Algorithms.

1. This book is one of the best books out there for Java Algorithms and Data-Structures. It helped me a lot through CS180 (Purdue University). Very easy to understand definitions and code give you the essence of the topic.

   HIGHLY RECOMMENDED!!!!!




2. When you're a beginner, and obviously one usually is when reading this type of material, you can't afford to waste time and energy reading 3 or 4 books to compensate for their flaws. You want one solid one that can quickly get you up to speed without tripping you up. I found the writing style to be awkward and perhaps it is the more formal British writing style. The material seems to be comprehensive but unfortunately the explanations are too brief. I found that I understood some stuff only because I have read other OOP and algorithm texts, and for a newbie without that background this book would be rather confusing. I might give it 3 stars but someone gave it 5 so I want to even it out immediately.



3. I've been reading through a copy of this book, and comparing it to another notable book on the same subject, mainly "Data Structures and Algorithm Analysis in Java" (DSAAJ) by Mark Allen Weiss. Something very noticeable is that Java Collections is a much simpler book to tackle, though I feel that this detracts slightly from its use as a textbook. As a PhD student in Computer Science, I prefer the mathematical detail I found in DSAAJ than the lesser amount of math that Watt and Brown provide in Java Collections. Yet, at the same time, the case studies in Java Collections are a tremendous help in understanding what a given ADT is useful for, which DSAAJ doesn't go into at all. And the detail on what a specific ADT is supposed to do is much better detailed in Java Collections than in DSAAJ. As a TA, I taught a course in Data Structures and Algorithms for Computer Engineering students. The textbook we used for that was Weiss' DSAA book directed towards C++ instead of Java, but for those who know both versions of the book, the two are very similar. If instead of C++ the course was oriented towards Java, I would have chosen this book as a textbook for that course; these students weren't needing the math focus, and they (and I) would have preferred the practical programming knowledge in here.

   For the programmer out of college, or the college student that wants an alternate view on ADTs than what DSAAJ provides, this is an excellent book.

   Member of the Columbia Java User Group (www.colajug.org)




4. If you step into the Java universe bubble, then "Java Collections" means the standard core API with the same name. This book does not cover the standard classes and interfaces that form the Java Collections API, and this is a real shame. I don't like books that feature highly misleading titles, because it hints at a lack of accuracy of the book's content.



5. I've been teaching data structures and algorithms for over 25 years,
   and the fundamentals--which every computer science student should
   know--haven't changed very much. However, it doesn't follow that
   everyone needs to write their own linked lists or hash tables from
   scratch, when Java already supplies so much of that. I have looked for
   a textbook that balances explanation of the basics with exploration of
   the Java Collections Interface, and this is by far the best book to date.
   (The similarly-named book by Zukowski has too many errors of fact
   in it for my taste.)

   Another reviewer said that this book does not cover the Java Collections
   API. This is incorrect. The authors develop the ideas behind each data
   structure as a suitably abstract data type, and then go on with "...and
   here's how the Java Collections API does it." I think the previous
   reviewer simply didn't read far enough to get to those parts.

   For a tutorial on just the Java Collections API, Sun's online "Trail" is
   the best single source, and has the advantage that it is not intermixed
   with implementation details. If that were enough, no data structures
   textbook would be necessary. However, in real problems, any
   predefined generic data structure is likely to be inadequate and will
   need to be extended; this is why a good programmer needs to know
   the Collections API (so as to avoid reinventing the wheel), but in
   addition a good computer scientist needs to know how these data

   structures are implemented, so that he/she can go beyond them when
   necessary.

   The book is somewhat weak on algorithms and would not serve as a
   reference on this topic; however, there is plenty of meat here for a first
   course on data structures and algorithms.

5 comments about The Icon Book: Visual Symbols for Computer Systems and Documentation.

1. This book is a great reference tool for people who have to design toolbar icons. I wouldn't try to design an icon without it.

   One note for people who may have seen the book before - only the book is available from Amazon - not the diskette with the set of starter icons. This leaves you with pictures of the starter icons in an appendix - which you can try to duplicate by hand in your icon editor of choice. Great reference book, too bad the disk isn't included. It's almost as valuable as the book itself.




2. This book is laid out nicely, with exercises and thought processes on how to develop effective icons. The author includes examples of icons he has developed for applications in the past, along with his workflow. For example, one section lists the name of each icon (Edit, Delete, Add quotation) and then has sketches of 5 different ideas a piece. This book also discusses why people associate certain symbols with certain phrases, as well as outlining when to use graying, broken lines, arrows, etc. to add meaning.

   One shipment of this book did not include the disks, I had to call back and get the disk shipped to me seperately.




3. If you need to do icon design this book is a must! Horton comes from the old school where you have to show the most in only a few pixels - and there is some very smart thinking here to pick up on. This book is great if you are just starting to learn about interactive design or an old pro looking for inspiration.



4. I haven't got the book, but just the diskette, which really disappointed me as these "starter icons" are absolutely basic and often ugly.
   I found it useless for anyone who already works with icons, Wingdrings are better.



5. This book is an comprehensive beginner’s guide of designing computer icons, and I recommend this book for anyone who is interested in designing, because the introduced strategies to create icons are so deliberate that we can use them to design other creative works like home pages.
   
   The main purpose of this book is to discuss how to design icons that are easy to recognize, understand, and remember, including the concept of icons, strategies to design them, making processes, and even a case study. So if you read thorough this book, you can get an overview of designing process of useful icons.
   
   Although this book is for icons, it provides many useful strategies in designing not only icons but also any designing works. One of the most useful strategies is to make an iconic language. This means that it is more efficient and wiser way to prepare common element parts of icons and make complicated icons by combining them, instead of making them from nothing. I think this idea is so useful for many designing works that we can apply those ideas to other works like homepages or posters besides icons.
   
   Another good point of this book is that there are many example icons. Because this is an introductory book and written for beginners of designing, every discussion is accompanied by many recommended or anti examples in order for readers to understand clearly what the author wants to say. There is also a sample icon starter set.
   
   Thus this book is a beginner guide book of creating computer icons and discusses many so useful and fundamental ways of designing them that you can create other decent designing works by applying them. That is why I recommend this book.

4 comments about C++ Programming Today (2nd Edition).

1. Few titles have ever gotten me really excited, but I have to tell you, "C++ Programming Today" has. The text is organized with the new and intermediate C++ programmer in mind. Each chapter leads the reader into new and more challenging concepts that are built upon topics presented in previous chapters. Throughout the book the author uses lots of color and highlighting which to me, is a lot easier on the eyes and makes the book a more enjoyable read. Another useful feature is the use of 4 Stoplight icons to tell the reader when a C++ programming method is either a "Good Programming Practice" (Green Stoplight), "Be Cautious" (Yellow), "Stop! Do Not Do This" (Red) or a Stoplight with yellow flags to represent a "Troubleshooting Tip". The appendices (over 115 pages) contain lots of great reference information such as C++ keywords, operators, string class, file IO, hex notation and ASCII character codes. I was REALLY happy to find out that this book also came with two CD's - the first one contains the full working code of all the examples Johnston uses throughout her book. The second CD is a full-blown copy of Microsoft's Visual C++ 6 (Intro edition). The only thing I didn't like about the book was that the perforated quick reference card was printed on the same paper as the rest of the book, in my opinion it's not strong enough for a reference card you'll be referring to all the time. (I took mine to Kinko's and had it laminated) All in all I would still highly recommend this book.



2. Johnston's book should replace Deitel & Deitel. It covers the essentials of C++ and object-oriented programming more thoroughly, and it has realistic debugging/troubleshooting discussions. The appendices give the reader a refreshingly complete one-stop reference for all the little details that I tend to forget.

   The book has lots and lots of sample code with careful discussion of what's being done and why. The troubleshooting and debugging advice alone is worth the price of the book.




3. Unfortunately I was requried to buy this book for a class. An absolute waste of money. Nothing is covered in any sort of detail at all, while the pages are dedicated to output from compilers. For an example, the information covering file Input and Output consists of a single paragraph. And it's wrong. C++ Primer Plus is a much better alternative. It's cheaper, bigger, more correct, and is actually a useful book. I want my money back Barbara! (And I suspect that you're the one who wrote the first review and that you also paid someone to write the second.)



4. I am goin to make this short and sweet because this is the third time I have had to type this because your site keeps crashing.( have been on sites before this one and many sites after with no problems so I am goin to assume it is just yours)
   problems:
   #1 ordered a book for class and recieved it late.
   #2 was sent the wrong book in my first order. sent that book back and recieved a replacement.
   #3 the replacement was again the wrong book.
   #4 was charge for 2 books while i only have the one in my possession. i sent the original book back and was told i would not be charged for the second one. no corrections have been made to my account so far.

5 comments about Beginning XSLT.

1. Jeni calls it "Beginning" XSLT since she probably wanted to attract new-comers, but this book goes well beyond the intro stuff. I have 3 books on XLST, the others being good books, but this is by far the best. Real world examples, plenty of explanation for each. What else can I say. Buy this if you need to work with XML/XSLT.



2. I buyed this book in Octuber, 2002. Recently I started to read it again. I think this tell many of the book. It is a very useful book and explains complex things in a very easy way. I would recomend this book to anyone that is thinking seriously to go into the XSLT world.



3. This is an exact copy of the book published by Wrox in 2002. I found a used copy of the Wrox edition for three bucks in a bin of a technical store. Looks like the folks at APress took the rights and re-published it. And I am noticing here now that the 2.0 version is scheduled for pubblication in a couple of months.



4. I found this to be an excellent book for XSLT beginners. I've been a web developer for about 6 years now (HTML, JavaScript, CSS, etc) but was totally new to XSLT. I was able to follow the examples in the book quite easily, and found the explanations to be clear and comprehensive. I was able to incorporate some of the examples into my own work right away, in particular the section on recursive templates.



5. Title says it all. Jeni Tenison is an outstanding XSLT developer, her book are top notch. If you develop XSLT pages consider the book...

2 comments about Software Management (Practitioners).

1. I am using this book for a Master's course. The book is a bit different from most books as it consists of a collection of articles.



2. First, if you're looking for a book on managing software projects, this is not it. It is a very difficult subject to learn from a book. In fact, large organizations typically have their own project management practices, and have classes to teach their PM's.
   
   Project Management is difficult to learn on your own, and is a hard topic to cover academically. This book can be used in others ways. For example, as a reference for experienced PM's; it can confirm notions of practices, or be reference for very narrow topics, as software estimations.
   
   Some of the articles are old, and may be out of date, and may be used anecdotally.
   
   This book contains facsimiles of articles ranging from HBR to the highly technical, and a broad range of topics from personnel, to organization, to management, to technical. I found it interesting, but not very useful in terms of practice.

5 comments about Microsoft Visual Basic .NET Language Reference (Pro-Documentation).

1. As usual with Microsoft's references, this is the same information that you can expect to find online and in the VB.Net help. That is a good thing for those that like to have a book to refer to while coding.

   The information in this book is essential to experienced VB programmers because of the many language changes from prior VB versions.




2. The VB6 Language Reference included all items of interest to VB6 with "Applies to" references which was very valuable. This is missing in VB.net reference. Also, procedures and event handlers were included in VB6 reference, but are not in vb.net reference. Compared to the wealth of information about VB6 in the VB6 reference and the lack of information about vb.net in the VB.net reference, I consider it a waste of money. A reference should include all the necessary information on procedures, event handlers, etc., much like a condensed version of what is included in the "Super Bible" series of VB books.



3. I am very happy with my purchase. This book is just what it is though, a language reference. It does show simple snippets of code for illustration of most functionality. This book used in conjunction with MSDN should be very helpfull. Having already done a good amount of .NET training with other materials in both vb.NET & C# I found this a good book to spend a few days reading through. No it won't teach you to code, but that's for beginner books. It does however, give an intermediate programmer from other technologies a quick way of getting familiar with common vb.NET functions and syntax. You'll still need to use MSDN or other resources for advanced application, but you can get very a good starting point from this book. For many, that's all you need. Overall I'm very happy with my purchase. If your new to .NET, this should not be your first buy, but definetally a good 3rd - 4th reference or so. Start with beginner book, then maybe coding techniques, Try this for when you think your ready to start developing and need a quick syntax boost. Happy coding.



4. Helpful book, had better examples than some "instructional" books I have seen! Wouldn't purchase as the first book but is handy to have around.



5. No hassles, great quality... What more can you ask for. I recommend this seller.

5 comments about Learn C++ By Making Games (Charles River Media Programming).

1. 
   Book is good if you need a C++ refresher since it covers all the necessary C++ you need to build a simple 2D games in C++ in bite sized chapters and are looking to build a cross-platform games.
   Writing is clear and to the point.
   Focusing on single battleship game through several chapters helps keep you interested in finishing the book.
   Still last few chapters a big letdown when you are supposed to have graphical version of simple text based version you started with.
   This book is pretty good until you get to the later chapters which is missing code.
   It seems as though the last chapter was rushed to press and author forgot to include some necessary files ie images to get code to work.
   I'm giving 4 stars so maybe author can provide updated files for last several chapters.



2. When I found out about this book, I was so excited! There arent many books that go over SDL, and the idea of a book that taught SDL, C++, and game coding all in one sounded like such a good idea.
   
   If the entire book were like the first half, i'd give it a 4.5. With full code listings, and great explanations, I feel like someone could really learn alot from this bit of the book. The only problems I had with the first half is, the author starts the reader out fast, and explanes as you go, wich is hard for someoen who is totally new. Overwhelming the n00b is not a good idea if you want him to continue. The second thing I kindof thought was silly was, static_cast. Using the code "double quotient = 5 / 4;" the author says you cant get a floating point result without either typing it out like "double quotient = (5 + 0.0) / 4;" or "double quotient = static_cast(5) / 4;". I say, how about trying this "double quotient = 5.0 / 4.0;". And to quote the author
   
   "the division (5 + 0.0) / 4 will be a floating point-operation. However, this is an ugly hack and introduces an unnecessary addition."
   
   ROFLOL
   
   After that sillyness, I was tempted to not read the rest of the book. This all happens on pg 61 btw.
   
   Anyways, back on track. The author does a good job through the rest of the first half of the book, ignoring that silly static_cast. Then for some reason, it all falls apart. The BlackJack game is where I really started feeling frustrated. His explanations were still on key, but something was missing. THE CODE! He stops listing the complete code in the book, and instead has you refer to the cd. The author also does this in several cases when introducing new threory's, he says something like "the new code can be applyed to the listing in chap 1, or you can look at the cd". In my opinion, this is terrible for several reasons. Let me just list a few.
   
   1.I bought the book used on amazon, and it didnt have the cd.
   2.Used book w/out cd, and I have no net access.
   3.I rented the book from the library, and the cd looks like a dog frisbie.
   4.My cdrom drive is broken/I have none.
   
   Ok, ok, i'll stop at that. As none of these reasons effect me, the reason I'm annoyed by it is, if you put the code in the book, and not on a cd, it encourages the reader to actually type it in, and see it all. If you put it all on cd, the user will be tempted to copy/paste, and will not learn as much as they could have typing in all the code. Afterall, programming is typing, and if your not willing to type out whats in the book, you might as well quit right now.
   
   I've read tons of coding books, and I've been coding for about 2 years now. Some of the books I've read were really good, and some of them were really bad. Unfortunately, the things that make a book of this nature "great" seem to be missing after the first half. In the first half of the book, the author has shown that he is capable of doing a good job, perhaps a second edition is in order?



3. Ok this book can be a very helpful tool for a beginner, but some of the software doesn't work with vista so be careful. Also I don't like the compiler that much, but it gets the job done.



4. The book is well written and good examples. However the CD has many errors in the examples and is incomplete.



5. Since I'm pretty experienced with C++, I was able to wade through the skimpy explanations of C++'s most advanced concepts without too much difficulty, but I fear that a reader new to C++ (the intended audience), will have a fair amount of difficulty.
   
   The book starts out well -- in the beginning chapters all the code is there, it's explained, and the examples are simple enough that a beginner can easily follow. However, as the book progresses and covers more advanced topics, the explanations become increasingly brief and almost cursory! Operator overloading, one of C++'s central features, for instance,is given a few pages of explanations and code, one poor example, and then it's off to the next topic which is covered in the same amount of detail.
   
   The main problem with this book is that it attempted to cover too much in too little space. Clearly, you're NOT going to go from a C++ neophyte to a 2D game programer in one book, in 500 or so pages. It's just impossible.
   
   So, I give this book a 3 star rating because while it may be useful to newbies and weathered programmers alike, the later chapters will invariably prove to be extremely difficult to understand for the newbies because while code is shown and examples are shown, the *theory* and explanations behind the workings of given features are simply not present, which makes this a sub par learning tool.

5 comments about Practical Java(TM) Programming Language Guide (Addison-Wesley Professional Computing Series).

1. This is the only Java book that I give 5 stars. Any technical leader who has not read this book likely has dangerous gaps in his/her Java knowledge, particularly in regard to threads in Java. The book is divided into 68 Praxis, following the trend started by Scott Meyers with this definitive Effective C++. From what I've heard, Joshua Bloch's Effective Java would also rate at 4-5 highlighters.



2. Now this is what I call good wisdom. This book is not for beginners, those who have done some programming in Java and/or c++ will really appreciate the insight of the author.
   I was really stumped by the praxis on equals method. I looked upon myself as an idiot after reading the praxis and realized how basic but true it was. If you have been programming for a while, you may be indeed knowing some of these practices but its anyway worthwhile to refresh yourself of the ABCD.
   I really liked the approach of the author to illustrate his thoughts using bytecode representation. It really drives home the point.
   I also noticed that this book takes help from The art of Programming, Effective Java language guide by Joshua, Effective C++ by Meyers. All these are great books to read.
   Buy this book definitely, go to starbucks and enjoy a cup of coffee breezing through this book. For the passionate reader, it should just take a weekend to read it.



3. This book could be a very good source if you are developing your own company or project guidelines. The discussion is structured around lessons that are called PRAXES by author. Each PRAXIS has a well-chosen title which is expressed as a one sentence guideline.
   The book covers general Java/OO topics and, in addition to that, has extensive sections devoted to performance and multi-threading.
   Most guidelines are simple enough to be understood by any Java programmer. The discussion is on intermediate level in most cases with some advanced stuff included. Many examples, especially, in a performance section are illustrated by JVM bytecode snippets. The ability to read bytecode would be a plus for a reader but unfamiliarity with it should not prevent a reader from understanding material.
   Overall, the book is a worthy reading for any Java developer.



4. Lots of great "common sense" best practices for Java, especially on things such as Exception handling - what goes in a finally block, what should and should not go in a try block etc. Probably not on a par with Josh Bloch's now classic "Effective Java" but a good adjunct.



5. Peter Haggars "Practical Java(TM) Programming Language Guide" focuses on how to use Java. The abstraction level is language idioms. It is not a book about design. It is easy and fun to read. Anybody who knows at least a little about Java will profit from a substantial portion of the 68 praxis tips. Even the performance tips of this Java 1.2 book still read fresh. They are backed up with many listings of disassembled byte code (The author is a former C developer.).
   The main disadvantage of this book is its age (2000, Java 2 SDK Standard Edition v1.2.1). You will not find the nice new stuff in java.util.concurrent and below or generics. The book still advocates the Vector class, which should be imho deprecated. Also the author is still very shy with the final keyword even in immutable class tips. But all those points are minor compared with the intrinsic value of this rich set of tips.

5 comments about Design for Trustworthy Software: Tools, Techniques, and Methodology of Developing Robust Software.

1. This is an excellent book providing exposure to a new technology in software design. Design For Trustworthy Software is well written. The quality initiative ideas are quite innovative.
   I like the fact that the book's focus is on building quality into the product at the early design phases. Bugs found further downstream in the development process get more and more expensive to fix.
   The exercises at each chapter's end are well presented to allow for better understanding of the material.
   This is a great resource for both students and software professionals for producing high quality software.



2. This thoroughly researched book begins with an excellent summary of the state of software development methodologies. It provides a useful description of the important strategies, life-cycle models, and process improvement methodologies. The theme of the book comes from applying Taguchi Methods to software development. This approach to trustworthy software shifts effort "upstream" from testing to design: Build software right in the first place rather than waiting for a huge quality assurance department (or worse yet, customers) to find the bugs for you. Several chapters provide detail on how to apply these principles to large scale software systems.
   
   The authors have pulled together material from an impressive set of resources into one, admittedly lengthy, book. The shear number of methodologies (including corresponding acronyms!) contained in this volume is staggering. The chapter endnotes document these sources and web references give many pointers for additional information. They also include several case studies written by practioners who have used the methodologies described in the book.



3. College-level students of quality assurance will welcome this integrated approach to software quality issues, which tells how to prevent bugs in implementation rather than discovering them after. Case examples of DFTS technology include FMEA, QFD and more, and provide a blend of theory, applications, and exercises designed to test student knowledge. Classrooms in particular will find it excellent. Its authors are a CEO of a quality assurance company and a chairman of a consulting group, and professor.
   
   Diane C. Donovan
   California Bookwatch



4. Design for Trustworthy Software is an excellent book for developing robust software designs. The book explains very well the principles and methodologies that can help in developing of software with emphasis on prevention rather than corrective action.Professionals have been looking for a good book which can describe and help them in the reliability side of the software. This book just does that.
   
   I particularly like Part II-Tools and Techniques of Design for Trustworthy Software. Although these tools and techniques are well known
   
   
   
   and applied for a long time on the hardware side, their application for software is very well rxplained here. The book is excellently organized for students and beginning practitioners. In each chapter key points are are braught out at the end to confirm the understanding and then the exercises and questions challenge that understanding.
   
   The authors have demonstrated their knowledge of wide array of concepts and principles.At the same time, their keen grasp of those concepts and princples is clearly evident.
   
   I will strongly recommend this book for the students of the subject as well as professionals who are working to achieve robust software designs.
   
   
   ASH SAHNI
   PRESIDENT,ASH AND ASSOCIATES
   International Consultants in Quality and Compliance Management



5. This book does justice to the many issues facing any corporation today when designing their software. It has a balanced blend of theory and practice. While it can be used very easily in a college classroom, it is also well-suited for a more practitioner oriented audience. Practicing managers will find the chapters and corresponding steps very useful as they try to design and implement higher quality software.
   
   My favorite chapter was chapter 5. This chapter presents a very clear list of steps that need to be addressed when designing trustworthy software. The authors do a great job integrating the various literatures on management of change. The implementation steps would probably apply to many more change issues in organizations - showing the versatile nature of the book.
   
   Great text!