The Developer's Code und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
  • Alle Preisangaben inkl. MwSt.
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Menge:1
The Developer's Code ist in Ihrem Einkaufwagen hinzugefügt worden
+ EUR 3,00 Versandkosten
Gebraucht: Gut | Details
Verkauft von cumvita-sellonnet-gmbh
Zustand: Gebraucht: Gut
Kommentar: Gutes Remittendenexemplar - Gekennz. Mängelexemplar. UNGELESEN! Lediglich minimale Anschmutzungen sowie weitere minimale Lagerspuren. . In engl. verfasst. Schutzverpackter Versand i.d.R. am Bestelltag! Versandbestätigung per Email. Rechnung mit ausgewiesener MwSt.. Service Mo.-Fr. von 08:00-14:30 Uhr unter 040 - 530 22 350.
Ihren Artikel jetzt
eintauschen und
EUR 0,10 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
Dieses Bild anzeigen

The Developer's Code (Englisch) Taschenbuch – 1. Februar 2012


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 18,95
EUR 16,08 EUR 1,00
48 neu ab EUR 16,08 5 gebraucht ab EUR 1,00

Hinweise und Aktionen

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

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



Produktinformation


Mehr über den Autor

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

Produktbeschreibungen

Pressestimmen

This is the next "Pragmatic Programmer"--a guide for the beginner, a reminder for the expert, and a wonderful chunk of wisdom about the craft (and life) of a developer.--Derek Sivers Founder of CD Baby, sivers.org Ka Wai Cheung has written a book for professional developers seeking a code they can live by. This is not a book replete with conventional, find-it- in-any-blog ideas but a very powerful, focused approach to the craft and realities of professional programming. If you are looking for a rehash of stale, sterile rules for programming, this is not the book for you. But if you are seeking a perspective on what creating software is, or if you want a set of guidelines laden by real-world experience, this is a book you need.--Bob Walsh Author and Founder of 47 Hats Packed with delicious lessons yet consumable in bite (byte?) sized chunks --there's a lot to be learned in these pages. Take some time and learn from someone who's been there.--Adam Hoffman Senior Development Lead

Über den Autor und weitere Mitwirkende

Ka Wai Cheung is a developer, designer, and founding partner at We Are Mammoth, an award-winning team of web developers as passionate about approachability as they are about technology. Ka Wai is also the co-author of Flash Application Design Solutions: The Flash Usability Handbook.


In diesem Buch

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

Kundenrezensionen

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: 12 Rezensionen
11 von 12 Kunden fanden die folgende Rezension hilfreich
Pleasant but lightweight 24. Februar 2012
Von A. Ali - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
I bought this book knowing it would be lightweight -- yet I hoped there might be some nuggets of insight. There are a few but I can't help feeling disappointed in this 140-page book (it's not 250 pages, as Amazon indicates). The book I'm comparing it to is Joel Spolsky's dense and meaty 360-page "Joel on Software." There's no comparison. Not complaining -- "The Developer's Code" is a pleasant read on the commute home but still .... Maybe in a few years a second edition will roll out and be more substantial in content.

The book is divided into 52 sections (the last two of which haven't been numbered), with titles like "Lie to Simplify," "Invest in a Good Work Environment," "Work Outside the Bedroom," and "Teach with Obvious Examples." It can't be said there are earth-shattering insights in these sections.
7 von 8 Kunden fanden die folgende Rezension hilfreich
A few of these essays will change the way I do my work... 6. Mai 2012
Von Thomas Duff - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I like books that gather a number of essays and thoughts about technology (in this case, software development) and bundle them in a single volume so I can contemplate what it is I do as a profession. The Developer's Code - What Real Programmers Do by Ka Wai Cheung (published by Pragmatic Bookshelf) fits that description perfectly. I've often said that one or two gems from a book like this can make it an excellent buy. For me, this one met and surpassed that criteria.

None of the essays here (52 in total) are technical in nature. You won't learn a new way to code algorithms or do systems architecture. Instead, they delve into mind-sets and concepts on how to think about the work and how it's done. An example would be the first two essays in the section on metaphors in software development. Since we've equated software construction to building construction, we tend to over-plan a system and nail everything down before we write a single line of code. But in reality, code is flexible and changeable, whereas bricks and mortar can't be easily "fixed" once it's put down. The metaphor of "construction" means that we may over-plan before writing code (think waterfall vs. agile), thereby limiting our productivity. Metaphors aren't bad, but you do need to be careful that it doesn't inadvertently create boundaries that don't exist.

I personally found the section on teaching fascinating. Specifically, "Lie to Simplify" put words behind a problem I fall prey to on far too many occasions. When trying to teach someone a new skill or feature, I want to tell them absolutely everything... all the edge cases, the minor oddities, and the obscure errors where things don't work as advertised. The problem is that the student doesn't even understand the basic concepts, much less the esoterica. Rather than dump everything on them at once, just lie. Tell them how things work in 95% of the situations. Don't even mention the exceptions... until they've mastered the basics. Once they know that knowledge, you can fill in the blanks. That single essay right there will change the way I convey information to others.

Since everyone comes from different backgrounds and experience levels, everyone will have different reactions to The Developer's Code. But I think I'm safe in saying it's well worth reading, and you should easily find the two or three gems that will make your purchase a wise investment in yourself.

Contents:
Introduction: Who Is the 21st-Century Programmer?; Discovering the Lessons Firsthand; This Book Is About Us
Metaphor: Follow Metaphors with Care; Plan Enough, Then Build; Launch Is Just the First Release; The "Ivory Tower" Architect Is a Myth; Throw Away Your Old Code; Diversification Over Specialization; Metaphors Hide Better Ways of Working
Motivation: The Perks Are in the Work; Begin Where You Love to Begin; Be Imperfect; Stop Programming; Test Your Work First Thing in the Morning; Work Outside the Bedroom; First Impressions Are Just That; The Emotional Value of Launch; Find an Argument
Productivity: Just Say "No" to the Pet Project; Constrain All of Your Parameters; Cut the Detail Out of the Timeline; Improve Your Product in Two Ways Daily; Invest in a Good Work Environment; Keep a Personal To-Do List; Create "Off-Time" with Your Team; Work in Small, Autonomous Teams; Eliminate the "We" in Productivity
Complexity: Sniff Out Bad Complexity; The Simplicity Paradox; Complexity as a Game of Pickup Sticks; Keep Complexity Under the Surface; "Hard to Code" Might Mean "Hard to Use"; Know When to Refactor; Develop a Programming Cadence
Teaching: Teaching Is Unlike Coding; Beware the "Curse of Knowledge"; Teach with Obvious Examples; Lie to Simplify; Encourage Autonomous Thought
Clients: The Tough Client Is Ubiquitous; Demystify the Black Magic of Software; Define the Goals of Your Application; Be Enthusiastic and Opinionated; Be Forgiving and Personable; Value Is Much More Than Time; Respect Your Project Manager
Code: Write Code As a Last Resort; A Plug-in Happy Culture; Code Is the Ultimate Junior Developer; Separate Robot Work from Human Work; Generating Code at Its Core; The Case for Rolling Your Own
Pride: We Have a Marketing Problem; Lessons from the Cooking Industry
Bibliography

Disclosure:
Obtained From: Publisher
Payment: Free
4 von 4 Kunden fanden die folgende Rezension hilfreich
Its The Book I Wish I Wrote 17. März 2012
Von Mark Orlando - Veröffentlicht auf Amazon.com
Format: Taschenbuch
While the author has been in the IT field for 15 years, I've been in this profession for 30 years. If I had to write down what I've learned over the last 30 years, this books collection of essays would have been it! Its an easy read that allows you to spend 10-15 minutes here and there reading bite by bite. I liked how the topics were laid out as it made the book easier to read.

Chapter 4 on productivity presented a great idea on how to take "Ta-Da", the free to-do list progam from 37 Signals one step higher. The author's simple technique in Essay 22 has already helped me to better track my accomplishments. Chapter 9, entitled "Pride" was a real pleasure to read. I liked how he explained the phenomena of the cooking-show industry, how its changed over the years, and how software development should use this as a marketing idea. The chapter also talked about "The Healing Power of Construction Work" and how developers fall into the same boat as construction workers, namely, that software development is therapeutic.

In summary, it was a great book to read on my Kindle and reminded me of things I learned in the past but have forgotten.
3 von 3 Kunden fanden die folgende Rezension hilfreich
Short but inspiring read 22. Februar 2012
Von Jack D. Herrington - Veröffentlicht auf Amazon.com
Format: Taschenbuch
This is a fun book to give you little pickups of inspiration, insight and even some coding advice. Though the coding advice I would consider only an extra in this case since it's clearly not the main point of the book. The book concentrates on the ins and outs of software development as a profession. How to teach people, how to work with clients, how to get things done, and perhaps most importantly how to be pragmatic and to have fun. Are you going to learn about some obscure C# syntactic construct here? No. But that's what Google is for anyway nowadays.

If you are a serious life-time engineer who wants a little pick-me-up to get back into fun development buy this book.
3 von 4 Kunden fanden die folgende Rezension hilfreich
Disappointing book on developer habits 5. Januar 2014
Von Bas Vodde - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I like the title of this book! I like the idea of writing some of the most important practices that "real programmers" do. After finishing this book, I hope someone else will write such a book. This one wasn't it. This book was a short collection of essays from one persons career and feels enormously biased to one persons context. The subtitle should probably be called "what one programmer has done".

The book consists of essays. Each essay is a couple of pages large and in total, there are 50 essays. The essays are categorized in eight categories: 1) Metaphor, 2) Motivation, 3) Productivity, 4) Complexity, 5) Teaching, 6) Clients, 7) Code, and 8) Pride. Each of these categories consist of about 5-10 essays.

I won't go over all the essays, so let me point out some that I felt good and some that I didn't like too much. Good ones were like Essay one "Follow Metaphors with Care". This isn't new (in fact, a very common subject in similar book). In our industry we have copied many metaphors from other industries and we are sometimes misled by them. Essay 24: "Work in small, autonomous teams". Again, nothing shocking new, but it is good to remind people that working in teams and giving them authority is a good thing. Essay 39: "Demystify the black magic of software" talks about having to explain how software development works (at least some basics) to clients. I think this isn't mentioned often enough and is good to stress. After all mutual understanding helps with better cooperation.

A couple of the essays that I didn't like. Essay 12 "Test your work first thing in the morning" was very unclear to me. I'm not sure what the author is implying with test here, but he seems to focus on manual test? Does that mean test automation isn't part of the "developer's code" anymore? Essay 13 "Work outside the bedroom" felt very irrelevant to me. I've worked well in the bedroom and it is too bad to hear it didn't work out for him. To make this a general "developer's code" sounds like overdoing it. Essay 44 "Respect your project manager". I'm not sure what to say about this, but respecting a role (which is often executed very poorly) doesn't sound like great advise for a developer. It feels like one-persons experience in one way of working (and conflicts a bit with the autonomous teams IMHO).

All in all, there were some good essays and some bad essays. It was only when the the section "Code" came that the book started to really annoy me. I was looking forward to the section on code and was wondering what useful tips the author would give. I was very disappointed. Why? Nearly all of the essays related to code generation!?!? Now, code generation can definitively be a good thing, but it isn't so good that the whole code sections should contain essays on code generation. This doesn't reflect my experience of "the developer's code".

The book was well written in an easy to read style. You'll be able to read through quickly. That said, there was quite some blah blah in it such as the talk about programming an elevator and the complexity that there is in such a problem. One to two sentences would do, but instead it goes on and on. So, overall I think it was an ok book (as I shouldn't except to agree with all essays), but then the code section change it in a book that I cannot recommend anyone to read. If you want a book on "developer's code", then I suggest to pick up The Pragmatic Programmer: From Journeyman to Master or The Passionate Programmer: Creating a Remarkable Career in Software Development (Pragmatic Life) but not this one.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.