4 comments about Fast Track UML 2.0.

1. As described on the back cover of the book, the target audience of Fast Track UML 2.0 includes folks with previous visual modeling knowledge, perhaps including UML 1.x experience. In the book, the author does not attempt to describe the differences between UML 2.0 and UML 1.x, or to point out the new features. Instead, in a content-packed 161 pages, Kendall, with a "fresh look" at UML 2.0, describes well what a typical developer would want to know about modeling with this improved language.

   Normally, when a book's title tries to convey that it's going to teach me something "really fast" or "in just XX hours", I won't even pick it up. In this case, from reading a few of his previous books, I trusted that the author, Kendall Scott, had probably put together another good book worth reading, and he did.

   I'm a mildly experienced developer with a bit of object-oriented analysis and design (OOAD) understanding. In this book, I was looking for something that would quickly bring me up to date with UML 2.0, while still serving as a good reference manual into the future, as I sit down for some fancy picture drawing, also known as visual modeling. This is that book.

   I would definitely recommend this book to anyone looking for a well-written, easy to follow and understand, concise UML 2.0 reference manual. If you're a career designer, note that this book does not describe in full detail, the complete syntax of UML 2.0. That said, if you're drawing fancy pictures using syntax not described in Fast Track UML 2.0, then perhaps that's a sign that you're models are too detailed. If you're brand new to the study of OOAD looking to develop these skills, this book alone probably isn't what you're after, though it would still serve well as a supplement to another material geared towards teaching OOAD. As a bonus, the book is priced well.




2. I bought this book for its value as a "quick read" of UML 2.0, and as prep for the OMG UML Certification.
   I'm just on Chapter 1, and have found so many glaring errors so far that I suspect everything in the book has to be carefully read and re-read to identify the errors.
   Examples: page 12 - the definitions for "precondition: and "postcondition" are EXACTLY the same. Page 17 - the graphic does not support the text that the notation for aggregation and composition are different. I suspect that the book was rushed to publication without adequate proofreading, which is too bad because, other than the errors, it's very consice and read-able.



3. In response to the comment "Too Many Errors to be Useful" dated August 19, 2004, I would like to further commenting how bad it was written. Not only it is too consise, sometimes you read it with lots of ambiguities come into your mind.
   
   Same as M. J. Graham, I stopped proceeding beyond half of the Chapter 1. Figure 1.13 shows two examples of provided interfaces, using both notations. The usage differences between the two notations are never addressed.



4. M. J. Graham correctly points out that the definition of postcondition is incorrect. This has been addressed. She also correctly notes that something is wrong with Figure 1-17; there was a problem in showing the box around PostingRule as a dashed outline, and I'm not sure why this was not corrected. However, I fail to see how these add up to 'so many glaring errors,' and I suggest that Ms. Graham forward notice of other errors she finds to APress for future correction.
   
   Mr. Ng, on the other hand, makes an assertion that is clearly false. The differences between the notations in Figure 1-13 are explained on the previous page; if he wishes to see an expression of which notation is 'better,' he'll have to find a different book. In the meantime, remarks such as 'sometimes you read it with lots of ambiguities come into your mind' is less than useful. With regard to the comment about how 'bad' it was written, I'll just say that at least I know proper grammar.

3 comments about Managing Projects with Microsoft Visual Studio Team System (Pro-Developer).

1. In Managing Projects with Microsoft Visual Studio Team System, Joel really gets to the heart of addressing the reasons and benefits of having a common set of application lifecycle management tools (Visual Studio Team 2005 System) for all participants in the software development process to effectively track and report on individual and team progress.
   
   It's not just the tracking and reporting, but its the metrics provided that allow answers to questions such as:" What percent complete are we at for this development project?; What's the overall software quality measurement?; How much more time is required before we are done?"
   
   Not only does Joel discuss the problem of inter and extra-team communications for reporting on software development projects, he provides practical advice, examples and guidelines on how to implement and use Visual Studio 2005 Team System to orchestrate the communications and reporting processes for all roles (project manager, architect, developer, tester, sponsor, etc.) in the software development process.
   
   A must read for anyone that manages Visual Studio.NET software development projects and wants to increase the effectiveness of their development efforts!



2. This book helped me with ideas that put in practice, provided new ideas of as it manages projects with VSTS. For me it was useful.



3. This book provides a good overview of VSTS. It goes into enough detail that the reader understands the broad range capabilities without being overwhelmed. If you just want a reference on VSTS, then I recommend this book.
   
   However, the book is just plain lousy when it comes to the process of managing an actual project. Firstly, PMBOK stands for "Body of Knowledge" not "Book of Knowledge". Secondly, the importance of gathering, analyzing, validating, and verify requirements is woefully under-represented. Quality is mentioned, but in such a cursory way as to be practically useless. Ditto on CMM - not enough detail is given on key processes and work products. The process here seems focused on building software without first determining what to build or checking the correctness of what was actually build.
   
   The approach here might work on small greenfield projects, but would be a train-wreck on any large project with involving any degree of human safety, legacy systems, accountability, etc. In other words, the project management approach in this book is probably not suitable for 90% of projects in an enterprise IT environment.

5 comments about Requirements Engineering: Processes and Techniques (Worldwide Series in Computer Science).

1. This book is broken down into requirements processes and techniques, which makes an ideal reference for companies that are implementing requirements engineering, for consultants who are developing and implementing requirements processes and procedures for clients, and for individuals who are seeking to improve their professional skills.

   I like the way this book starts with a frequently asked questions (FAQ) about requirements. In my experience requirements and the processes and techniques that are associated with eliciting and analyzing them are not clearly understood. Too often requirements spill into design, and this part of the book will show you what a requirement is and what it is not.

   The requirements process models covered in this book are complete, and serve as a complete life cycle of a requirement from elicitation to analysis, validation and management. Some strong points about this approach include the need to test requirements, as well as to manage changes as they are refined. Moreover, the authors' approach to constantly assuring traceability is a mature practice and the key, in my opinion, to effective requirements management.

   Part two of this book covers the requirements engineering techniques that are the "moving parts" of the processes. Some are outdated or cumbersome, such as Structured Analysis and Design Technique (SADT), while others are interesting, such as Viewpoint-oriented System Engineering (VOSE). Some highlights of this part of the book include: definition of non-functional requirements (another grossly misunderstood aspect of requirements management), interactive system specification approaches and transitioning to object-oriented design. I also found the case study at the end of the book both useful and interesting.

   I think this book is an excellent starting point for understanding requirements engineering. It covers a wide range of methods and does not advocate any particular methodology, which makes it valuable for generalists who do not want to lock themselves into a single way of managing requirements. The processes provided are excellent and complete. I recommend this as a first book on requirements engineering because of its unbiased and straightforward treatment of this discipline.




2. Since the publication of this book, newer software development methodologies have either hit the marketplace or become more popular including the Rational Unified Process (1999), eXtreme Programming, Scrum, etc. This book needs to be updated to incorporate these newer approaches to software development. The principal drawback of this book is a lack of treatment on how to manage the requirements change during the iterations that are the mainstay of these iterative development methodologies.

   Even though this book is not aimed at detailing any particular methodology, I believe a newer edition should address this last concern from a general perspective. To prove this point, there are only a few pages that briefly talk about a couple of aspects of the Use Case approach to requirements which is now here to stay.

   Other than that, this is an excellent book that takes a text book approach to requirements engineering and explains everything you ever wanted to know about this topic from an abstract and general perspective. It also has a lot of practical techniques.

   For a book dedicated to best practices, you should look at Software Requirements by Karl E. Wiegers. Managing Software Requirements Leffingwell and Widrig is part of the Object Technology Series and does a better job of addressing the Use Case approach and is more recent. Effective Requirements Practices by Ralph R. Young takes a more step by step approach to the whole requirements gathering process and is worthwhile looking into.

   Now that I have outlined what's missing and what the competitor books on this topic address, back to the book being reviewed. The book is divided into two parts - The Requirements Engineering Process and The Requirements Engineering Techniques.

   The chapters in the process section are very useful. The first chapter starts off with an FAQ approach to explaining requirements and outlines the basic requirements document and how to write it. The other chapters in the first part are Requirements Engineering Processes, Requirements Elicitation and Analysis, Requirements Validation, and Requirements Management. All are very well written and quite thorough.

   The chapters in the Techniques section are a mixture of excellent and okay topics. I found Chapter 6: Methods for Requirements Engineering to be very interesting as it addresses data-flow modeling, semantic data models, object-oriented approaches, and formal methods (I am directly stating the different sub-sections of this chapter). Chapter 8: Non-functional Requirements is a must-read! Other books haven't done such a good job of addressing this critical topic that seems to get neglected in many a project. The last chapter is a case study.

   Overall, this is a good book on requirements engineering but in my opinion, you are better off reading this book as part of a classroom course and not as recommended if you are taking a self-taught approach. The other books I mention are better suited for that purpose. Do read Linda Zarate's review on this book as I did not address some things that she does a better job of explaining.

   It is absolutely critical that requirements engineering be mastered in order to have successful software project and product. Overall, this book is pricey for the value added but worth looking into if it is part of your company's project management library. Good luck!




3. Wiley should be ashamed to publish this book; every page shocks me with careless grammar errors and convoluted logic. Tonight's bombs included "This are stable features of the system" (page 116) and "Surprisingly, Davis does not mention what we consider to be the most important traceability information namely information which records the dependencies between the requirements themselves" (page 129). The diagrams are extremely simplified, usually a handful of boxes with arrows, some labeled, some not. The print looks as if it had been delivered as "camera-ready" out of an aging departmental laser printer; entire lines are skewed to italic, and the grey backgrounds behind "key points" and other focus boxes are very dark with distracting vertical stripes. Getting useful information out of this book is very challenging, as I have been constantly tripping over run-on sentences, oddly phrased summaries, and incorrect assertions about the state of technology as it applies to the practice. If you can find ANY other book that may suit your needs, get it instead of this one. It's offensive to have to pay so much for a book that doesn't even meet high-school standards for composition. If it weren't required for a class, I'd be trying to get a refund right now. You can bet I'll be selling this paperweight at the first opportunity.



4. This book is severely out of date, which is obvious from the techniques and methods it discusses that nobody uses any longer. It is, in general, poorly written. However, it does make a good doorstop. It would be better if it were a little heavier.



5. This book should not be the primary text used for a Systems Engineering course, yet it was. I read several reviews that stated this book had errors. Indeed the author must not have proof read his text. It is poorly written with so many spelling and grammar errors you have to wonder how accurate the information in the text is. Additionally I have noticed that the author has half-facts or contradictory statements. If you are forced to purchase this book for a class, sorry to hear about that. If you have an option to not buy this book, don't.

No comments about Decision Procedures: An Algorithmic Point of View (Texts in Theoretical Computer Science. An EATCS Series).

5 comments about Java Regular Expressions: Taming the java.util.regex Engine.

1. Who are these people giving 5 stars??
   
   Clearly this book is short on material. It seems like the author tried to cover up that fact by putting extra wide margins shortening the pages. Also, there were typos all over the place. Not so good especially when regexp characters are concerned.
   
   Here's a book that seems like a major rush job lacking in annotations and illustrations, yet plenty of white spaces and margins.



2. The book consists of 250 pages of wide-spaced text, split into 5 chapters. The first chapter is an introduction to regular expressions, explaining basic regular expression syntax. The book's pace is relatively slow, which may suit some people but not others. It doesn't explain many of the "gotcha's" or differences between regex flavors. Clearly, this book is aimed at people who are relatively new to regular expressions, and only plan to use them with Java.
   
   The second chapter is the most useful part of the book. It describes all the classes in the java.util.regex package, and nearly all of their methods. Most of the descriptions come with example Java source code illustrating its use. If you prefer to learn by reading Java source code rather than English, you'll appreciate these code snippets.
   
   The third chapter explains advanced regular expression syntax, such as lazy and possessive quantifiers (called "qualifiers" in the book), and lookaround. Unfortunately, the quality of the book starts to go downhill from here. Minor errors such as using alternation (I|i)ce instead of a far more efficient character class [Ii]ce (page 104) or stating that \d represents a digit in the replacement text (page 107; \d only works in the regex, not in the replacement) could be attributed to sloppy editing. But the example that was intended to explain positive lookahead (page 130) is simply wrong. The regex (?=^255).* does exactly what ^255.* does. The crucial aspect of lookahead (it doesn't consume the text it matches) is completely irrelevant in this example.
   
   The fourth chapter could have easily been omitted from the book. It talks more about object-oriented programming techniques than about regular expressions. Some of the advice is questionable. The author suggests storing regular expressions in external files, so they can be edited without recompiling the application. The problem with this advice is that the regular expressions will then sit in an external file without context, making them much harder to understand. It contradicts the books key selling point: most concepts are explained with regexes used in Java code. If another programmer has to maintain the code later, a better idea is to use a tool such as RegexBuddy to insert a detailed English description as a Java comment into the Java source code (RegexBuddy generates them on the Use tab).
   
   The fifth chapter presents you with several more elaborate examples performing a number of real-world tasks with regular expressions in Java. While the examples are relatively simple, they do bring everything together nicely.
   
   Should you buy this book? While it's definitely not perfect, I would recommend this book to Java developers who are experienced with Java, but have little or no experience with regular expressions. The book's description of the java.util.regex package is far more detailed than documentation included with the JDK. But to learn the ins and outs of the regular expression syntax itself, you'll need to complement this book with another resource, such as the tutorial at http://www.regular-expressions.info/



3. This book provides by far the clearest exposition of regular expressions that I have ever seen. The writing flows nicely and the explanations are lucid, yet one doesn't get the feeling that the material has been dumbed-down. It assumes no knowledge of regular expressions and starts with the basics, but works up to advanced topics such as possessive and reluctant quantifiers and lookaheads.
   
   The focus of the book is how to write regular expressions that will do what you want to do. There is no discussion of the mathematics of regular expressions and their relationship to finite state automata. There is some discussion of optimization, but not a lot of detail. I think that this is appropriate. Most people don't need to know a lot about optimization. Those who do can find the material in Jeffrey Friedl's book Mastering Regular Expressions.
   
   This book deals with regular expressions in the context of Java, but it should be useful to readers who are not using Java. Most of the book deals with aspects of regular expressions that do not depend on the details of Java, and one doesn't have to know Java in order to understand most of the material. Since Java has the most extensive set of regular expression constructs and named character classes of any widely used language, a person who masters Java regular expressions should not find it difficult to adapt that knowledge to other languages. Of course, for someone learning Java the explanation of java.util.regex is quite helpful.
   
   Some other reviews have harped on the errors in the book. It is true that the book has more such errors than is desirable. However, I don't think that these errors are so numerous or so severe as to detract greatly from the book's value. I've used regular expressions frequently for over 25 years in more than 20 languages. That may mean that it is hard for me to take the perspective of a novice, but my experience is that once you have a good grasp of the ideas, it is easy to check details in the documentation.



4. This book starts very well with a practical, easy to follow, step-to-step introduction to regular expressions and their use with Java. This is to be appreciated since regexp are a complex subject that can easily be presented in an intimidating and obscure way. The problem is, this books never soars over this elementary level and in the end leaves you a bit disappointed even if you are totally new to the subject. The book is small and there are lots of white spaces, repetitions and not so useful discussions. I am under the unpleasant impression that the author and publisher realized the book lacked some meat and tried to cover up for it. It can still be a useful text if you want a really gentle intro to regexp usage in Java, but be warned that it lacks a serious and convincing treatment of regexp syntax. You will come out from this book with the ability to use regular expresisons only for really simple cases.
   The subtitle should be "a light intro to java.util.regex engine" and not certainly "taming the java.util.regex engine".



5. Java, with simplicity being the prime motto started off by striking off pointers, generics, multiple inheritance, regex, high-end reflection etc., from the core language. But as time progressed, folks at sun started bringing those features back into the language out of growing necessity. Java 1.2 added a proper Collections API, Java 1.3 added Dynamic Proxy model, Java 1.4 added Regex, Java 1.5 added generics and so on...
   
   Regular Expressions (REGEX) are one of those weirdly named concepts that establishes a back-off-i-am-complex sort of impression at first sight. Admittedly, it has a strong mathematical foundation and a tidy sum of theory backing its existence. But, that doesnt mean that learning and using them in programming languages have to be difficult, in fact it is not even close to difficult as long as we are well guided by trained personnel.
   
   In this book, the author attempts to train us on regular expressions as it applies to java.
   
   Chapter 1 answers questions like "What is a regular expression" and "How to create regular expressions with that weird syntax".
   In my opinion, this chapter is a tad quicker than one would like. So, those new to regex might find it a bit intimidating.
   
   Chapter 2 introduces you to the java's regex object model. Specifically the Pattern and Matcher objects are addressed along with the additions to the String class.
   At first, i thought that this chapter is nothing but a copy-paste of javadocs. Later, when i referred javadocs for further information i realized that the author truly took the pain to decode it before presenting it here. This chapter is a good reference for the java regex object model.
   
   Chapter 3 explains the advanced concepts like groups, subgroups, back-references, greedy qualifiers, possessive qualifiers, reluctant qualifiers, positive look-aheads, negative look-aheads, positive look-behinds and negative look-behinds. Finally, the author enlightens us with some tips on how to create efficient regular expressions.
   In my opinion, this section is too thin. It covers too many concepts in too little pages. I would have expected a more exhaustive coverage here.
   
   Chapter 4 tries to demonstrate practical usage of regular expressions in the context of an object oriented language like java.
   This chapter is too ambitious about being practical; and gets too involved with file I/O and NIO than is necessary. Reading this chapter is a waste of time because it neither explains NIO nor REGEX well.
   
   Chapter 5 takes a few of real-life use-cases like Email validation, Phone Number validation etc. and attempts to solve it.
   Again, i was hoping that this section will contain interesting information, but was very dissapointed. Many examples were a mere copy-paste from earlier chapters.
   
   Bottomline, if you are looking for a head start in java regex; this book helps. But, if you are looking for an indepth coverage of concepts, the art of writing efficient expressions and are expecting to become a regex expert, then this book alone wont suffice. You might have to try reading this book(for java api) along with "Mastering Regular Expressions" (for regex concepts) to achieve that goal.

1 comments about Developing eBay Business Tools For Dummies (For Dummies (Business & Personal Finance)).

1. A significant proportion of this book is dedicated to producing well presented listings. Easy HTML for ebay does a far better job of covering the same ground. There are also alot of quick tips that are easy to apply (and have been better covered in books such as ebay hacks).
   
   Most of the software packages on the CD are trial versions. Nothing innovative or new is included.
   
   The descriptions of the ebay sandbox and API are very superficial - enough to get you started but little else. The chapter on office development tells you that "serious"
   experience is required and little information is availible from the ebay development site and advises the reader to concentrate on PHP - not bad advice but it takes 7 pages to get there.
   
   Conclusion: the scope of the book is overambitious. It results in a good description of how to prepare listings, some useful tips and a superficial introduction to the ebay API.

5 comments about The Mac Xcode 2 Book.

1. First off for the people who thought this was a cocoa or obj-c book im sorry to say but you must be the stupiest people on the planet. if you read the title of the book it says XCODE!! which is an ide this book is not about how to program or about any programming lanague at all. If your looking for an intro to Xcode, Want to start programming on the mac using Xcode, or are just curious to see what Xcode has to offer buy this book. If you want to learn about cocoa, obj-c, c++, java, foretrain, cobalt, or martian langauge(some people think because this is Xcode it should talk about programming lanagues) this is not the book for you and if you can't understand that then well im sorry. As for the style of this book if you don't know Andy Inhantko then you shouldn't buy this either this is his style he thinks hes a comedian i don't think hes funny either but i know his style so i knew what i was getting into.



2. I buy a lot of technical books, and other books too (history, philosophy, etc.). This is one of the worst technical books I have ever read. There is almost no content, but there are a lot of puns, anecdotes, and attempts at jokes. As Gertrude Stein once said, "There is no there there." I have read the book completely twice now, and I have periodically gone back to look for something specific, hoping I might find it. No such luck.



3. Straight up this book is nearly impossible to read. It is more focused on impressing itself with it's chatter and giving very little depth on the topic. In particular Interface Builder, which is crucial to understanding how to do more with less in in the Xcode package, is given casual attention. If the gab were eliminated from this book it would be at least half the size, and more useful. I wish I could get my money back. Very disappointing.



4. I'm just starting to learn how to use xcode and programming languages in general, and I think this book is a great tool for those of us who have no freaking clue as to what's going on when it comes to xcode.



5. Too bad so many people have no sense of humour. Thank goodness the new bred of code monkeys are not such losers. This is a gret book and ANdy and gang do a wonderful job of oresenting this environment. One of the best books to learn the ins and outs of basic Xcode Dev environment.

5 comments about OpenGL SuperBible, Second Edition (2nd Edition) (SuperBible).

1. I found this book went into the great detail explaining how the examples they give work, but there's so much more to OpenGL than the examples they give. I found myself asking "Wow! That's a great example of that function working in that example, but how do I get that function to do what I want it to do?" I was left with no clue. I suppose I could infer it painstakingly through studying the contexts of the sample code, but I thought the book was supposed to just teach me. I don't have that much time!

   I eventually started skimming over entire chapters that lost me in a barage of techno-geek jargon and explainations of advanced math, etc. I'll have to go back and read those again. This is the trouble with learning from books. The author has no idea if you actually understood his explaination of one thing before he moves on to another. It makes sense to him, so he goes on to the next part.

   On the plus side, I found the basics were covered quiet well. The authors got you going on your first OpenGL baby-steps within a few chapters. That was actually fun. But then they lost me in assuming I knew things they hadn't adequetly discussed.




2. This book provides a decent introduction to many OpenGL techniques, but falls short in providing guidance on avoiding the many pitfalls that 3D graphics programmers can stumble into.

   Movement and positioning in 3D space, using multiple windows and camera/eyes viewing from various locations and angles, is downright complex. I found more useful information in 7 pages of "Linux Game Programming" (p96-102) than five readings of the 30-odd pages the SuperBible devotes to the subject (ch5).

   I was also very annoyed that the SuperBible publishers don't allow for online download of their sample code, very little of which is actually printed in the book. If you lose or scratch your CD (I did), then the book suddenly becomes an overlarge paperweight, filled with short snippets that won't compile and have fatal dependencies on variables and matrices set or modified "elsewhere".

   I wanted to like this book for personal reasons: the author teaches at a school very near me, used to work at my same company, and a friend of mine used to be one of his teaching assistants. Moreover, I'd already paid for it, and wanted to get some value out of the purchase :-/

   Nonetheless, it failed to provide answers to the real-world problems I've encountered, which other books have shown to be easily anticipated and simply resolved.




3. If you are looking to learn OpenGL on Windows, then this is the book for you. Each chapter gives an excellent description of the concepts learned. The authors writing is clear and concise.

   The book uses GLUT for most of the programs. This is great as you can spend the time learning on program in 3d as oppossed to OS specific code. GLUT takes about 10 minutes to learn(Window,keyboard,and mouse functions), but you can do A LOT with it. You can make lots of small games and demos with it. Once the code works, remove GLUT and use your OS code.

   This is a book on programming 3d graphics. You most likely wont understand it if you've never gone past algebra in school. This is not the authors fault. You need to be able to understand some trig and linear algebra. If your math education is somewhat lacking, you should be able to understand it. He explains it a lot better than most math teachers do.

   Overall, I highly recommend this book. The examples are somewhat boring, but this is not a game programming book. It is a graphics book. You should have no problem taking what you learn and apply it to a game. If you are looking for an OpenGL Game Programming book, then buy the book with same title from the guys at Gamedev.net. It's very good.




4. A very good introduction for the opengl newbie who doesn't want to mess up with 3D theory and math right from the start. The price to pay is some of the explanations end up being rather superficial. I like the practically oriented attitude of the book and the wealth of examples, from basics to more complex. Do not expect this to be a book that will transform you from a complete openGL newbie to a master... but it a very good introduction for somone who needs to make sense of openGL and see it at work. It uses GLUT as a library to interface with OS specific command like showing windows or getting keyboard input to shield you from having to deal with the dreaded windows API or any other OS dependent functions. If this is a good or bad thing , you decide. You will have to "treasure" the CD coming with the book as you will have no chance to download the source code form the web. I find this EXTREMELY annoying! The third edition is coming out so watch out for it!



5. Using this book I was always expecting to have good experience in learning. Especially whether the essential data tables are listed in a suitable position so that it can be used as a reference.

   However, this book places function list in many chapters that once I want to look for relevant information I found I rather look for it from the internet. I don't doubt it as a good intorduction, but I won't say this book to be very good, because its codes are not well documented and not continuous as a whole project. Therefore users have to get familiar to many new codes in each chapter, and they are mostly unrelated.

   Another weakness of this book is the index. I think if I am not too stupid that means this book does not organise its index very well.

5 comments about The Enterprise Unified Process: Extending the Rational Unified Process.

1. The book provides a very readable coverage of IBM's Rational Unified Process, as well as useful extensions that address important aspects of enterprise systems planning, development, and management. The systematic and disciplined treatment is greatly enhanced by the inclusion of much useful, pragmatic advice that draws from the practical experience of the authors in building real systems.
   I quite liked this book. Although it doesn't give enough emphasis to conceptual data analysis (something RUP has always been weak on), it has loads of useful, practical content that make it a worthwhile addition to the literature.



2. This book is must readying for any organization using -- or attempting to use -- the RUP. The EUP's additional disciplines completes the RUP in a necessary and sufficient manner.
   The book is written in a straight-forward manner, is easy to read and is well-organized. Each chapter reminds you to be practical (the antipatterns), explains how the additional discipline relates to the others and provides software tools and suggested reading.
   Don't RUPture your software development efforts without having the more comprehensive approach of the EUP!



3. The Enterprise Unified Process (EUP) unites diverse disciplines, including development, enterprise architecture, operations, production and portfolio management, reuse and business process modeling, under an easy to follow framework. It was refreshing to find a book that recognizes the need to accommodate the installed base of existing software as part of the planning, development and deployment process. This is an excellent guide for any manager who wants to ensure that essential IT disciplines are addressed.
   
   The focus of EUP is to enhance the commonly accepted Rational Unified Process (RUP). The authors have added new disciplines to RUP that include business modeling, portfolio management, enterprise administration, reuse, enterprise architecture and process improvement. The introduction of business modeling into the overall process is essential to weave IT processes and disciplines into the most essential driver of any systems initiative - the business. The enterprise architecture discussion was also refreshing given that many organizations have forgone this discipline and have created redundant, stovepipe applications and data structures that significantly stifle business agility.
   
   The "Reuse" chapter raises the rarely deployed reuse strategy. It is critically important to not replicate business processes, models, systems, data structures, source code and interfaces. The costs and risks of trying to keep parallel assets synchronized have been written about extensively. This book promotes the idea that reuse is just another aspect of the enterprise unified process. It is also one of the few discussions about reuse that recognizes the value of harvesting existing assets.
   
   Also of note is the portfolio management discussion that focuses attention on the need to incorporate project management with application management. It should be noted, however, that portfolio management has much less focus on applications than the traditional industry definition as promoted by Gartner, Inc.
   
   Finally, this book makes great use of tips, tool references and citations to books or papers that readers can use to expand on their understanding of a given topic. The last chapter of the book takes a realistic and honest look at deploying the enterprise unified process, including its possible retirement.



4. Many IT organizations still pursue pet projects and develop duplicate applications in isolation, only to address later crises in corporate reporting, portfolio management, IT infrastructure, business objectives, and other areas.
   
   EUP gives a coherent roadmap of how to architect smarter and for the long term. For organizations that don't have a strong enterprise aptitude, this book is a lifesaver. The EUP provides the business case for implementing EUP that will help cut through the politics by addressing the benefits to the bottom line for pursuing an Enterprise Unified Process.
   
   I will be referencing the EUP regularly, and passing it around to others in my organization!



5. If you are using the Rational Unified Process, or considering doing so, and worried about applying it to a whole IT department rather than separate projects then this book could well be useful. The book has four parts - From RUP to EUP, Beyond Development, Enterprise Management Disciplines and Putting it all Together. Each section has several chapters and the chapters all start with a nice reader ROI section (showing the payoff for reading that chapter). The writing is clear and there are plenty of diagrams, tables and helpful tips.
   
   The book starts of with some background in the RUP. I particularly liked the description of RUP as serial in the large and iterative in the small. Within the RUP there are also nine disciplines (Business Modeling, Requirements, Analysis and Design, Implementation, Test, Deployment, Configuration and Change Management, Project Management, and Environment). The authors outline 10 best practices they see as core to the EUP (they extend the original 6 in RUP) - Develop iteratively, Manage requirements, Proven architecture, Modeling, Continuously verify quality, Manage change, Collaborative development, Look beyond deployment, Deliver working software regularly and Manage risk. Each is clearly described.
   
   In addition to the change best practices, EUP adds a Production phase and a Retirement phase. They point out that the Production phase is not just maintenance or just operations and support but both and more. I think that any organization building systems should spend as much time and effort thinking about production and running their application in production (which includes maintaining it over time) as they do in building it and I was glad to see this so strongly proposed. They also added an operations and support discipline, mostly but not entirely in the production phase. This discipline includes running the system and making hot fixes. I think the Retirement phase is overkill for most organizations but some will find it useful.
   
   They also added some "Enterprise Management" disciplines for use outside the context of a project and this too is a good idea. The disciplines are Enterprise business modeling, Enterprise Portfolio Management, Enterprise Architecture (I particularly liked the idea that "modifiability" should be considered as part of an enterprise architecture - far too few organizations do this well and fail to differentiate between stable services and much more changeable ones), Strategic Reuse (Again I liked the called-out focus on this - without a real plan no reuse is going to happen), People management , Enterprise Administration and Software Process Improvement (Another good one and a timely reminder to all that you should keep improving your software processes)
   
   Overall I liked the book, though it was a somewhat dry subject (as methodologies often are). There was a lot of good advice, some nice tips and some clearly hard-won experience being shared!

4 comments about Gtk+ Programming in C.

1. When it came time for me to make the transition from the nice and cozy world of Windows/MFC to X Windows, I started to scrounge for an X toolkit to develop applications on. As a result, I searched for decent documentation.

   This book tries to be a primer and a reference, but it really only succeeds as a reference. This book covers the straight GTK code from a C perspective, and documents most of the basic widgets.

   With only this book, you will find it difficult and tedious to produce usable applications.

   However, armed with glade, a glade tutorial, and this book, you can be as productive in designing X GUIs as a Visual Basic programmer.

   Highly recommended.




2. First off, I'd like to explain why I'm judging this book so negatively. I gauge all computer texts against one of the best instructional books I've come across in my 12 years of programming; "C Programming: A Modern Approach" -- by K. N. King. This book explains the c language with out using too much jargon....

   "GTK+ programming C" on the other hand is so jargon laden, it becomes tiresome before the first chapter is even complete, and what's worse, no "target audience" is ever addressed. This book is not for a novice in any way shape or form (though the back cover would lead you to believe otherwise). I'm not a novice, but I'd rather spend my time reading an instructional book with a little personality rather than one that seems straight from a man page, but enough of my opinion laden book bashing let me back up some of my accusations:

   --Jargon (this is straight from the book BTW)--
   "Gtk+ (via Glib) allows applications to load shared library code at runtime and execute routines that the shared library exports." say that three times fast. Again I'm being a little more critical of writing such as this because no target audience is ever specified. A novice programmer might find a sentence such as this a little confusing.

   Another point of contention I have is the lack of GOOD example code. The book is seeded with function definitions, and code snippets throughout, but has very few actual examples to drive the new information home. As an example lets look at chapter 3 (Signals, events, objects and types). This chapter is about 50 pages long and is devoted to the functions that allow a Gtk+ program to interact with the OS, but this entire chapter (Very important subject matter) only included 2 (that's right TWO) working examples. Oh, the example code isn't commented either!!!

   A) That is a poor programming technique in general, and
   B) Comments in the code help those trying to learn the language to understand the what's, and why's, as they read the code (or type it in)

   Anyway, I could go on like this for some time, but I think I've made my point. Novices and maybe Intermediate programmers stay away. Strong intermediate programmers, or better, looking for a REFERENCE, not an instructional manual, this book might be for you.




3. My first impression after I purchased this book was that it would have limited usefulness. However, after about two weeks on my first GTK+ project it became clear that it was actually the most useful of three books I had purchased. After having this book for more than a year, it is what I turn to about 85% of the time when I have a GTK+ question. If this book has a weakness it would be that it doesn't mention much about the GNOME desktop. However, for "real world" programming on a GTK+ based project that will last more than a couple of weeks or go beyond the basics, this book is a timesaver. I also have the book by Peter Wright that covers GNOME and is a fairly useful supplement to this book.



4. This book has a fairly clean layout. The index is a bit tepid, but Ok. So far, for content, the book is slightly better than the other two books I have seen. Donna Martin's doorstop for SAMs is pretty good, but a bit winded. Eric Harlow's book is also good, but too lean. I see a Jack Sprat pattern there.
   
   I consider this book a good reference, not a tutorial. I like a book that does not waste too much time on the ubiquitous 'Hello World', crawling its way up to an excruciating sample application. I do not have an affinity to that style; Even for tutorials. Usually open source is replete with examples anyway.

   I often judge a book by seeing if it can quickly answer a specific question, which did not immediately leap to my attention, from the standard Web docs. How do I change the text label on a button? What do the arguments really look like? Having figured it out already, I noticed this book answers the question right out of the contents page and on page 179, with an example of the proper object property arg "GtkButton::label". It is more pleasant to learn from brief working examples, than syntax diagrams and source code.

   Another feature that jumped out was the "API Synopsis" sections. Fast, single sentence descriptions followed by the API call, on a class by class basis. Nice touch.

   An IMPORTANT note on ergonomics, which you cannot possibly experience by clicking 'What's inside': This book is fabricated with the same lightweight, semi-gloss, low-acid paper that another one of my favorite books, Stroustrup's C++ opus, is published with. This means the book is thinner, taking up less shelve space. More importantly, the pages turn easily, indexed by finger, and when browsing the inner meat of the book, it stays open without coaxing. This means I don't have to constantly interrupt my browsing both machine and book to crack the binding. This kind of babysitting quickly vectors toward the intolerable, in particular, with the big, cheap doorstops. Good reference books need to be browseable in random fashion, right out of the shrink wrap.

   A note to Logan: Nice job. On the second edition, put a bigger index in the book. It might be nice to see your "Synopsis" block style description of the most popular signals for widgets (table 4.2)and containers (table 10.1) in the signal chapter, as well as the classes. It saves flipping.