A suggestion from Bob Martin's "Clean code" has me scratching my head..
"If once function calls another, they should be vertically close and the caller should be above the callee"

So far, I've been more or less sticking close to the .Net guidelines, which group class members by type (properties, ctors, functions) and visibility (public / prot. / private).
The tip seems like trouble at first.. but it "just might work". I personally have encountered cases where I liked this layout - easier to drill down when you're in the right call chain.

The idea behind the tip seems sound but other scenarios like "let me look at the public interface of this class" might get worse. Maybe Uncle Bob is banking on the small classes and IDE support for viewing types...

Has anyone tried this out for an extended period ?

Update: Seems like a code-snippet is in order

```
class SomeType()
{
  /// fields, ctors, et. all
  public void Method1()   { // calls HelperMethod1 and HelperMethod2 }
  private void HelperMethod1 { // calls HelperMethod3 }
  private void HelperMethod3 {}
  private void HelperMethod2 {}

  public void Method2 () { // and so on... }

}

```