fashionwintersale15 Hier klicken Kinderweihnachtswelt Kalenderangebote Oktober2015 Cloud Drive Photos UHD TVs Fire TV sally bosch Hier klicken Fire Shop Kindle dvd XMAS
Think Like a Programmer und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
EUR 21,95
  • Statt: EUR 25,90
  • Sie sparen: EUR 3,95 (15%)
  • Alle Preisangaben inkl. MwSt.
Nur noch 7 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Think Like a Programmer: ... ist in Ihrem Einkaufwagen hinzugefügt worden
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
Alle 3 Bilder anzeigen

Think Like a Programmer: An Introduction to Creative Problem Solving (Englisch) Taschenbuch – 13. August 2012

1 Kundenrezension

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Gebundene Ausgabe
"Bitte wiederholen"
EUR 66,19
"Bitte wiederholen"
EUR 21,95
EUR 21,95 EUR 27,11
48 neu ab EUR 21,95 3 gebraucht ab EUR 27,11

Hinweise und Aktionen

  • Verschenken Sie Bücher zu Weihnachten: Entdecken Sie die schönsten Buchgeschenke zu Weihnachten, Adventskalender und Bücher rund ums Fest. Hier klicken.

Wird oft zusammen gekauft

  • Think Like a Programmer: An Introduction to Creative Problem Solving
  • +
  • Write Great Code: Understanding the Machine
Gesamtpreis: EUR 61,81
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.


  • Taschenbuch: 252 Seiten
  • Verlag: No Starch Press; Auflage: 1 (13. August 2012)
  • Sprache: Englisch
  • ISBN-10: 1593274246
  • ISBN-13: 978-1593274245
  • Größe und/oder Gewicht: 17,8 x 2,8 x 22,9 cm
  • Durchschnittliche Kundenbewertung: 3.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 85.795 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


Über den Autor und weitere Mitwirkende

V. Anton Spraul has taught introductory programming and computer science for more than 15 years. This book is a distillation of the techniques he has used and honed over many one-on-one sessions with struggling programmers. He is also author of Computer Science Made Simple.

In diesem Buch

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


3.0 von 5 Sternen
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne
Siehe die Kundenrezension
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

4 von 5 Kunden fanden die folgende Rezension hilfreich Von Elbwasser am 18. April 2013
Format: Taschenbuch Verifizierter Kauf
Ich fand die Idee des Buches interessant, das Problemlösungsdenken zu trainieren. Wirklich hilfreich ist das Buch aber wohl eher für Einsteiger in die Programmierung, die sich (noch) schwertun, algorithmisch zu denken. Erfahrene Programmierer werden aber wohl eher enttäuscht sein.

Wer problemlos Programme "from scratch" schreiben kann, braucht dieses Buch nicht. Für alle anderen kann es aber eine lohnende Lektüre sein.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden

Die hilfreichsten Kundenrezensionen auf (beta) 30 Rezensionen
48 von 50 Kunden fanden die folgende Rezension hilfreich
I'd make this a required book for starting CS students 8. Oktober 2012
Von William Springer - Veröffentlicht auf
Format: Taschenbuch
While I was working on my PhD in computer science, part of my job as a TA was to run the computer lab. I never cared for Java, but I learned enough of it to be able to help the undergraduates when they got stuck working on their homework assignments.

What struck me is that often the undergrads know more Java than I did; their problem was that they didn't understand how to solve problems. Once I walked them through the process of designing a solution, then they could write the program. When I interviewed at Microsoft, the interviewer said the same thing: that many of the people he had talked to were not able to even answer the first interview question (which required figuring out a solution to a problem and then coding it).

As such, it's no surprise that I was happy to see this book, with its promise of helping people understand how to solve problems rather than simply how to write code. The first chapter immediately dives in to solving some logic puzzles; while these aren't computer related (and some are classic problems that everyone knows) they get the point across that programming is about solving problems. The actual language is secondary; what's important is being able to break the problem down to the relevant information and figure out a way to solve it. Once you have an approach that allows you to tackle the problem, then you can figure out how to do each individual step.

Chapter two switches to solving problems using C++, rather than generic logic puzzles, and then we're off and running. We follow that with one chapter each on solving problems using arrays, pointers and dynamic memory, classes, recursion, and code reuse. Finally we have a chapter about working to your strengths as a programmer to find solutions efficiently.

For the most part, I enjoyed the book. There are a few places where it seems that the author made a change to a problem or assumption and then didn't fix later text that referred to the original version; for example, in chapter 5 the default constructor for a student object initializes grade to 0 and studentID to -1, but the following text refers to a possible error due to grade being initialized to zero. Except for a problem in chapter two where relevant information is introduced in the solution rather than the problem description, though, these don't detract too much from the reading.

At the end of each chapter is a list of simply-described programming problems that require you to thoroughly explore the concept covered in that chapter. Working through them all should take some time, but will probably be worth it; even as a working programmer, I'm tempted to go through all of them just to get a better handle on C++, which I rarely use.

The book assumes that the reader understands how to write a program with C++, but everything except the absolute basics has a review at the start of the relevant chapter. I think this would be a very good text to use for a freshman course on programming, assuming you can find one these days that still uses C++ rather than Java! (Although for the most part, the concepts apply to any language, so you could use it with Java anyway.) Having read this, a novice programmer should be much better equipped to break down a problem and get to work, rather than staring at the description wondering where to start.

I give this 4.5 stars due to the errors mentioned above, which rounds up to five for a highly recommended book.

Disclosure: I received a free review copy of this book for Vulcan Ears Book Reviews (
26 von 28 Kunden fanden die folgende Rezension hilfreich
Getting past "blank page, what do I do?!" 19. November 2012
Von Michael Larsen - Veröffentlicht auf
Format: Taschenbuch
I recently read Andy Hunt and Dave Thomas' "The Pragmatic Programmer". I thought to myself that it was interesting to see this book from the perspective of 13 years later and what was still being practiced actively and where we may have moved on, as well as the suggestions they made to be effective and, yes, pragmatic programmers.

To book end this experience, I wanted to look at another title that was in a similar vein, but much more recent, as in this title was released just a few months ago. This book, V. Anton Spraul's "Think Like a Programmer", covers much of the same ground as "The Pragmatic Programmer", but does so with a much narrower scope. While "The Pragmatic Programmer" looked to focus on many different aspects of being effective, "Think Like a Programmer" puts the bulk of its energy on one issue; problem solving and the tools necessary to approach problems and develop solutions. The goal of this book is to help answer that age old challenge... I understand the syntax, I can read code, I can modify code, I can work with other people's code and understand what it's doing, but when I sit down in front of a blank editor, I'm lost!

"Think Like a Programmer" takes the reader down a number of paths to help explain some of programmings more challenging aspects and do so with generally basic coding structures. The entire book's examples are in C++, so there is a unity to the problems being presented. While the examples are in C++, all but a few of the problems could be ported to other languages like Java, Ruby, Python, etc.. The Chapter on pointers might be the sole exception, and the chapter on classes comes from the perspective of a language that can be used with both procedural and object oriented approaches.

Don't let the code intimidate you, especially if you are not a programmer by trade. I did enough C++ programming in college to recognize the structures and the methods used for the solutions, so there was nothing in the code itself that was terribly frightening or all that advanced. Beginners, or those who have never seen any C++ code, may feel a little lost in spots, but Anton takes the time to explain every line. The goal of the book is not to focus specifically on coding syntax, but on the problem solving domain. Getting good and usable code, that's a definite bonus, and he makes the case for doing all of the things that Andy and Dave talk about in "Practical Programmer".

The problems all use standard elements of the C++ programming language. Arrays, pointer, classes and recursion all get a chapter dedicated to their own issues. Problems are presented and a detailed breakdown as to how to go about solving them is shown. Each chapter has a variety of exercises to work through.

The last chapter focuses on allowing the programmer to devise their own game plan to solve problems, and each game plan will be unique to that particular programmer. Strengths and weaknesses are rarely the same, so making a "best practices" list for everyone would be pointless. Instead, Anton works the reader through methods and aspects that can help them create their own unique problem solving methodology, using all the tips and techniques practiced in the book, and leveraging their own individual strength, weaknesses, and areas of focus and interest. One thing to be aware of... there are no answers to the exercises provided. That's by design. the point to the exercises is to see what you would come up with, and help break the cycle of "blank page, I'm lost!"

Bottom Line:

Seasoned developers may find this a bit basic for their tastes. Rank beginners might find the examples intimidating. Those in between, even those who are not C++ programmers, will likely learn a good deal and help de-mystify a few areas by working through the examples and problems. As a tester, rather than a programmer, I think that these titles are helpful to look at the issues that programmers face, as well as the issues and methods used to solve problems. Since we have to test those solutions, understanding how programmers get there and the tools they use to get there is helpful. "Think Like a Programmer" is a solid step in helping both programmers and testers look at these situations in interesting ways.
31 von 35 Kunden fanden die folgende Rezension hilfreich
Ask Felgall - Book Review 11. August 2012
Von Stephen Chapman - Veröffentlicht auf
Format: Taschenbuch
One thing I have noticed over the years is that at least 95% of programmers spend a long time writing what ought to be relatively simple code and that they usually end up with a lot more code than they really needed. The problem is that these programmers have only learnt half of what they really need to know in order to be able to write programs - the programming language itself. The other half of programming is a creative process that is not taught in most programming classes and which in part is a talent that can't be taught.

This book sets out to teach the part of the creative part of programming that can be taught to those who don't have the talent of visualising solutions to complex problems. Anyone who uses the techniques taught in this book will eventually find their way into that top 5% of programmers who can write good solutions to complex programming problems. As they use creative problem solving to produce more effective code their programming ability will improve even though they may have no greater understanding of the particular programming language syntax than they did at the start.

While just about everything in this book seemed trivial and obvious to me (but then I'm not part of the target audience for the book), experience has shown me that such things are seldom either trivial or obvious to most other programmers and I have not previously seen any resource that explains these processes as clearly as this book does. This is definitely a book that I would use in teaching programming to others,

The author has chosen C++ as the language used for the solutions to the various problems the book uses to demonstrate the problem solving process. This is a good choice because many modern languages use a similar syntax so that those who don't know C++ should still be able to understand what the code does well enough to be able to implement an equivalent in a language that they do know. The book also has several chapters that deal with the types of problems that are those most likely to cause problems for those programmers who don't really understand creative problem solving. Those are the ones where there are many solutions that will sort of work but which are either require many times as much code or will be extremely inefficient of both.

Those teaching computer programming no longer have an excuse for only teaching the students half of what they need to know to be good programmers. They should all now be adding an extra subject to their course to teach the other half using this book as the class text.
14 von 15 Kunden fanden die folgende Rezension hilfreich
How To Think Like A (C++) Programmer 31. März 2013
Von Joe Helfrich - Veröffentlicht auf
Format: Taschenbuch
Is it possible to "spoil" a technical book? Well, if so, here's your spoiler warning.

The most important lesson from "How To Think Like A Programmer" is simply this: "when faced with a problem you are unable to solve, you reduce the scope of the problem, by either adding or removing constraints, to produce a problem that you do know how to solve." It's a simple concept that should be engraved on every surface a beginning programmer sees. Learning to do that is possibly the most important part of turning technical knowledge of a programming language into the ability to solve problems with that knowledge. Every problem can be broken down into smaller pieces, and eventually you'll get to a point where the problems are simple enough that you can solve them yourself or quickly look up a solution, and then start bolting those solutions together until you have a passable solution to the original problem. (It may not be the most efficient or bug free code, but writing code is like all other types of writing in one fundamental respect: write something, even if it sucks. You can improve it later, but having a first approximation is the most important part of a project.)

The above quote comes from the first chapter of the book, which focuses on problem solving methodologies rather than actual code. This was the most useful part of the book for me, not just because it laid out several simple strategies for attacking programming problems, but because it was language agnostic. The rest of the book, unfortunately, isn't.

The programming examples in the book are all done in C++, and while they're usually simple enough that anyone with a basic understanding of modern object oriented programming can follow the examples in the book, being able to attack the problems in that language is a completely different matter. I was often able to approximate the exercises in languages I am more familiar with, but in doing so, I didn't always end up solving the same problems that the exercise was supposed to cover.

As a programmer who works mostly with web projects, I would have liked to see more variety in the languages used; it would have only added a few pages to provide code examples in javascript or python or java, in addition to C++. Only a small portion of the book deals with issues that are specific to C++. But given Spraul's apparent belief that "real programmers" only use C++ (he writes in the introduction that "C++ is the real deal--it's programming without training wheels") such a change seems unlikely.

Regardless, the book is still worth a read for programmers looking to break that barrier from having learned about programming to actually being able to program something (and probably hugely useful to programmers looking to make that jump in C++), and the first chapter should be required reading for every introductory programming course.

(This book was provided to me for review as part of the O'Reilly Blogger Review Program)
14 von 16 Kunden fanden die folgende Rezension hilfreich
Good book for the right kind of reader 1. November 2012
Von Joseph Kong - Veröffentlicht auf
Format: Taschenbuch
I'll admit right away that I'm probably not the target audience for this book, because I'm not new to programming or problem solving. However, I know that whenever I revisit something like programming fundamentals, I learn something new.

In this review I'd like to highlight my favorite parts of Think Like a Programmer (TLAP).

On page 31 the following problem is presented: "Write a program that takes an identification number of arbitrary length and determines whether the number is valid under the Luhn formula. The program must process each character before reading the next one." I liked this problem because I've seen similar ones during job interviews. That is, ones that require you to process each character before reading the next one.

Chapter 5, "Solving Problems with Classes," was a good refresher for me as I haven't worked with classes in years. A person who programs with classes regularly may not find this chapter as useful. However, for a procedural programmer like myself, I rather liked it.

Chapter 6, "Solving Problems with Recursion," described recursion in a very clear manner. I was taught recursion in high school and again in undergrad and I don't recall it ever being explained this concisely.

Chapter 8, "Thinking Like a Programmer," is my favorite chapter because of the problem presented in it: Write a text-based version of hangman. The twist is that the program must cheat the player. I found this to be the most fun problem in the book. I rather enjoyed Spraul walking me through his methods in order to come up with a solution.

I subtracted one star from the overall rating for one reason: There are a number of errors in this book. Here are some examples.

On page 32 Spraul states "starting with the digit to the right of the check digit." There is nothing to the right of the check digit, he meant left.

On page 38 there is a line of code that reads "else checksum += 2 * (digit - '0');" This line doubles the numerical value of digit and adds that to checksum, which is the incorrect behavior as per the problem description. On page 31 the problem description states "if a doubled value now has two digits, add the digits individually." On page 37 (one page earlier) Spraul implements the correct behavior, so when I got to the code on page 38, I read it multiple times in order to make sure that I didn't miss something. I didn't, the code there is just incorrect.

On page 66 there is a sentence that reads "Therefore, we initialize it to 0 and not the value in location[0]." There is no variable named location in the code listing, Spraul meant histogram[0].

The errors in TLAP don't reduce the value of its contents, but I found them jarring.

In conclusion, while I would like the errors to be addressed in an errata or second edition, if you're new to programming or have trouble writing original programs you should check out this book.

Note: I have a pre-existing business relationship with No Starch Press. I've written two books for them. Also, they sent me a review copy of TLAP.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.