Journal of Research in Innovative Teaching - National University

the scope-by-name feature of Ruby enhances code readability. Knowing the scope of a variable
from its name is a very concise yet informative aspect of Ruby (Matsumoto, 2001).
Polymorphism
While there are different definitions of polymorphism in the literature, Ruby implements a
specific type of polymorphism that is not hard to define, interface polymorphism. Interface
polymorphism exists when objects have methods of the same name but are not inheriting from
each other. Ruby's version allows methods of modules to be mixed into existing classes. Matz
described this mixing in as “a restricted form of multiple inheritance with implementation
sharing,” and that is discussed in more detail in the next feature, inheritance (Fulton, 2006).
Overloading operators is a specific polymorphism case. Operators like “+” and “*” are
implemented as methods in Ruby. Fulton (2006) explained how this means that a Ruby
programmer can easily override an operator by redefining its method to give it a new meaning in
a particular context. The ability of overriding operators means that we can now add real estate
properties, subtract office branches, and divide an apple pie.
Inheritance
Ruby was designed with eliminating confusion in mind. It only supports single inheritance
because multiple inheritance can cause class hierarchies to be confusing complex networks. The
aforementioned module mix-in feature makes up for the lack of multiple inheritance in Ruby
(Matsumoto, 2000). Inheritance was used in the project to reduce redundancy in the AST nodes
implementation.
Reflection
A reflective programming language allows an active environment to query, extend, or modify
objects at runtime. As a dynamic language, Ruby implements reflection, allowing a programmer
to check type, class, and methods of objects at runtime. The ObjectSpace Ruby module can
access all and any living object at runtime (Fulton, 2006).
Garbage Collection
Scott (2006) affirms that a big portion of costly application bugs are caused by programming
errors in memory management. Memory leaks and dangling pointers are common bugs in
applications written in languages that require manual memory deallocation. Ruby has an
automatic garbage collector (GC) that relieves a programmer from performing such a task. Just
like mostly anything else in Ruby, the garbage collector is an object that can be accessed and
managed using the GC module or the ObjectSpace module (Thomas, Fowler, & Hunt, 2004).
Exception Handling
Exception handling is the mechanism that deals with unexpected conditions that may arise in an
application at runtime. If a programmer is to deal with such conditions, he or she would invent a
default value, return a status value, or pass a closure to a routine to handle that condition (Scott,
2006). Luckily, Ruby programmers do not have to choose any of the previous possible actions
because Ruby has built-in exception handling. There are many classes of exceptions that can be
extended as needed (Fulton, 2006). Catching an exception in Ruby is as simple as using rescue
and ensure clauses to deal with a certain type of exception (Matsumoto, 2001). Exceptions in
65