Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-31T18:16:05Z

Mvkantra: /* History of Metaprogramming: */

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques. Metaprogramming is writing computer programs that manipulate other programs, or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves [http://en.wikipedia.org/wiki/Automatic_programming generative programming]. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.

Lisp first used metaprogramming by using macros as a standard facility to write code that will directly be read and compiled by the system at run time.

In C-language, one of the popular examples of meta-programming is the [http://en.wikipedia.org/wiki/Yacc Lex/Yacc] system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.

Template metaprogramming done in C++ is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.

Metaprogramming also exists in Java, C# and Prolog. Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and [http://en.wikipedia.org/wiki/Yacc Yacc]
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open,it means they are open for enhancing their functionality anytime i.e even at runtime.<ref>[http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class]</ref>

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So now we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string at runtime, which can be used to define classes and methods on the go at runtime.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 http://www.slideshare.net/bsbodden/ruby-metaprogramming-08]</ref>

This will be illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code that is stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Instance_eval] evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Class_eval] evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables()<ref>[http://www.khelll.com/blog/ruby/ruby-reflection/ http://www.khelll.com/blog/ruby/ruby-reflection/]</ref> to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:<ref>[http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html]</ref>====

Singleton classes are used to implement instance specific behavior in Ruby.<ref>[http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/ http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/]</ref>

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior.

Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does it mean an object itself can hold method definitions?

Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method 'hi' go?

It goes into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its new method raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (which is explained earlier in this article).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass
def MyClass.my_class_method1
'class method 1'
end
def self.my_class_method2
'class method 2'
end
class << self
def my_class_method3
'class method 3'
end
end
end

Here all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:<ref>[http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/ http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/]</ref>====

Ruby has the ability to define methods on the fly using ‘define_method’<ref>[http://metaclass.org/2007/9/18/define-method http://metaclass.org/2007/9/18/define-method]</ref>, method_missing, [http://www.infoq.com/articles/eval-options-in-ruby ‘eval’] family methods.

=====Using 'eval' family methods :<ref>[http://ilikestuffblog.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/]</ref>=====

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:<ref>[http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html]</ref><ref>http://technicalpickles.com/posts/using-method_missing-and-respond_to-to-create-dynamic-methods/</ref>====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example<ref>[http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/ http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/]</ref> which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

====Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>====

To alias a method or variable name in Ruby is to create a second name for the method or variable. Aliasing can be used either to provide more expressive options to the programmer using the class, or to help override methods and change the behavior of the class or object. We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar -> Creates a foo alias for bar

alias $MATCH $& -> $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

====Modules:====

Module<ref>[http://www.rubyist.net/~slagell/ruby/modules.html Modules]</ref> is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module<ref>[http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html]</ref> is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.

Example<ref>[http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/ http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/]</ref>
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod."
end
end

class Klass
def hello
"Hello from Klass."
end
end

k = Klass.new
k.hello » "Hello from Klass."
k.extend(Mod) » #<Klass:0x401b598c>
k.hello » "Hello from Mod."

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”

==References==
<references/>

==Further Reading==

[http://pedromtavares.wordpress.com/2010/02/24/ruby-object-model-and-metaprogramming/ More About Metaprogramming]

[http://www.devalot.com/articles/2008/09/ruby-singleton More about Singleton Classes]

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-31T18:08:12Z

Mvkantra: /* History of Metaprogramming: */

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques. Metaprogramming is writing computer programs that manipulate other programs, or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves [http://en.wikipedia.org/wiki/Automatic_programming generative programming]. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.

Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.

In C-language, one of the popular examples of meta-programming is the [http://en.wikipedia.org/wiki/Yacc Lex/Yacc] system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.

Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and [http://en.wikipedia.org/wiki/Yacc Yacc]
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open,it means they are open for enhancing their functionality anytime i.e even at runtime.<ref>[http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class]</ref>

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So now we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string at runtime, which can be used to define classes and methods on the go at runtime.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 http://www.slideshare.net/bsbodden/ruby-metaprogramming-08]</ref>

This will be illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code that is stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Instance_eval] evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Class_eval] evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables()<ref>[http://www.khelll.com/blog/ruby/ruby-reflection/ http://www.khelll.com/blog/ruby/ruby-reflection/]</ref> to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:<ref>[http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html]</ref>====

Singleton classes are used to implement instance specific behavior in Ruby.<ref>[http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/ http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/]</ref>

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior.

Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does it mean an object itself can hold method definitions?

Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method 'hi' go?

It goes into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its new method raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (which is explained earlier in this article).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass
def MyClass.my_class_method1
'class method 1'
end
def self.my_class_method2
'class method 2'
end
class << self
def my_class_method3
'class method 3'
end
end
end

Here all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:<ref>[http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/ http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/]</ref>====

Ruby has the ability to define methods on the fly using ‘define_method’<ref>[http://metaclass.org/2007/9/18/define-method http://metaclass.org/2007/9/18/define-method]</ref>, method_missing, [http://www.infoq.com/articles/eval-options-in-ruby ‘eval’] family methods.

=====Using 'eval' family methods :<ref>[http://ilikestuffblog.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/]</ref>=====

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:<ref>[http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html]</ref><ref>http://technicalpickles.com/posts/using-method_missing-and-respond_to-to-create-dynamic-methods/</ref>====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example<ref>[http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/ http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/]</ref> which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

====Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>====

To alias a method or variable name in Ruby is to create a second name for the method or variable. Aliasing can be used either to provide more expressive options to the programmer using the class, or to help override methods and change the behavior of the class or object. We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar -> Creates a foo alias for bar

alias $MATCH $& -> $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

====Modules:====

Module<ref>[http://www.rubyist.net/~slagell/ruby/modules.html Modules]</ref> is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module<ref>[http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html]</ref> is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.

Example<ref>[http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/ http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/]</ref>
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod."
end
end

class Klass
def hello
"Hello from Klass."
end
end

k = Klass.new
k.hello » "Hello from Klass."
k.extend(Mod) » #<Klass:0x401b598c>
k.hello » "Hello from Mod."

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”

==References==
<references/>

==Further Reading==

[http://pedromtavares.wordpress.com/2010/02/24/ruby-object-model-and-metaprogramming/ More About Metaprogramming]

[http://www.devalot.com/articles/2008/09/ruby-singleton More about Singleton Classes]

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-24T23:52:27Z

Mvkantra: /* Modules: */

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques. Metaprogramming is writing computer programs that manipulate other programs, or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.
Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.
In C-language, one of the popular examples of meta-programming is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.
Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and Yacc
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open,it means they are open for enhancing their functionality anytime i.e even at runtime.<ref>[http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class]</ref>

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So now we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string at runtime, which can be used to define classes and methods on the go at runtime.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 http://www.slideshare.net/bsbodden/ruby-metaprogramming-08]</ref>

This will be illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code that is stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Instance_eval] evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Class_eval] evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables()<ref>[http://www.khelll.com/blog/ruby/ruby-reflection/ http://www.khelll.com/blog/ruby/ruby-reflection/]</ref> to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:<ref>[http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html]</ref>====

Singleton classes are used to implement instance specific behavior in Ruby.<ref>[http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/ http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/]</ref>

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior.

Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does it mean an object itself can hold method definitions?

Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method 'hi' go?

It goes into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its new method raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (which is explained earlier in this article).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass

def MyClass.my_class_method1
'class method 1'
end

def self.my_class_method2
'class method 2'
end

class << self

def my_class_method3
'class method 3'
end

end

end

Here all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:<ref>[http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/ http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/]</ref>====

Ruby has the ability to define methods on the fly using ‘define_method’<ref>[http://metaclass.org/2007/9/18/define-method http://metaclass.org/2007/9/18/define-method]</ref>, method_missing, [http://www.infoq.com/articles/eval-options-in-ruby ‘eval’] family methods.

=====Using 'eval' family methods :<ref>[http://ilikestuffblog.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/]</ref>=====

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:<ref>[http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html]</ref><ref>http://technicalpickles.com/posts/using-method_missing-and-respond_to-to-create-dynamic-methods/</ref>====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example<ref>[http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/ http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/]</ref> which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

====Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>====

We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar -> Creates a foo alias for bar

alias $MATCH $& -> $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

====Modules:====

Module<ref>[http://www.rubyist.net/~slagell/ruby/modules.html Modules]</ref> is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module<ref>[http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html]</ref> is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.

Example<ref>[http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/ http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/]</ref>
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod."
end
end

class Klass
def hello
"Hello from Klass."
end
end

k = Klass.new
k.hello » "Hello from Klass."
k.extend(Mod) » #<Klass:0x401b598c>
k.hello » "Hello from Mod."

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”

==References==
<references/>

==Further Reading==

[http://pedromtavares.wordpress.com/2010/02/24/ruby-object-model-and-metaprogramming/ More About Metaprogramming]

[http://www.devalot.com/articles/2008/09/ruby-singleton More about Singleton Classes]

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-24T19:57:19Z

Mvkantra: /* Aliasing:Aliasing */

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques. Metaprogramming is writing computer programs that manipulate other programs, or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.
Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.
In C-language, one of the popular examples of meta-programming is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.
Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and Yacc
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open,it means they are open for enhancing their functionality anytime i.e even at runtime.<ref>[http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class]</ref>

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So now we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string at runtime, which can be used to define classes and methods on the go at runtime.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 http://www.slideshare.net/bsbodden/ruby-metaprogramming-08]</ref>

This will be illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code that is stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Instance_eval] evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Class_eval] evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables()<ref>[http://www.khelll.com/blog/ruby/ruby-reflection/ http://www.khelll.com/blog/ruby/ruby-reflection/]</ref> to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:<ref>[http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html]</ref>====

Singleton classes are used to implement instance specific behavior in Ruby.<ref>[http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/ http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/]</ref>

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior.

Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does it mean an object itself can hold method definitions?

Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method 'hi' go?

It goes into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its new method raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (I'll probably cover this in another blog post).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass

def MyClass.my_class_method1
'class method 1'
end

def self.my_class_method2
'class method 2'
end

class << self

def my_class_method3
'class method 3'
end

end

end

Here all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:<ref>[http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/ http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/]</ref>====

Ruby has the ability to define methods on the fly using ‘define_method’<ref>[http://metaclass.org/2007/9/18/define-method http://metaclass.org/2007/9/18/define-method]</ref>, method_missing, [http://www.infoq.com/articles/eval-options-in-ruby ‘eval’] family methods.

=====Using 'eval' family methods :<ref>[http://ilikestuffblog.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/]</ref>=====

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:<ref>[http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html]</ref><ref>http://technicalpickles.com/posts/using-method_missing-and-respond_to-to-create-dynamic-methods/</ref>====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example<ref>[http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/ http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/]</ref> which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

====Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>====

We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar -> Creates a foo alias for bar

alias $MATCH $& -> $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

====Modules:====

Module<ref>[http://www.rubyist.net/~slagell/ruby/modules.html Modules]</ref> is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module<ref>[http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html]</ref> is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.

Example<ref>[http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/ http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/]</ref>
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod."
end
end

class Klass
def hello
"Hello from Klass."
end
end

k = Klass.new
k.hello » "Hello from Klass."
k.extend(Mod) » #<Klass:0x401b598c>
k.hello » "Hello from Mod."

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”
==References==
<references/>

==Further Reading==

[http://pedromtavares.wordpress.com/2010/02/24/ruby-object-model-and-metaprogramming/ More About Metaprogramming]

[http://www.devalot.com/articles/2008/09/ruby-singleton More about Singleton Classes]

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-24T19:55:00Z

Mvkantra:

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques. Metaprogramming is writing computer programs that manipulate other programs, or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.
Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.
In C-language, one of the popular examples of meta-programming is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.
Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and Yacc
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open,it means they are open for enhancing their functionality anytime i.e even at runtime.<ref>[http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class]</ref>

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So now we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string at runtime, which can be used to define classes and methods on the go at runtime.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 http://www.slideshare.net/bsbodden/ruby-metaprogramming-08]</ref>

This will be illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code that is stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Instance_eval] evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Class_eval] evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables()<ref>[http://www.khelll.com/blog/ruby/ruby-reflection/ http://www.khelll.com/blog/ruby/ruby-reflection/]</ref> to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:<ref>[http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html]</ref>====

Singleton classes are used to implement instance specific behavior in Ruby.<ref>[http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/ http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/]</ref>

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior.

Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does it mean an object itself can hold method definitions?

Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method 'hi' go?

It goes into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its new method raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (I'll probably cover this in another blog post).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass

def MyClass.my_class_method1
'class method 1'
end

def self.my_class_method2
'class method 2'
end

class << self

def my_class_method3
'class method 3'
end

end

end

Here all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:<ref>[http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/ http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/]</ref>====

Ruby has the ability to define methods on the fly using ‘define_method’<ref>[http://metaclass.org/2007/9/18/define-method http://metaclass.org/2007/9/18/define-method]</ref>, method_missing, [http://www.infoq.com/articles/eval-options-in-ruby ‘eval’] family methods.

=====Using 'eval' family methods :<ref>[http://ilikestuffblog.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/]</ref>=====

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:<ref>[http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html]</ref><ref>http://technicalpickles.com/posts/using-method_missing-and-respond_to-to-create-dynamic-methods/</ref>====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example<ref>[http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/ http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/]</ref> which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

====Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>====

We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar -> Creates a foo alias for bar

alias $MATCH $& -> $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

====Modules:====

Module<ref>[http://www.rubyist.net/~slagell/ruby/modules.html Modules]</ref> is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module<ref>[http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html]</ref> is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.

Example<ref>[http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/ http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/]</ref>
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod."
end
end

class Klass
def hello
"Hello from Klass."
end
end

k = Klass.new
k.hello » "Hello from Klass."
k.extend(Mod) » #<Klass:0x401b598c>
k.hello » "Hello from Mod."

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”
==References==
<references/>

==Further Reading==

[http://pedromtavares.wordpress.com/2010/02/24/ruby-object-model-and-metaprogramming/ More About Metaprogramming]

[http://www.devalot.com/articles/2008/09/ruby-singleton More about Singleton Classes]

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-24T18:05:54Z

Mvkantra:

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques. Metaprogramming is writing computer programs that manipulate other programs, or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.
Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.
In C-language, one of the popular examples of meta-programming is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.
Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and Yacc
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open,it means they are open for enhancing their functionality anytime i.e even at runtime.<ref>[http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class]</ref>

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So now we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string at runtime, which can be used to define classes and methods on the go at runtime.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 http://www.slideshare.net/bsbodden/ruby-metaprogramming-08]</ref>

This will be illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code that is stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Instance_eval] evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Class_eval] evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables()<ref>[http://www.khelll.com/blog/ruby/ruby-reflection/ http://www.khelll.com/blog/ruby/ruby-reflection/]</ref> to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:<ref>[http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html]</ref>====

Singleton classes are used to implement instance specific behavior in Ruby.<ref>[http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/ http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/]</ref>

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior.

Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does it mean an object itself can hold method definitions?

Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method 'hi' go?

It goes into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its new method raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (I'll probably cover this in another blog post).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass

def MyClass.my_class_method1
'class method 1'
end

def self.my_class_method2
'class method 2'
end

class << self

def my_class_method3
'class method 3'
end

end

end

Here all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:<ref>[http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/ http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/]</ref>====

Ruby has the ability to define methods on the fly using ‘define_method’<ref>[http://metaclass.org/2007/9/18/define-method http://metaclass.org/2007/9/18/define-method]</ref>, method_missing, [http://www.infoq.com/articles/eval-options-in-ruby ‘eval’] family methods.

=====Using 'eval' family methods :<ref>[http://ilikestuffblog.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/]</ref>=====

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:<ref>[http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html]</ref><ref>http://technicalpickles.com/posts/using-method_missing-and-respond_to-to-create-dynamic-methods/</ref>====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example<ref>[http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/ http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/]</ref> which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

====Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>====

We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar -> Creates a foo alias for bar

alias $MATCH $& -> $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

====Modules:====

Module<ref>[http://www.rubyist.net/~slagell/ruby/modules.html Modules]</ref> is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module<ref>[http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html]</ref> is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.

Example<ref>[http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/ http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/]</ref>
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod."
end
end

class Klass
def hello
"Hello from Klass."
end
end

k = Klass.new
k.hello » "Hello from Klass."
k.extend(Mod) » #<Klass:0x401b598c>
k.hello » "Hello from Mod."

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”
==References==
<references/>

==Further Reading==

[http://pedromtavares.wordpress.com/2010/02/24/ruby-object-model-and-metaprogramming/ More About Metaprogramming]

[http://www.devalot.com/articles/2008/09/ruby-singleton More about Singleton Classes]

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-24T17:57:17Z

Mvkantra:

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques. Metaprogramming is writing computer programs that manipulate other programs, or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.
Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.
In C-language, one of the popular examples of meta-programming is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.
Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have to have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and Yacc
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open,it means they are open for enhancing their functionality anytime i.e even at runtime.<ref>[http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class http://www.vitarara.org/cms/ruby_metaprogamming_declaratively_adding_methods_to_a_class]</ref>

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So now we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string at runtime, which can be used to define classes and methods on the go at runtime.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 http://www.slideshare.net/bsbodden/ruby-metaprogramming-08]</ref>

This will be illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code that is stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Instance_eval] evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*[http://blog.jayfields.com/2007/03/ruby-instanceeval-and-classeval-method.html Class_eval] evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables()<ref>[http://www.khelll.com/blog/ruby/ruby-reflection/ http://www.khelll.com/blog/ruby/ruby-reflection/]</ref> to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:<ref>[http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html http://ola-bini.blogspot.com/2006/09/ruby-singleton-class.html]</ref>====

Singleton classes are used to implement instance specific behavior in Ruby.<ref>[http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/ http://www.lucasallan.com/2011/09/05/singleton-classes-on-ruby/]</ref>

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior.

Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does it mean an object itself can hold method definitions?

Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method 'hi' go?

It goes into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its new method raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (I'll probably cover this in another blog post).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass

def MyClass.my_class_method1
'class method 1'
end

def self.my_class_method2
'class method 2'
end

class << self

def my_class_method3
'class method 3'
end

end

end

Here all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:<ref>[http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/ http://gregmoreno.ca/how-to-create-a-class-on-the-fly-in-ruby/]</ref>====

Ruby has the ability to define methods on the fly using ‘define_method’<ref>[http://metaclass.org/2007/9/18/define-method http://metaclass.org/2007/9/18/define-method]</ref>, method_missing, [http://www.infoq.com/articles/eval-options-in-ruby ‘eval’] family methods.

=====Using 'eval' family methods :<ref>[http://ilikestuffblog.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/]</ref>=====

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:<ref>[http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html http://www.trottercashion.com/2011/02/08/rubys-define_method-method_missing-and-instance_eval.html]</ref><ref>http://technicalpickles.com/posts/using-method_missing-and-respond_to-to-create-dynamic-methods/</ref>====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example<ref>[http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/ http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/]</ref> which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

====Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>====

We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar -> Creates a foo alias for bar

alias $MATCH $& -> $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

====Modules:====

Module<ref>[http://www.rubyist.net/~slagell/ruby/modules.html Modules]</ref> is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module<ref>[http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html]</ref> is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.

Example<ref>[http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/ http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/]</ref>
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod."
end
end

class Klass
def hello
"Hello from Klass."
end
end

k = Klass.new
k.hello » "Hello from Klass."
k.extend(Mod) » #<Klass:0x401b598c>
k.hello » "Hello from Mod."

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”
==References==
<references/>

==Further Reading==

[http://pedromtavares.wordpress.com/2010/02/24/ruby-object-model-and-metaprogramming/ More About Metaprogramming]

[http://www.devalot.com/articles/2008/09/ruby-singleton More about Singleton Classes]

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-20T23:59:12Z

Mvkantra:

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques is writing programs that generate programs ro program parts. Metaprogramming is writing computer programs that manipulate other programs or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.
Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.
In C-language, one of the popular examples of meta-programming is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.
Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have to have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and Yacc
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open that means open for enhancing their functionality anytime i.e even at runtime.

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string.

This will illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*Instance_eval evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*Class_eval evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables() to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:====

Singleton classes are used to implement instance specific behavior in Ruby.

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior. Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does that mean that an object itself can hold method definitions?
Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method hi go?
Yes, that's correct, it went into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its newmethod raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Now hopefully we have understood how singleton classes work.
Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (I'll probably cover this in another blog post).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass

def MyClass.my_class_method1
'class method 1'
end

def self.my_class_method2
'class method 2'
end

class << self

def my_class_method3
'class method 3'
end

end

end

And yes, you've guessed right: all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:====

Ruby has the ability to define methods on the fly using ‘define_method’, method_missing, ‘eval’ family methods.

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/

==Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>==

We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar  Creates a foo alias for bar
alias $MATCH $&  $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

==Modules:==
Module<ref>[http://www.rubyist.net/~slagell/ruby/modules.html Modules]</ref> is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module<ref>[http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html]</ref> is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.

Example<ref>[http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/ http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/]</ref>
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod."
end
end

class Klass
def hello
"Hello from Klass."
end
end

k = Klass.new
k.hello » "Hello from Klass."
k.extend(Mod) » #<Klass:0x401b598c>
k.hello » "Hello from Mod."

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”
==References==
<references/>

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-20T23:55:16Z

Mvkantra:

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques is writing programs that generate programs ro program parts. Metaprogramming is writing computer programs that manipulate other programs or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.
Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.
In C-language, one of the popular examples of meta-programming is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.
Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have to have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and Yacc
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open that means open for enhancing their functionality anytime i.e even at runtime.

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string.

This will illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*Instance_eval evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*Class_eval evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables() to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:====

Singleton classes are used to implement instance specific behavior in Ruby.

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior. Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does that mean that an object itself can hold method definitions?
Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method hi go?
Yes, that's correct, it went into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its newmethod raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Now hopefully we have understood how singleton classes work.
Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (I'll probably cover this in another blog post).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass

def MyClass.my_class_method1
'class method 1'
end

def self.my_class_method2
'class method 2'
end

class << self

def my_class_method3
'class method 3'
end

end

end

And yes, you've guessed right: all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:====

Ruby has the ability to define methods on the fly using ‘define_method’, method_missing, ‘eval’ family methods.

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/

==Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>==

We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar  Creates a foo alias for bar
alias $MATCH $&  $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

==Modules:==
Module<ref>[http://www.rubyist.net/~slagell/ruby/modules.html Modules]</ref> is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module<ref>[http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html]</ref> is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.

Example<ref>[http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/ http://mousebender.wordpress.com/2007/11/18/including-a-module-in-ruby/]</ref>
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod.\n"
end
end

class Klass
def hello
"Hello from Klass.\n"
end
end

k = Klass.new
k.hello » "Hello from Klass.\n"
k.extend(Mod) » #<Klass:0x401b598c>
k.hello

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”
==References==
<references/>

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-20T23:49:35Z

Mvkantra:

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques is writing programs that generate programs ro program parts. Metaprogramming is writing computer programs that manipulate other programs or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.
Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.
In C-language, one of the popular examples of meta-programming is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.
Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:<ref>[http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf http://www.vanderburg.org/Speaking/Stuff/oscon05.pdf]</ref>==

* Metaprogramming<ref>[http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html Uses]</ref> allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have to have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and Yacc
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open that means open for enhancing their functionality anytime i.e even at runtime.

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string.

This will illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*Instance_eval evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*Class_eval evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables() to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:====

Singleton classes are used to implement instance specific behavior in Ruby.

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior. Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does that mean that an object itself can hold method definitions?
Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method hi go?
Yes, that's correct, it went into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its newmethod raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Now hopefully we have understood how singleton classes work.
Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (I'll probably cover this in another blog post).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass

def MyClass.my_class_method1
'class method 1'
end

def self.my_class_method2
'class method 2'
end

class << self

def my_class_method3
'class method 3'
end

end

end

And yes, you've guessed right: all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:====

Ruby has the ability to define methods on the fly using ‘define_method’, method_missing, ‘eval’ family methods.

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

====Defining methods using method_missing:====

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/

==Aliasing:<ref>[http://pragprog.com/book/ppmetr/metaprogramming-ruby Aliasing]</ref>==

We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax<ref>[http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html]</ref><ref>[http://www.ruby-forum.com/topic/135598 http://www.ruby-forum.com/topic/135598]</ref>:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar  Creates a foo alias for bar
alias $MATCH $&  $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

==Modules:==
Module is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.
Example
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod.\n"
end
end

class Klass
def hello
"Hello from Klass.\n"
end
end

k = Klass.new
k.hello » "Hello from Klass.\n"
k.extend(Mod) » #<Klass:0x401b598c>
k.hello

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”
==References==
<references/>

CSC/ECE 517 Fall 2011/ch4 4g ms

2011-10-20T23:37:53Z

Mvkantra:

==What is Metaprogramming?==

Metaprogramming<ref>[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]</ref> can change the way you program in your programming language. This is the most under used programming techniques is writing programs that generate programs ro program parts. Metaprogramming is writing computer programs that manipulate other programs or that which do a part of their work at compile time that would otherwise be done at runtime. This is very advantageous because it gives greater flexibility to programs to efficiently handle new situations without recompilation. Languages which provide metaprogramming are called metalanguages. Metaprograms treat themselves as part of data and they can modify their own structure and behaviour.

==History of Metaprogramming:==

Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if an incremental compilation is available, then techniques can be used to perform metaprogramming without actually generating source code.
Template metaprogramming is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these templates include compile-time constants, data structures, and complete functions.
In C-language, one of the popular examples of meta-programming is the Lex/Yacc system for generation of parsers and lexical scanners. That is, it reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in C. Instead of doing the laborious work of generating a parser in C, one can use Yacc to generate the repetitive parts of the program. Then, one can add only the code necessary to operate on the parsed entities.
Metaprogramming in Java comprises of three main components reflection, generics, annotations.

==Uses of Metaprogramming:==

* Metaprogramming allows us to write programs that will pre-generate tables of data for use at runtime. For example, if a quick lookup table for the sine of all 8-bit integers is needed, then the sin can either be calculated and hand coded or the program can be made to build the table at startup at runtime or a program can used to build the custom code for the table before compile-time. While it may make sense to build the table at runtime for such a small set of numbers, other such tasks may cause program startup to be prohibitively slow. In such cases, writing a program to build static data tables is usually the best answer.
* A mini language can be created when there are a lot of functions which include a lot of boilerplate code. This mini language will do the boilerplate code and lets the user code only the important parts.
It is best to abstract out the boilerplate portions into a function. But often the boilerplate code isn't so pretty. Maybe there's a list of variables to be declared in every instance, or maybe there are several pieces of the boilerplate that have to have code inserted in certain circumstances. All of these make a simple function call impossible. In such cases, it is often a good idea to create a mini-language that allows the developer to work with the boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.
Finally, a lot of programming languages make the developer write really verbose statements to do really simple things. Code-generating programs allow the developer to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

==Examples of metaprograms are:==

* Compiler or interpreter of any language
* Lex and Yacc
* CORBA's IDL compiler
* Quine
* Programs to generate EJB code and XML from database metadata
* Enhanced Cweb.

==Metaprogramming in Ruby==

===Aspects of Ruby make it easy for metaprogramming:===

====Everything in Ruby is an object====

This means even native types in other languages such as Integer, Float, String and even the null value (‘nil’ in Ruby) is an object. So ruby doesn’t really have functions, if every single data is an object then every single action on the data is a method.

Following example demonstrates that:

puts "cat".class
#Here's an iterator method being called on a simple Integer (Fixnum in Ruby)
5.times { puts 'hi'}
puts 5.class

#Even nil is an object!
puts nil.class

#You can even define methods in nil! We'll be looking more at this later.
def nil.hi
puts 'hi!'
end
nil.hi

====Classes and objects are open====

In Ruby classes are open that means open for enhancing their functionality anytime i.e even at runtime.

This can be illustrated by following example:

Suppose we have an array [1,2,3,4,5] and we want to find the sum of elements, so we invoke method called ‘sum’ on it.

[1,2,3,4,5].sum
#It gives us ‘No method error’

So we try to enhance the functionality of Array class by defining a method called sum on it

Class Array
def sum
inject(0){|s,v| s+v}
end
end

Now lets try to invoke sum on the array

[1,2,3,4,5].sum
Output: 15

====Code can be manipulated as data====

Ruby code can evaluate the contents of the string.

This will illustrated by following example:

# say_hello.rb
puts “puts ‘Hello World !!’ “

Code that invokes code

ruby –e “ ‘ruby say_hello.rb’ “
Output: Hello World !!

Ruby provides the ‘eval’ family of methods for runtime execution of code stored in strings

*‘eval’ can evaluate any string. Other important methods of this family are instance_eval and class_eval.

eval(“2*2”)
Output: 4

*Instance_eval evaluates string or a code block in the context of the receiver (object).

Class MyClass
end
MyClass.instance_eval(“def hi; ‘hi’; end; “)
MyClass.hi
# ‘hi’
Obj =MyClass.new
Obj.hi
#NoMethoError : e=undefined method ‘hi’

*Class_eval evaluates an string or a code block in the context of the class or module it is invoked on.

Class MyClass
end
MyClass.class_eval(“def hi; ‘hi’; end; “)
MyClass.hi
#NoMethoError : e=undefined method ‘hi’
Obj =MyClass.new
Obj.hi
# ’hi’

====Deep reflection capabilities====

In Ruby it's possible to read information about a class or object at runtime. We could use some of the methods like class(), instance_methods(), instance_variables() to do that.

=====Example:=====

# The code in the following class definition is executed immediately

Class Rubyist
# the code in the following method definition is executed later,
# when you eventually call the method

def what_does_he_do
@person = 'A Rubyist'
'Ruby programming'
end
end

an_object = Rubyist.new
puts an_object.class # => Rubyist
puts an_object.class.instance_methods(false) # => what_does_he_do
an_object.what_does_he_do
puts an_object.instance_variables # => @person

===Meta programming techniques:===

====Using Singleton Classes:====

Singleton classes are used to implement instance specific behavior in Ruby.

class MyClass
def blah
'blah'
end
end

obj = MyClass.new
obj.hi # => NoMethodError

def obj.hi
'hi'
end

obj.hi # => 'hi'

another_obj = MyClass.new
another_obj.hi # => NoMethodError

obj.class # => MyClass
another_obj.class # => MyClass

The above code shows one way to add instance-specific behavior. Interesting thing to note is that the new method is invokable only from the instance it was defined on and not from other instances of the same class. This means that the method was not added to the class of the instance.

Does that mean that an object itself can hold method definitions?
Well, the answer is no (unless it's an object that represents a class or a module). One of the reasons the concept of classes exists in Ruby is that they are meant to hold method definitions and act as blueprints for their instances, ie, they determine what methods can be invoked on their instances.

So where did the method hi go?
Yes, that's correct, it went into the singleton class of the instance. This hidden class is different from the class the instance was created from and is a Ruby implementation detail that is typically not revealed to anyone (there is only one way to get to the singleton class, which is discussed later in the article ). This is the reason it is sometimes called ghost class or anonymous class or shadow class. The singleton class is created for an object as soon as the Ruby interpreter needs to add instance-specific behavior for that object (but not before that). Going forward, if more methods need to be added to the same object, its already-created singleton class is used. Also, more instances cannot be created using a particular singleton class (its newmethod raises an error). Because of this one-to-one relationship between an object and its singleton class, the word 'singleton' is used.

So, what is the way in which one can get access to an object's singleton class?

# ... in continuation from previous snippet
obj_singleton_class = class << obj; self; end
obj_singleton_class.ancestors # => [MyClass, Object, Kernel]
MyClass.ancestors # => [MyClass, Object, Kernel]

Here class << obj; self; end is the key: anything written after class << obj and before the corresponding end is evaluated against the context of the singleton class of obj, ie, selfpoints to the singleton class.

In the above snippet, we return self, getting a reference to it in the variable obj_singleton_class. We then see that the singleton class fakes the same ancestry as the original class of the object. This implies that when a method is invoked on an object, Ruby first looks for the method definition in the object's singleton class (if it exists), if not, Ruby then continues looking up the normal inheritance hierarchy.

# ... in continuation from previous snippet
obj.hi # method looked for in singleton class; found; invoked
obj.blah # method looked for in singleton class; not found; looked for in MyClass; found; invoked
obj.xyz # method looked for in singleton class, MyClass, Object, Kernel; not found; obj.method_missing() called, raising NoMethodError

Now hopefully we have understood how singleton classes work.
Let's quickly look at two other ways in which we could have added instance-specific behavior to an object:
class << obj
def hi
'hi'
end
end

obj.instance_eval do

def hi
'hi'
end
end

The former one should be clear from what has already been explained. The latter is tied to how def works with instance_eval (I'll probably cover this in another blog post).
Now, before concluding, let's take a step back and see if we've seen the syntax discussed so far, before. You'll probably recognize their use in defining class-level methods:

Class MyClass

def MyClass.my_class_method1
'class method 1'
end

def self.my_class_method2
'class method 2'
end

class << self

def my_class_method3
'class method 3'
end

end

end

And yes, you've guessed right: all class methods go into the singleton class of the object representing the class, in this case, the object referenced by the constant name:MyClass (remember classes are also objects). After all, these class method definitions need to go somewhere, and in such a way that the methods don't become part of the class's instances (ie, they aren't instance methods) nor do the methods go to the super class.

====Defining methods on the fly:====

Ruby has the ability to define methods on the fly using ‘define_method’, method_missing, ‘eval’ family methods.

This is illustrated by following example.

Class Person
def self.make_greeting (language, greeting)
class_eval “def greet_in_#{language}; puts ‘#{greeting}’; end”
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end
alan=Person.new
alan.greet_in_English
#Hello!

p=Person
p.make_greeting(“dutch”,”Hallo!”)
lisa=p.new
lisa.greet_in_dutch
#Hallo!

The above example is used to create greetings in different languages on the go. A new greeting is created in make_greeting method, which uses class_eval to evaluate the string that defines a method for a ‘language’ (argument for the make_greeting method). As the method defined using class_val it would in the scope of the entire class (Person). Now to access greet_in_English method we need to create an object and use it to invoke the method. Now to define method at runtime we can invoke make_greeting method using the class (Person.make_greeting(language,greeting)). And now the newly defined method is available for access by any Person’s object.

The same functionality can be achieved by define method in following was:

Class Person
def self.make_greeting (language, greeting)
define_method “greet_in_#{language};” do
puts “#{greeting}”
end
end

make_greeting(“Spanish”,”Hola!”)
make_greeting(“English”,”Hello!”)
end

Defining methods using method_missing:

One of the ways Ruby is dynamic is that we can choose how to handle methods that are called, but don’t actually exist. If we have a lot of very similar methods, we can even use this to define them all at once. Ruby does this using the method_missing method, which we override in the classes where we need more dynamic method calling.

This can be illustrated by using following example which creates a widget that store any attribute that is given to it.

# lib/widget.rb
Class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end

widget = Widget.new
#<Widget:0x0000010383f618>
widget.name = 'Bob'
# "Bob"
widget.age = 30
# 30
widget.name
# "Bob"
widget.age
# 30

We have a created Widget and no methods are defined in it, so whenever a method is invoked it would call method missing. In method it is looking for a command with ‘=’ symbol that means it assigning something, so if that is the case it would put that variable into the instance variable set for later retrieval. If the command doesn’t have ‘=’ it is simply displaying the attributes from the instance variable set.

http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/

==Aliasing:==

We can redefine a method in an existing class by opening it up and rewriting it, but since we cannot loose the behaviour provided by the original method, we can use alias_method.
alias :new :old
alias_method :new, :old

Syntax:

alias method-name method-name
alias global-variable-name global-variable-name

Creates a new reference to whatever old referred to. old can be any existing method, operator, global. It may not be a local, instance, constant, or class variable. Alias_method is used when there is a need to override a method but still count on its old behaviour.

Example1:

alias foo bar  Creates a foo alias for bar
alias $MATCH $&  $MATCH is an alias for $&

Example2:

1. def oldmtd
2. "old method"
3. end
4. alias newmtd oldmtd
5. def oldmtd
6. "old improved method"
7. end
8. puts oldmtd
9. puts newmtd

The output is:
1. old improved method
2. old method

Local variables, instance variables, class variables and constants may not be aliased. The parameters to alias may be names or symbols. When a method is aliased, the new name refers to a copy of the original method’s body. If the method is subsequently redefined, the aliased name will still invoke the original implementation. Aliases cannot be defined within the method body. The alias of the method keeps the current definition of the method even when the methods are overridden.
Making aliases for the numbered global variables ($1,$2,….) is prohibited. Overriding the built in global variables may cause serious problems.

==Modules:==
Module is just a bunch of instance methods. A class is just a module but has certain additional features like a superclass and a new() method. The main reason for having both modules and class in Ruby is to make the code more explicit. A module is used in situations where it has to be included somewhere or when it needs to be used as a namespace. A class is used when it needs to be instantiated or inherited.
A module can be included by a class. A module can be shared between and included by multiple classes at the same time. Modules can be used to organize constants in the same way as directories are used to organize files.
Example
module Stats
def max_health
100
end
def constitution
50
end
end

class Character
include Stats
attr_accessor:name
attr_accessor:location
def talk; end
def walk; end
end

In the above example we have extracted max_health and constitution into a module. The Character class incudes the Stats module. Whenever a method is called on an instance of Character, that cannot be found in the referenced class, Ruby will look if the method can be found in one of the included modules. This is not the same as inheritance. Multiple modules can be included at the same time.
Modules define a namespace, a sandbox in which your methods and constants can play without having to worry about being stepped on by other methods and constants.
include mixes a module into a class or another module. Methods from that the module are called function-style (without a receiver).

Extend keyword can be used to extend a single functionality for the object. Adds to object the instance methods from each module given as a parameter.

module Mod
def hello
"Hello from Mod.\n"
end
end

class Klass
def hello
"Hello from Klass.\n"
end
end

k = Klass.new
k.hello » "Hello from Klass.\n"
k.extend(Mod) » #<Klass:0x401b598c>
k.hello

extend is used to include a module in an object(instance). Methods in the module become methods in the object

The possibilities meta programing opens up seem to be endless. Joining on the way are endless possibilities to do something wrong. “with great power comes great responsibility”
==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:51:31Z

Mvkantra: /* Comparison notes */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different Integrated development environments [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing<ref>[http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails Editing]</ref> <ref>[http://netbeans.org/features/ide/editor.html NetBeans Editor]</ref> ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting<ref>[http://vimeo.com/channels/radrails#9895797 Radrails features]</ref>. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine<ref>[http://www.jetbrains.com/ruby/features/ruby_ide.html RubyMine]</ref> is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring<ref>[http://r2.ifs.hsr.ch/rubyrefactoring.pdf Refactoring]</ref>==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

Netbeans<ref>[http://netbeans.org/features/java/debugger.html Netbeans]</ref> supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

==References==
<references>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:51:07Z

Mvkantra: /* Comparison notes */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different Integrated development environments [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing<ref>[http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails Editing]</ref> <ref>[http://netbeans.org/features/ide/editor.html NetBeans Editor]</ref> ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans<ref>[http://netbeans.org/features/ide/editor.html NetBeans Editor]</ref> provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting<ref>[http://vimeo.com/channels/radrails#9895797 Radrails features]</ref>. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine<ref>[http://www.jetbrains.com/ruby/features/ruby_ide.html RubyMine]</ref> is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring<ref>[http://r2.ifs.hsr.ch/rubyrefactoring.pdf Refactoring]</ref>==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

Netbeans<ref>[http://netbeans.org/features/java/debugger.html Netbeans]</ref> supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

==References==
<references>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:50:23Z

Mvkantra: /* Comparison notes */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different Integrated development environments [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing<ref>[http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails Editing]</ref> <ref>[http://netbeans.org/features/ide/editor.html NetBeans Editor]</ref> ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans<ref>[http://netbeans.org/features/ide/editor.html]</ref> provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting<ref>[http://vimeo.com/channels/radrails#9895797 Radrails features]</ref>. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine<ref>[http://www.jetbrains.com/ruby/features/ruby_ide.html RubyMine]</ref> is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring<ref>[http://r2.ifs.hsr.ch/rubyrefactoring.pdf Refactoring]</ref>==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

Netbeans<ref>[http://netbeans.org/features/java/debugger.html Netbeans]</ref> supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

==References==
<references>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:49:51Z

Mvkantra: /* Comparison notes */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different Integrated development environments [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing<ref>[http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails Editing]</ref> <ref>[http://netbeans.org/features/ide/editor.html NetBeans Editor]</ref> ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans<ref>[http://netbeans.org/features/ide/editor.html NetBeans Editor]</ref> provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting<ref>[http://vimeo.com/channels/radrails#9895797 Radrails features]</ref>. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine<ref>[http://www.jetbrains.com/ruby/features/ruby_ide.html RubyMine]</ref> is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring<ref>[http://r2.ifs.hsr.ch/rubyrefactoring.pdf Refactoring]</ref>==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

Netbeans<ref>[http://netbeans.org/features/java/debugger.html Netbeans]</ref> supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

==References==
<references>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:48:57Z

Mvkantra: /* EditingEditing[http://netbeans.org/features/ide/editor.html] */

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:48:12Z

Mvkantra: /* EditingEditing */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different Integrated development environments [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing<ref>[http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails Editing]</ref><ref>[http://netbeans.org/features/ide/editor.html]</ref> ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine<ref>[http://www.jetbrains.com/ruby/features/ruby_ide.html RubyMine]</ref> is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring<ref>[http://r2.ifs.hsr.ch/rubyrefactoring.pdf Refactoring]</ref>==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

Netbeans<ref>[http://netbeans.org/features/java/debugger.html Netbeans]</ref> supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

==References==
<references>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:46:45Z

Mvkantra: /* Comparison notes */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different Integrated development environments [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing<ref>[http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails Editing]</ref> ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine<ref>[http://www.jetbrains.com/ruby/features/ruby_ide.html RubyMine]</ref> is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

Netbeans<ref>[http://netbeans.org/features/java/debugger.html Netbeans]</ref> supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

==References==
<references>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:45:20Z

Mvkantra: /* Debugging */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different Integrated development environments [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing<ref>[http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails Editing]</ref> ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

Netbeans<ref>[http://netbeans.org/features/java/debugger.html Netbeans]</ref> supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

==References==
<references>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:44:39Z

Mvkantra: /* Debugging */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different Integrated development environments [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== <ref>[http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails Editing]</ref> Editing==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

<ref>[http://netbeans.org/features/java/debugger.html Netbeans]</ref> supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

==References==
<references>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:35:11Z

Mvkantra: /* References */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different Integrated development environments <ref>[http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] </ref> that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

[http://netbeans.org/ Netbeans] supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

==References==
<references>

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:34:15Z

Mvkantra: /* Introduction */

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:30:57Z

Mvkantra: /* Introduction */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article analyzes and compares different [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of features such as:

* A [http://en.wikipedia.org/wiki/Source_code_editor source code editor].
* A [http://en.wikipedia.org/wiki/Compiler compiler] and/or an [http://en.wikipedia.org/wiki/Interpreter_(computing) interpreter].
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.Some IDE's support multiple languages support for some alternate languages is provided through plugins.

==What is RUBY and its features?==

[http://www.ruby-lang.org/en/ RUBY]is a dynamic, reflective, open source, general-purpose object-oriented programming language.

[http://www.ruby-lang.org/en/ Ruby] supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| [http://www.eclipse.org/mylyn/ Mylyn Integration]
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

[http://netbeans.org/ Netbeans] supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect. [http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.ptp.rdt.doc.user%2Fhtml%2Ftoc.html RDT] is a standard Eclipse plug-in, with features and plug-ins, so you can expand the zip file directly into the Eclipse folder. The paths in the archive take care of the rest.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

=References=

1. http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails/

2. http://devnet.jetbrains.net/docs/DOC-1146

3. http://netbeans.org/features/java/debugger.html

4. http://r2.ifs.hsr.ch/rubyrefactoring.pdf

5. http://www.jetbrains.com/ruby/features/ruby_ide.html

6. http://netbeans.org/features/ide/editor.html

7. http://vimeo.com/channels/radrails#9895797

8. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_11_f1%2C

9. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_22

10. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_rf

11. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_aa

12. http://www.aptana.com/products/radrails

13. http://netbeans.org/features/all.html#ruby

14. http://www.jetbrains.com/ruby/documentation/index.html

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:15:05Z

Mvkantra: /* Debugging */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article is trying to analyze and compare different [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An IDE is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of:

* A source code editor.
* A compiler and/or an interpreter.
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.

==What is RUBY and its features?==

RUBY is a dynamic, reflective, general-purpose object-oriented programming language.

Ruby supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| Mylyn Integration
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

[http://netbeans.org/ Netbeans] supports a configurable [http://en.wikipedia.org/wiki/Debugger debugger] which can be used to set [http://en.wikipedia.org/wiki/Breakpoint breakpoints], look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

[http://www.aptana.com/products/radrails Aptana RadRails] has an integrated Debugger which allows us to set breakpoints, inspect variables and control execution.

'''RubyMine'''

[http://www.jetbrains.com/ruby/ RubyMine] supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

[http://www.jetbrains.com/idea/ IntelliJ] supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in [http://en.wikipedia.org/wiki/Debugger debugger]. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for [http://www.eclipse.org/ Eclipse] broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

=References=

1. http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails/

2. http://devnet.jetbrains.net/docs/DOC-1146

3. http://netbeans.org/features/java/debugger.html

4. http://r2.ifs.hsr.ch/rubyrefactoring.pdf

5. http://www.jetbrains.com/ruby/features/ruby_ide.html

6. http://netbeans.org/features/ide/editor.html

7. http://vimeo.com/channels/radrails#9895797

8. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_11_f1%2C

9. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_22

10. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_rf

11. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_aa

12. http://www.aptana.com/products/radrails

13. http://netbeans.org/features/all.html#ruby

14. http://www.jetbrains.com/ruby/documentation/index.html

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-25T22:06:14Z

Mvkantra: /* Conclusion */

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article is trying to analyze and compare different [http://en.wikipedia.org/wiki/Integrated_development_environment Integrated development environments] that are in use for software development in [http://www.ruby-lang.org/en/ Ruby]. We will be comparing [http://www.aptana.com/products/radrails Aptana RadRails], [http://www.jetbrains.com/ruby/ Ruby Mine], [http://www.eclipse.org/ Eclipse] and [http://netbeans.org/ NetBeans].

==What is an IDE?==

An IDE is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of:

* A source code editor.
* A compiler and/or an interpreter.
* Build automation tools.
* A [http://en.wikipedia.org/wiki/Debugger debugger].

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.

==What is RUBY and its features?==

RUBY is a dynamic, reflective, general-purpose object-oriented programming language.

Ruby supports multiple programming paradigms, including:

*[http://en.wikipedia.org/wiki/Functional_programming Functional]: Computation is evaluation of a mathematical function.
*[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented]: Data structures consisting of data fields and methods are used.
*[http://en.wikipedia.org/wiki/Imperative_programming Imperative]: Computation in terms of statements that change the program stare.
*[http://en.wikipedia.org/wiki/Reflective_programming Reflective]: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =

== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| Mylyn Integration
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''[http://netbeans.org NetBeans]'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''[http://www.eclipse.org/ Eclipse]'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''[http://www.jetbrains.com/idea/features/ruby_rails.html Idea]'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''[http://www.aptana.com/products/radrails RadRails]'''

It supports syntax highlighting, auto completion, code assist and error reporting. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''[http://www.jetbrains.com/ruby/ Rubymine]'''

Rubymine is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's.

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support [http://subversion.tigris.org/ SVN], [http://git-scm.com/ Git], [http://www.nongnu.org/cvs/ CVS] version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

Netbeans supports a configurable debugger which can be used to set breakpoints, look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

Aptana RadRails has an integrated Debugger which allows us to set breakpoitns, inspect variables and control execution.

'''RubyMine'''

RubyMine supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

It supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in debugger. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for Eclipse broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect.

=Conclusion=

Users accustomed on working in [http://www.eclipse.org/ Eclipse] can continue using the [http://www.aptana.com/products/radrails RadRails] plugin. Eclipse provides excellent debugging capabilities.

[http://netbeans.org/ NetBeans] supports multiple languages like C++, Java.

[http://www.jetbrains.com/ruby/ RubyMine] is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility.RubyMine pops open any file with just a few key strokes. It also provides instantaneous formatting and project navigation [http://www.jetbrains.com/idea/ IntelliJ] is known to be the most intelligent IDE, it understands the code and makes right suggestions and helps in shaping the code.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

=References=

1. http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails/

2. http://devnet.jetbrains.net/docs/DOC-1146

3. http://netbeans.org/features/java/debugger.html

4. http://r2.ifs.hsr.ch/rubyrefactoring.pdf

5. http://www.jetbrains.com/ruby/features/ruby_ide.html

6. http://netbeans.org/features/ide/editor.html

7. http://vimeo.com/channels/radrails#9895797

8. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_11_f1%2C

9. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_22

10. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_rf

11. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_aa

12. http://www.aptana.com/products/radrails

13. http://netbeans.org/features/all.html#ruby

14. http://www.jetbrains.com/ruby/documentation/index.html

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-09-08T19:49:56Z

Mvkantra: Undo revision 47576 by Hsun6 (talk)

CSC/ECE 517 Fall 2010/ch1 1a ms
----
=Introduction=

This article is trying to analyze and compare different Integrated Development Environments(IDE) that are in use for software development in Ruby. We will be comparing Aptana RadRails, Ruby Mine, Eclipse and NetBeans.

==What is an IDE?==

An IDE is a software application which provides comprehensive facilities to maximize computer programmers' productivity. An IDE consists of:

* A source code editor.
* A compiler and/or an interpreter.
* Build automation tools.
* A debugger.

The aim is to abstract the configuration necessary to piece together command line utilities in a cohesive unit. Most IDE's are graphical to improve interaction.

==What is RUBY and its features?==

RUBY is a dynamic, reflective, general-purpose object-oriented programming language.

Ruby supports multiple programming paradigms, including:

*Functional: Computation is evaluation of a mathematical function.
*Object oriented: Data structures consisting of data fields and methods are used.
*Imperative: Computation in terms of statements that change the program stare.
*Reflective: Computer program can evaluate and modify its structure.

Additionally, it has a dynamic type system and automatic memory management.

= Comparison =
== System requirements ==

'''General'''
{| class="wikitable" border="1"
|-
|
! Eclipse
! NetBeans
! Aptana RadRails
! RubyMine
|-
! Version
| Helios 3.6
| NetBeans 7.0.1
| Aptana 2.0.5
| RubyMine 3.2.3
|-
! Windows
| Windows XP/Vista/7
| Windows XP/Vista/7
| Windows XP/ more
| Windows 2003/XP/Vista/7
|-
! Windows Processor
| P4 or higher
| 500 MHZ Intel Pentium 3
| Pentium Level 4
| Intel Pentium 3 or higher.
|-
! RAM
| 1 GB*
| 2GB
| 512 MB
| 2GB RAM recommended.
|-
! Disk Space
| 1GB free disk space.
| 1GB free disk space.
| 71.9MB for an Eclipse Plugin
| 91.5MB or more.
|-
! Mac OS X
| Mac OS X 10.4.10 minimum
| Mac OS 10.5 Intel
| Mac OS 10.4 +
| Mac OS 10.5 or higher
|-
! Processor
| Dual-Core Intel, PowerPC G5
| Dual Core Intel(32 or 64 bit)
| Power PC G4/G5
| 1.42GHz Intel based Mac recommended.
|-
! RAM
| 512 MB of RAM (2 GB recommended)
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 122MB
| 650MB of free disk space.
| 71.9MB for an Eclipse Plugin.
| 84.7MB or more.
|-
! Linux
| No preferences mentioned.
| Ubuntu 9.10
| No preferences mentioned.
| GNOME or KDE Desktop.
|-
! Processor
| Linux x86
| 800MHz Intel Pentium III or equivalent.
| Pentium 4-level processor.
| Intel Pentium III 800 MHz or higher.
|-
! RAM
| 64 MB
| 512 MB RAM
| 512 MB RAM
| 2GB RAM recommended
|-
! Disk Space
| 58 MB
| 650 MB of free disk space
| 71.9 MB for an Eclipse Plugin
| 82.1MB or more
|}

==General==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
|-
| Statements and keyword completion
| YES
| NO
| YES
| YES
|-
| Generate Type Constructor
| NO
| YES
| YES
| NO
|-
| Override Method
| NO
| YES
| YES
| NO
|-
| Code Formatting
| Yes
| YES
| YES
| YES
|-
| Brace Matching
| YES
| YES
| YES
| YES
|-
| Go to symbol
| NO
| NO
| YES
| YES

|}

== Editing ==

{| class="wikitable" border="1"
|-
!
! Eclipse
! RadRails
! NetBeans
! Rubymine
|-
| Code Analysis
| YES
| YES
| YES
| YES
|-
| Call Hierarchy View
| YES
| YES
| NO
| NO
|-
| Regular Expression Tester
| YES
| YES
| NO
| NO
|-
| Mark Occurences
| YES
| YES
| YES
| NO
|-
| Smart Indent
| YES
| YES
| YES
| NO
|-
| Mylyn Integration
| YES
| YES
| NO
| NO
|}

==Comparison notes==

'''NetBeans'''

NetBeans provides effective and clear sytnax highlighting. The autocompletion provided is more advanced than Idea and Eclipse. However NetBeans misses a finalized installation configuration and live coding templates. NetBeans makes it easy to add plugins. It includes a complete editing assistance.

'''Eclipse'''

Eclipse provides advance refactoring tools developed by students and also comes with a well done documentation and explanations. The biggest advantage of Eclipse is its Debugging ability.

'''Idea'''

Idea has a nice syntax highlighting and interactivity with the coder. Autocompletion in Idea is limited to keywords and statements only.

'''RadRails'''

It supports syntax highlighting, auto completion, code assist and error reporting. It also supports refactoring but it is limited to instance variables, inlining and renaming. It also supports fast and integrated debugger.

'''Rubymine'''

Rubymine is an intelligent full featured code editor. It also performs automatic Ruby code styling with brace matching.It also provides code completion and navigation. RubyMine allows quick rake tasks execution.

==Refactoring==

{| class="wikitable" border="1"
|-
!
! Netbeans
! RadRails
! Rubymine
! IDEA IntelliJ
! Eclipse
|-
| Rename
| YES
| YES
| YES
| YES
| YES
|-
| Convert Local variable to field
| NO
| YES
| NO
| NO
| YES
|-
| Encapsulate field
| NO
| YES
| YES
| NO
| YES
|-
| Extract Method
| NO
| YES
| NO
| NO
| YES
|-
| Inline Class
| NO
| YES
| NO
| NO
| YES
|-
| Inline Local Variable
| NO
| YES
| NO
| NO
| YES
|-
| Inline Method
| NO
| YES
| NO
| NO
| YES
|-
| Merge Class Parts in file
| NO
| YES
| NO
| NO
| YES
|-
| Merge with external Class Parts
| NO
| YES
| NO
| NO
| YES
|-
| Move Field
| NO
| YES
| NO
| NO
| YES
|-
| Move Method
| NO
| YES
| NO
| NO
| YES
|-
| Push Down
| NO
| YES
| NO
| NO
| YES
|-
| Split Local Variable
| NO
| YES
| NO
| NO
| YES

|}

As it can be concluded from the above table, Eclipse IDE with the Ruby development tools plugin is far better for editing than the other IDE's .

==Version Control Integration==

All the IDE's under comparison (Aptana RadRails, Ruby Mine, Eclipse and NetBeans) support SVN, Git, CVS control version systems.

Individual features are:

*Recognition of existing version-controlled directories.
*Versioning window shows new, removed, or modified files.
*Color-coded status of lines, files and folders: New, removed, up-to-date, or modified.
*Color-coded Diff Viewer for intuitive merge conflict resolution.
*Export Diff Patch action.
*Sharable project metadata.

==Debugging==

'''Netbeans 7.0'''

Netbeans supports a configurable debugger which can be used to set breakpoints, look at the local variables, navigate the call stack and switch threads. The Netbeans debugger also supports expression evaluation, expression steping, multi-session debugging, multi- threaded Debugging etc. It also allows us to attach the debugger to any remote process started from the command line.

'''RadRails'''

Aptana RadRails has an integrated Debugger which allows us to set breakpoitns, inspect variables and control execution.

'''RubyMine'''

RubyMine supports an advanced graphical debugger. It provides a convenient user interface with a fully customizable UI. It also allows us to define hit conditions for breakpoints and determine whether to stop or continue the execution.

'''IntelliJ'''

It supports a highly fast and powerful debugger which is capable of executing multiple profiles. It also displays custom objects in debugger. Remote debugging, variable modifications and expression evaluations are other important debugging options supported.

'''Eclipse'''

The Ruby interpreter for Eclipse broadcasts debugging information over a specific (configurable) port, and tools like the RDT can listen over that port and supply the types of debugging support developers expect.

=Conclusion=

Users accustomed on working in Eclipse can continue using the RadRails plugin. Eclipse provides excellent debugging capabilities.

NetBeans supports multiple languages like C++, Java.

RubyMine is exceptionally good when it comes to refactoring and can be chosen over other IDE's if this is of greater utility. RubyMine also has an intelligent code editor which others don't.

The document covers some of the major IDE's in the market for Ruby. Every IDE has its own advantages and disadvantages. The criteria for choosing a specific IDE solely depends on the perspective of a Ruby programmer and which features he wants the most from the IDE as compared to others.

=References=

1. http://tnlessone.wordpress.com/2007/02/28/ruby-rails-ide-comparison-idea-netbeans-radrails/

2. http://devnet.jetbrains.net/docs/DOC-1146

3. http://netbeans.org/features/java/debugger.html

4. http://r2.ifs.hsr.ch/rubyrefactoring.pdf

5. http://www.jetbrains.com/ruby/features/ruby_ide.html

6. http://netbeans.org/features/ide/editor.html

7. http://vimeo.com/channels/radrails#9895797

8. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_11_f1%2C

9. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_22

10. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_rf

11. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki1a_6_aa

12. http://www.aptana.com/products/radrails

13. http://netbeans.org/features/all.html#ruby

14. http://www.jetbrains.com/ruby/documentation/index.html

CSC/ECE 517 Fall 2011/ch1 1a ms

2011-08-31T18:47:25Z

Mvkantra:

CSC/ECE 517 Fall 2011

2011-08-31T18:46:04Z

Mvkantra:

*[[CSC/ECE 517 Fall 2011/ch1 1a ms]]

*[[CSC/ECE 517 Fall 2010/ch1 1e vs]]

*[[CSC/ECE 517 Fall 2011/ch1 1e aa]]

*[[CSC/ECE 517 Fall 2011/ch1 1d sr]]

*[[CSC/ECE 517 Fall 2011/ch1 1e dm]]

*[[CSC/ECE 517 Fall 2011/ch1 1b sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1b ds]]

CSC/ECE 517 Fall 2010/ch1 1a ms

2011-08-29T02:05:50Z

Mvkantra: