Forum: Ruby RCR debug

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
703fbc991fd63e0e1db54dca9ea31b53?d=identicon&s=25 Robert Dober (Guest)
on 2007-04-13 15:27
(Received via mailing list)
Hi list

this is incredibly simple, but I just wanted to know what you think
about it.

I really often write the following code

puts <whatever> if $DEBUG

I guess you all do that to some extent, James just talked a newbie
into it recently ;)

The first programmer's virtue of course makes me do some things like
def debug *args, &blk
   return unless $DEBUG
  <do something incredibly smart with the args ;)>
end
and sometimes on some of my machines I will do something like

require 'ilmig/tools/debug'

I feel that this might be so common place that a Kernel::debug or
whatever other suitable name might be a good idea.

I am listening .... ;)

Cheers
Robert
4d5b5dd4e263d780a5dfe7ac8b8ac98c?d=identicon&s=25 Tim Pease (Guest)
on 2007-04-13 17:31
(Received via mailing list)
On 4/13/07, Robert Dober <robert.dober@gmail.com> wrote:
>
> whatever other suitable name might be a good idea.
>
> I am listening .... ;)
>

For medium to large programs having a global $DEBUG flag is going to
create lots of "line noise" as all those debug messages go whipping
by.

I much prefer the fine grained control that the 'logging' and 'log4r'
packages give you.


require 'logging'

class A
  def initialize
    @log = Logging::Logger[self]
    @log.debug "new object created '#{self.object_id}'"
  end
end

class B
  def initialize
    @log = Logging::Logger[self]
    @log.debug "new object created '#{self.object_id}'"
  end
end

Logging::Logger['A'].level = :warn
Logging::Logger['B'].level = :debug


It's a little more setup, but you have far greater control over what
gets logged and what doesn't. The framework also takes care of
timestamps, outputting class info, etc.

And if you don't want all that complexity, there is always the core
Logger class that comes with Ruby.

Blessings,
TwP
703fbc991fd63e0e1db54dca9ea31b53?d=identicon&s=25 Robert Dober (Guest)
on 2007-04-13 22:01
(Received via mailing list)
On 4/13/07, Tim Pease <tim.pease@gmail.com> wrote:
> > into it recently ;)
> > I feel that this might be so common place that a Kernel::debug or
> > whatever other suitable name might be a good idea.
> >
> > I am listening .... ;)
> >
>
> For medium to large programs having a global $DEBUG flag is going to
> create lots of "line noise" as all those debug messages go whipping
> by.
Tim the $DEBUG mechanism is quite primitive and other things are
needed for large scale development, no doubt.
My idea of the CR is orbiting around $DEBUG which is widely used  in
quick hacks or small to medium scale development, but...
>     @log.debug "new object created '#{self.object_id}'"
> Logging::Logger['A'].level = :warn
> Blessings,
> TwP
... I take one idea from your mail, with your kind permission ;)

Why not enhancing the semantics of $DEBUG at the same moment, I will
elaborate
-----------------------------------------------------------------------------------
def Kernel.debug *args, &blk
   return unless $DEBUG
   begin
      $DEBUG.puts args.join(" ") unless args.empty?
      blk.call $DEBUG if blk
   rescue
      warn $DEBUG does not respond to the #puts message
   end
end

now you can write code like

debug "OMG this should be deadcode, why I am here, I just kept that
code for sentimental reasons!!!!"

or
debug do
   puts "whatever"
end

or

debug {
   | stream |
   stream.puts "@inst = #{@inst}"
}

or
debug do
  $DEBUG.print "one"
end

of course the -d switch of ruby would just set $DEBUG to $stdout,
maybe a -l <stream>
switch could be introduced to set $DEBUG to a writeable IO object
representing <stream>
------------------------------------------------------------------------------------------------------

Now I realize I did not think about other debugging mechanisms, the
core idea is just to simplify what I think is a common and useful
idiom namely
  puts "/...." if $DEBUG

I do not think that this will compete with more advanced debugging,
logging features, but why not enhance the $DEBUG switch as suggested
above.

Yeah and before I forget, thx for your input Tim.

Cheers
Robert
4d5b5dd4e263d780a5dfe7ac8b8ac98c?d=identicon&s=25 Tim Pease (Guest)
on 2007-04-14 16:29
(Received via mailing list)
On 4/13/07, Robert Dober <robert.dober@gmail.com> wrote:
> Tim the $DEBUG mechanism is quite primitive and other things are
> needed for large scale development, no doubt.
> My idea of the CR is orbiting around $DEBUG which is widely used  in
> quick hacks or small to medium scale development, but...

A simple debug method seems like a great idea. But what happens when
it ends up in Kernel and everyone starts using it?  Now you'll get all
the debug messages from your code and all the library code that you
include.  That's why I don't like the $DEBUG option.

I know you want to put it into Kernel so everyone can use. But that's
the whole problem -- everyone will start using it!  And then it
becomes not so useful.

This is similar to making sure that your code runs -w clean (i.e.
won't throw out warnings). The rails core is very bad about this --
lot's of warnings.  Now you cannot find the warnings in your own code
because all the rails warnings are cluttering things up.

Same problem with a global $DEBUG flag.

Just my $0.02 on the matter.

Blessings,
TwP

PS  Why not include this in the facets library? I think this would be
a much more suitable place for such a creature.

<http://facets.rubyforge.org/>
Cb48ca5059faf7409a5ab3745a964696?d=identicon&s=25 unknown (Guest)
on 2007-04-14 18:18
(Received via mailing list)
On Sat, 14 Apr 2007, Tim Pease wrote:

>
>
> Just my $0.02 on the matter.
>
> Blessings,
> TwP
>
> PS  Why not include this in the facets library? I think this would be
> a much more suitable place for such a creature.
>
> <http://facets.rubyforge.org/>

alternatively

   logger = Logger.new STDERR
   logger.level = ENV['DEBUG_ENV_FOR_MY_CODE'] ? Logger::DEBUG :
LOGGER::INFO

   logger.debug{ 'now you have a debug method that can be turned on/off
from the environment' }

it's prety kiss...

-a
703fbc991fd63e0e1db54dca9ea31b53?d=identicon&s=25 Robert Dober (Guest)
on 2007-04-14 19:41
(Received via mailing list)
On 4/14/07, ara.t.howard@noaa.gov <ara.t.howard@noaa.gov> wrote:
> > the debug messages from your code and all the library code that you
> >
> > <http://facets.rubyforge.org/>
> -a
> --
> be kind whenever possible... it is always possible.
> - the dalai lama
>
>
Ara I guess you are right about the Kernel, a standard library
module/class might be better, voici Logger.
Funnily I think I really have not done enough research about Logger
after Tim's input, well maybe because Tim just explained that he
prefered Logger and that was not on my mind.
Sorry Tim if I was not thoughtful enough.
I feel that I just wanted to facilitate a common pattern, I had not
though a second about if that common pattern was worth being
facilitated...
... probably it is not.
Thanks for your input, I guess I'll call it an RCR ;).

This is a great ML, they think for you, someone to write a solution
for this weeks Ruby Quiz for me ? :)))

Cheers
Robert
This topic is locked and can not be replied to.