# To sleep no more

**URL:** <https://www.ruby-forum.com/t/to-sleep-no-more/127171>\
**Category:** Ruby\
**Created:** [January 25, 2008, 7:25pm UTC](https://www.ruby-forum.com/t/to-sleep-no-more/127171 "2008-01-25T19:25:58Z")\
**Posts on this page:** 8\
**Page:** 1

<div class="post-metadata">

**Author:** ![DrBenway](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/2bfe46/32.png) [@DrBenway](https://www.ruby-forum.com/u/DrBenway)\
**Post date:** [January 25, 2008, 7:25pm UTC](https://www.ruby-forum.com/t/to-sleep-no-more/127171/1 "2008-01-25T19:25:58Z")

</div>

hi all,

I’m a ruby noop trying his first steps. I’d like a little advice.

What I want to make is the following.

An object Chicken

- its attribute starts as ‘egg’
- after x times sleep() it the attribute gets the value chicken
- x times sleep later the object can make a call to make a new  
instance of chicken (creating another egg)

I could make a method to change the attribute and call this from my  
main program.  
In other words my sleep method would be in my main program and call  
the objects method.  
I was wondering if it would be possible to keep the sleep in the  
object.  
(Since I was planning on creating some other animals as well, each  
with a special amount of time needed to go to the next step.)

I think it’s called threads in ruby but I’m not sure. (if it’s called  
threads is this the way to handle this problem? Does it act like an  
Ajax call?)

Many thnx

DrBenway

---

<div class="post-metadata">

**Author:** ![DrBenway](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/2bfe46/32.png) [@DrBenway](https://www.ruby-forum.com/u/DrBenway)\
**Post date:** [January 25, 2008, 8:28pm UTC](https://www.ruby-forum.com/t/to-sleep-no-more/127171/2 "2008-01-25T20:28:27Z")

</div>

On Friday 25 January 2008 13:25:00 DrBenway wrote:

> instance of chicken (creating another egg)  
> I think it’s called threads in ruby but I’m not sure. (if it’s called  
> threads is this the way to handle this problem? Does it act like an  
> Ajax call?)
> 
> Many thnx
> 
> DrBenway

Something like this might work for your purposes:

class Animal  
attr\_reader :incubation\_period, :maturation\_period, :from\_type,  
:to\_type, :current\_type, :slept, :children

```
    def initialize(i_period = 60, m_period = 120, from = "egg", to

```

= “chicken”)  
@incubation\_period = i\_period  
@maturation\_period = m\_period  
@slept = 0  
@from\_type = from  
@to\_type = to  
@current\_type = @from\_type  
@children = []  
end

```
    def mysleep(seconds = @incubation_period)
            @slept += sleep(seconds)
            if @slept >= @incubation_period
                    @current_type = @to_type
            end
    end

    def give_birth(count = 1)
            if @slept >= @maturation_period
                    for number in children.length..(children.length 

```

- 

count - 1)  
puts “I had another child.”  
children[number] =  
Animal.new(@incubation\_period, @maturation\_period, @from\_type,  
@to\_type);  
end  
else  
puts “I’m too young to give birth.”  
end  
end  
end

snake = Animal.new(5, 10, “egg”, “snake”)  
snake.mysleep(4)  
puts snake.current\_type  
snake.give\_birth  
snake.mysleep(4)  
puts snake.current\_type  
snake.give\_birth  
snake.mysleep(4)  
puts snake.current\_type  
snake.give\_birth(5)

---

<div class="post-metadata">

**Author:** ![DrBenway](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/2bfe46/32.png) [@DrBenway](https://www.ruby-forum.com/u/DrBenway)\
**Post date:** [January 25, 2008, 9:20pm UTC](https://www.ruby-forum.com/t/to-sleep-no-more/127171/3 "2008-01-25T21:20:49Z")

</div>

On Jan 25, 8:27 pm, Stephen K. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) wrote:

> > An object Chicken  
> > object.
> 
> ```
> @slept = 0
> end
> else
> 
> ```
> 
> puts snake.current\_type  
> snake.give\_birth  
> snake.mysleep(4)  
> puts snake.current\_type  
> snake.give\_birth(5)

Wow thnx Stephen for coocking up an example so fast 🙂  
That’s indeed what I was planning to do.

The only thing that may not have been very obvious (sorry for this) in  
my example above was:  
Is there a way to take the snake.mysleep(4) out of our main program  
and put it in the class/object itself  
That way I call snake = Animal.new(5, 10, “egg”, “snake”) once and  
from then on it leads a life on its own (that’s what got me to think  
that I needed threads).  
Same goes for all the other snakes that get born from the first.  
I don’t feel like messing with arrays of  
snakes,pigs,boars,chickens,… out of the classes

---

<div class="post-metadata">

**Author:** ![DrBenway](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/2bfe46/32.png) [@DrBenway](https://www.ruby-forum.com/u/DrBenway)\
**Post date:** [January 25, 2008, 9:56pm UTC](https://www.ruby-forum.com/t/to-sleep-no-more/127171/4 "2008-01-25T21:56:01Z")

</div>

On Jan 25, 2008 12:19 PM, DrBenway [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) wrote:

> Wow thnx Stephen for coocking up an example so fast 🙂  
> That’s indeed what I was planning to do.
> 
> That way I call snake = Animal.new(5, 10, “egg”, “snake”) once and  
> from then on it leads a life on its own (that’s what got me to think  
> that I needed threads).

You could do something like:

> > class Animal  
> > def initialize(i\_period = 60, m\_period = 120, from = “egg”, to  
> > = “chicken”)  
> > @incubation\_period = i\_period  
> > @maturation\_period = m\_period  
> > @slept = 0  
> > @from\_type = from  
> > @to\_type = to  
> > @current\_type = @from\_type  
> > @children = []  
> > Thread.run do  
> > while true do  
> > mysleep(1)  
> > end  
> > end  
> > end

As a start, anyway. Much better to rejigger the whole thing so that  
the thread looks like

Thread.run do  
sleep(incubation\_period)  
born  
sleep(maturation\_period)  
mature  
sleep(adult\_lifetime)  
die  
end

Also, it seems pretty obvious that you should do different species as  
subclasses of Animal, so that:

class Snake \< Animal  
def incubation\_period; 5; end

def maturation\_period; 10; end

def adult\_lifetime; 15; end

def born; @state=“snake”; end  
#etc, etc  
end

menagerie = []  
Snake.new(menagerie)  
Deer.new(menagerie)  
Fox.new(menagerie)  
sleep 6  
menagerie.each {|animal| animal.give\_birth} =\> “Snake 1: I had 150  
children. Deer 1: I had 1 child. Fox 1: I’m too young to reproduce”

Granted, incomplete as it stands, but there’s a direction there.

---

<div class="post-metadata">

**Author:** ![DrBenway](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/2bfe46/32.png) [@DrBenway](https://www.ruby-forum.com/u/DrBenway)\
**Post date:** [January 25, 2008, 10:11pm UTC](https://www.ruby-forum.com/t/to-sleep-no-more/127171/5 "2008-01-25T22:11:52Z")

</div>

hi,

ok let’s code a zoo. threads is what you are looking for, but there  
might be a better way. but threads first.

class Animal

def initialize  
@lifetime\_in\_sec = 0  
@dead = false  
thread = Thread.new do  
until @dead  
@lifetime\_in\_sec += 1  
sleep 1  
end  
end  
end

def kill  
@dead = true  
end

end

depending on your zoo this might lead to a lot of threads, so maybe  
you should think about using a more event-based design. (make the egg  
by initialization register a ‘timed’ event to become a biddy.)

shutdown = true  
$events = Hash.new { |hash, key| hash[key] = [] }  
$time = 0

class Animal  
def initialize  
$events[$time+time\_to\_become\_a\_biddy] \<\< self  
end  
def progress  
# become a biddy or chicken or …  
$events[$time+time\_to\_become\_a\_chicken] \<\< self if @state==:biddy  
end  
end

event\_handler = Thread.new do  
counter = 0  
until shutdown  
counter += 1  
$events[counter].each { |animal| animal.progress }  
end  
end

this way your simulation is calucaluatet as fast as possible and you  
can throttle it to be realtime. asuming your machine is fast enough  
for your zoo. 😉

g phil

---

<div class="post-metadata">

**Author:** ![DrBenway](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/2bfe46/32.png) [@DrBenway](https://www.ruby-forum.com/u/DrBenway)\
**Post date:** [January 25, 2008, 9:57pm UTC](https://www.ruby-forum.com/t/to-sleep-no-more/127171/6 "2008-01-25T21:57:12Z")

</div>

On Friday 25 January 2008 15:19:58 DrBenway wrote:

> > > - after x times sleep() it the attribute gets the value chicken  
> > > with a special amount of time needed to go to the next step.)
> > 
> > ```
> > @from_type = from
> > end
> > puts "I'm too young to give birth."
> > 
> > ```
> > 
> > snake.give\_birth  
> > and put it in the class/object itself  
> > That way I call snake = Animal.new(5, 10, “egg”, “snake”) once and  
> > from then on it leads a life on its own (that’s what got me to think  
> > that I needed threads).  
> > Same goes for all the other snakes that get born from the first.  
> > I don’t feel like messing with arrays of  
> > snakes,pigs,boars,chickens,… out of the classes

Ah, now I understand. Yes, if you want each Animal to be able to run  
through  
its lifecycle independently and concurrently, you’d need to use threads.  
The  
example class above would be simplified by the fact that each Animal  
would be  
responsible for its own lifecycle. The constructor would just need to  
sleep  
for the incubation period, update its current type, sleep for the  
maturation  
period minus the incubation period (if any), give birth (spawning other  
threads and creating other Animals), and then die at some point. You can  
find  
some info on using threads in Ruby here:  
[http://www.ruby-doc.org/docs/ProgrammingRuby/](http://www.ruby-doc.org/docs/ProgrammingRuby/)

Stephen K.  
Network Engineer  
CTI Networks, Inc.

---

<div class="post-metadata">

**Author:** ![DrBenway](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/2bfe46/32.png) [@DrBenway](https://www.ruby-forum.com/u/DrBenway)\
**Post date:** [January 28, 2008, 1:40pm UTC](https://www.ruby-forum.com/t/to-sleep-no-more/127171/7 "2008-01-28T13:40:45Z")

</div>

On Jan 25, 9:54 pm, Judson L. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) wrote:

> > > ```
> > > @current_type = @from_type
> > > 
> > > ```
> 
> As a start, anyway. Much better to rejigger the whole thing so that
> 
> def born; @state=“snake”; end
> 
> Granted, incomplete as it stands, but there’s a direction there.
> 
> –  
> Your subnet is currently 169.254.0.0/16. You are likely to be eaten by a grue.

This is indeed what I needed. Many thnx

---

<div class="post-metadata">

**Author:** ![DrBenway](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/2bfe46/32.png) [@DrBenway](https://www.ruby-forum.com/u/DrBenway)\
**Post date:** [January 28, 2008, 1:45pm UTC](https://www.ruby-forum.com/t/to-sleep-no-more/127171/8 "2008-01-28T13:45:53Z")

</div>

On Jan 25, 10:11 pm, Philipp H. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) wrote:

> ```
> thread = Thread.new do
> 
> ```
> 
> class Animal  
> counter = 0  
> g phil
> 
> > > > I was wondering if it would be possible to keep the sleep in the  
> > > > DrBenway  
> > > > @maturation\_period = m\_period  
> > > > @current\_type = @to\_type  
> > > > end  
> > > > snake.mysleep(4)  
> > > > my example above was:  
> > > > Is there a way to take the snake.mysleep(4) out of our main program  
> > > > and put it in the class/object itself  
> > > > That way I call snake = Animal.new(5, 10, “egg”, “snake”) once and  
> > > > from then on it leads a life on its own (that’s what got me to think  
> > > > that I needed threads).  
> > > > Same goes for all the other snakes that get born from the first.  
> > > > I don’t feel like messing with arrays of  
> > > > snakes,pigs,boars,chickens,… out of the classes

Thnx for the example Philipp.  
The first one I get, but the second makes my head spin 🙂  
To much of a Ruby/OOP noob I guess 🙂