Title: The Pragmatic Programmer
Author(s): Andrew Hunt, David Thomas
Pages: 321

Table of Contents:

1 A Pragmatic Philosophy
1. The Cat Ate My Source Code
2. Software Entropy
3. Stone Soup and Boiled Frogs
4. Good-Enough Software
5. Your Knowledge Portfolio
6. Communicate!

2 A Pragmatic Approach
7. The Evils of Duplication
8. Othogonality
9. Reversibility
10. Tracer Bullets
11. Prototypes and Post-it Notes
12. Domain Languages
13. Estimating

3 The Basic Tools
14. The Power of Plain Text
15. Shell Games
16. Power Editing
17. Source Code Control
18. Debugging
19. Text Manipulation
20. Code Generators

4 Pragmatic Paranoia
21. Design by Contract
22. Dead Programs Tell No Lies
23. Assertive Programming
24. When to Use Exceptions
25. How to Balance Resources

5 Bend, or Break
26. Decoupling and the Law of Demeter
27. Metaprogramming
28. Temporal Coupling
29. It's Just a View
30. Blackboards

6 While You Are Coding
31. Programming by Coincidence
32. Algorithm Speed
33. Refactoring
34. Code That's Easy to Test
35. Evil Wizards

7 Before the Project
36. The Requirements Pit
37. Solving Impossible Puzzles
38. Not Until You're Ready
39. The Specification Trap
40. Circles and Arrows

8 Pragmatic Projects
41. Pragmatic Teams
42. Ubiquitous Automation
43. Ruthless Testing
44. It's All Writing
45. Great Expectations
46. Pride and Prejudice


Review:
The book that makes a programmer a programmer, that changes you from hobbyist (or school boy/girl) to a programmer. This book teaches you not about how to program, but rather how to be a programmer.

A pragmatic programmer learns new programming languages every year! If you are looking for habits that build your value and make you a better, stronger programmer, then this is the book.

If your coding methods are good, but not great then read this book! It covers the methodology of coding, testing, and securing your code.

Actually sounds like a decent book. I've got a few books of my own lying around. They're how I learned HTML, CSS, and the basics of PHP. (JavaScript was via PB tutorials... fail, I know.) They work very well, but they can only get you so far, as you basically mentioned in your review right there.

Title: Refactoring: Improving the Design of Existing Code
Author(s): Martin Fowler
Pages: 431

Table of Contents:

1 Refactoring, a First Example
2 Principles in Refactoring
3 Bad Smells in Code
4 Building Tests
5 Toward a Catalog of Refactorings
6 Composing Methods
7 Moving Features Between Objects
8 Organizing Data
9 Simplifying Conditional Expressions
10 Making Method Calls Simpler
11 Dealing with Generalization
12 Big Refactorings
13 Refactoring, Reuse, and Reality
14 Refactoring Tools
15 Putting It All Together

(It was my intention to copy each table of contents essentially as is to this, but I forgot how absolutely massive the number of sub-sections was in this book. Suffice it to say that each chapter covers A LOT.)

Review:
Code always gets out of hand. It always becomes a mess. There are always problems with it. Sometimes it's your own code, and you've just let it slip here-and-there, finally ending up with a few shortcuts turned into a massive screw up, bug prone and hard to change. Sometimes it's someone else's code, that you were lucky enough to inherit responsibility for (you'll know too, when they smile and say be my guest when the duties have been assigned to you).

The point is, it doesn't really matter. At some time in your programming career, you will have to deal with shitty code. You can tip-toe around the edges and take ages making the changes that were requested. That's one option, and just for the record, it's a very shitty option (coming from experience).

The other option is to refactor. To take that code that looks battered and broken and make it pristine, clean, and beautiful. The challenge is high, it may seem difficult, it may seem like it would take forever. Not to fear though!

Refactoring is a book that not only explains refactoring, but it tells you EXACTLY how to do it. It's almost as good as the book doing the refactoring for you (but not quite). The book goes over what needs to refactored and how to do it (offering many options along the way).

Following the rules and the methods set down in this book, you can make your scary and mean looking code into an easy to use and easy to understand code.

Truth be told, I haven't gone and refactored entire applications down to the finest level. However, I applied the methods in this book to turn those applications into more manageable ones. Before I got this book, I was afraid to mess with code that someone else wrote (with the feeling of "Oh God, I might break it"). This book gives you a process to follow that works, and makes that fear needless.

No code is truly perfect, which is why it is important for a programmer to understand refactoring. It might not be able to be perfect, but it can be better!

Title: Design Patterns: Elements of Reusable Object-Oriented Software
Author(s): Erich Gamma, Richard Helm, Ralph Johnson, John M. Vlissides
Pages: 416

Table of Contents:

1 Introduction
What Is a Design Pattern?
Design Patterns in Smalltalk MVC
Describing Design Patterns
The Catalog of Design Patterns
Organizing the Catalog
How Design Patterns Solve Design Problems
How to Select a Design Pattern
How to Use a Design Pattern

2 A Case Study: Designing a Document Editor
Design Problems
Document Structure
Formatting
Embellishing the User Interface
Supporting Multiple Look-and-Feel Standards
Supporting Multiple Window Systems
User Operations
Spelling Checking and Hyphenation
Summary

3 Creational Patterns
Abstract Factory
Builder
Factory Method
Prototype
Singleton
Discussion of Creational Patterns

4 Structural Pattern
Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy
Discussion of Structural Patterns

5 Behavioral Patterns
Chain of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Template Method
Visitor
Discussion of Behavioral Patterns

6 Conclusion
What to Expect from Design Patterns
A Brief History
The Pattern Community
An Invitation
A Parting Thought

Review:
The book that started it all (well, not really, but it did for me!). You probably hear the term "design pattern" thrown around fairly often, you might even know a few. All the time I see design patterns treated as amazing things, like, "wow, you know design patterns."

Let me just first say that anyone who says that is an idiot. Design patterns, as explained by the book, are common solutions to common problems. Writing a program is closer to solving a set of problems than it is creating something from scratch. Knowing design patterns will help you solve these problems, as they are tested time and time again.

Design patterns are not magical pieces of code, they are not done for you. They are patterns that you fill in yourself, solving the problem. It requires an understanding of the pattern and the problem to be used properly.

That's where the book comes in. It goes over some of the most common patterns, and some of the first, and explains their usefulness. Even if you don't immediately start applying the concepts you learn, it will get the clocks turning, and in time you will be more architecturally-aware (I guarantee it).

The book is broken into two sections, the first is an overview and a "case study." The case study just shows how the design patterns are used to solve problems encountered. The second section is a reference of a few design patterns. No book could hope to contain every design pattern, as there are a ton of them, and new patterns are being discovered as the solutions to new problems every day.

If you are looking to start learning more about how to put together code rather than just how to code, this is the book for you.

Note: it is mainly focused on independent applications, and not all of it can be applied to the web, but I'd highly recommend it anyways.


Last Edit: Jun 22, 2009 4:00:15 GMT by Eric