Facts and Fallacies of Software Engineering

by Robert L. Glass, Paul Becker, Robert Glass

Book Overview

The practice of building software is a "new kid on the block" technology. Though it may not seem this way for those who have been in the field for most of their careers, in the overall scheme of professions, software builders are relative "newbies." In the short history of the software field, a lot of facts have been identified, and a lot of fallacies promulgated. Those facts and fallacies are what this book is about. There's a problem with those...

• Format: Paperback
• Language: English
• ISBN: 0321117425
• ISBN13: 9780321117427
• Release Date: October 2002
• Publisher: Addison-Wesley Professional
• Length: 216 Pages
• Weight: 1.05 lbs.
• Dimensions: 0.5" x 7.4" x 9.3"

Customer Reviews

Against common wisdom

Here's another short book (195 pages) that cannot be missing from a good software engineer's personal library. Robert L. Glass condenses in 55 facts and 10 fallacies - some of them well known, others more controversial - his vast knowledge of the field. The 55 facts are subdivided into four main sections: 1. About management 2. About the Life Cycle 3. About Quality 4. About Research The ten fallacies are instead grouped as follows: 1. About Management 2. About the Life Cycle 3. About Education This organization could provide a hint as to what sections of the book you'd better read first if you are managing programmers rather than if you're more involved in coding. But in any case, I suggest that whatever your positions, you will be better served by reading it all. Glass, a member of the "old guard" of software engineering, having been a practitioner of the field since its very beginnings, is a bit wary of espousing the latest trends in software, like eXtreme Programming. Some of his facts and fallacies fly right in the face of some XP principles and practices. See for instance fallacy nr. 3: Programming can and should be egoless. How can you reconcile this with collective code ownership and pair programming?. In other instances, he shares some of XP's convictions. See for instance fact 28: Design is a complex, iterative process. Initial design solutions are usually wrong and certainly not optimal. In the end, no matter what development process you like best, you're bound to find some controversial statements inside this book. If this makes you think about what you're doing and how successful you're being at it, I think the book will have fulfilled its purpose. By being apparently dogmatic in its format (what sounds more dogmatic than a list of asserted "facts"?) Glass manages to teach us that what you should be avoiding mostly is indeed dogma. In the current climate, dogma typically takes the form of a new development methodology that promises to end all debates on methodology. To fight this, everyone should memorize fallacy 5: Software needs more methodologies. Highly recommended!

Insightful To The New Manager/Team Leader

The other reviewers have done a fine job of covering the content of the book. I will comment about its usefulness. In short, this book is truly valuable to the developer who has recently been promoted to team leader. While developers would benefit greatly from this book, the reality is that most developers would rather read books like "Effective C++", "Design Patterns", "Expert One on One Oracle", etc. To the new manager, though, this book is a gem. The book talks about specific management issues as well as the development life cycle and quality. In short, the book focuses exactly on what the team leader does and the team leader's team. In addition to the material presented in the book, the author gives a great number of sources and reference for further reading.

Good summary of Software Engineering ideas and trends

Written in the style of "Effective */More Effective *", this book presents what the author asserts are 55 facts about software engineering.While you will see the obligatory "Adding people to a late project makes it later" section, the book also introduces several 'facts' that I have never really thought much about e.g. "Enhancements represent roughly 60 percent of maintenance costs"The true gems of this book are the 'source' and 'reference' section of each fact. Their purposes are twofold. Firstly, they serve to validate the author's claim for each of these facts. Secondly, they provide readers with good follow-ups.Amazingly, many if not most of the software classic are somehow mentioned in this book. (Even the cult classic Zen and the Art of Motorcycle Maintenance!)This book manages to capture most of the essence of software engineering literature of today. Certainly, you may not agree with what the author terms as facts. The author does attempt to address these issues under 'Controversy' for each fact.If you read this book, be sure to follow up on your reading with one of the many mentioned articles/books. Otherwise, you could potentially be left with only a surface understanding of the many issues involved.Fact 56: "This reviews is written from the viewpoint of a 4 year old software developer in Singapore"

A valuable and easy to read summary of the state of the art

I have read a fair number of software engineering books, and this is one of the more enjoyable books that I have read. When I first heard about it, I thought the concept of a sort of summary of the state of the art sounded really interesting. Although I haven't read any of the author's previous books, I have read and enjoyed his columns in IEEE Software and Communications of the ACM, so I had high hopes about this book. And I wasn't disappointed.Facts and Fallacies of Software Engineering is divided into 55 facts and 10 fallacies. Each fact and fallacy is presented in the same way. There is a headline/slogan that summarizes it, usually one or two pages of Discussion giving more details, then a Controversy section describing what (if anything) people disagree about and finally Sources and References.The 55 Facts are divided into the following sections and sub-sections: Management (People, Tools and Techniques, Estimation, Reuse, Complexity), Life Cycle (Requirements, Design, Coding, Error Removal, Testing, Reviews and Inspections, Maintenance), Quality (Quality, Reliability, Efficiency) and Research.The 10 Fallacies are divided into Management, Life Cycle and Education.This way of organizing the material works really well, and makes the book very accessible and easy to read. It also allows you to jump around and read what interests you the most first (which is what I did, although I eventually read all of it).Many of the facts are well known (for example Fact 3 "Adding people to a late project makes it later", Fact 16 "Reuse-in-the-large remains a mostly unsolved problem" and Fact 24 "Requirement errors are the most expensive to fix during production"), but that doesn't matter. It is actually good to be reminded of these facts even if you already know them, and the author does a very good job of summarizing them.Another thing I like about the book is the Sources and Reference parts (although I think they might as well have been combined into just one Reference section). Often there are references to research papers where the original fact was presented. It is nice to know that what is presented as a fact is indeed a fact that has been validated by research, and not just the opinion of the author (although there is certainly room for opinions in a lot of places as well).There are also lots of references to other books on software engineering, and a lot of the classic books (like The Mythical Man-Month, Peopleware and Design Patterns) are referenced. So there is plenty of leads in case you want to find out more about a certain fact.Among the facts I liked the most were Fact 12, Fact 21 and Fact 26. Fact 12: "Since estimates are so faulty, there is little reason to be concerned when software projects do not meet estimated targets. But everyone is concerned anyway". This fact and the related ones simply state that when a project is late, it is very likely because the estimated time to complete it was unrealistic. Very true.Fact 21: "For every 25 perc

(Not so) common wisdom about building software

Bob Glass is a programmers' programmer -- he's at the other end of the scale from software engineering gurus. This collection of fifty-five software facts and ten fallacies is distilled from his forty-five years of programming experience. Much of it is the kind of thing your grandmother could have told you -- if your grandmother was a programmer -- but some items will surprise and others annoy some people. Take the following two items as examples:"The 60/60 rule: 60 percent of software's dollar is spent on maintenance, and 60 percent of that maintenance is enhancement.""Understanding the existing product consumes roughly 30 percent of the total maintenance time." That implies that one of the most valuable skills you can teach a Computer Science student is how to *read* code. But as Glass points out (and he taught graduate students for a while) CS courses only teach students to *write* programs, and then they don't often grade the code on readability.The section on design, which Glass describes as the most intellectual phase of a software project, is the best description of how software designers actually work that I've ever read. He claims that top-ranked designers routinely ignore or subvert the methodologies used by their shops in order to do the job the right way. He has an especial warning for anyone trying to develop anything other than the most trivial program using XP.The ten fallacies may have taken some well-known quotes out of context. Surely Eric Raymond of the open source movement didn't really mean, "Given enough eyes all bugs are shallow", to be taken literally. Either way, the point Glass is trying to make is that, without proof, we shouldn't *assume* that open source code is less buggy than proprietary code.Facts and Fallacies of Software Engineering is aimed at two audiences: those without Glass' 45 years of programming experience, and those who have it but, like all good professionals, want to refresh the basics. Since some of the wisdom came with useful statistics that I've never seen published before, I'd recommend the book to anyone involved in developing or maintaining software.