Comments on: My main() Method Is Better Than Yours

By: David Leppik

David Leppik — Fri, 18 Feb 2011 17:27:42 +0000

Actually, the main method is the easiest method at all to test– so easy that you often don’t even need to test it!

Assuming you’ve tested all the code going into main, when you run the program, it’s either going to run properly or it’s going to fail spectacularly, and often with an obvious cause. Typically there aren’t that many permutations to the command line arguments, and each one should be easy to test.

The reason I say you often don’t need to test it is that many main methods (for the sorts of programs I write at least) do exactly one thing, and I’m going to be running it before I hand it off to anyone else. And if I’m bothering to write a main method at all, somebody’s going to be using it right away. Which means that even if I were silly enough not to run it before handing it off, the bug would be discovered and I would get my well-deserved public shame long before a customer gets the code.

By: misko

misko — Thu, 10 Sep 2009 03:53:22 +0000

@peter,

Your reasoning is correct, if the main method is responsible for instantiating and wiring all of the pieces together, how does one tests the wiring without actually running the application. The solution is to move the instantiation/wiring into a separate class (which we call factory)

By: peter

peter — Mon, 07 Sep 2009 00:30:42 +0000

Hey!
Maybe I’m missing the point here, but why not wrap the startup task inside a command (pattern)eg. ApplicationStartupCommand that takes a Server and args as the constructor arguments ..
eg.

public class ApplicationStartupCommand extends Command{

Server server;
ApplicationStartupCommand ( Server server){
this.server = server
}

public void Run(){
server.Start(); }
….
}

}
Then the ApplicationStartupCommand becomes testable (because we’ve seperated it from the application and we can mock the server) and the main method (applying MY simple mind to this) becomes.
// for the Manual injection
static void main(String[] args){
Command startup =new StartupCommand ( new ServerFactory(args)
.createServer() ) ;
startup.Run();
}

I’m not a Java guy so forgive me for not know what the server factory etc does.

It would be cool if you could shed some light on the above.
Once again, Thank you

By: misko

misko — Sun, 18 Jan 2009 16:39:55 +0000

Hi Iwamot,

The GUICE module should be one responsible for parsing the args using your favorite CLI parser. The module should than set up different bindings based on the arguments. Once GUICE builds the server and hands it back to you the server is already wired with all of the configuration information set. You just need to start it.

By: iwamot

iwamot — Sun, 18 Jan 2009 08:30:47 +0000

Hi Misko, I’m a manual DIer (and am a Japanese).First, for the second example, I think the ‘args’ should be passed to the createServer() method. The constructor doesn’t seem to use it. Any reasons?Second, I think there should be a ‘Parsing Phase’ before the ‘Creation Phase’. The ‘args’ often needs to be parsed by a parser(ex. Commons CLI). What’s your opinion?

By: Where Have all the “new” Operators Gone | Miško Hevery

Where Have all the “new” Operators Gone | Miško Hevery — Wed, 10 Sep 2008 17:23:56 +0000

[...] My main() Method Is Better Than Yours we looked into what a main() method should look like. There we introduced a clear separation [...]

By: Abhirama

Abhirama — Sun, 07 Sep 2008 06:37:08 +0000

I have a doubt regarding the separation of object graph creation and application running. Say I am writing a person class and the constructor takes weight as an argument. Now I want to make sure that the weight assigned is within some bounds, say it should not be negative or something like that. Do you advocate doing this validation in the constructor itself, before assigning to the weight instance variable?

Btw thanks for the wonderful blog.