5 comments about Leading a Software Development Team: A developer's guide to successfully leading people & projects (Practitioner Series).

1. This is an excellent "how to" book. It describes in detail all the steps required to properly lead a software development team. It pays particular attention to conflict resolution including examples on how to handle difficult situatuions and people. I get the impression that in Richard Whitehead's limited project experience he has had significant exposure to conflict.
   It would have been useful if he had fully explored some of the other paths during conflict resolution. He explains what to do in certain circumstances, but does not go the additional step; what if it doesn't get results, what then?



2. While the programmer in me has often railed at the managers of software development, generally with very good reason, but admittedly sometimes for reasons that were less than pure, I do readily admit that it is a very difficult job. Humans tend to have distinct sets of skills, some of which seem to have a fundamental incompatibility. Writers of good software seem to be predisposed to having limited social and managerial skills and in general one needs to be able to understand a great deal about software in order to be able to manage its' creation. Programmers are also known as being "somewhat difficult" to organize, so even the best managers can be challenged by what is oftentimes an unruly bunch of developers.
   However, difficult does not mean impossible, I have yet to meet a quality programmer who did not have a "weakness", that properly exploited, will cause them to work intensely and log an enormous amount of keyboard time. Teams are built in many ways, and Whitehead quite properly notes that many (most) successful teams are made of people who respect and rely on each other's skills, but may not personally like each other. Some of the most successful sports teams of all times were made up of players who did not speak to each other outside the bounds of play. Arguing and bickering, as long as it is within clearly defined boundaries, should be considered normal and tolerated. Attempts to dictate that people like each other and engage in silly "teambuilding" exercises more often lead to failure rather than success. Other examples in the book show the same good sense, as Whitehead clearly has experience in making projects work.
   The book is split into sections, which are

   * The new leader.
   * Project management.
   * Leading people.
   * Requirements capture.
   * Stress and conflict management.
   * Relationship with management.
   * Making decisions.
   * Analysis and design.
   * Testing and project release.

   Under these sections, there are a total of 40 different points, with a header and explanation of some of the rights, wrongs and different shades of gray inherent in the points. While forty is not large enough to cover all possible contingencies, I cannot find a reason to criticize those that were chosen.
   Writing good software is hard, and managing hard people is difficult. However, from this book you can find some very sound advice that will improve your chances of managing a project to a successful conclusion.




3. After reading this book, I would say for sure that Richard Whitehead understands the role of the project lead. I would buy this book for a new, or existing lead, if I wanted him to understand the challenges he might face. I really applaud this and would add that many books feel like they were written from the outside looking in (sure, everyone on the outside wants twice the functionality in half the time!). I would love to see an update that included more strategies for success however. A lot of the solutions seemed to be based on a specific set of circumstances and personalities. Perhaps adding some examples from others who faced similar challenges, and overcame them with different methods, would increase the impact of this book.



4. Whitehead covers alot of the basics of team management. It shouldn't be difficult, and that what Whitehead explains through "questioned" title chapters. It works quite well because you can zero in on the question about leadership in your situation that may be plaguing your mind. The book is short and easy to read, so it can be read in about 3 days on a bus.

   The author subscribes to making you aware of the qualities of good managers and how to handle common types of problems, like what to do when you don't have the technical knowledge about a problem, or how to handle difficult/disruptive team members. In summary, Whitehead helps you get into thinking like a ternary leader, that is you are part of a group, all working towards a common goal and you, (the teamleader/manager), should not dictate your "will and whim" to others.

   The only criticism is that it is probably too light on the aspect of project management. There are issues about project management of people in terms of requirements, risk, scheduling that are not discussed. This book is about working with your colleagues not clients.... but overall a good read at a good price.




5. I bought this book in the middle of a project where we face lots of problems. We come accross about 90% of the problems that are describe in this book. How I wish I could have read this before involving in leading a project. The recommendation and advice are very practical. It took me a few trials to get to the solution by myself before this. Now I can just refer to this book whenever I have problem in handling project issues and save me lots of unnecessary trials. I highly recommend this for new project leaders.

5 comments about Object-Oriented PHP: Concepts, Techniques, and Code.

1. From the perspective of a an experienced procedural PHP programmer learning OO, having read both this book and "PHP 5 Objects, Patterns, and Practice" by Matt Zandstra, I would definately recommend the latter to this book.
   
   Just because Zandstra's book doesn't have a cartoon on the front, doesn't make it less accessible. In fact I found it both more advanced and easier to understand at the same time. I imagine Lavin writing this book one chapter at a time, writing each successive chapter based on what he forgot in the previous. Zandstra's order of explanation on the other hand I found invaluable and thoughtful. When you're trying to make sense of a system by reading about it in a linear (book) explanation, the order in which the information is introduced and its context is very important.
   
   Zandstra's book is also more thorough, and seems to approach implementation from an enterprise (read proper) perspective.
   
   Lavin spends a lot of time on an example of using OO to build a system to display images in a directory. In hindsight, it turns out the design of his code is flawed in some places. Introduction material is no place to be teaching bad habits of any kind.
   
   This book is $10 cheaper than Objects, Patterns, and Practice, but I think if you're serious about learning OO in PHP the extra $10 is worth it for a higher quality book.



2. Thanks to this book now I understand the php code written on OOP style.
   After reading this book I was able to develop a very large open source project written entirely in OOP style with php5 and it was not very difficult either.



3. Peter Lavin provides us with sound, easy to understand concepts, techniques, and examples in Object-Oriented PHP. This book woke me up to the universe of OOPhp where many other PHP5 books had put me to sleep or utterly confused. If you want to get a grasp on how to implement Object-Oriented programming in your PHP code, I can highly recommend this book. It will get you moving along.
   
   I have used php since v.3 first came out. PHP's initial poor implementation of OOP completely turned me off. I found that I just did not want to do any OOP in PHP, not if that is what OOP is in PHP. Although PHP5 introduced good OOP capabilities I was so entrenched in procedural coding, and have a fairly large library of functions for a framework that I developed for my client websites that I pretty much ignored the OOP capabilities of PHP5 except in some minor cases. And all the books I got on PHP5 just left me scratching my head as to why would I want to go through all the hassle of converting the code to OOP.
   
   With an Amazon gift certificate, I picked up this book, my curiosity peeked again regarding OOP in PHP due to taking a Java class on-line. I read it cover to cover and put it down saying, good book, OOP in PHP might be worth it. Without even thinking about it, I suddenly found myself converting my framework to OOP code and loving it. Peter Lavin flipped the ol' light bulb switch to on and I got it.
   
   Object-Oriented PHP by Peter Lavin did three things, no make that four to get me to want to switch to OOPhp.
   
   1. It explained PHP's OOP concepts simply and clearly. I didn't put the book down thinking it is still all a mystery to me. For example, it didn't throw Design Patterns at me early like most of the other books so by the time I got to his brief explanation of Patterns I was ready for them. Ironically, he only discusses the Singleton Pattern and then very briefly.
   
   2. It provided useful examples of the concepts he presents. I wanted to understand the concepts of PHP and his examples helped me do that. I do wish that he would have provided more extensive code examples (or less truncated) but his explanations of the code examples were sufficient that maybe he really didn't need more.
   
   3. This book is not long. Some may actually feel robbed by its brevity but I found the concise explanation of the concepts with good examples refreshing and understandable. It kept me moving along and not bogged down so that I could finish the book. Again, I sort of wished for more complete code examples but that may have ruined the pacing of the book - maybe a follow-up "Recipe book" from the author to round it out?
   
   4. Finally, and I suppose this will sound silly, but the author gave me permission to use procedural code. This was so unlike many OOP advocates that it really stuck out although it was only one line in this fine book. More importantly, after giving me permission to use procedural code, he showed me why I would rather use OOP techniques instead. And bam! Here I am, converting thousands of lines of procedural code over to OOP.
   
   Thanks Peter Lavin



4. I'll agree with others and say that Mike Zandstra's book covers this topic better. The author goes through one example throughout the book (using classes to manipulate a file directory) without fulling explaining how some of the topics work. For example, the author gives a code example, say in english what it's doing to the files, but doesn't explain how.
   
   On the flip side, it is a good book for explaining what OOP is and why it's such and advance for PHP. I just wouldn't use this book to learn it.



5. I am an experienced sequential PHP programmer and wanted to make the jump to Object Oriented PHP.
   
   I have already learned OO concepts and programming through various classes. This book has a lot of good information that was exactly what I needed.
   
   The reading can be a bit awkward at times, and requires reading ahead to understand back(?). In other words things are used before their explained, and sometimes their used to explain other things, so you must eventually double back.
   
   PRINTED ON RECYCLED PAPER - 2 thumbs up.
   
   All in all if you are a PHP programmer wanting to upgrade, its worth the price.

2 comments about Pro Java 6 3D Game Development: Java 3D, JOGL, JInput and JOAL APIs (Expert's Voice in Java).

1. There is some overlap between this book and the author's other book on Java game programming, "Killer Game Programming in Java", but overall there is enough new material to make it a worthwhile purchase. The author starts out trying to explain Java3D. His explanations are OK, but the best explanation I have ever found as an overview of the API is "Java 3D API Tutorial" on the Sun Microsystems website. It's old, but the basics haven't changed. For the specifics of working with Java 3D in the modern era, come back to this book. The author has done a good job of putting together some programming examples that show how to program in current versions of Java 3D including a 3D version of Conway's game of life. He then modifies the program to show off some of the features of Java 6 such as its ability to communicate with scripting languages. Further chapters show how to build creatures with operational limbs that demonstrate Java 3D's TransformGroups, how to handle physics and Java3D using a specific physics API, multitexturing for more natural looking outdoor scenes, and finally how to deal with level of detail problems using mixed mode rendering. In each case, the author just doesn't talk about how to do something, he produces working code that gets the job done and provides a blueprint for the reader to go further.
   
   The section on non-standard input devices deals with interfacing devices such as webcams, game controllers, game pads, and the P5 Virtual Reality Glove to your 3D worlds and games. He mentions parts of Java that are seldom well-explained such as JInput to describe how to control these devices. In the section on webcams, the author talks about JMF and an alternative method of interfacing to cameras. This is good, since for all intents and purposes JMF is really a dead API with very little useful capability. One of the more interesting chapters in this section really has nothing to do with input devices, that being the chapter on JOAL, which is a wrapper around OpenAL, the OpenAudio Library. This is very practical since there are bugs in Java 3D's sound interface that have been there from the beginning and show no sign of being resolved. This chapter provides a practical way for Java programmers to get actual reliable 3D sound into their games and applications.
   
   The final section of the book is on JOGL, which is a Java wrapper for the OpenGL graphics library. The author explains and illustrates the use of JOGL by first implementing a very simple application to clearly illustrate all of the steps needed. Next, a 3D world is written using JOGL that includes a floor with a checkerboard pattern, an orbiting earth, a skybox of stars, a billboard that shows a tree, overlays, and keyboard navigation.
   
   This book, along with the Sun tutorial, is a good education in how to use the Java 3D API in general, and also how to build virtual worlds in Java as well as how to write 3D Java games, which was the book's original purpose. Highly recommended.



2. If you are new to 3D programming in Java then this book is not a very good place to start. That's not to say this isn't a good book its just that you will need to be somewhat comfortable with Java3D before reading this book. Like the previous reviewer said the sun tutorials will help to understanding the examples used in this book, just don't think that this book will hold your hand.

No comments about Beginning PivotTables in Excel 2007: From Novice to Professional (Beginning from Novice to Professional).

3 comments about The Developing Child, 10th Edition.

1. Now in its 10th edition, this book (in order to stay in print so long) does what many other textbook series fail to do: change as the discipline changes.
   
   Child Development (along with early childhood education) continues to accelerate in advances with each passing year...and Brisbane's book stays right with it.
   
   As always, their sections and chapters on parenting rival the very best sources(Ellen Galinksy, Jane Brooks, E.H. Berger, Janet Gonzalez-Mena, Kevin Swick, Chandler & Nita Barbour, and Donna Couchenour).



2. Please be aware that despite the editorial review describing "mydevelopmentlab," a multimedia program that is meant to accompany this textbook, the edition offered here does not come either with the CD-ROM version of the program or with access to the online version. My rating of 1 star has nothing to do with the content of the textbook, only with the misleading nature of the editorial review.



3. Well-written and unique among child development books.
   
   Bee & Roberts do it again by updating this text with information (i.e. the Theories of the Mind section) that you won't find in many other competitors.
   
   Rosiland Childworth's CHILD DEVELOPMENT and Jeffrey Trawick-Smith's EARLY CHILD DEVELOPMENT are excellent texts if you can't get this one...but this one does a more thorough job of injecting many little details and nuances that stem straight from the primary literary sources of many of the theories.
   
   Great!

5 comments about Principles of Digital Design.

1. However, students need the solutions manual to help them understand and master these "principles."



2. This book doesn't have the greatest examples for the students. It also lacks a solutions manual. Not worth a 100 bucks to say the least.



3. This book is very suitable for a 10 week intro. course to digital design. In fact, the author wrote the book with this in mind, since he teaches ICS 151 at UC Irvine which is a 10 week introductory course on the subject. As an instructor, I was thankful that the book came with transparency templates and a solutions manual (although the publisher does not sell it to students). Using this book is also advantageous for the computer science major who needs a solid foundation in digital design for learning computer architecture, but does not need to be overburdened by an indepth analysis of issues such as timing, hazard-free designs, etc. (although these subjects are discussed, but not in much detail). Moreover, the final chapter discusses design and synthesis issues for developing a cpu. Thus, this book is very appropriate for computer scientists and computer engineers...but may be not the best book for a design engineer who may need a reference with more information.



4. Much Errata in this book. Many concepts are just not explained in terms that can be understood. More effort was spent on marketing and cover design then content and proof reading.



5. This book is just a mess. It doesn't explain a list of concepts per every chapter and what it does discuss is just hard to follow. There are too many typos in the Exercise section and even some example problems are incorrect. Then you go to check the back of the book for answers and you won't find any. So you're essentially stuck with a crappy material that is faulty in the explanation of concepts and that won't let you even check your work. As the other reviewer pointed out, the money was clearly spent on making the book look good rather than trying to proof-read it and focus on the content.

5 comments about Pro WPF: Windows Presentation Foundation in .NET 3.0.

1. I really didn't need another book on WPF, at least that is what my girlfriend would say. I already own "Applications = Code + Markup" by Charles Petzold, "Essential Windows Presentation Foundation" by Chris Anderson, "Foundations of WPF: An Introduction to Windows Presentation Foundation" by Laurence Moroney, "Windows Presentation Foundation Unleashed" by Adam Nathan, and "Professional WPF Programming: .NET Development with the Windows Presentation Foundation" by an assortment of Wrox authors.
   
   But I saw Pro WPF: Windows Presentation Foundation in .NET 3.0 on Amazon and decided to investigate the possibility that I need to have it. After reviewing the TOC I still wasn't sure. But after downloading the code from Apress I was sold. I have been a fan of Matthew MacDonald for some time. He has definitely worked his magic on this title.
   
   Some of the highlights I like:
   His in-depth coverage of printing.
   His Custom Elements chapter.
   His approach with 3-D drawings makes extensive use of the 3DTools from CodePlex.
   The chapter on using ClickOnce with WPF.
   Everything is gone into in depth. This is not a brush over the topic book.
   The usability of the code makes the book all that much more valuable.
   
   He also has a great site named ProseTech that has a companion site for the book. It contains all the links found in the book
   
   For extreme coverage of Expression Blend you will have to by a book specifically on Blend. Too bad no good ones exist yet. One I have seen that is out has bad reviews. None of the books I have listed above cover Blend in-depth at all. The Wrox book has 2 high level chapters on it, but I have been playing with Blend 2 a lot and find myself in the XAML most of the time because I don't know how to get to what I want to do in Blend. On that note, this book is excellent for showing you how to work XAML to the maximum.
   
   This book also does not cover Silverlight. It is a book about Windows Applications, not Browser Applications.
   
   I highly recommend this book as addition to any developer's or designer's (those who need to know XAML) library. It was definitely worth buying.



2. Books stated purpose: This book is an in-depth exploration of WPF for professional developers who know the .NET platform, the C# language, and the Visual Studio development environment.
   
   This book introduces the developer to the WPF (Windows Presentation Foundation), which is a new graphical display system for Windows. This book is well written from beginning to end, and takes the developer through the process of learning how to utilize the capabilities of WPF. The author provides references to outside sources throughout the book. These either provide a more in depth look at the current topic, or point to a tool that would be useful. The author introduces WPF in a manner that lets developers of any level understand what WPF is and the benefits of using WPF. Then chapter by chapter he provides instructions and examples that take the developer through the learning process about WPF.
   
   System Requirements;
   * To run WPF applications, you must be running Windows Vista or Windows XP with Service Pack 2.
   * To create WPF application, you must have either Visual Studio 2005 with .NET 3.0 and the WPF extension, or Visual Studio 2008.
   
   The early part of the book is about the basics in and about WPF. The author gives basic, but understandable examples that lead the developer in a growing understanding of WPF. Once the developer has the basics of WPF down, the author begins to build on this base.
   
   One of the basics covered is the creation of the Application object. This is the foundation for all the code throughout the book. Another basic operation covered is the layout of the forms. WPF provides the ability for Windows forms to dynamically grow and resize based on data and language, similar to Web Forms. It takes more work to set up a form, but it will give the user a much better experience in using it.
   
   Now that the developer has the basics, the author moves along the path for using them. The developer is introduced to the WPF controls and how to develop with them. There are a number of features added to familiar controls. Some examples include: Tooltips can now contain both images and text. Multi-line text boxes can grow dynamically and text does not have to always break where it fits the textbox edge. You can add a dynamic spell check to textboxes.
   
   There is a chapter on building control templates or modifying existing controls. This feature appears to be more powerful, and quicker than the old method of building a new specialized control from scratch.
   
   The following topics are part of what is covered as the book continues. Data Binding to a database, Printing, Animation, Sound and Video and 3-D drawing.
   
   The author wraps the book up with a short tutorial on using the ClickOnce Deployment. If the developer has already learned to use the ClickOnce Deployment, this chapter can be skipped. However, it is a useful conclusion to the book if the developer has not yet used the ClickOnce Deployement.
   
   The book is pretty detailed. This review only touches on a few of the highlights from the book that specifically caught the reviewer's eye. It is worth adding to any developers library if they are looking to do new development for Windows Vista or Windows XP SP2.



3. I already have several WPF books now, each of them has something to offer and it's a rare day when you can find all the information you need on a complex, wide ranging topic like WPF in one book.
   
   Without detracting from the other books that I admire, I think if one book does come closest to being a one-stop source then possibly it is this one. Coverage of topics is comprehensive, detailed and accurate. At just under 1000 pages it's definitely a heavyweight, although you're unlikely to want to be parted from it long enough to use it as a doorstop.
   
   The author's writing style is clear and friendly without being patronising. If I have a gripe about the book, it's the same complaint I've been making since the middle of 2007 - this is yet another WPF book that only has code behind samples in C#. However I understand that there will be a VB2008 version out early in 2008.
   
   Of the books I have on WPF, I turn to this one early in most researches. I consider this book to be a good investment. I have several of Matthew MacDonald's earlier books, which I have always found relevant, well-written and useful; this book is in the same mould.



4. This review is a comparison between
   Windows Presentation Foundation Unleashed (WPF) (Unleashed) by Adam Nathan
   
   and
   
   Pro WPF: Windows Presentation Foundation in .NET 3.0 by Matthew MacDonald
   
   I have been using both of these books for learning WPF. What I like about "WPF Unleashed" is the quality of the pages with the color printing. I believe this higher quality is a great step in the right direction and I know a lot of developers appreciate good quality printing such as this. But as good as the printing is I still find myself spending more time in the "Pro WPF" book.
   
   I think it has to do with the flow of the book and how the information is presented to the reader. I'll do my best to explain my experience. In the "Unleashed" book I found myself reading a bit of knowledge, looking at the example, try to work with it in Visual Studio and struggling. Then going back over the knowledge, going to the internet, find out some more, work with it in Visual Studio, back to the book and in some cases giving up because I couldn't achieve some result.
   
   In the "Pro WPF" book though I didn't have this happen nearly as much. In the Pro book it had a really nice flow to it where he would present some basic information, give and example, present some information, give an example. So here I found myself reading some knowledge, do it in Visual Studio like his example, read some knowledge, do it in Visual Studio. I didn't have to reread nearly as much and the knowledge seemed to build upon itself nicely; taking you from simple to more complex. He was really good at NOT introducing newer topics (WPF class/methods) that he hadn't already covered.
   
   The books work well together though and that's how I used them. I use the "Pro WPF" as my main and the "Unleashed" book for more examples.
   
   The "Pro WPF" book has also been updated since publishing and split into two books for C# and VB.NET in .NET 3.5:
   Pro WPF in C# 2008: Windows Presentation Foundation with .NET 3.5, Second Edition (Books for Professionals by Professionals)
   Pro WPF with VB 2008: Windows Presentation Foundation with .NET 3.5 (Pro)
   I haven't read these books yet so I cannot comment on them. I just wanted to include them as a note to the reader.



5. Judging by the number of reviews, MacDonald's fan base is similar to that of Alison Balter-Mastering Access 97 Development (one of SAMS best). The learning and example experience is fairly similar. I got Pro WPF before the VB version came out. Migrating from VB to WPF is difficult enough without dealing with C#. The downloaded code of the VB version is only for examples but they are generally relevant to me. I still break out Visual Basic 2005 (.NET or Bust) for a succinct reorientation.

5 comments about Professional Visual Studio Extensibility.

1. I just ordered the book from Amazon after a careful search online and in bookstores. This was the only in-depth text that covers the topic of extending Visual Studio in all its manifestations be they macros, add-ins or other extension strategies. Team leads, configuration managers and toolsmiths in Windows development environments will not want to miss this.
   
   Anyway, then I saw a copy on a shelf at the local bookseller, so I read the first chapter and skimmed most of the chapters. I'm writing a review because I am very impressed with the tone, honesty and objectivity of the text as well as a refreshing economy of expression that is difficult to find in most books written about Microsoft technology. Most authors, especially, but not limited to Microsoft press, fall all over themselves trying to explain just how wonderful, easy and powerful everything is, adding to your frustration when you sit down and try and use the product. Not this book. It is realistic and open about the complexity that we experienced developers are accustomed to, and then it steers you around the pitfalls.
   
   Good job Keyvan! You go into careful detail about the history of Visual Studio as a com product, and how that makes extending it a little tricky. Thank you for this refreshing honesty and insight, so I know I'm not the only one. You also detail some of the hoops you had to jump through to get proper documentation. I can't wait for my copy to arrive later this week!
   
   If you want an independent, realistic text, this is the book for you.
   
   Update: I've completed a first pass of the entire book and found it broad but not very deep. There are many place that could use more detail or maybe a second edition. It could also benefit from a few detailed examples. The simple examples were a fine start.



2. Covers all aspects of VS extensibility, but in a shallow way. Its not surprising, considering the page count and the number of different ways you can extend and use Visual Studio.
   
   The book concentrates more on addins than other points of extensibility. So if you're looking at creating an addin, or some other not-too-complex work (such as visualizers) this is a good starting point.
   
   If you are looking to do some heavy lifting, such as creating VS packages, you won't get much more than an introduction into the subject. A good intro, but not much more.



3. This is one of those difficult books to review because it attempts to cover a huge topic. Overall it provides a good overview of Visual Studio extensibility but if you want to really use it you're going to have to dive into the MSDN documentation and browse the source on CodePlex (Iron Python and Iron Python Studio are a must). Some topics, such as DSLs and MSBuild have other books dedicated to them.
   
   Unfortunately, due to the depth of the topic, a lot of the chapters are simple introductions and are only useful for highlighting a feature and what can be done with it. This isn't a bad thing, although I think these chapters could have been shortened and merged, and other topics added for completeness (such as language services).
   
   Overall, the book is well written with few errors, although chapter 11 (Tools Options Page) seems to have missed the editors pen and the code is incorrect (and/or not explained properly). The chapters on extending the debugger (17), code snippets (19) and templates (20) are particularly useful and make the book a worthwhile read.



4. Keyvan Nayyeri explores each of the areas of VS Extensibility. He breaks the book up into logical sections, first illustrating the API that Visual Studio uses to represent the user interface. If you have never looked at the API for Visual Studio before, it's not user friendly, so it was good that he provided a brief description of the properties and methods for the various objects, followed by a few examples using those objects to perform certain tasks.
   
   I thought some of the most useful content of the book features discussions on showing custom windows forms, and creating custom option windows using user controls (to display in the Tools > Options dialog), and creating custom debugger type proxies and visualizers. That's definitely not all the book focuses on; the subject matter also ranges in the areas of working with solutions, projects, code files, the text editor, command bars, custom windows, deployment, testing, unit testing and more.
   
   The book covers other topics related to extensibility. Keyvan covers the Visual Studio hive and how it can be used when developing VS extensions. It also covers Domain Specific Language tools (which I was appreciative for because I didn't fully understand what DSL was supposed to be) by creating a sample language. Code Snippets and Templates are another feature I look forward to implement in one of my applications, because it will be very useful and helpful to my fellow coworkers. And, one of the more interesting topics for VS Packages,
   Keyvan works with a consistent motion throughout the book. When he explained the API, he started out explaining each object related to the chapter, then ended the chapter with some sample code. When getting into the other subjects like extending the debugger or macros, Keyvan discusses each subject and mixes in screenshots and code of what each feature looks like as he goes. Only in a couple of chapters does he primarily show the screenshots of how the utility or feature gets setup.
   
   The other point about the book is how he attempt to explain the intricate details about the code that Visual Studio generates, regarding the Connect.cs and .AddIn files generated by the template. This is important because even though the code is generated for you. Again, it's not always clear what the code files are for and it's good to get an overview of these files from the book, and their purpose.
   
   This book help whet my appetite for developing extensions, and I hope to develop one that is functional. The one caveat to this book is that it left me wanting to know more about extensibility, and I thought a few topics were cut short from what they could have been. I agree no book is perfect and will explain every subject to the readers desire, but I felt that a few more examples, or a larger example in an appendix would have been a benefit to the readers.



5. I'm not sure what the basic idea for the book was; to provide a summary of some (not anywhere near all) the features of the Visual Studio SDK or to serve as an introduction to using the SDK?
   
   In any case, the book is mostly filler. The few examples are always trivial ones like hooking up a button or printing a message somewhere. I think I learned more about the capabilities of the SDK from reading the (argh!) actual SDK doc intros than from reading this entire book.
   
   If you just want to write macros or add-ins for Visual Studio then there are other better books, online examples, etc. If you want to do something more advanced like create a VSPackage, language service, etc. then this is not the book.

5 comments about MySQL and Java Developer's Guide.

1. I have bought this book because I had expected to find there some more advanced hints and tricks, especially about performance tuning and bottlenecks of Java and MySQL applications. Unfortunatelly, this book only covers the very basic problematics. It is a good kickstart for beginners, but only for them. Experienced developers should pick a general J2EE book instead.



2. I have not come across the errors in this book that some other reviewers have talked about and the code I wrote using info from this book works. My only bad words about this book are that the sections were not really ordered in with any logic, and were not very long. This was Ok though because they give enough information and coresponding well explained code examples to get the job done. I thought I was in trouble because the first half of the book didnt talk about using java and mysql on a web page but half way through they talked about servlets. With this book you can code a three tier web application that runs a store driven from your mySQL DB or you can write stand alone apps with mySQL functionality. In short this book is effective where it counts.



3. This book is fantastic, it teach step by step.
   I hope you can buy this book if you are a beginner in MySQL but if you have some level in java languaje.
   -------------------------------------------------------------
   THIS ARE THE CHAPTER
   
   1. AN OVERVIEW OF MYSQL
   2. JDBC AND CONNECTOR/J
   3. WORKING WITH MYSQL SQL
   4. INSTALLING MYSQL, JAVA, AND CONNECTOR/J
   5. USING JDBC WITH JAVA APPLICATIONS AND APPLETS
   6. ACHIEVING ADVANCED CONNECTOR/J FUNCTIONALITY WITH SERVLETS
   7. MYSQL TYPE MAPPING
   8. TRANSACTIONS AND TABLE LOCKING WITH CONNECTOR/J
   9. USING METADATA
   10.CONNECTION POOLING WITH CONNECTOR/J
   11.EJBS WITH MYSQL
   12.BUILDING A GENERAL INTERFACE FOR MYSQL
   13.DATABASE ADMINISTRATION
   14.PERFORMANCE AND TUNING
   
   APENDIX A -> MYSQL DEVELOPMENT AND TESTE ENVIRONMENTS
   APENDIX B -> DATABASES AND TABLES
   APENDIX C -> THE JDBC API AND CONNECTOR/J
   APENDIX D -> MYSQL FUNCTIONS AND OPERATORS
   APENDIX E -> CONNECTOR/J LATE-BREAKING ADDITIONS
   
   ------------------------------------------------------
   
   EXCELLENT BOOK.
   THANK YOU MARK MATTHEWS
   JIM COLE
   JOSEPH D. GRADECKI



4. I'd never done anything with databases, and SQL was an almost total mystery. So when I decided it was time to "modernize" a tracking tool I'd developed for my team using Perl and a simple flat file "database", I knew it was the opportunity I'd been waiting for to learn something useful and new: database programming. And while there are a lot of ways to develop a database application, I've always kinda wanted to learn Java.
   
   A search for references on databases and Java didn't turn up a lot of hits that looked useful, and this book was about the only serious or substantial work focusing on my need. I bought it with some trepidation; but found it straightforward, approachable, and reasonably comprehensive. Armed with this book plus the MySQL PDF manual and Sun's online Java reference for additional details, I forged ahead and in a couple of weeks of "spare time" programming, I've designed a reasonable and usable database schema, implemented it, and populated my database with data recovered from various project archives. My tool's "not all there" yet, but I expect this book will remain relevant as I expand my humble command line tool into a servlet and GUI... it has good simple examples of all that, too.
   
   I wouldn't lay claims to being an expert database or Java programmer, but it's pretty cool to be able to say this book helped me become competent in just a few weeks of part-time development.



5. I'm currently enrolled in an Undergraduate Course in Relational Database Systems. I was getting tired of reading incomplete tutorials around the internet on how to use JDBC and MySQL effectively so I bought this book bought last week on Amazon Marketplace. It was ridiculously cheap (About $3), but after seeing how useful it is, I definitely would've paid the regular price. One of the authors, Mark Matthews, actually wrote the Connector/J driver for MySql!
   
   -This book is a tutorial, NOT a reference.
   -All of the code and examples used in the book are available online so you don't need to waste hours retyping code to get the feel of it.
   -The book assumes you are somewhat competent in Java and goes into applets, beans, and EJBs, but I think someone who knows C++ and really understands OOP will be able to manage alright.
   
   Good luck!

2 comments about IBM Rational Unified Process Reference and Certification Guide: Solution Designer (RUP).

1. In a world of lean, agile, etc., large projects and complex organizations still require rigor that is difficult to accomplish with lightweight methods. Although RUP was never intended to be a heavyweight method, misinformed and undereducated RUP users have often misused and abused RUP, counteracting its primary objectives.
   
   Jochen's diverse background and experience offers grounding for presentation of RUP in a pragmatic manner that offers a lot of information in an efficient format. Anyone who is involved in non-trivial projects will be well-served to understand the key elements of RUP to ensure that those projects sufficiently handle critical tasks to reduce project risk. Instead of drowning in information overload, Jochen's book provides a thorough, comprehensive, and clear explanation of the elements of RUP that are most useful and relevant for project work.



2. This book is excelent, but I don't make my exam yet. By the way I can't rate this book in 5 stars.
   The book sintax is really simple and good to read.
   Thank's Shuja