Ruby: slow down evaluation

I'm interested in simply slowing down the evaluation of ruby code. Of course I know about using sleep(), but that does not solve my problem.

Rather, I want to slow down every single object instantiation and destruction that happens in the VM.

Why? So I can learn about how particular procedures in ruby work by watching them being carried out. I recently l开发者_如何学Pythonearned about ObjectSpace and the ability to see/inspect all the objects currently living in a Ruby VM. It seems that building a simple realtime display of the objects and properties of those objects within the ObjectSpace and then slowing down the evaluation would achieve this.

I realize there may be ways of viewing in realtime more detailed logs of what is happening inside the ruby process, including many procedures that are implemented at low-level, below the level of actual ruby code. But I think simply seeing the creation and destruction of objects and their properties in realtime would be more edifying and easier to follow.

---

You could be interested in the answer to this question: getting in-out from ruby methods

With small edits to the code reported there, you could add a sleep to each method call and follow the code execution.

---

If you want to output some information every time an object is instantiated, you could do that by overriding Class#new. Here's an example:

class Class
  alias old_new new

  def new(*args)
    puts "Creating: #{self.inspect}"
    sleep 0.1
    old_new(*args)
  end
end

class Point
end

class Circle
end

The alias old_new new line creates a backup new method, so we can have the old behaviour. Then, we override the new method and put some code to inspect the subject class and sleep for just a bit for the sake of better readability. Now, if you invoke Point.new, you'll see "Creating: Point". Circle.new will display a "Creating: Circle" and so on. Any objects that are created will be logged, or at least their classes, with a small delay.

The example is a modified version of the one from here.

As for destruction of objects, I'm not sure if there's a sensible way to do it. You could try to override some method in the GC module, but garbage collection is only initiated when it's necessary (as far as I'm aware), so you could easily play with ruby for a while without it ever happening. It probably wouldn't be very useful anyway.

---

I think the problem is not that ruby is too fast.

In your case you should use some software architecture, for example Model-View-Controller.

It could be in this way. In View you can show options at which speed the Controller should show information for you or you're able to slow down or increase the speed of showing information. Then Controller evaluate small steps (calling methods in Model) and rendered the results of evaluation in the View.

The View is not always the browser or window application, it could be also just a simple terminal.