The real challenge of programming isn't learning a language's syntax—it's learning to creatively solve problems so you can build something great. In this one-of-a-kind text, author V. Anton Spraul breaks down the ways that programmers solve problems and teaches you what other introductory books often ignore: how to Think Like a Programmer. Each chapter tackles a single programming concept, like classes, pointers, and recursion, and open-ended exercises throughout challenge you to apply your knowledge.
You'll also learn how to:
–Split problems into discrete components to make them easier to solve
–Make the most of code reuse with functions, classes, and libraries
–Pick the perfect data structure for a particular job
–Master more advanced programming tools like recursion and dynamic memory
–Organize your thoughts and develop strategies to tackle particular types of problems
Although the book's examples are written in C++, the creative problem-solving concepts they illustrate go beyond any particular language; in fact, they often reach outside the realm of computer science. As the most skillful programmers know, writing great code is a creative art—and the first step in creating your masterpiece is learning to Think Like a Programmer.
|Publisher:||No Starch Press|
|Product dimensions:||6.90(w) x 9.20(h) x 0.80(d)|
About the Author
Table of ContentsIntroduction
Chapter 1: Strategies for Problem Solving
Chapter 2: Pure Puzzles
Chapter 3: Solving Problems with Arrays
Chapter 4: Solving Problems with Pointers and Dynamic Memory
Chapter 5: Solving Problems with Classes
Chapter 6: Solving Problems with Recursion
Chapter 7: Solving Problems with Code Reuse
Chapter 8: Thinking Like a Programmer
Most Helpful Customer Reviews
This book bills itself as an introduction to creative problem solving and it starts off on the right track. Using a few interesting logical puzzles such as the "fox, goose, and corn crossing the river" puzzle and an alien combination lock puzzle invented by the author, it explains some useful problem solving techniques such as breaking a problem into manageable pieces, looking for analogies to previously solved problems, and attacking the easiest parts of a problem first. Unfortunately the author is sometimes rather pedantic, beating a topic into the ground long after it has lost all interest. The book also spends a lot of time on programming-specific topics that aren't really creative problem solving. For example, the book spends six pages explaining what arrays are and how they work, eight pages on string manipulations, and whole sections on basic data structure topics such as linked lists. These are important topics but they really aren't creative problem solving. These topics also require a fair amount of C++-specific syntax and manipulation. For example, the sections on string manipulation don't make any sense in languages such as C#, Java, or Visual Basic that treat a string as an entity instead of as a series of bytes. You can still read the text and try to pull out the deeper concepts but they are obscured by the C++ orientation. The book might have been improved by using pseudo-code for everything and focusing only on problem solving tricks and techniques, but perhaps the author wanted to use C++ so readers could write concrete, testable programs. This might be a good second book for a beginning C++ programmer, but more experienced programmers will be familiar with most of the topics covered in this book and programmers using other languages will need to make some mental adjustments to convert the C++ examples into a more familiar form.