Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:26:42Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA wherein we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown.

Example:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
#http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
#http://rubylearning.com/satishtalim/ruby_open_classes.html
#http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://en.wikipedia.org/wiki/Ruby_(programming_language)
#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:24:12Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown.

Example:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
#http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
#http://rubylearning.com/satishtalim/ruby_open_classes.html
#http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://en.wikipedia.org/wiki/Ruby_(programming_language)
#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:23:46Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown.

Example:

class Numeric

def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
#http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
#http://rubylearning.com/satishtalim/ruby_open_classes.html
#http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://en.wikipedia.org/wiki/Ruby_(programming_language)
#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:21:17Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown.

Example:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
#http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
#http://rubylearning.com/satishtalim/ruby_open_classes.html
#http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://en.wikipedia.org/wiki/Ruby_(programming_language)
#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:20:54Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown.

Example:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
#http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
#http://rubylearning.com/satishtalim/ruby_open_classes.html
#http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://en.wikipedia.org/wiki/Ruby_(programming_language)
#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:19:57Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown.

Example:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:17:29Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown.

Example:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:15:52Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown.

Example:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:15:07Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown:
Example:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:14:30Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown:
Example:
class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:12:44Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown:
Example:
class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end
def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:11:08Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class, we can do it as shown:
Example:
class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:09:25Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Example:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:
Example:
class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:08:40Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Examples:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:
Examples:
class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:07:50Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Examples:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:
Examples:
class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:07:00Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Examples:

class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:
Examples:
class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T01:04:20Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

Examples:
class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:
Examples:
class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T00:59:54Z

Schandr9:

==Introduction==

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
===Open Classes===

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

<Code>
class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end
</Code>

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T00:59:01Z

Schandr9:

==Introduction==

----

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==Metaprogramming in Ruby==
----
===Open Classes===
----

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===Implementing custom methods in Open Classes===

----

As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

<Code>
class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end
</Code>

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===Method Missing===
----
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==Summary==
----
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==References==
----
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==Further Reading==
----
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T00:57:44Z

Schandr9:

==1. Introduction==

----

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

==2. Metaprogramming in Ruby==

----

===2.1 Open Classes===

----

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

===2.2 Implementing custom methods in Open Classes===

----

As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

<Code>
class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end
</Code>

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

===2.3 Method Missing===
----
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

==3. Summary==
----
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

==4. References==
----
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

==5. Further Reading==
----
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T00:56:39Z

Schandr9:

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T00:47:07Z

Schandr9:

{{1. Introduction
2. Metaprogramming in Ruby
2.1 Open Classes
2.2 Defining custom methods in Open Classes
2.3 Method Missing
3. Summary
4. References
5. Further Reading}}

1. Introduction

----

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

2. Metaprogramming in Ruby

----

2.1 Open Classes

----

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

2.2 Implementing custom methods in Open Classes

----

As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

<Code>
class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end
</Code>

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

2.3 Method Missing
----
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

3. Summary
----
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

4. References
----
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

5. Further Reading
----
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T00:43:06Z

Schandr9:

1. Introduction
2. Metaprogramming in Ruby
2.1 Open Classes
2.2 Defining custom methods in Open Classes
2.3 Method Missing
3. Summary
4. References
5. Further Reading

1. Introduction

----

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

2. Metaprogramming in Ruby

----

2.1 Open Classes

----

In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

2.2 Implementing custom methods in Open Classes

----

As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

<Code>
class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end
</Code>

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

2.3 Method Missing
----
When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

3. Summary
----
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

4. References
----
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

5. Further Reading
----
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T00:41:22Z

Schandr9:

1. Introduction
2. Metaprogramming in Ruby
2.1 Open Classes
2.2 Defining custom methods in Open Classes
2.3 Method Missing
3. Summary
4. References
5. Further Reading

1. Introduction

----

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

2. Metaprogramming in Ruby
2.1 Open Classes
In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

2.2 Implementing custom methods in Open Classes
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

<Code>
class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end
</Code>

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

2.3 Method Missing

When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

3. Summary
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

4. References
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

5. Further Reading
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-04T00:40:07Z

Schandr9:

1. Introduction
2. Metaprogramming in Ruby
2.1 Open Classes
2.2 Defining custom methods in Open Classes
2.3 Method Missing
3. Summary
4. References
5. Further Reading

1. Introduction

One of the most impressive aspects of Ruby is its metaprogramming capabilities. As a dynamic language, Ruby gives you the freedom to define methods and even classes during runtime. Metaprogramming with Ruby, one can do in a few minutes what other languages may take hours to do. By cleverly planning your code and applying the techniques mentioned here, you’ll be able to write code that is DRYer, lighter, more intuitive and more scalable.

2. Metaprogramming in Ruby
2.1 Open Classes
In Ruby, classes are never closed: you can always add methods to an existing class. This applies to the classes you write as well as the standard, built-in classes. All you have to do is open up a class definition for an existing class, and the new contents you specify will be added to whatever's there.

Comparing this to other object oriented languages like JAVA, we cannot modify the existing standard classes and add custom methods. We will have to create a new class of our own which inherits from the standard class and add new functionalities to it. Then, we need to use this user-defined class in place of the standard class.

2.2 Implementing custom methods in Open Classes
As an example of Open Classes explained above, consider the functionality of converting Euros to Dollars.

<Code>
class Numeric
def euros ; self * 0.019; end # custom method defined here.
end

class Bank
..
account.deposit(20.euros) # call to custom method.
..
end
</Code>

Here, we define our own method 'euros' by extending the Numeric class. Euro-to-Dollar conversion can then be done by invoking the euros method as shown above.

2.3 Method Missing

When you send a message to an object, the object executes the first method it finds on its method lookup path with the same name as the message. If it fails to find any such method, it raises a NoMethodError exception - unless you have provided the object with a method called method_missing. The method_missing method is passed the symbol of the non-existent method, an array of the arguments that were passed in the original call and any block passed to the original method.

If we extend the previous example to define method_missing for the Numeric class,//1.euro we can do it as shown:

class Numeric
def method_missing(method_id)
if method_id.to_s == "euro"
self.send('euros')
else
super
end
end

def euros
..
end
end

The above implementation of Numeric class allows calling euros as well as the euro method(since 1.euro is more appropriate). Here, since euro is not defined, method missing is passed the name of the method that does not exist: "euro" which can then be used to call the 'euros' method through self.send. Furthermore, if this is not defined, then the control is transfered to the parent class.

3. Summary
All the classes in Ruby are open which allow you to define custom methods.
To make code more readable, it is okay to reopen the standard classes to define custom methods.
These features saves a lot of effort in Ruby compared to other Object Oriented languages like JAVA, C++

4. References
http://rubylearning.com/blog/2010/11/23/dont-know-metaprogramming-in-ruby/
http://rubylearning.com/satishtalim/ruby_open_classes.html
http://rubylearning.com/satishtalim/ruby_method_missing.html

5. Further Reading
http://ruby-doc.org/docs/ProgrammingRuby/
http://en.wikipedia.org/wiki/Ruby_(programming_language)
http://rubymonk.com/
http://www.ruby-lang.org/en/documentation/quickstart
http://www.ruby-doc.org/downloads/

CSC/ECE 517 Fall 2012/ch1b 1w57 mp

2012-10-03T22:47:36Z

Schandr9: Created page with "'''Saas 3.5 Metaprogramming''' 1. Introduction"

'''Saas 3.5 Metaprogramming'''
[[1. Introduction]]

CSC/ECE 517 Fall 2012

2012-10-03T22:44:16Z

Schandr9:

*[[CSC/ECE 517 Fall 2012/ch1 n xx]]
*[[CSC/ECE 517 Fall 2012/ch1 1w1 rk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w20 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w5 su]]
*[[CSC/ECE 517 Fall 2012/ch1 1w6 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w4 aj]]
*[[CSC/ECE 517 Fall 2012/ch1 1w7 am]]
*[[CSC/ECE 517 Fall 2012/ch1 1w8 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w9 av]]
*[[CSC/ECE 517 Fall 2012/ch1 1w10 pk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w11 ap]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w12 mv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w14 gv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w17 ir]]
*[[CSC/ECE 517 Fall 2012/ch1 1w18 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w22 an]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 wi]]
*[[CSC/ECE 517 Fall 2012/ch1 1w31 sa]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w16 br]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w23 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w24 nr]]
*[[CSC/ECE 517 Fall 2012/ch1 1w15 rt]]
*[[CSC/ECE 517 Fall 2012/ch1 1w3 pl]]
*[[CSC/ECE 517 Fall 2012/ch1 1w32 cm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w67 ks]]

*[[CSC/ECE 517 Fall 2012/ch1 1w27 ms]]
*[[CSC/ECE 517 Fall 2012/ch1 1w29 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w33 op]]
*[[CSC/ECE 517 Fall 2012/ch1 1w19 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w34 vd]]
*[[CSC/ECE 517 Fall 2012/ch1 1w35 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w30 rp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w47 sk]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w69 mv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w44 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w45 is]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w53 kc]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 ar]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w39 sn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w54 go]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w56 ms]
*[[CSC/ECE 517 Fall 2012/ch1b 1w64 nn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w66 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w42 js]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w46 sm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w71 gs]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w63 dv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w55 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w57 mp]]