Head First Software Development und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
  • Alle Preisangaben inkl. MwSt.
Nur noch 2 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Menge:1
Head First Software Devel... ist in Ihrem Einkaufwagen hinzugefügt worden
+ EUR 3,00 Versandkosten
Gebraucht: Gut | Details
Verkauft von Deal DE
Zustand: Gebraucht: Gut
Kommentar: Dieses Buch ist in gutem, sauberen Zustand. Seiten und Einband sind intakt.
Ihren Artikel jetzt
eintauschen und
EUR 3,40 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Alle 2 Bilder anzeigen

Head First Software Development (Englisch) Taschenbuch – Dezember 2007

3 Kundenrezensionen

Alle 3 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Taschenbuch
"Bitte wiederholen"
EUR 31,95
EUR 28,94 EUR 22,79
53 neu ab EUR 28,94 7 gebraucht ab EUR 22,79

Hinweise und Aktionen

  • Große Hörbuch-Sommeraktion: Entdecken Sie unsere bunte Auswahl an reduzierten Hörbüchern für den Sommer. Hier klicken.


Wird oft zusammen gekauft

Head First Software Development + Head First Design Patterns
Preis für beide: EUR 69,90

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



Produktinformation

  • Taschenbuch: 495 Seiten
  • Verlag: O'Reilly & Associates; Auflage: 1 (Dezember 2007)
  • Sprache: Englisch
  • ISBN-10: 0596527357
  • ISBN-13: 978-0596527358
  • Größe und/oder Gewicht: 20,3 x 2,5 x 23,5 cm
  • Durchschnittliche Kundenbewertung: 4.7 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 76.068 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

Synopsis

Even the best developers have seen well-intentioned software projects fail - often because the customer kept changing requirements, and end users didn't know how to use the software you developed. Instead of surrendering to these common problems, let "Head First Software Development" guide you through the best practices of software development. Before you know it, those failed projects will be a thing of the past. With its unique visually rich format, this book pulls together the hard lessons learned by expert software developers over the years. You'll gain essential information about each step of the software development lifecycle - requirements, design, coding, testing, implementing, and maintenance - and understand why and how different development processes work. This book is for you if you are: tired of your customers assuming you're psychic. You'll learn not only how to get good requirements, but how to make sure you're always building the software that customers want (even when they're not sure themselves); wondering when the other 15 programmers you need to get your project done on time are going to show up.

You'll learn how some very simple scheduling and prioritizing will revolutionize your success rate in developing software; confused about being rational, agile, or a tester. You'll learn not only about the various development methodologies out there, but how to choose a solution that's right for your project; and, confused because the way you ran your last project worked so well, but failed miserably this time around. You'll learn how to tackle each project individually, combine lessons you've learned on previous projects with cutting-edge development techniques, and end up with great software on every project. "Head First Software Development" is here to help you learn in a way that your brain likes...and you'll have a blast along the way. Why pick up hundreds of boring books on the philosophy of this approach or the formal techniques required for that one? Stick with "Head First Software Development", and your projects will succeed like never before. Go on, get started...you'll learn and have fun. We promise.

Über den Autor und weitere Mitwirkende

Dan Pilone is a Senior Software Architect with Blueprint Technologies, Inc. and a mediocre rock climber. He has designed and implemented systems for Hughes, ARINC, UPS, and the Naval Research Laboratory. He also teaches project management, software design, and software engineering at The Catholic University in Washington D.C.

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


In diesem Buch

(Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:

Kundenrezensionen

4.7 von 5 Sternen
5 Sterne
2
4 Sterne
1
3 Sterne
0
2 Sterne
0
1 Sterne
0
Alle 3 Kundenrezensionen anzeigen
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

8 von 8 Kunden fanden die folgende Rezension hilfreich Von O. Kring am 29. Februar 2008
Format: Taschenbuch
Das Buch vermittelt Einsteigern auf unterhaltsame Weise die Grundlagen erfolgreicher Softwareentwicklung. Es weist anhand von (Java) Fallbeispielen auf die üblichen Fehler und deren Folgen hin, und gibt konkrete Methoden an, um solche Fehler zu vermeiden und Programmier-Katastrophen abzuwenden, ohne jemals langweilig und zu theoretisch zu werden.

Entwickler-Profis bietet das Buch sicherlich wenig Neues, da aufgrund der Vielzahl der Themen nicht allzu sehr in die Tiefe gegangen werden kann. In diesen Fällen kann dieses Buch die etablierte Spezialliteratur nicht ersetzen.

Insgesamt ein klasse Grundlagen-Buch - als solches ausnahmslos zu empfehlen.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
7 von 7 Kunden fanden die folgende Rezension hilfreich Von M. VINE-PRODUKTTESTER am 14. Juni 2008
Format: Taschenbuch
Bereits auf der ersten Seite wird man darüber informiert, dass dieses Buch didaktisch auf dem neuesten Stand psychologischer Forschung basiert.
Das merkt man auf jeder einzelnen Seite! Dieses Buch ist didaktisch so hervorragend gearbeitet - es kommt alles wie aus einem Guss. Und man merkt gar nicht, dass man ein Fachbuch in der Hand hält. Mit diesem Buch lernt man im wahrsten Sinne des Wortes spielerisch!
Ich bin der Meinung, dass jeder Fachbuchautor als Pflichtlektüre eines der Head First Bücher gelesen haben sollte. Hier kann sich ausnahmslos jeder didaktisch noch etwas abgucken.
Dieses Buch bringt einen im Software Engineering das Maximale was ein Buch bringen kann, den Rest muss man eh in der Praxis lernen, da hilft einem kein Buch weiter.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
0 von 7 Kunden fanden die folgende Rezension hilfreich Von Thomas Kruse am 4. November 2008
Format: Taschenbuch
Die Tips und Hinweise in dem Buch sind ausgezeichnet und machen aus einem Programmieranfänger einen guten Entwickler.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 32 Rezensionen
39 von 43 Kunden fanden die folgende Rezension hilfreich
The Head First series scores again 16. Januar 2008
Von calvinnme - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I've read and reviewed several of the "Head First" series of books on programming languages and software design, so I thought I would give this one a try too. Unlike so many books on software development, this one doesn't start with a terse and rather useless overview chapter. Instead it clearly tells you who this book is for: Those who have a background in programming, specifically Java, who want to learn techniques for building and delivering software. First the book explains the Head First concept in learning - using puzzles, cartoons, graphics, and anything else that should stick in your head to explain the usually dry topic of software engineering.

The first three chapters - "Great Software Development", "Gathering Requirements", and "Project Planning" - talk about how software development usually goes wrong and talks about some of the methods for organizing your efforts. Chapter 4 puts some of these ideas in motion when the book analyzes the development of a mythical application, iSwoon. The book has the application get into serious trouble and then shows you the way out of the abyss using good software design methodology. Next, the book has you adding features to "BeatBox Pro", which is an application from the "Head First Java" book. This is where your ability to understand Java code comes into play. The book also discusses the use and usefulness of the Ant build tool for Java projects. However, this is a book on how to approach the design of the software, not how to perform the detailed coding, so having somewhat rusty Java skills should be acceptable. Throughout the book are puzzles, Q&A sessions, and "There are no dumb question" sessions that really drive home the points being made. The following is the table of contents for the book:

1. Great Software Development
2. Gathering Requirements
3. Project Planning
4. User Stories and Tasks
5. Good-enough Design
6. Version Control
6.5 Building Your Code
7. Testing and Continuous Integration
8. Test-Driven Development
9. Ending an Iteration
10. The Next Iteration
11. Bugs
12. The Real World
Appendix A. Leftovers
Section A.1. #1. UML class diagrams
Section A.2. #2. Sequence diagrams
Section A.3. #3. User stories and use cases
Section A.4. #4. System tests vs. unit tests
Section A.5. #5. Refactoring
Appendix B. techniques and principles
Section B.1. Development Techniques
Section B.2. Development Principles

In summary I would highly recommend this book for someone looking for an approachable guide to software development. It will probably also help students enrolled in a course in software engineering since it makes clear and accessible a subject that usually gets bogged down in dry academic prose in the textbooks usually assigned for such classes.
31 von 34 Kunden fanden die folgende Rezension hilfreich
Modern, Lucid and Rational 13. Februar 2008
Von Craig Riecke - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
Since becoming a Development Manager, this is the first book I've made required reading for the team. Good software development is NOT common sense. When confronted with something as complex as a software project, people tend to respond with panic (which the book calls the Big Bang) or massive attempts at control (the Waterfall method).

HFSD preaches Iterative Development without all the dogma of Scrum or XP. It leaves the controversial stuff to other books, focusing on what good developers pretty much agree on. The practices are easily adopted and flexible, although like all worthwhile things in the world, they take a lifetime to master.

There's a lot to like about this book. The other Head First guides are good, but the style really, really fits the material here ... maybe because development is really less about technology than it is about working with others.
13 von 14 Kunden fanden die folgende Rezension hilfreich
This actually has material for both new and long-time developers... 3. November 2008
Von Thomas Duff - Veröffentlicht auf Amazon.com
Format: Taschenbuch
When I first looked at Head First Software Development by Dan Pilone and Russ Miles, I was thinking that it would be best targeted at people who had never formally written software before. It definitely fits that bill. But I can see a use for experienced developers who have never been exposed to agile development techniques. Either way, it's a very good book.

Contents:
Intro
Great Software Development: Pleasing Your Customer
Gathering Requirements: Knowing What The Customer Wants
Project Planning: Planning For Success
User Stories and Tasks: Getting To The Real Work
Good-Enough Design: Getting It Done With Great Design
Version Control: Defensive Development
Building Your Code: Insert Tab A Into Slot B...
Testing and Continuous Integration: Things Fall Apart
Test-Driven Development: Holding Your Code Accountable
Ending An Iteration: It's All Coming Together...
The Next Iteration: If It Ain't Broke... You Still Better Fix It
Bugs: Squashing Bugs Like A Pro
The Real World: Having A Process In Life
Appendix 1 - Leftovers: The Top 5 Things (We Didn't Cover)
Appendix 2 - Techniques and Principles: Tools For The Experienced Software Developer

The authors do a great job of covering the entire software development process, from getting requirements to debugging code. But instead of going back to the older and more traditional waterfall method of software development, they chose to expose the reader to the agile methodology. Personally, I think that's a great decision, as it gets across important techniques such as story cards, iterations, and test-driven development. Learning those skills as the primary way to build software goes a long way towards prepping the new developer for the marketplace.

But as I contemplated this approach, I realized that the content would work for more than just new software developers. There are still a large number of long-time developers who have been raised in the waterfall method. When you start talking about agile techniques, there's a hesitancy to try something so radically different than what they've always done. HF Software Development can serve as that "first exposure" to the agile methods for them. It's no secret that I love the Head First method of teaching, so I'm convinced that the style of writing would also be perfect for absorbing the new information.

It's not often that I find a book that can effectively address two audiences at entirely different ends of the spectrum. But I guess I shouldn't be surprised that it's a Head First book that pulls it off. If you're a new software developer, this will get you started off on the right foot. And if you're an experienced (read: long-time) developer, don't be so quick to dismiss this...
12 von 15 Kunden fanden die folgende Rezension hilfreich
Good for the new Team... but 10. Mai 2009
Von Trevor G. Leybourne - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I looked through this book online using Amazon and some of the pages looked of interest to me as I am working with some new teams who have not used Agile before and there were parts of this books (mainly around user stories) which got my attention.

I have been developing for 25 years and have been managing Agile teams over the last 4 years, recently using Scrum as the framework of choice. I was looking for some further material to expand my knowledge base and having read Head First Design Patterns (highly recommended) I thought this book would fit my needs.

For me, I was dissapointed. I read this book basically cover-to-cover in about 3 hours and there were aspects which made me think, on the whole there was nothing new in this book and the topics it did cover it did not go into any real depth. For me, not a good use of my money.

However, as a book to get my team and future teams who are new to Agile, Test First, Continuous Integration, Version Control, Unit Testing, User Stories, etc, this book is great and I do recommend it.

The Head First series of books take the reader on a simple journey. Nothing complex or where there is something complex they de-complex it and in some ways dumb it down to a reasonably low common-denominator. This means just about anyone can read this book and should understand the concepts and principles in it. I plan to provide this to some non-technical BA's who I work with and other than the section on Unit Testing know that they will be able to read this, digest it, and understand the principles and then hopefully use them within our organisation.
4 von 4 Kunden fanden die folgende Rezension hilfreich
If you want to learn simple effective tehniques for software development, this is the book! 16. Januar 2011
Von Armando Fonseca - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
Before begining my first professional program, I bought this book. At first, I was wondering how all those pictures and games exercises will help me to learn about software development. I told to myself, "I'm a in a profession that has books with "dummy" in their titles, and now books with middle school games... what's next? coloring books for developers?" After that though, I went straight to code and put this book right back into my bookshelf. While I was able to deliver the software on-time (with overtime), I experienced success but not with out frustrations. In retrospective, I think I did the right thing by not using this book at first because now I really appreciated what this book offers. I would recommend this to any developer for the following reasons: First, those pictures and middle school games that I just mention, some how they work pretty well if you want to learn something. While I put certain effort to learn from more traditional books, with the head first approach, I was able to learn software development techniques and principles with no effort whatsoever. Seconds, while this book is load with software development fundamentals, their main goal is help out the real-world working developer. With this book, I felt understood, I felt that they knew about my personal frustrations (and mistakes) that I encountered when I was developing my program. Finally,they also try to avoid getting into complex and formal software processes (SCRUM, XP, etc) by presenting pen and pencil techniques that keeps you focus on learning the fundamentals. I just finished reading this book, I feel that my developing powers have increased. Right now, I'm setting up my home CI server to begin my first real open source program. I just got head first design pattern and head first object oriented design and I hope to get the same fun that I got with this book!
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.