I've been reading the ObjectMentor blog, and it's got some fun stuff in it. The one I particularly liked is how do you know when a function does "just one thing" - the answer - extract methods until you can't extract any more.
Now, I know there is the feeling of - why should I waste all this time writing lots of tiny little functions? But after trying it for a bit, I'm convinced, for two main reasons (although I am sure there are more):
When you write small functions, each one is eminently readable. You look at it, and in an instant you understand what it does and its intent. You don't have to "decode" the method to understand the intent - it just tells you. I think this is essential - when you understand a code's intent, you can also understand if it is doing what you want it to.
Discovering New Classes
When you extract functions, sometimes you run into this situation where you are passing umpteen (meaning more than two) parameters into the function. To me, particularly when the list of parameters is long, this indicates the need to extract a class which encapsulates all this data you're passing around.
And I often find once I've extracted the class, it clarifies the design for me. You have an idea of a design, but you should really let the design reveal itself to you, and this is one of the great ways I have found that happening.
Also, often once a class is extracted, I can see how it can be used elsewhere - I have a new unit of reusability.
Anyway, I recommend keeping an eye on the ObjectMentor blog, there's good stuff there.