|
PSP(sm): A Self-Improvement Process for Software Engineers (SEI Series in Software Engineering) | 
 enlarge | Author: Watts S. Humphrey
Publisher: Addison-Wesley Professional
Category: Book
List Price: $59.99
Buy New: $43.97
You Save: $16.02 (27%)
New (16) Used (13) from $25.00
Rating:  4 reviews
Sales Rank: 56191
Media: Hardcover
Pages: 368
Number Of Items: 1
Shipping Weight (lbs): 1.7
Dimensions (in): 9.2 x 6.4 x 1.2
ISBN: 0321305493
Dewey Decimal Number: 005.1
EAN: 9780321305497
ASIN: 0321305493
Publication Date: March 13, 2005
Availability: Usually ships in 1-2 business days
Condition: All orders ship same business day via standard shipping (USPS Media Mail) if received by 1 PM CST.
| |
| Also Available In:
|
| Similar Items:
|
| Editorial Reviews:
Product Description
Most software-development groups have embarrassing records: By some accounts, more than half of all software projects are significantly late and over budget, and nearly a quarter of them are cancelled without ever being completed. Although developers recognize that unrealistic schedules, inadequate resources, and unstable requirements are often to blame for such failures, few know how to solve these problems. Fortunately, the Personal Software Process (PSP) provides a clear and proven solution. Comprising precise methods developed over many years by Watts S. Humphrey and the Software Engineering Institute (SEI), the PSP has successfully transformed work practices in a wide range of organizations and has already produced some striking results. This book describes the PSP and is the definitive guide and reference for its latest iteration. PSP training focuses on the skills required by individual software engineers to improve their personal performance. Once learned and effectively applied, PSP-trained engineers are qualified to participate on a team using the Team Software Process (TSP), the methods for which are described in the final chapter of the book.The goal for both PSP and TSP is to give developers exactly what they need to deliver quality products on predictable schedules. PSPSM: A Self-Improvement Process for Software Engineers presents a disciplined process for software engineers and anyone else involved in software development. This process includes defect management, comprehensive planning, and precise project tracking and reporting. The book first scales down industrial software practices to fit the needs of the module-sized program development, then walks readers through a progressive sequence of practices that provide a sound foundation for large-scale software development. By doing the exercises in the book, and using the PSP methods described here to plan, evaluate, manage, and control the quality of your own work, you will be well prepared to apply those methods on ever larger and more critical projects. Drawing on the author's extensive experience helping organizations to achieve their development goals, and with the PSP benefits well illustrated, the book presents the process in carefully crafted steps. The first chapter describes overall principles and strategies.The next two explain how to follow a defined process, as well as how to gather and use the data required to manage a programming job. Several chapters then cover estimating and planning, followed by quality management and design. The last two chapters show how to put the PSP to work, and how to use it on a team project. A variety of support materials for the book, as described in the Preface, are available on the Web. If you or your organization are looking for a way to improve your project success rate, the PSP could well be your answer.
|
| Customer Reviews:
 Excelent book April 10, 2007
S. V. Moreno (Toluca, México)
0 out of 1 found this review helpful
This book is a great tool to learn how to improve our development process. I'm very happy with my buy.
 Study a good self improvement software engineering method August 27, 2005
Manca Massimo (Pordenone, PN Italy)
5 out of 10 found this review helpful
The book is good, every argument weel written with simple language and lesson tailored. PSP is a good set of processes to use in software development. If you wish to self study PSP it is good but you have to download a lot of material from the SEI website (exercises, workbooks and so on). Humprey write about process extensions but not so much as needed in practice. Also a more detailed description about PSP processes isn't present on the book so you haveto read about on SEI website material.
Applies well in some but not all situations... May 8, 2005
Thomas Duff (Portland, OR United States)
20 out of 24 found this review helpful
As an IT professional and software developer, I'm all for standards and processes. PSP - A Self-Improvement Process for Software Engineers by Watts S. Humphrey (Addison-Wesley) outlines a personal methodology for improving your development efforts. But it's definitely not applicable to all environments...
Chapter List: The Personal Process Strategy; The Baseline Personal Process; Measuring Software Size; Planning; Software Estimating; The PROBE Estimating Method; Software Planning; Software Quality; Design and Code Reviews; Software Design; The PSP Design Templates; Design Verification; Process Extensions; Using The Personal Software Process; Index
From an overall perspective, I think the concepts in here are good and the book is well-written. Watts has devised a methodology that a developer can apply on their own to improve their coding, estimating, and defect resolution skills. This is done by extensive measurement and recording of statistic and time taken to accomplish certain tasks. These numbers are transferred to forms that can then be statistically analyzed to see the trends and make corrections in your techniques based on personal problem areas. The advantage that this methodology offers is that you don't have to get buy-in from an entire department in order to implement it. Conversely, PSP can be extended to apply to a team development environment in order to improve everyone's ability to work and develop code as a group.
Where I start to have issues is that it doesn't translate well to all environments. It's best applied to situations where you're developing programs with actual lines of code (like Java or C++) that allow you to do things like count lines of code, program sizes, or function points. It doesn't address rapid application development (RAD) environments like Lotus Notes/Domino very well, as "lines of code" is often next to nothing. Graphical design techniques that code underlying "plumbing" will make your numbers seem very small. Counting and tracking defects could be useful, but once again you'll often have to ignore stats related to defects per program size. You'll also need to be pretty comfortable with statistics to work with this methodology, as Watts gets into some pretty large formulas to generate the "score" of some of the tracking measures.
This is one of those books where if I were coding 15000 line Java programs, I might be really excited. Developing in a RAD environment makes me see a lot of this as unnecessary tracking for tracking's sake. But if you're a "true software engineer" in the most traditional sense, you'll probably find things in here that you'll want to try out.
review before compiling?! April 15, 2005
W Boudville (Terra, Sol 3)
14 out of 16 found this review helpful
The intent is to reduce the defect rate in software. With an emphasis on doing this when we have several million lines of source code. All the more so if the application might involve safety issues or be critical to its company's bottom line.
Humphrey points out that the writing of such large code might typically follow practices used for code bodies orders of magnitude smaller. But that this leads to far too many defects. He explains that PSP offers a discipline for the individual programmer to follow. And how this can be scaled to a team of programmers.
PSP stresses investing in design time and review time, relative to the actual coding time. It's big on writing down the times spent on these stages, so that you have actual quantities to see and from which to get metrics. You cannot improve what you cannot measure. The review time is considered a good investment, for finding bugs here is inherently more productive than relying on a downstream testing stage or user feedback.
Perhaps the most contentious aspect is whether to do a review of your code before compiling it?! Many will not. After all, the compiler can swiftly find the syntax errors. Why waste time looking for these beforehand? Isn't this a retrograde step? The book's rejoinder is that syntax errors might be considered to be distributed like more serious logic errors. Hence, if you review before compiling, and find 80% of the syntax errors that the compiler finds, then perhaps you only also found 80% of the logic errors. Opps?
A simple and ingenious self diagnostic tool. But despite the logic of this, water will flow uphill before any significant portion of programmers adopts this method. Pressing 'make' or its equivalent to do a compilation is simply too easy. The book is on far more plausible ground describing the other aspects of PSP.
|
| We Accept All Major Payment Types! | |
|
|
|
|
Brought to you by Sagetips, LLC in Association with Amazon | |
