Jetzt eintauschen
und EUR 0,10 Gutschein erhalten
Eintausch
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Den Verlag informieren!
Ich möchte dieses Buch auf dem Kindle lesen.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Writing Solid Code: Microsoft Techniques for Developing Bug-free C. Programs (Microsoft Programming Series) [Englisch] [Taschenbuch]

Steve Maguire
3.8 von 5 Sternen  Alle Rezensionen anzeigen (22 Kundenrezensionen)

Erhältlich bei diesen Anbietern.


Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Taschenbuch --  

Kurzbeschreibung

Mai 1993 Microsoft Programming Series
Written by a former Microsoft developer, this book takes on the problem of bugs by examining the development process and the places where developers typically make mistakes. The author provides practical solutions for detecting mistakes and examples of how bugs are caught at Microsoft. More advanced sections talk in detail about stepping through code to find programming errors and using the C run-in library as an ally against bugs. This book is of special interest to readers who have bought "Programming Windows", "Microsoft Guide to C++ Programming", "Microsoft C Run-Time Library Reference" or "Code Complete".

Kunden, die diesen Artikel gekauft haben, kauften auch


Produktinformation

  • Taschenbuch: 256 Seiten
  • Verlag: Microsoft Press Corp. (Mai 1993)
  • Sprache: Englisch
  • ISBN-10: 1556155514
  • ISBN-13: 978-1556155512
  • Größe und/oder Gewicht: 23 x 18,7 x 2,2 cm
  • Durchschnittliche Kundenbewertung: 3.8 von 5 Sternen  Alle Rezensionen anzeigen (22 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 14.044 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

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

Produktbeschreibungen

Amazon.de

Any programmer worth their silicon knows that it is wiser to invest time preventing bugs from hatching than to try to exterminate them afterwards. And this is one of the best books for developing a proactive attitude towards electronic entomology. Follow Maguire's advice, and your testers, supervisors and customers will love you. Recommended.

Synopsis

Written by a former Microsoft developer, this book takes on the problem of bugs by examining the development process and the places where developers typically make mistakes. The author provides practical solutions for detecting mistakes and examples of how bugs are caught at Microsoft. More advanced sections talk in detail about stepping through code to find programming errors and using the C run-in library as an ally against bugs. This book is of special interest to readers who have bought "Programming Windows", "Microsoft Guide to C++ Programming", "Microsoft C Run-Time Library Reference" or "Code Complete".

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


Eine digitale Version dieses Buchs im Kindle-Shop verkaufen

Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen. Weitere Informationen

Kundenrezensionen

Die hilfreichsten Kundenrezensionen
45 von 51 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Avoid this book 20. Juli 2000
Von Ein Kunde
Format:Taschenbuch
I've never written a review here before, but I feel I should warn people against this book. I bought it myself, because of the positive reviews here. This book will NOT teach you to write solid code, at least not the way I see it. For one thing, it's dated, the examples are written in C, not C++ or some other object-oriented language. That wouldn't matter if it was good advice as sound design can be language-independent. However, in my opinion, it isn't. To start with naming, he uses Hungarian notation (which is a way of putting the type of the variable in the variable name (which doesn't give much meaning in C++, with user-defined types)), like "pchFrom", which means "pointer to char," which gives cryptic variable names, reminiscent of much C code. If you get past that, he offers among other things, the following suggestions. The first ones are about the compiler. He suggests that the compiler should be able to catch the following "mistake":
while(size-- > 0); // ";" should not be here, in this case.
*pchTo++=*pchFrom++;
I don't want an infantilizing compiler telling me I shouldn't have an empty statement following a "while," thank you very much.
Other advice is (with my comments after the quotes):
"Maintain both ship and debug versions of your program." - Don't. Don't duplicate code. He actually means having separate code for both versions. That means having to maintain both, and even if you fixed it in the debug version, it's not in the ship version.
He advocates using comments to explain unclear things. I prefer to have code self-documenting. That way, it's always up to date, too. If the code is unclear, rewrite it.
Lesen Sie weiter... ›
War diese Rezension für Sie hilfreich?
6 von 7 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Very good book on preventing C and C++ bugs 22. Oktober 1999
Format:Taschenbuch
I'm posting this mostly to counteract the buffoons who obviously gave this book a poor rating only because it was published by Microsoft Press. That's like criticizing Core Java 2 because you don't like Sun.
MS Press actually has an enviable stable of writers, and publishes many fine books. Ever heard of Steve McConnell? Jeff Prosise? Charles Petzold?
Anyway, this book is a very good source of advice on preventing C bugs on any platform. At one company where I worked, the VP of Engineering used to loan it to many programmers fresh out of college. Like Practice of Programming, it helps you get from what you learn in school to what will help you write production code in the real world.
I don't give it 5 stars because it's just not really a classic. You should give it a read if you program C or C++, though.
War diese Rezension für Sie hilfreich?
2 von 2 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Good summary of sound techniques 27. Juli 1999
Von "chuckw3"
Format:Taschenbuch
This book contains practical advice on how to write bug-free code. It covers a large number of guidelines which are generally applicable to all software development projects.
My only caution is that these techniques, when applied by novice programmers, is no doubt the source of much of Microsoft's code bloat. Also, encouraging the programmer to rely heavily on the source-level debugger can prevent developers from getting a real sense of the program's performance on user-level hardware.
Otherwise, a very good book and very useful advice, much of which I've been applying in my own projects.
War diese Rezension für Sie hilfreich?
1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Just brilliant 23. Juli 2008
Von xurg
Format:Taschenbuch
That book is brilliant. Read it, keep an open mind to understand the _principles_ behind solid coding which to author tries to communicate, such as: use all toolchain support you can get to make your code bug free; use a debugger to ensure your code is doing what you believe it's doing; stay consistent; write code so you and you co-worker can understand it 3 months from now.

Anyone sincerly enough interested in these issues should be able to look past minor details such as the programming language (C) used to explain them. Please, ignore the initial bad review, read it and improve your code quality *even* in a weak language like C.
War diese Rezension für Sie hilfreich?
5.0 von 5 Sternen Solid Food for Thought 16. März 1997
Von Ein Kunde
Format:Taschenbuch
The text starts by asking two questions about bugs found in code:

1) How could I have automatically detected this bug ?

2) How could I have prevented this bug ?

Steve goes on to lay out the process, techniques and guidelines for eliminating bugs. He systematically builds on the ideas and principles from previous chapters. Many of his techniques were new to me but made perfect sense, as if they should be universally embraced without question. He draws on his years of experience at Microsoft, where these techniques are still used today. The guidelines are meant to be integrated into the thought process of the programmer during the design stage. It is here where bugs can be eliminated in the least costly fashion. Many fine examples are provided, including a suite of memory management functions that are ready for deployment. I will definitely be using these principles in my code from now on. A perceptive, deliberate work that will sharpen the programmer's scalpel and pay dividends throughout the development and testing phases.
War diese Rezension für Sie hilfreich?
5.0 von 5 Sternen Great book on how good software is developed 7. Januar 1999
Format:Taschenbuch
This book is not a programmer's desk reference. Those looking for a how-to tome should look elsewhere. What this book contains is practical advice and lessons learned about software construction and projects. Maguire is a proponent of the theory that good software doesn't just happen - it is the result of good processes, and in this book he explains how to create these processes in your work environment, whether your job is that of a line programmer, a lead programmer, or a software project manager.
It is essential that the reader be able to take specific lessons in the book - like the Macintosh Excel programming project refereneced by another reviewer - and relate them not literally, but in the context of their own problems and projects. This requires independent thought, and may account for some of the bad reviews. I seriously doubt that anyone who rated this book below three stars read and understood it.
A great book and worth every penny.
War diese Rezension für Sie hilfreich?
Möchten Sie weitere Rezensionen zu diesem Artikel anzeigen?
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Die neuesten Kundenrezensionen
4.0 von 5 Sternen Just because its printed by the Microsoft press...
Mr. Maguire is an experienced programmer, and this shows in his book. You'll find a lot of his advice useful. Lesen Sie weiter...
Veröffentlicht am 2. Juli 2000 von Vishal G Soni
1.0 von 5 Sternen Who are you kidding?
Is Microsoft really the one to write a book on how to write solid code? Is this some kind of perverse oxymoron?
Veröffentlicht am 24. Juni 2000 von "i104800"
5.0 von 5 Sternen Excellent Content
The presentation of the content - as noted by other reviews - may not be 5 star, but the content definitely makes up for any failings of the book. Lesen Sie weiter...
Veröffentlicht am 15. Juni 2000 von Benjamin B Cronin
5.0 von 5 Sternen Exellent book for the experienced developer
As a software developer with 18 years of experience, I didn't expect to get much out of this book at all. Silly me. It changed the way I write code. Lesen Sie weiter...
Veröffentlicht am 2. Mai 2000 von Miguel A. Munoz
1.0 von 5 Sternen Microsoft writes bug-free code?
Well sorry to say it folks but this is just another way to get our users; money.
Am 6. Oktober 1999 veröffentlicht
5.0 von 5 Sternen I really want it!
I read the second book of Magurie. I like it
Am 23. September 1999 veröffentlicht
5.0 von 5 Sternen Should be required reading!
This book should be required reading for every college graduate. It teaches real world programming techniques which should be in every C/C++ programmers bag of techniques. Lesen Sie weiter...
Am 18. März 1999 veröffentlicht
1.0 von 5 Sternen no no no no no no no no!!!
Just think about the title!!! Microsoft - Bug free.... I don't think so!?!?!
Am 6. Dezember 1998 veröffentlicht
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar