On Jun 19, 2006, at 13:14, thomas coopman wrote:
> Suppose I have a program, with a class say A and a main.
> My program also has a verbose option (program --verbose).
> What's the best way to implement the verbose option in a OO-way?
>
> a) give the boolean verbose to the class and let the class control  
> it. (method(verbose) --> puts "something" if verbose)
> b) run the program and let the main handle with the verbose option.
> c) something else

Hard to say without a little more knowledge of the program and the  
nature of the class.  In general I'd say it depends mostly on how  
many different places in the code would have different behaviour  
based on the parameter.  In other words, how many places in the code  
need something like this: "if @verbose then..."

If there's just one place, then it's fine to do it there.

If there's more than one place, then you want to make it one place.   
One way of doing this is using a logger: the class would *always*  
tell the logger what's going on, and the logger worries about the  
verbose parameter and whether or not to tell you.  Sort of like this:

class A
   def initialize(verbose = false)
     @logger = Logger.new(verbose)
   end
   def do_something_complicated
     @logger.write("verbose information")
   end
   def do_something_even_more_complicated
     @logger.write("verbose information")
     @logger.write("more verbose information")
   end
end

class Logger
   def initialize(verbose = false)
     @verbose = verbose
   end
   def write(str)
     puts str if @verbose
   end
end

The Logger class in Ruby's stdlib does exactly this, but in a  
significantly more sophisticated way.


> A second question about this is suppose my program runs a loop for  
> a number of times and the user may specify the number of loops to  
> make, and if the program must run to the end in once or ask for  
> user action every x steps)
> like: program --loops 50 --steps 5 --> this would ask for user  
> input every 5yt steps and loops 50 times.
>
> What's the best way to do this?
>
> a) again let the class handle it (a method run(number_of_loops,  
> steps))
> b) or let the main handle it (in the class just a method step() and  
> in the main the method run(number_of_loops, steps))
> c) something else

a) and b) are the same thing, it's just the location of the 'run'  
method that's different, so the question boils down to "where's the  
appropraite place to have my 'run' method?"  Which is actually quite  
difficult to answer without knowing anything about the code.  Do you  
think that the 'run' method is integral to the A class?  Or is it  
more of a user-interface thing that should be separate from A?  Both  
approaches could be justified.

matthew smillie.