5 comments about Beginning Hibernate: From Novice to Professional (Beginning: from Novice to Professional).

1. I found only first 3 chapers are readable in this book. The chapters for Annotation, xml mapping are absolutely unreadabel. I'd like to see more complete examples with some brief explanation.



2. New to Hibernate, I started with the advanced "Java Persistence with Hibernate". It was such a painful experience that I decided to look for a better introduction and chose "Beginning Hibernate". Our two year old project is already using Hibernate, and now I have to deal with it when fixing bugs and/or adding new features. Hibernate has been a huge source of problems on this project because the people who knew how to use it didn't do it right and now have left. Perhaps Hibernate also shares some of the blame as it is a technology that doesn't seem to support quick ramp up (which is a sign of complexity).
   
   Although "Beginning Hibernate" is not perfect, it does introduce concepts in an easy and smooth way which is exactly what I needed. I now feel as if I have the foundation to maintain the existing Hibernate code in our project. I still have ways to grow with this technology, and maybe now with this book under my belt I'll be able to tackle "Java Persistence with Hibernate".
   
   As typical with my experience with Apress, I couldn't find a published errata on-line. This is important with technical books, in my opinion, since this is a precise technology. On the plus side, this book did impress me with their appendix of goodies that are very real-world oriented.
   
   The jury is still out for me if Hibernate is a technology worth using on projects due to all the trouble it brings with it, but what is clear to me is that if you need to get ramped up, do yourself a favor and start with this book. Rating 3.5/5 stars (rounded up).



3. I found this book to be really well organized and methodical, starting with the basics of Hibernate and working up to more complex aspects and features in a gradual, measured fashion. My only prior exposure to a book on Hibernate was Hibernate: A Developer's Notebook; it was short and sweet, and of necessity was kind of lightweight, not sufficient for really getting into Hibernate deeply. I looked at Java Persistence with Hibernate but found it kind of baroque. Although that seems to be the most popular book on the subject, I found its approach not especially conducive to learning the subject matter.
   
   My background is that I am an experienced Java/J2EE programmer with a strong database background. My organization has been making use of Hibernate but others in my group have been the ones really blazing the trails. So I'd been exposed to Hibernate usage, I could "get" a good portion of what's going on under the hood, but I required better and deeper understanding if I wanted to work more intimately with our lower-level "DAO" code.
   
   Most complaints I'm seeing here seem to be saying that this book is not for beginners. First, I would question what kind of "beginners" we are talking about--would a novice Web designer who can use design tools but doesn't know HTML, or a PHP programmer who doesn't know Java or J2EE or enterprise design patterns, find this book useful and readable? I don't think so. So I would have to agree, this is not a book for that kind of "beginner".
   
   But this is an indictment of the title, not of the book itself. This IS a book that starts at the beginning and works its way up to rather advanced stuff in what I thought was a well-organized manner. The material in later chapters requires background and experience with other aspects of Java and database technology, including understanding of annotations, abstract query language concepts, etc.
   
   For a lighter-weight introduction to Hibernate I might recommend Hibernate: A Developer's Notebook, but if you are really looking to get into the trenches and dig deep, I found this book to be excellent. I've been told that other APress books named "Beginning XXXXX" are mis-titled, that the "Beginning" title really isn't appropriate and really doesn't do the book(s) justice. So be aware that these are books that start at the "beginning" but that doesn't mean they're necessarily appropriate for total neophytes in related technologies.



4. Most APress books seem to be well done. Sadly, this book is poorly organized and poorly written. There is only one example program in the book and it does not compile due incorrect instructions and code omissions. You can fix the errors without too much trouble and compile the project, but the example is too simple to use in your work. The rest of the book outlines (without runnable examples) other aspects of the Hibernate api, but a programmer is going to want complete example applications that run in order to get a good feel of how all the parts fit together and work together.
   
   A better choice, if you need to learn the basics of Hibernate is the web tutorial given on the Hibernate web site. The tutorial is free and, unlike the book example, it works! The tutorial on the Hibernate site is well written and clear.



5. This book is a good book on Hibernate, but not for the complete beginner, ss the title suggests.
   
   The book moves quickly into advanced topics, introducing DAOs a little too early for a beginner, as another review has said. I think a total beginner might be frustrated with this book, or so some have complained. I think this book is more focussed on people who are beginning Hibernate, but have a good deal of experience working with other databases or database frameworks.
   
   If you're used Toplink, worked heavily with DAOs, did alot of CMP mapping, or have a good deal of JDBC or database programming experience, then this is the right book for you to pick up in order to jump into Hibernate. It's a perfect fit for that type of professional. For someone a little less familiar with database persistence technologies, Hibernate: A Developer's Notebook, or Hibernate Made Easy: Simplified Data Persistence with Hibernate and JPA (Java Persistence API) Annotations might be a better fit.

5 comments about Flash Math Creativity: Second Edition.

1. The book is great. I find the negative reviews puzzling because this book is like a $30 kit for a working spaceship, but you have to weld the wings on yourself. Big deal. What's wanting in so many Flash books are examples of the astonishing things you can do with Flash. This book shows what can be done, then hands you the code on a platter. I guess if you're more the designer type and you want to do great stuff using the math functions in Flash, you, um, er -- need to learn some math. But don't complain that every author hasn't lined up to correct your particular brand of ignorance. Read a book.



2. The Flash Math books are great. But not if you want an O'Reilly cookbook of answers to your design problems. It's all about inspiration. Being able to look at something and say "wow, that's so beautiful" and either need to make it yourself just on principal, or see that maybe one day you can use the idea yourself on all those practical things you're so worried about. If you get all juiced up creatively from the things you see around you, this is a perfect book. It's 4 instead of 5 because it doesn't come with a CD. But you can go to the website for the book and see things in action.
   
   That probably appealed to the left brain folks.
   
   For the right brain ones among you. No, this will not teach math. No it won't explain much in the math department at all. It does give the code, it allows you to experiment with what Flash will do, it might renew your interest in Flash. Kind of like watching one of the a-lister Flash kids talk at a Flash Forward conference, it might do that more than looking at a Hockney photo collage (both work for me). If you don't work that way, buy it and give it to one of your left brain Flash friends.
   
   It will be great fun for them, they will get to feel like they remember their math and are much better at it now. And it will make pretty things.



3. I appreciate the book and it helps to understand how to create nice animations by using maths.
   I think it needs more Classes writing and not only timeline.



4. This book is stunning visually and is just overflowing with inspiration. This is a book intended to show us what the Flash community has been able to come up in terms of creation and allows us to tinker around with the code. If you like to take a basic principle and see it evolve given enough time and interest, then this is the book for you. If you enjoy seeing "how" things function rather than "why" they work, you have the opportunity to tinker and toy with the variables to see exactly "how" it changes the overall look of the final piece. To get the most from this book the reader is expected to understand the basics of ActionScript as well as the techniques common in most projects. This is not intended to deter the beginner, as you will surely learn much.
   
   The book is laid out pretty straightforward. There are 15 chapters with each one dedicated to a certain individual who goes through each of his creations and iterations.Suggested reading by the people at "Friends of Ed" is to grab the source files, run them, and then read the chapters. Some of the source files are adequately commented so in some, the book isn't even needed. That is not to say, however, that this book is not necessary to understand what's going on. The book gives you quick insight to the authors' mindset and thinking, and each chapter begins with an overview of where they are from, what they do, how they have come to do this, and interests.
   
   There are actually two parts to the book. The second part consists of the last three chapters and has what you'd consider an "application" or an "engine" for viewing the creations and being able to manipulate them directly. The first part of the book is dedicated to finding a variable, which for the most part is explained in the book, changing it to your liking, viewing the results, and reviewing the code. At the end of the book there is a Tangents page which provides 54 links to explore.
   
   In case you are wondering where the math fits in, it's scattered throughout the book. However, sometimes, we are not presented with the reasons for using "128" for variable "p" to multiply by var "b" which has the value of "14". You may often be left scratching your head and asking why, but that isn't the point. Sine and Cosine are presented quite clearly in the first chapter and there is a terrific example from Gabriel Mulzer, but if you are looking to the find the mysteries behind using atan2 to get an angle, then this book will not answer that question. It is up to you to play the part of explorer to find those answers. You are presented with a wealth of methods that people use, inspiration for them, and experiments that the reader is encouraged to break. You are given a chance to use these methods to have fun and use them as springboards to access that creativity that lurks in each and every one of us.
   
   In conclusion, if you enjoy going through code with a fine toothed comb and if you want to pick up valuable techniques for doing certain things with Flash, as well as be dazzled by some of the innovators of our time, get the book. It is the perfect culmination of what Flash ActionScripting can do. I would show the table of contents at this point, but all of the chapters are named after the innovators themselves, and would provide little insight to the contents.



5. Though it's in ActionScript 2.0, this book is very good if you're into creating visualizations via programming (not only ActionScript). It shows the creative and logical process behind the code (I think that's much more important that the code itself). And it's also a beautiful book to add to your collection :-)
   
   And you can also download all the .fla used in the examples.

5 comments about Perl Cookbook.

1. As a programming cookbook, this book presents a bunch of problems that you, as a Perl programmer, may encounter in your everyday development work and then shows you both the code that solves the problem and a lengthy discussion on how the code works. So far none of the problems has applied to my everyday Perl development chores, but by simly reading through some of the more interesting problems, I've learned a great deal more about Perl than before.
   
   So this book works well as a learning tool for someone who already knows Perl but is still intrigued by its vast arsenal of powerful features -- and arcane usage. Any serious Perl programmer can be helped by this book, whether he or she finds the examples in the book directly applicable or not.



2. Once you've learnt the syntax of a language, you want to learn the idioms, and how it's used most effectively. And given Perl's famous 'There's More The One Way To Do It' motto, you'll need all the help you can get. Perl Cookbook is that help.
   
   Neither a reference nor a tutorial, if you've ever read another cookbook, you'll know what to expect -- after all, this is the daddy of them all. Themed chapters, consisting of short tasks that most people will find handy e.g. trimming white space from a string, or populating a hash. What makes Perl Cookbook so valuable is not just finding out how to do it, but finding out what the most efficient and idiomatic way to do it is. This is where you'll see the Perl way of doing things in action, and it's an immensely valuable learning experience, even if you never need to do exactly any of the things in the book.
   
   For me, the most vital material is the earliest stuff, which takes you through how to use the string, array and hash, the guts of any Perl program. The final half of the book explores Perl's libraries for the use of databases, and a lot of network and web-related stuff, from simple socket programming, to CGI, and the use of mod_perl.
   
   This is a cornucopia of Perl lore, firmly established in the Perl Canon, and deservedly so. You want it on your bookshelf if you want to really call yourself a Perl programmer.



3. Very useful, well worth it. Getting a book like this and having it save you the time of working out how the (yes, come on, admit it, a lot of perl syntax etc. is quite arcane) actual program should be set out, formatted or whatever, is fantastic. Several times this book has done that for me, so one of the best computer book purchases I have ever made.



4. yummy perl recipes; easy to prepare! very helpful for working with date and time data.



5. Most O'Reilly Perl titles imply you'll learn something useful. Only Learning Perl and the Perl Cookbook fully come through in that regard.
   
   The Perl Cookbook features some very practical solutions to some very practical problems (in Perl).
   
   I find myself coming back to this one again and again - more so than Learning Perl, Programming Perl, Programming the Perl DBI, or Perl Best Practices. This is The One. The book to use to learn the Right Way to perform quite a large number of useful functions or tasks in Perl.

5 comments about Pro WCF: Practical Microsoft SOA Implementation (Pro).

1. Finding couple of articles in MSDN Magazine will be much clearer than reading this book.



2. This book's puslisher cannot be Apress.
   
   you don't buy definitely.You can read msdn instead of this book.



3. I must say that this book is not up to the standard I've come to expect from recent APress titles on .NET. I'd love to give you details, but the simple fact is that I haven't found it to be of much use as a reference.
   
   While it could be a little better, I recommend Programming WCF Services (Programming) instead. It serves well as a reference and a reader.



4. I got this book, because I had learned WF from another book in the series which I thought was exceptional. This book has lots of examples, and it will be an excellent reference once I am done reading it the first time.
   
   The language isn't as clear as the WF book, and there is an extensive use of "buzz words" to describe the advantages of SOA development in the early chapters that don't really give you a sense that you're learning anything.
   
   In the end however, they manage to give a very concise, comprehensible rundown on what is a pretty complex subject. I would recommend this book for anyone wanting to learn WCF.



5. This book was poorly edited. After reading nearly every paragraph, I just want to rewrite it for readability. The book makes easy concepts difficult due to the writing style of the author. A sample sentence: "WCF provides you with a number of settings to implement fairly sophisticated means of applying network congestion detection,timeout intervals,retry counts,ordering,and so on." Lets see.. what? "...settings to implement sophisticated means of applying..."? This is a really simple idea that the author has butchered with his delivery. Another complaint: glossing over an idea, and then saying "It really is pretty much as simple as that." Well, which one? "really is" or "pretty much"? It can't be both. Just a case in point - this book went through no editing whatsoever.

4 comments about Pattern-Oriented Software Architecture Volume 4: A Pattern Language for Distributed Computing.

1. This is a great book. It pulls together 114 patterns and shows how to use them in the context of distributed software architectures. It also claims to reference 150 patterns in other publications.
   
   The authors did a great job of creating a language composed of patterns for distributed software architectures.
   
   The book does not go into the details of the pattern's implementations, so you should already be familiar with the patterns, or be prepared to spend some time researching. They do provide brief descriptions and a model for each pattern included in the language. If you need to research a pattern a little more, that shouldn't be a problem because they have included an excellent References section that contains sources for all the patterns original resources and they do a great job pointing to them throughout the text.
   
   The book's best attribute is in how they show the relationships between the patterns. At the beginning of each section they include an introduction to a problem area that ties all the patterns in that section together.
   
   They have broken the language up into the following sections:
   From Mud To Structure
   Distribution Infrastructure
   Event Demultiplexing and Dispatching
   Interface Partitioning
   Component Partitioning
   Application Control
   Concurrency
   Synchronization
   Object Interaction
   Adaptation and Extension
   Modal Behavior
   Resource Management
   Database Access
   
   Although the book is a pattern language for distributed software architectures, the patterns are definitely usable in other contexts.
   
   I used the search on this page to check out the internals of the book before buying it.
   
   Every Software Architect should own a copy of this book. It is a wealth of information. If you have a Software Architect working for you, you should make this mandatory reading in order for them to keep their job.



2. I found this book more theoretical and I personally would like to read books that have a flow with concepts, examples and practicality. Lot of material to read and if not put in practice you loose it. Some of the books of my taste are like Accelerated C++, Effective STL etc.



3. I don't have much to add over T. Anderson's review, but wanted to weigh in with a 5-star vote as a practicing distributed-systems architect. In particular I'm irritated by the one-star review from the person who obviously didn't understand what he/she was buying.
   
   This is as close as you're going to get to a one-stop "encyclopedia" of patterns relevant to distributed computing (and other areas as well). I own most of the architecture/design patterns books, but this is the one I'll go to first for ideas, study, and use as a reference.
   
   As for content, the catalogue of patterns is more comprehensive than any other volume I'm aware of and it is well organized. Each chapter describes a group of patterns that address recurrent vertical and horizontal architectural problem spaces. Each group is briefly introduced and described in the context of that. These introductions are pithy, on-target, and along with the complete pattern descriptions almost constitute a good introduction to distributed computing in general.
   
   Most patterns are described in two pages in a format that has been well-honed over time for usefulness and comprehensibility. You find out where and when each pattern is likely to be useful, what motivates it, how it works, pros and cons, and what other patterns might be used with it.
   
   The cross-referencing between patterns both within this book and in other sources is extensive and one of its most valuable features. The authors provide you with 114 pattern descriptions cross-referenced with "over 150" from other sources. That's a pretty extensive language!
   
   Lots of spelling errors and such, but nothing that should confuse anyone.
   
   This book is NOT a true encyclopedia, and you will want or need some of the core volumes that cover the "over 150" patterns that are referenced but not described here. The most notable are:
   
   Patterns of Enterprise Application Architecture (The Addison-Wesley Signature Series)
   
   Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions (The Addison-Wesley Signature Series)
   
   Remoting Patterns: Foundations of Enterprise, Internet and Realtime Distributed Object Middleware (Wiley Software Patterns Series)
   
   Most, if not all, of the material in Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects is covered in Volume 4. If you don't have that book you might want it for deeper discussion of some of the patterns. On the other hand, the current volume contains important updates to a couple of patterns in the earlier volume.
   
   If you're new to patterns, please avoid Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series), also known as the "GoF" (Gang of Four) book. It is a classic and the authors deserve their "props" for introducing design patterns to the broader development community, but it is the worst-written and most misleading book I've ever read on patterns. (In fairness to the authors, it was the "grand-daddy" of them all and perhaps they can be excused for not having the intervening 12 years of experience in pattern documentation to help them.)
   
   I've heard good things about Head First Design Patterns (Head First) and Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition) from people who have read the GoF book, so you might try that. I haven't read either myself.
   
   If you're familiar with patterns and want perhaps the most comprehensive and useful single pattern book to date, especially if you're involved with the architecture of distributed systems, buy this!
   
   It is not for beginners or those looking for boilerplate code!



4. This book is an absolute must for system architects, system engineers, system testers, and developers.
   
   I have been working DoD systems since 2000 and have studied and studied and studied trying to synch DoD's efforts to embrace SOA and distributed systems with commercial concepts, approaches, and practices. I have tried to specify system requirements from architecture views and contrived requirements trees. I have had GOF's book and POSA 1 since 2002 but, by themselves, they only make a certain level of sense. In addition, countless other books and methods only provide parts of the overall distributed system view. I have been very frustrated.
   
   This book, while not the complete picture, provides a wire up of hundreds of different approaches. The authors provide a logical approach and path to defining distributed system architectures. The authors point the reader to dozens and dozens of other references to allow them to dig deeper. When they disagree or choose why they don't implement a pattern a certain way, they provide logical rationale to go with it and provide references for the other ways you could attack the problem.
   
   Requirement developers/managers and system architects should sleep with this under their pillow. To specify system requirements using the right terminology that does not force an implementation is a primary objective. To evaluate a developer's design requires a comprehensive understanding of the forces at play in a distributed system. This book provides a roadmap. I am now much less frustrated. In fact, I am much more motivated.
   
   Ah... now to read all the references...

2 comments about A Guide to MATLAB Object-Oriented Programming.

1. I have been developing a MATLAB toolbox incorporating OOP-Principles.
   It has been quite painful, the MATLAB documentation covers the functions but provides little guidance.
   This is a guide, it addresses many things that had been making me crazy, like...
   - what should the relationship between get/set and subsref/subsasgn be?
   - is nargout really as broken as it seems?
   - what functions need to be overloaded to get MATLAB-like behavior?
   - what functions can be overloaded to provide enhanced MATLAB-like behavior?
   - how is inheritance done?
   This book has little fluff, it sticks to its objectives throughout.
   My only complaint is that there appears to be no website dedicated to it.



2. Quite simply, changes to Matlab's OOP features in the 2007 and 2008 releases made this book 100% irrelevant.

3 comments about Practical JRuby on Rails Web 2.0 Projects: Bringing Ruby on Rails to Java (Expert's Voice in Java).

1. Over the past several months I have spent a lot of time searching the internet for information on JRuby, specifically looking for ways to have Ruby on Rails host Ruby powered applets. I thought I been fairly successful at gathering information until I read this book, and realized how much information I had missed. If you are working on building a production quality application or just want to learn what you can do with the current state of JRuby on Rails, try this book. It will help get you on track right away while avoiding many of the 'gotchas' that come with using Rails on JRuby.
   
   You will need to have a good understanding of Ruby, and prior experience with Rails would be very good too. I did encounter a few issues where a few commands listed in the book did not work, but JRuby and Rails being actively under development make problems like that unavoidable.
   
   This book would make a good companion for the Pragmatic Programmer's Pickaxe book as well as their Agile Development with Rails book. The projects in this book are definitely more fun than the store in the Agile Rails book.
   Agile Web Development with Rails, 2nd Edition
   Programming Ruby: The Pragmatic Programmers' Guide, Second Edition
   
   Finally, remember that one of the best ways to support open source projects like JRuby is to buy the book (written by a core developer of the project).



2. I am not in this book's target audience. Whereas the book is aimed at experienced java developers who are just getting started with rails and want to take advantage of JRuby, I've rarely touched Java but have lots of ruby and rails experience and am interested in JRuby mainly to see where I might be able to take advantage of java libraries, or ship my ruby apps into new contexts. In that respect, the book was helpful but there's probably space for a companion volume for people like me.
   
   The book takes a measured pace, introducing Rails early on and then building in different components from the Java world as it works through four different projects. Use of JDBC within a rails app, calling ruby code from Java, deployment strategies, packaging a Rails app as a .jar that can be dropped into an application server, and making use of java for interfacing with SOAP web services are all covered.
   
   Readers will probably need to spend some time experimenting with each feature to really get comfortable with them, but the book works well to get you started and point in the right direction. The introduction to Ruby and Rails is a case in point, as Ola dives right in to his examples after a brief lead-in. That may work well for experienced developers who will enjoy exploring the accompanying code, but it is worth being aware of.
   
   It did feel like there were some missed opportunities later in the book, particularly in the final project, to introduce more of Rails' "RESTful" features since that example really invited that style of design, and it would have been interesting to have some discussion of the pros and cons of treating the libraries built to interface with external services as models within a rails app, making the interface more transparent.
   
   I'm also not quite sure where the "Web 2.0 Projects" line in the title comes from. The final project interfaces with amazon web services, which I suppose might get thrown onto the "web 2.0" bandwagon, but don't go into the book expecting a series of stereotypical "web 2.0" projects. It's an introduction to JRuby on Rails for Java developers, whatever approach to the web they may be taking.
   
   JRuby is a really exciting technology that promises to help developers take another step towards picking technology based on their projects, not just the platforms their organisations may have standardised on over the past decades. If you're a java developer wanting to learn how to make use of JRuby and looking for some help to get up and running, this book is likely to give you just that.
   
   Disclaimer: I was sent a copy of this book for review by the publisher.



3. Have you had any experience with Ruby or Rails? If you have, then this book is definitely for you. Author Ola Bini, has done an outstanding job of writing a book about four technologies: Ruby, Rails, JRuby and Java.
   
   Bini, begins by giving you information about the technologies covered, why they should interest you, and an overview of the book. Then, the author shows you how to install everything you need for the rest of the book, including all RubyGems you'll be using. Next, he describes what parts it contains and things that are good to know when doing Rails development. The author also introduces many of the more practical details of Rails in the process. He continues by looking at the databases that JRuby on Rails supports. Then, the author focuses exclusively on the syntax and usage of JRuby's Java integration features. Next, he shows you how create most of the Rails code needed for the CMS application, but stubs out all rendering functionality. The author continues by showing you how to complete the CMS application by adding all the rendering functionality and also taking a look at a few alternative approaches. Then, he shows you how to use JRuby from inside a J2EE Enterprise Bean, implementing the functionality of this bean in Ruby. Next, the author also details deployment options for a JRuby on Rails application, how regular Rails deployment usually works, and how to make the situation much better with JRuby. The author also looks at the options available to consume web services with JRuby, and implements a library to search for books at [...]. He continues by showing you how to create two different libraries for JMS interaction. Finally, the author shows you how to contribute to JRuby or its surrounding projects.
   
   This most excellent book can offer you many possibilities if you use JRuby on Rails. It will help you create your first application with JRuby on Rails, and get it into production.

No comments about Foundation Website Creation with CSS, XHTML, and JavaScript.

5 comments about Leading a Software Development Team: A developer's guide to successfully leading people & projects (The 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 Principles of CMOS VLSI Design.

1. this book is just a collection of too many thing without a deeper insight. at least for circuit design, john uyemura's book will give you a much organized presentation.



2. Great book for beginners. I would recommend reading the first half of the book and then reading "Skew Tolerant Circuit Design" and then "Logical Effort." These books will give a circuit designer the basic tools to circuit design.



3. I strongly recommend this book after I read the first half one.
   It contains lots of stuffs you need to understand if you are a circuit designer, or device engineer designing test structures.
   The format in this book is very comfortible to readers, and you can also make notes on each page (lots of space for readers)!



4. type of MoS transistors,graphic symboles for MOS transistors



5. A good starting point if you want to transition from the discrete to the integrated. A useful book if you quickly move on to more advanced books such as Logical Effort and Skew-tolerant Circuit Design. The later edition of this book is more voluminous and up to date (and more muddled as well).