Home | Family | Birth Control
Part one among the book covers tools and techniques that can be applied on projects. Project coming up with, estimation, scheduling, reviews, requirements, style and programming and testing every have their own chapter. Half 2 is concerning using project management effectively and has chapters on understanding change, management and leadership, managing an outsourcing project and process improvement. A clear thread throughout the book is a description of the everyday problems software project teams face - inadequate necessities, managing changes, lack of quality assurance at every stage in a very project, endless testing and bug-fixing cycles, tensions and misunderstandings between the software engineers and business users. None of those issues are technical in nature, however are organisational and managerial. Stellman & Greene supply sensible advice to solve these problems based mostly upon their experience on similar projects. Stellman & Greene actually appear to understand a ton about issues that face software teams. As early because the introduction they describe the necessity to overcome chronic issues and this theme is continued throughout the book. For every drawback, there is always a minimum of one proposed solution. For instance, they describe a common scenario whereby senior managers do not trust the estimates of the technical team, somehow believing that the technical team are deliberately over-estimating in order to grant themselves some slack time. Their proposed resolution is to involve these managers within the estimation process thus they'll see the estimates being made in a very transparent and systematic fashion. They then last to describe well the way to run a Wideband Delphi estimation session and provide samples of templates and documents that can be used throughout such sessions. They also give a valuable process script for groups to follow. Subsequent chapters cover designing, scheduling, reviews, requirements, design and testing. While most of these chapters cover every topic in reasonable detail, the section on style is lacking intimately and provides no description about what sort of design deliverables would possibly be made nor any detailed description of what these design deliverables might contain. This can be in contrast to the requirements chapter that contains method scripts for requirements elicitation and analysis as well as a close description of use cases and software necessities specifications documents. Another nice side to the book is the checklists that appear once coping with one of the main project management or software engineering topics. Checklists are vital quality assurance techniques that the authors rightly purpose out ought to be used throughout software comes as a method of catching errors early. For example, if a checklist applied to the software needs specifications catches the actual fact that a critical requirement is missing or ambiguous, then the error will be corrected throughout the analysis stage. The authors explain that by catching and fixing errors early, the price is little compared with the price of fixing errors found later in an exceedingly project. Their stress on quality assurance techniques being applied throughout the project with samples of checklists to apply is so terribly practical and useful. The authors would possibly need to reconsider some of the examples they use. They describe the process of refactoring code in order to create it more maintainable and use an example of some Java code which they gradually refactor over many iterations. At the top of this method they say why refactoring would be applicable in things where code is spaghetti-like. This is often fine, except they use an example of very un-spaghetti-like Java code to refactor. By doing this it appearance to me that they fall into a standard programmers entice of code beautification where programmers spend time from the schedule iteratively improving code that works simply fine so as to write the ‘excellent’ code, class or object. I’ve seen this happen on projects where there simply wasn’t the time within the schedule to allow this, and it actually didn’t bring any additional business benefits to the stakeholders. But this is often a minor gripe. I'd have liked to own seen additional pages devoted to risk management. Time and once more, not managing risks is cited as a reason why comes fail. The authors do describe risk management during a cursory way, nevertheless the book would benefit from a better description of how and why risk management should be done throughout the project, not simply in the early stages of project planning. One thing I assumed the book lacked was a detailed study iterative methods. The implicit assumption throughout is that the software project ought to follow the waterfall method. I might disagree. There are some necessary alternatives to the waterfall technique that are developed over the last twenty years most notably those primarily based upon iterative approaches. The main downfall with the waterfall approach is it’s assumption that everything about needs is known at the beginning of a project. Iterative approaches on the opposite hand assume that necessities can amendment throughout the project either because users gain a higher understanding of what they have, or because of changes to the business environment. Primarily based upon this assumption, iterative methods are designed to better manage this changing environment. With waterfall approaches, changes in needs usually need the project to revisit earlier stages with a corresponding increase in prices and effort. The authors pay barely a page on the Rational Unified Process (RUP) and the authors should look more closely into how their sensible advice and processes might be used on alternative iterative approaches to the waterfall approach. Finally, I suppose the book tried to be too broad by appealing to 3 totally different groups of people. Firstly, part one is geared toward those involved in a software team (project managers, analysts, programmers and testers). Part two is aimed at consultants hired to enhance project management practices and project managers who want to manage software outsourcing projects. The book would are better had it centered solely on those concerned in the software team. The penultimate chapter handling managing an outsourcing project is prohibited during a cursory method almost as if the authors felt they needed to say it as a result of outsourcing is such a business priority these days. The ultimate chapter dealing with method improvement is additionally too short to deal effectively with such a giant topic. Separate books dealing solely with these issues would have been additional appropriate. Not withstanding these points, this book is an excellent guide for those individuals concerned in software projects, both project managers and technical team members alike. They will find a lot of they will apply directly on their own projects. I might recommend this book to anyone who works on a software development team as a result of the book has so much practical advice to assist individuals improve their capability to deliver quality software. Return to think about it, I might also suggest it to senior managers of corporations who have a negative view of their own software development teams. Maybe then senior managers might understand why committing resources to process improvement is one amongst the simplest investments they can make.
Article Source: http://www.onlinearticlessite.com
Link : Barbara K Howard has been writing articles online for nearly 2 years now. Not only does this author specialize in Book Reviews, you can also check out his latest website about: Freehost24hWhich reviews and lists the best Virtual Server Hosting
Please Rate this Article
5 out of 54 out of 53 out of 52 out of 51 out of 5
Not yet Rated
