• Statt: EUR 39,83
  • Sie sparen: EUR 0,59 (1%)
  • Alle Preisangaben inkl. MwSt.
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Facts and Fallacies of So... ist in Ihrem Einkaufwagen hinzugefügt worden
+ EUR 3,00 Versandkosten
Gebraucht: Gut | Details
Verkauft von Nearfine
Zustand: Gebraucht: Gut
Kommentar: Gelesene Ausgabe in gutem Zustand. Buch kann Gebrauchsspuren aufweisen oder Bibliotheksstempel enthalten. Lieferung voraussichtlich innerhalb von 20 Tagen.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Hörprobe Wird gespielt... Angehalten   Sie hören eine Hörprobe des Audible Hörbuch-Downloads.
Mehr erfahren
Dieses Bild anzeigen

Facts and Fallacies of Software Engineering (Agile Software Development) (Englisch) Taschenbuch – 28. Oktober 2002

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
"Bitte wiederholen"
EUR 39,24
EUR 36,12 EUR 26,74
8 neu ab EUR 36,12 6 gebraucht ab EUR 26,74

Wird oft zusammen gekauft

  • Facts and Fallacies of Software Engineering (Agile Software Development)
  • +
  • Peopleware: Productive Projects and Teams
Gesamtpreis: EUR 68,19
Die ausgewählten Artikel zusammen kaufen

Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone

Geben Sie Ihre E-Mail-Adresse oder Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr



A lot of what software engineers ought to know about building software is, for whatever reason, not known (forgotten, neglected, never considered, etc.). This book is a collection of fifty-five facts that software engineers should always consider. The facts are fundamental. The facts are frequently forgotten. And above all, the facts are important to the success of a project. Robert Glass brings a lifetime's work in software engineering to this often-witty book. In his considerable experience, the author has witnessed that software engineers need to learn the same lessons over and over again. In formally presenting many of these key facts, he hopes that software builders can avoid many of the pitfalls that all too often plague a project. The book covers management, all stages of the software lifecycle, quality, research, and much more. The author even presents ten common fallacies that help support the fifty-five facts. Anyone with an interest in building better software can benefit from this thought-provoking new book.

Über den Autor und weitere Mitwirkende

Robert Glass is the founder of Computing Trends. He has written more than a dozen books on software engineering and on the lessons of computing failures. Robert is trusted by many as a leading authority on software engineering, especially by those who read his columns in Communications of the ACM and IEEE Software. Robert also publishes a newsletter, The Software Practitioner, and speaks frequently at software engineering events. 0321117425AB09232002

Alle Produktbeschreibungen


Es gibt noch keine Kundenrezensionen auf Amazon.de
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: HASH(0xa0856390) von 5 Sternen 42 Rezensionen
88 von 90 Kunden fanden die folgende Rezension hilfreich
HASH(0xa08669e4) von 5 Sternen A valuable and easy to read summary of the state of the art 16. Dezember 2002
Von Henrik Warne - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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 percent increase in problem complexity, there is a 100 percent increase in complexity of the software solution." I had never seen this fact before, but it does ring true to me. And as the author writes, it explains a lot of the other facts in the book as well.
Fact 26: "Explicit requirements 'explode' as implicit (design) requirements for a solution evolve". In other words, each explicit requirement leads to many more implicit requirements (by a factor of up to 50). This too I had never seen stated, but I definitely recognize this from my own experience.
The Fallacies section list ten common misunderstandings in software engineering, and this is where I disagree on a couple of points. Fallacy 7 states "Random test input is a good way to optimize testing". I agree that it can not be the only test approach, but since he also writes "It may or may not survive as a test approach", he is skeptical to it in general. My own experience is that it is an invaluable complement that helps flush out numerous what I call "timing dependent" bugs caused by the nature of asynchronous events.
I also don't think all his arguments in Fallacy 8 are valid. I agree that since there is no data demonstrating the truth of "Given enough eyeballs, all bugs are shallow", we should not just accept it as truth. But I think he misses the point when he refers to research showing that inspections don't get much extra benefit beyond 2 to 4 participants. My interpretation is that the "enough eyeballs" are not so much inspecting the software in question as running it and debugging it when there is a problem. And the "all bugs are shallow" should not be interpreted too literally. Of course the bugs may still be difficult, but if many people look at it, the chances of someone solving it fairly quickly increases.
Those two examples notwithstanding, I did find myself nodding my head and saying "yes, I agree with that" almost all of the time reading this book.
There are many more interesting facts that I have not commented on, and if you are interested in software engineering I highly recommend this book.
33 von 33 Kunden fanden die folgende Rezension hilfreich
HASH(0xa0869f9c) von 5 Sternen Insightful To The New Manager/Team Leader 4. April 2003
Von Philip R. Heath - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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.
10 von 11 Kunden fanden die folgende Rezension hilfreich
HASH(0xa0869558) von 5 Sternen (Not so) common wisdom about building software 3. Dezember 2002
Von Celia Redmore - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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.
13 von 15 Kunden fanden die folgende Rezension hilfreich
HASH(0xa086e180) von 5 Sternen Good summary of Software Engineering ideas and trends 28. Februar 2003
Von Garry Bor - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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"
4 von 4 Kunden fanden die folgende Rezension hilfreich
HASH(0xa086e348) von 5 Sternen Insightful and Painful 2. Mai 2008
Von Isaac Z. Schlueter - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
This book covers all the mistakes we know about, but keep on making regardless.

When it arrived in the mail, I was amazed by how small this book was. It's a short read, but every section is brilliantly distilled to the bare essentials.

I've worked on several different teams developing software. There was very little in this book that came as a surprise. Every point seemed obvious, though in many cases, I was amazed by the wealth of research that Glass was able to cite to make his points. From the bankruptcy of hypesters to the importance of a work environment, Glass states the obvious with compelling and refreshing clarity.

The "painful" part was realizing that at some point in my career, I've made almost every mistake he highlights.

I found the tongue in cheek nature of the writing to be a bit much at times. That is my only complaint, and it's not so bad as to be unreadable.

It probably won't make you a better programmer, but the knowledge in this book will provide magnificent insight into all the non-coding aspects of software development that we so often overlook. Human nature hasn't changed, and software will always be complex. The facts and fallacies he cites truly are fundamental, and will be with us forever.

This book has given me a vocabulary with which to confront the absurd that we see every day in the world of software. Hopefully, I can now be a part of the solution rather than a part of the problem. Thank you, Dr. Glass!
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.