#ConnectionManagement | Explore Tumblr posts and blogs

karankurani · 7 years ago

Text

Why you should not have Managers in your class name

And why you should be careful about anything that ends with -er. Before I go any further, please go and read Steve Yegge’s blog post on the overuse of Nouns in Javaland.

Most coders I know do not give naming things the importance it deserves. It is highly critical to get the class/method name right the first time. The name will affect the way you structure your code base, think about it further down the line, how you refactor and extend it. Nothing creates technical debt faster than choosing a wrong name for your class. It will come back and bite you very painfully.

The name of a class will determine how you delegate responsibilities to that class. Let me illustrate. Lets say you are designing the iOS client for Shoutt. The client needs to establish a connection to the server, fork over the data and then handle the response. At this point many coders will say - “Aha! What we need is a ConnectionManager which manages all these tasks.” So we go ahead and create that class with the required functionality.

It works fine until we realize that the app requires multiple simultaneous connections to the server. Now because you have a ConnectionManager, you go ahead and introduce an array inside the class which maintains the state of all the open connections to the server. The code is a tad little bit more complex because each connection is established by a different object in the client and the response needs to be routed to the appropriate caller.

Fine so far… Oh wait, but now the client also needs to handle retries in case of failure. What do you do if one of the connections fail? You introduce a hashmap in ConnectionManager which maintains the number of retries a particular connection has made to the server.

Oh crap, what if the object establishing the connection wants to end it before MAX_RETRIES is reached? So now you have a connection_id which is stored on each view and is used every time you want to cancel the connection. Also, did I mention that sometimes connections need to be asynchronous and sometimes synchronous (this requirement crops up two weeks into building the app btw). So now, in your code base, when you want asynchronous connections, there is an event thrown in the ConnectionManager with the connection_id that shows the response. But in case of synchronous connections it returns the response immediately. So you have two methods on ConnectionManager object called establish_sync_conn() and establish_async_conn().

At this point, your ConnectionManager object has an array, a hashmap, probably another hashmap to track connection types and two different methods just to create a connection. Its a very complex thing to look at. Even worse is the fact that if someone else looks at your code, it will take them a while to figure out whats happening where and how everything is linked together. It also makes you prone to make mistakes and have more bugs/complexity in your code.

What would have happened if you had named the class just Connection instead of ConnectionManager? Just because of the name being Connection you think of it as a proper object (like a proper connection - think of it as an information pipeline between the client and server). You need multiple connections? Just create another object of connection. What about a single connection for the entire app? You just create a global connection variable which has that object. Retrying is also maintained by each connection object independently. How about max retries? You just have an internal max_retries variable in the class. So each connection maintains it’s state internally. Since we have separate objects for each connection, each object can just handle that connection on its own and terminate it without worrying about whether there are any other connections or not. What about the sync and async type of connections? The answer is in the word type. You pass in the type of connection you want in the constructor and the object is setup accordingly.

Obviously the ConnectionManager could be designed differently and made cleaner, but giving the name Manager makes defining the responsibility of the class ambiguous. On the other hand, naming the class Connection would make its responsibility clear and unambiguous.

Anything that has the name manager (or anything else that ends in -er) in it is usually (not always) a code smell that you haven’t designed your application properly. Eliminating that type of class will automagically lead you to write much better code and keep things simple as you extend your application.

Picking the right name helps you keep your code structure clean. It also make it easy to extend as well as refactor. So next time you are naming a class, please give it an extra 5 minutes of thought before you start coding.

========

[Note - This was originally posted on March 30, 2013 on my previous startup’s blog (archive link here). Reposting it here since back then it was under an anonymous handle.]

Discuss this on HN.

#managers #coding #design patterns #software engineering

1 note · View note