I have come up with some coding conventions that I seem to spend a not-insignificant amount of time explaining to some of the people I work with. Specifically, I have a convention for what actions are performed in a class's constructor vs. a factory method that creates an instance of the same.
Constructors. It's not very easy to figure out what's going on if your constructor manages to throw an exception. Furthermore, if you've derived from a class whose constructor can throw exceptions, it's even more difficult to debug. Constructors should just initialize a class's members, but do no real 'work'.
Take the .NET class System.DirectoryServices.DirectoryEntry. You can construct an instance of this class with a completely bogus LDAP path in the correct format, but the constructor will not throw an exception. It is not until an action is performed using the instance that anything will go wrong.
Factory methods. In my convention, if you want to create a new instance of a physical object like an object in Active Directory, you'd have to use a factory method. If I had written DirectoryEntry, it would have a static Create() method on it, rather than having to add to the children collection, which I find a bit weird.
eg. DirectoryEntry.Create( DirectoryEntry parentContainer, string commonName, string className );
If you have two constructors, one which just encapsulates an existing physical thing, and another which creates a physical thing, that just doesn't feel right to me. Obviously this is comes down to personal style of coding, and there is nothing technically wrong with doing work in contstructors, I find that I have written more intelligible, easily readable code by clearly differentiating between the two.
My inspiration for this convention came from a Magritte painting, "The Treachery of Images". The painting, just as it says, is not a pipe. It is merely an abstract representation of a pipe. Just like the DirectoryEntry class is not actually a directory entry; it is merely an abstract representation of an object on a server that you can manipulate via code. To construct a instance of a DirectoryEntry class, you'll first need an actual existing directory entry. Let your factory method create that entry, and then return an instance of the class wrapping around it.
Am I babbling yet?