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.

GUI Bloopers: Don'ts and Do's for Software Developers and Web Designers (Morgan Kaufmann) [Englisch] [Taschenbuch]

Jeff Johnson
4.4 von 5 Sternen  Alle Rezensionen anzeigen (8 Kundenrezensionen)

Erhältlich bei diesen Anbietern.



Kurzbeschreibung

14. April 2000
"GUI Bloopers" looks at user interface design bloopers from commercial software, Web sites, and information appliances, explaining how intelligent, well-intentioned professionals made these dreadful mistakes - and how you can avoid them. While equipping you with all the theory needed to learn from these examples, GUI expert Jeff Johnson also presents the reality of interface design in an entertaining, anecdotal, and instructive way. This is an excellent, well-illustrated resource for anyone whose work touches on usability issues, including software engineers, Web site designers, managers of development processes, QA professionals, and usability professionals.

Hinweise und Aktionen

  • Studienbücher: Ob neu oder gebraucht, alle wichtigen Bücher für Ihr Studium finden Sie im großen Studium Special. Natürlich portofrei.



Produktinformation

  • Taschenbuch: 576 Seiten
  • Verlag: Morgan Kaufmann (14. April 2000)
  • Sprache: Englisch
  • ISBN-10: 1558605827
  • ISBN-13: 978-1558605824
  • Größe und/oder Gewicht: 23,5 x 18,8 x 3,1 cm
  • Durchschnittliche Kundenbewertung: 4.4 von 5 Sternen  Alle Rezensionen anzeigen (8 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 37.698 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Mehr über den Autor

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

Produktbeschreibungen

Amazon.de

In GUI Bloopers, consultant Jeff Johnson uses 550+ pages to illustrate common pitfalls in user interface design, the all-important iceberg tip that end users confuse with applications and that developers confuse with end users. Reporting on 82 incidents of bad design, Johnson manages to cover the essential point of his message: software designers should think of their user interfaces from the user's point of view. Not profound, but profoundly overlooked in most low-end to mid-range development efforts. His codification of GUI design in eight predictable principles will help GUI newbies realize that the customer must be pleased with the product. Of course, the customer doesn't always understand what he or she wants. Hence, GUI development is iterative. When the customer is not at hand, a surrogate will do, so usability testing is essential.

The bloopers include mistakes in window design, labeling consistency, visual/grammatical parallel construction, coherence of look and feel, and clarity. Most perceptively, Johnson observes that CPU speed in the development group hides many design mistakes. Moreover, context-scoping, already a subtle problem in software design, must be implemented in GUI design. Input error handling is the most psychologically sensitive of all GUI design characteristics. User error messages can easily be too vague or too specific, and diagnostic error messages should be user-manageable, if not actually user-interpretable.

Like the Hollywood outtakes that gave us the "blooper," the entertainment quotient here is measured in mistakes, not successes. Teaching by counter example rather than by example at an estimated ratio of three to one, Johnson panders to our invertebrate instinct to measure our own successes by someone else's failure. To his credit, he recognizes that user interfaces include pedestrian texts (like his) as well as graphical interfaces for computer applications. His self-referential style gives the book an egocentric slant, but he is both priest and practitioner: he submitted a draft to usability testers and reports the results in an appendix. One criticism was that there were too many negative examples. Hmmm.

Thanks to other tester comments, GUI Bloopers is a browsable book, allowing the few nuggets of wisdom to be located. For the most part, the book's value can be captured by reading the seven-page table of contents carefully. --Peter Leopold

Pressestimmen

"Better read this book, or your design will be featured in Bloopers II. Seriously, bloopers may be fun in Hollywood outtakes, but no movie director would include them in the final film. So why do we find so many bloopers in shipped software? Follow Jeff Johnson as he leads the blooper patrol deep into enemy territory: he takes no prisoners but reveals all the design stupidities that users have been cursing over the years." - Jakob Nielsen, Usability Guru, Nielsen Norman Group "If you are a software developer, read this book, especially if you don't think you need it. Don't worry, it isn't filled with abstract and useless theory--this is a book for doers, code writers, and those in the front trenches. Buy it, read it, and take two sections daily." - Don Norman, President, UNext Learning Systems

In diesem Buch (Mehr dazu)
Einleitungssatz
"I wish! Alas, many others have stated this principle before me, and it doesn't seem to have done much good." Lesen Sie die erste Seite
Mehr entdecken
Wortanzeiger
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:

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

4.4 von 5 Sternen
4.4 von 5 Sternen
Die hilfreichsten Kundenrezensionen
7 von 7 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen An Essential Guide. Buy It. 23. Mai 2000
Format:Taschenbuch
You might be put off by the title - "'Bloopers'? I don't want to know what NOT to design, I want to know WHAT to design." That was my initial reaction. I was looking for a good intro to GUI for a graduate-level course and didn't want to teach by negative example. Well, fret not. Although he uses negative examples, Johnson does it extremely well and buttresses each yang with the yin of positivity - what the design should have done, and why it went wrong. The result is easily the best of the current crop of 'how to design GUIs' texts. It is readable, well-organized, and covers all the basics. I do not agree with the other Amazon reviews which question the negative slant and Johnson's frequent self-references. For me they fit right in and are appropriate. Finally, a usability book which was usability tested, the results used in editing the book, and the whole process reported in an appendix. Marvelous.
War diese Rezension für Sie hilfreich?
3 von 3 Kunden fanden die folgende Rezension hilfreich
Format:Taschenbuch
This is an indispensable book for anyone involved in the making of software. In 560 pages, Jeff Johnson presents 82 carefully selected examples of mistakes in GUI software and mistakes occuring in the process of developing GUI software (a GUI Blooper). Instead of just pointing his fingers at the Bloopers which are listed, Mr. Johnson provides a VERY exhaustive walk-through of the mistakes including: Why is this a mistake, what category does it belong to, what could be done to remedy the situation (including examples), common reasons for committing this mistake. As extras, two case stories from Mr. Johnsons career as an UI consultant are provided together with some general remarks on user centred development. My favorite chapter of the book contains examples on GUI mistakes wich are due to poor management. This chapter ought to be required reading for any software manager. The Bloopers are grouped in seven chapters: GUI Component Bloopers; Layout Bloopers; Textual Bloopers; Interaction Bloopers; Web Bloopers; Responsiveness Bloopers; Man-agement Bloopers. This grouping combined with a very extensive index makes this book ideal for reference purposes. The layout of the book is simple and clear - some may say boring. There are a number of drawings with examples of remakes of GUI elements which, although effective, are somewhat poor. For dictionary purposes this book may rightly deserve 5 stars. But due to the fact this book is overly wordy (I would say that 20% of the text is superfluous) and due to a somewhat content weak chapter on Web Bloopers, it will have to do with just four stars.
War diese Rezension für Sie hilfreich?
2 von 2 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen I Wish I Had it 6 Months Ago 30. April 2000
Von Ein Kunde
Format:Taschenbuch
I wish I had this book 6 months ago before my company blew money on cruddy software. The front end was absolutely horrible, but being an amateur I couldn't place my finger on what it was. My company bought the software and I bought this book. Just simply looking through the book, I now realize just what the problem with the front end was. Every single "don't" the book tells you to avoid, the software does! It blew my mind just how bad the software was. Too bad Jeff Johnson didn't do the work on the software :^( Why four stars? Some of the concepts, in my opinion, were a little difficult to work with. He gives wonderful "don'ts" for examples, but some of those "don'ts" don't seem to always have a solution for a work around. (Especially when dealing with large amounts of information.) Despite the four stars, any person who writes any code should at least look through this book, or steal a friend's.
War diese Rezension für Sie hilfreich?
1 von 1 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Good Overall 25. April 2000
Format:Taschenbuch
This book explains more "don't" than "do." I found several instances within projects I've been involved that Mr. Johnson rails against, and after reading his explanation, I tend to agree. That isn't to say that one will agree with everything Johnson says(you won't), but for the most part he was very insightful. My only complaint is that there aren't enough examples of how to avoid some of the problems(in some cases the remedies are only applicable in simplistic situations) - the section on TTY interfaces especially. Also note, that while the book often touches on web interfaces, the text is obviously geared towards traditional software developers. Overall, a worthy purchase.
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.

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