If you need to call methods from main(), they shouldn’t be hidden in the first place.

For general design I think the categories or extensions (“anonymous” categories) mechanism is better suited to keeping private methods separate from the public interface. This certainly would fit better when implementing and maintaining a UML design and/or keeping the internal methods separate from the object interface.

– (void)logMessageByTouch:(UITouch *)touch withDescriptor:(NSString *)desc {

then later a compiler error:

[self logMessageByTouch:activeTouch withDescriptor:@"touchesBegan"];

The compiler is fine when I specify the method in the header, so it’s not my syntax. Maybe I’m missing something (I was surprised). To eliminate this compilation problem, and to avoid order of function definition dependencies (mentioned above), one can declare an @interface for a private category at the top of the .m file. Not sure if this is acceptable but it works:

@interface MyClass(private)
- (void)logMessageByTouch:(UITouch *)touch withDescriptor:(NSString *)desc;
// other private methods here
@end

@implementation
…

// ===========================
// = File: SomeClass.h
// = Interface for SomeClass
// ===========================
#import 
 
@class SomeClassImpl;
 
@interface SomeClass : Object {
  SomeClassImpl *myImpl;
} 
-(int) msg;
+(void) classMsg; 
@end

—————————-

// ===========================
// = File: SomeClass.m
// = Implementation for SomeClass
// = NB: the pImpl class is both declared and its implementation defined here.
// ===========================
 
//The hidden interface goes here. These methods will not be available for the outside world.
@interface SomeClassImpl : NSObject {
}
+(void) hiddenClassMethod;
-(void) hiddenInstanceMethod; 
@end
 
@implementation SomeClass
-(id) init {
  if (self = [super init]) {
    myImpl = [[SomeClassImpl alloc] init];
  }
  return self;
}
 
-(int)msg {
  return [myImpl hiddenInstanceMethod];  //These will be perfectly hidden: no instance is leaked.
}
 
+(void) classMsg {
  [SomeClassImpl hiddenClassMethod];  //Well, you can't _really_ hide class methods
}
 
-(void) dealloc {
 [myImpl release];
 [super dealloc];
}
@end
 
@implementation SomeClassImpl
...
@end

1) Declare the private methods in a separate .h file (with a file name like “SomeClassPrivate.h”).
2) Tag this interface with a (private) category.
3) Import both the SomeClass.h & SomeClassPrivate.h into your implementation .m file

The benefits are:
Increased separation of code – the private interface is apart from the public (still)
The private methods can be placed anywhere in your implementation (the whole reason for header files in the first place).