anchor.diff:          return cmd.getExitCodeExceptionMapper() != null
                       ? cmd.getExitCodeExceptionMapper().getExitCode(ex)
                       : cmd.getCommandSpec().exitCodeOnExecutionException();
  +    }
  +}
  +----
  +
  +.Kotlin
  +[source,kotlin,role="secondary"]
  +----
  +class PrintExceptionMessageHandler : IExecutionExceptionHandler {
  +    override fun handleExecutionException(ex: Exception,
  +                                          cmd: CommandLine,
  +                                          parseResult: ParseResult): Int {
  +
  +        // bold red error message
  +        cmd.err.println(cmd.colorScheme.errorText(ex.message))
  +
  +        return if (cmd.exitCodeExceptionMapper != null)
  +            cmd.exitCodeExceptionMapper.getExitCode(ex)
  +            else cmd.commandSpec.exitCodeOnExecutionException()
       }
   }
   ----
  
positive.code: 
  ==== Return Value from Callable or Method
  
  .Before:
  
  ```java
  class MyCallable implements Callable<MyResult> {
      public MyResult call() { ... }
  }
  
  MyResult result = CommandLine.call(new MyCallable(), args);
  ```
  
  .After:
  ```java
  CommandLine cmd = new CommandLine(new MyCallable());
  int exitCode = cmd.execute(args);
  MyResult result = cmd.getExecutionResult();
  ```
  
  ==== Invoking Command Methods
  
  .Before:
  
  ```java
  class MyCommand {
      @Command
      public MyResult doit(@Option(names = "-x") int x) { ... }
  }
  
  MyResult result = CommandLine.invoke("doit", MyCommand.class, args);
  ```
  
  .After:
  ```java
  Method doit = CommandLine.getCommandMethods(MyCommand.class, "doit").get(0);
  CommandLine cmd = new CommandLine(doit);
  int exitCode = cmd.execute(args);
  MyResult result = cmd.getExecutionResult();
  ```
  
  ==== Executing Commands with Subcommands
  
  
negative.code: List<Object> result = cmd.parseWithHandler(new RunAll(), args);
  ----
  
  .Kotlin
  [source,kotlin,role="secondary"]
  ----
  val cmd = CommandLine(MyTopLevelCommand())
          .addSubcommand("status",   GitStatus())
          .addSubcommand("commit",   GitCommit())
          .addSubcommand("add",      GitAdd())
  val result = cmd.parseWithHandler<List<Any>>(CommandLine.RunAll(), args)}
  ----
  
  After
  
  .Java
  [source,java,role="primary"]
  ----
  CommandLine cmd = new CommandLine(MyTopLevelCommand())
          .addSubcommand("status",   new GitStatus())
  