Metaprogramming Ruby: Core Concepts - Eval Family I

In ruby, block is the cornerstone of metaprogramming with a surprisingly powerful scope controlling capability. Based on this definition, much brilliant interfaces are introduced, and help to implement many valuable features, like callable objects, eval and its huge family.

1. blocks

Block represents a snippet of code, it permits to be called immediately or lately depends on different cases. But compared with some similar concepts in functional programming languages, like Lisp, block still has more limits, and more readability respectively.

In commonly, block can be used like this:

def show_hello
  yield 'hello' if block_given?

show_hello { |say| puts say }

show_hello do |say|
  file ='/tmp/output.txt', 'w')
  file.write say

‘yield’ is a ruby keyword used to call blocks sent to the current method. block_given? is an instance method from Kernel to probe whether there is a block for current method.

One of the most useful aspect of block is closure, it captures bindings where it’s defined, and avoid impact of scope changing by connecting to those bindings, like flat scopes, and shared scopes.

Frankly speaking, block is actually not responsible for running code, but only representation (Except yield, which indeed means running code immediately). There are more powerful tools to help enhance block usage.

2. callable objects

Block is just like a package of code, and you need to use yield to execute it if you like. However, there are more ways to package code in ruby, including Proc and lambda.


We already know that block is not an object in ruby which is really quite a few, but Proc is basically a block turned object, can be seen as a consistent form of block, and you do not have to use yield to run it immediately, it will be running later as you want (Deferred Evaluation). you can define a Proc like this:

inc = {|x| x + 1} #2
dec = proc {|x| x - 1} #1


Except for Proc, lambda can also be used for transferring blocks, but with simpler and a little different way:

inc = lambda {|x| x + 1} #2
dec = ->(x) {x - 1} #1

& operator

Once you have defined a block for a method, there is a way to convert it to a Proc inner method by using &. For example:

def bar
  yield 'ruby'

def foo(&operation)

foo {|x| puts "hello #{x}"}
# hello ruby
# hello world

& can be seen like transferring a block into Proc, but you need to remove & if you want to use it as a Proc.

Comparison between procs and lambdas

You may notice that lambda is also a Proc, but you can still use Proc#lambda? to see the actual type of the target. Besides there are two important differences: keyword ‘return’ and arguments checking.

a. return

As plain blocks, the program will return out of scope where block defined if return statement is set inner block, so does Proc (which may mean that the return may cause exception when the block is called in nonreturnable scope, like top-level). While for lambda, the return only runs out of block, not even farther.

b. arity

Arity means the number of arguments. In real case, lambda has less tolerance than Proc, which means that lambda requires correct number of arity, which is no need for procs.

Method objects

All methods are objects of Method. You can use Kernel#method or Kernel#singleton_method to get the object of method, then use Method#call to run the method. Also you may use Method#to_proc and define_method to convert method and proc to each other. Eventhough the method still has scope of it’s defined.

Unbound Methods

Method object can also be unbound from original scopes by using Method#unbind, or Module#instance_method. Generated UnboundMethod object can not be called directly, but you can still call it after bind it to another scope by using UnboundMethod#bind. The only notice is that UnboundMethod object can only be bound to same class or sub if it’s from class, and no such limitation when it’s from module.


Metaprogramming Ruby: Core Concepts - Open Classes & Refinements

Opening Classes

Opening classes brings much flexibility for ruby. It permits you to modify existed classes or modules permanently, without having to implement whole world in case you just need to give a simple patch for current tool. For example:

class String
  def to_alphanumeric
    gsub(/[^\w\s]/, '')

to_alphanumeric is new interface to return only alpha and numeric part of a string. However, opening class may not work well, especially it’s commonly dangerous to opening a frequently used target which would cause unexpected error in code. Due to this reason someone calls opening classes monkey patch and just leaves far from this feature.

While whatever, monkey patch continues conciseness in ruby, sometimes you are able to save your life gracefully with such powerful tool, except the trap behind it.


From ruby 2.0, there is a more advanced form of monkey patch which is called refinements. Refinements are providing a way to extend classes only under specific scope, but not including modules. For example:

class C
  def foo
    puts "C#foo"

module M
  refine C do
    def foo
      puts "C#foo in M"

Module#refine creates an anonymous module that contains the changes or refinements to the class (C in the example). self in the refine block is this anonymous module similar to Module#module_eval.


We use using to activate refinements defined in any places, but you may only activate refinements at top-level, not inside any class, module or method scope. You may activate refinements in a string passed to Kernel#eval that is evaluated at top-level. Refinements are active until the end of the file or the end of the eval string, respectively.

Refinements are lexical in scope. When control is transferred outside the scope the refinement is deactivated. This means that when you require or load a file or call a method that is defined outside the current scope the refinement will be deactivated.

If a method is defined in a scope where a refinement is active the refinement will be active when the method is called.

When defining multiple refinements in the same module, inside a refine block all refinements from the same module are active when a refined method is called.

You may also activate refinements in a class or module definition, in which case the refinements are activated from the point where using is called to the end of the class or module definition.

Method lookup under refinement

When looking up a method for an instance of class C Ruby checks:

1. If refinements are active for C, in the reverse order they were activated:

The prepended modules from the refinement for C

The refinement for C

The included modules from the refinement for C

2. The prepended modules of C
3. C
4. The included modules of C

If no method was found at any point this repeats with the superclass of C.

Note that methods in a subclass have priority over refinements in a superclass. For example, if the method / is defined in a refinement for Integer 1 / 2 invokes the original Fixnum#/ because Fixnum is a subclass of Integer and is searched before the refinements for the superclass Integer.

If a method foo is defined on Integer in a refinement, invokes that method since foo does not exist on Fixnum.


When super is invoked method lookup checks:

The included modules of the current class. Note that the current class may be a refinement.
If the current class is a refinement, the method lookup proceeds as in the Method Lookup section above.
If the current class has a direct superclass, the method proceeds as in the Method Lookup section above using the superclass.

Note that super in a method of a refinement invokes the method in the refined class even if there is another refinement which has been activated in the same context.

Refinements and module inclusion

Refinements are inherited by module inclusion. That is, using activates all refinements in the ancestors of the specified module. Refinements in a descendant have priority over refinements in an ancestor.

After all, refinement is still an experiment feature in ruby 2.x series, there is a detailed specification in official website, which should cover most aspect of it.


Metaprogramming Ruby: Core Concepts - Scope & Self

Scope defines the circumstance around any ruby statement, which basically limits your accessibility to resources. But ruby also has implicit and complicate Constants/Methods lookup strategy to make things not so easy at all. This article will clarify the concepts about scope and self firstly, then deep into the Constants/Methods lookup strategy. Finally, let’s try to understand top-level which may be the most special case in this topic.

1. Scope

In most cases, the ‘Scope’ we say in ruby commonly refers to variable scope, which has a little bit different from other popular languages. For example, there are four basic variable scopes including local, global, instance and class level, none of them has business with each other. We’ve already know the naming specification below:

Name begins with Variable scope
[a-z] or _ local variable
$ global variable
@ instance variable
@@ class variable

Actually the tricky is not naming, it’s about default scope changing. As we know that ruby has lexical scope, but not like others, it does not support nested scope, like inner scope shares outer scope in some languages. Each of four variable scopes in above figure is purely independent to each other.

message & scope resolution operator

Dot . is message operator in ruby, mainly used for message receiving, like method call. Double colon :: is scope resolution operator, commonly used for getting constant in specific scope, Like Foo::Bar, means searching ./foo/bar with relative path. If Foo is undefined in current scope, you should always use ::Foo::Bar to figure it out using absolute path.

scope changing

There are four basic cases which may create and change the scope lexically: Class definitions (class), Module definitions (module), Methods (def) and Blocks. Block scope is a little bit different from others and more interesting, which would create its own scope after the block defined, but also have closure capability, like code below:

foo = ''
bar = lambda { foo = 'hi' if foo == 'hello' }
foo = 'hello'
foo #hi

For sure we can break this very easily:

foo = ''
bar = lambda { |;foo| foo = 'hi' if foo == 'hello' }
foo = 'hello'
foo #hello

Notice that |;foo| defines foo as a local variable in its block, this kind of feature was introduced from ruby 1.9.

constants scope

The scope we’ve talked until now basically only means variable scope. In ruby, constant is totally different type of data compared with other languages like C++ or Java, any constant name must be started with uppercase character. And none of them can be assigned dynamically. Like:

def foo
  Bar = 'hello'
end #should give SyntaxError for dynamic constant assignment

Constants defined within a class or module can be accessed within its parent. And scope operator we talked before should be used when it’s outside the class or module. Constants defined outside any class or module are global scope, can be accessed directly or by using the scope operator ‘::’ with no prefix.

2. Self

As we know that the grail in ruby world would be conciseness. However, such conciseness is built on many bright solutions like keyword self.

if you just type a name in ruby console, it will show you an error:

foo #NameError: undefined local variable or method `foo' for main:Object

Indeed it has a huge gap between ruby and other languages in such case. But the expression with only name as a statement in ruby really means asking for local variable first, if found nothing then go on for searching method defined by current object. Here ‘main’ is a special object which represents the top-level, will have more discussion in the last part of this article.

calling methods

When you want to call a method, there should always be a receiver pointed to target object. Commonly that would be in this form:


If some_object is omitted, some_method will be called on the object where the current scope belongs to. self is one of the keywords referring to the current object. Note that private is an exception in this case, we will show an example here which has already been introduced in last several articles talking about private and public.

def foo

foo #Hello #NoMethodError: private method `foo' called for main:Object

The most usage of self would be defining a class method, or getting singleton class of current class.

3. Method lookup

The order of name lookup should be local variable/constant, then method. We has discussed about variable and constant scope in the first part. Here let’s have a look at method lookup.

When a message call happens, ruby will found its receiver firstly which should be an object. Since all methods are stored in classes and modules so method lookup walks these, not the objects themselves.

Here is the order of method lookup for the receiver’s class or module R:

i. The prepended modules of R in reverse order.

ii. For a matching method in R.

iii. The included modules of R in reverse order.

If R is a class with a superclass, this is repeated with R‘s superclass until a method is found. And once a match is found method lookup stops. If no match is found this repeats from the beginning, but looking for method_missing. The default method_missing is BasicObject#method_missing which raises a NameError when invoked.

4. Understanding top-level

May be you’re not interested in top-level mechanism as a rails developer (You have to use top-level one day even you’re only develop rails application), but you need to notice that ruby is also regarded as a powerful scripting language and already as a built-in tool in many popular OS distributions. We talk about top-level because it behaves different from any ruby official documents.

I’ve found a nice explanation about top-level here, but there are some newer update in latest ruby, we’ll go through this.

Most of us may know that top-level refers to main, which is an object of Object. You can prove it very easily like this:

self #main
self.class #Object

But how about define a top-level method?

def foo
foo #hello
method(:foo).owner #Object
Object.private_method_defined?(:foo) #true
self.class.private_instance_methods(false) #[:foo]

Does that look like a class definition? Even for the constant definition:

Foo = 'hello'
Object.const_defined?(:Foo, false) #true

It just looks like you’re operating on class Object. Not only for this, we found that there can also use public, private, or include method, they are shadow in singleton_class of main:

singleton_class.private_instance_methods(false) #[:public, :private, :include, :using, :define_method]

Based on our analyst above, we find a strange dual-nature of ruby top-level with some unexpected definitions in main object in purpose. Matz gives a explanation about design of top-level. You can also get more discussion here. From my view, such unusual design exactly helps conciseness of this language, but also gains our confusion and curiosity.


Metaprogramming Ruby: Core Concepts - Object Oriented Hierarchies

Since last several articles, we’ve gone through all basic but the most important internal definitions in Ruby lang. They are BasicObject, Object, Module, and Kernel, don’t forget Class. The five composite the root of Object Oriented Hierarchies in Ruby world. One of their most useful benefit is incredible metaprogramming ability, which already provides people revolutionary tools like Ruby on Rails. Frankly speaking, the word metaprogramming makes itself too mysterious to be accepted by most people. Conciseness and Expressiveness - are the only purpose of this feature.

1. Class

Classes in Ruby are first-class objects, each class in Ruby is an instance of class Class. Typically, you create a new class by using: When a new class is created, an object of type Class is initialized and assigned to a global constant (Name in this case). When is called to create a new object, the new method in Class is run by default. Classes, modules, and objects are interrelated, we will discuss more in next chapter.

Public Class Methods


Creates a new anonymous (unnamed) class with the given superclass (or Object if no parameter is given). You can give a class a name by assigning the class object to a constant. If a block is given, it is passed the class object, and the block is evaluated in the context of this class using class_eval.

Public Instance Methods


Allocates space for a new object of class’s class and does not call initialize on the new instance. The returned object must be an instance of class.


Calls allocate to create a new object of class’s class, then invokes that object’s initialize method, passing it args. This is the method that ends up getting called whenever an object is constructed using .new.


Returns the superclass of class, or nil. Returns nil when the given class does not have a parent class.

Private Instance Methods


Callback invoked whenever a subclass of the current class is created.

2. Hierarchy of Five Kings

For more clearly, here we give a figure to cover all five items listed in preface. (We also list two guests in this figure to represent custom codes in the hierarchy)

More advance Ruby OO hierarchy

From the figure, we can see that class can be completely separated with objects under well design. Ruby uses this kind of hierarchy to implement its internal Object Oriented design. Here we would like to introduce the responsibilities on metaprogramming for each in above figure, and have deeper discussion on Module and Class, which are directly related to custom codes.


BasicObject is the root of all objects in Ruby through its subclass Object. The only class method in BasicObject is ‘new’, which is used to allocate memory to new object, and do initialization. For the public instance methods, mainly including object_id, send, and instance_eval/instance_exec to provide basic operations on any objects in Ruby. Also, BasicObject figures out the method_missing mechanism, which is very important for Ruby DSL definition, and singleton methods hook — which actually connects classes and objects in Ruby.


If any class is defined by using keyword ‘class’ without other specific inheritance, it should be inherited from Object by default. Object offers the top useful Constants in Ruby world, like ARGV, ENV, RUBY_VERSION, STDIN/STDOUT/STDERR, etc. Also for public instance methods, it provides objects comparison, clone/dup, freezing, and respond_to? checking, etc.

In metaprogramming field, Object mainly focus on instance level usage, like getting class of object, extend, instance_of?, methods, retrieving singleton_class/singleton_methods of object. etc.


Kernel is very special in the hierarchy, because it’s absolutely not class but an object. On the other hand, Kernel is mixed into class Object, making it become the earliest members in the whole hierarchy and also play very important role in the process.

Unlike Object, Constants in Kernel do not refer to some parameters of internal Ruby lang, they’re more like an utility or tool kit for subclasses, especially the reference to popular classes. Kernel also plays hard in Process operations(abort, fork, spawn), Source file loading(auto loading, require), Exception(catch, fail, raise, throw), String(chomp, chop, format, gets, gsub, sprintf, sub), Controlling(loop, sleep, rand, srand, trace/untrace), and IO(open, print, put, readlines, select).

Kernel also enhances the metaprogramming, like binding, block_given?, caller, eval, lambda, and proc.

3. Modules and Classes


Basically, Modules serve two purposes in Ruby: namespacing and mix-in functionality.

A namespace can be used to organize code by package or functionality that separates common names from interference by other packages. Mix-in functionality allows sharing common methods across multiple classes or modules. Ruby comes with the Enumerable mix-in module which provides many enumeration methods based on the each method and Comparable allows comparison of objects based on the <=> comparison method.

A module is created using the module keyword.


Every class is also a module, but unlike modules a class may not be mixed-in to another module (or class). Like a module, a class can be used as a namespace. A class also inherits methods and constants from its superclass. Use the class keyword to create a class. Any method defined on a class is callable from its subclass, the same is true for constants. You can override the functionality of a superclass method by redefining the method. If you wish to invoke the superclass functionality from a method use super.

If you do not supply a superclass your new class will inherit from Object. You may inherit from a different class using < followed by a class name.

When used without any arguments super uses the arguments given to the subclass method. To send no arguments to the superclass method use super(). To send specific arguments to the superclass method provide them manually like super(2). super may be called as many times as you like in the subclass method.

Common properties

Note that there are many similarities between modules and classes. Besides the ability to mix-in a module, the description of modules also applies to classes.


Reopening classes is a very powerful feature of Ruby, but it is best to only reopen classes you own. Otherwise it may lead to naming conflicts or difficult to diagnose bugs.


Modules may be nested.


Many packages create a single outermost module (or class) to provide a namespace for their functionality. You may also define inner modules using :: provided the outer modules (or classes) are already defined.


self refers to the object that defines the current scope. And it will change when entering a different method or when defining a new module.


Accessible constants are different depending on the module nesting (which syntax was used to define the module). if you use :: to define A::B without nesting it inside A a NameError exception will be raised because the nesting does not include A. If a constant is defined at the top-level you may preceded it with :: to reference it.


Class methods may be called directly(This is slightly confusing, but a method on a module is often called a “class method” instead of a “module method”. See also Module#module_function which can convert an instance method into a class method.). When a class method references a constant it uses the same rules as referencing it outside the method as the scope is the same. Instance methods defined in a module are only callable when included. These methods have access to the constants defined when they were included through the ancestors list.


Ruby has three types of visibility. The default is public. A public method may be called from any other object.

The second visibility is protected. When calling a protected method the sender must be a subclass of the receiver or the receiver must be a subclass of the sender. Otherwise a NoMethodError will be raised. Protected visibility is most frequently used to define == and other comparison methods where the author does not wish to expose an object’s state to any caller and would like to restrict it only to inherited classes.

The third visibility is private. A private method may not be called with a receiver, not even self. If a private method is called with a receiver a NoMethodError will be raised.

Alias and Undef

You may also alias or undefine methods, but these operations are not restricted to modules or classes.

4. Singleton classes

The singleton class (also known as the metaclass or eigenclass) of an object is a class that holds methods for only that instance. You can access the singleton class of an object using class << object like this:

class Foo
  class << self
    # self is the singleton class here

class << Foo
  # self is the singleton class here

This allows definition of methods and attributes on a class (or module) without needing to write def self.my_method.

Since you can open the singleton class of any object this means that this code block:

bar =

def bar.bar_method
  1 + 1

is equivalent to this code block:

bar =

class << bar
  def bar_method
    1 + 1

Understanding singleton class in ruby is very important to investigate internal ruby, especially for its OO design. In next article, we’ll introduce the scope mechanism in ruby.


Metaprogramming Ruby: Core Concepts - Kernel

The Kernel is the object of Module, thus it has all instance methods from the parent. Also it’s available as instance methods in every Ruby object since the Kernel is included by class Object. Kernel has widespread usage including but not limit to internal Constant references, Processes operations, Loading Strategies, Exceptions, Controlling, IO, and Basic string operations. This article will focus on metaprogramming on instance level.


All Constants and instance methods are public in Kernel, thus they all can be used in any objects as callee.


Returns a Binding object, describing the variable and method bindings at the point of call. This object can be used when calling eval to execute the evaluated command in this environment.


Evaluates the Ruby expression(s) in string. If the binding is given, which must be a Binding object, the evaluation is performed in its context. If the optional filename and lineno parameters are present, they will be used when reporting syntax errors.

block_given? / iterator?

Returns true if yield would execute a block in the current context. The iterator? form is mildly deprecated.

callcc{|cont| block}

Generates a Continuation object, which it passes to the associated block. You need to require ‘continuation’ before using this method. Performing a will cause the callcc to return (as will falling through the end of the block). The value returned by the callcc is the value of the block, or the value passed to In general, Continuation object is used to be analogous to C setjmp/longjmp, or a thread. cont will return itself, and will jump to end of callcc block.


Returns the current execution stack—an array containing strings in the form file:line or file:line: in ‘method’. Returns nil if start is greater than the size of current execution stack. Optionally you can pass a range, which will return an array containing the entries within the specified range.


Returns the current execution stack—an array containing backtrace location objects. Returns nil if start is greater than the size of current execution stack. Optionally you can pass a range, which will return an array containing the entries within the specified range.


Evaluates the Ruby expression(s) in string. If binding is given, which must be a Binding object, the evaluation is performed in its context. If the optional filename and lineno parameters are present, they will be used when reporting syntax errors.


Lookup global variables.


Equivalent to, except the resulting Proc objects check the number of parameters passed when called.


Equivalent to


Metaprogramming Ruby: Core Concepts - Module

For internal ruby, Module is mainly used for holding class methods for descendants. Suppose each object has class of A, A always has class of Class, and Class inherits from Module, thus class A should hold all class methods from instance methods in Module. On the other hand, user can mix in self defined Module to provide more instance methods for their class, or use module function directly.


Module provides two kinds of class level metaprogramming methods, either public or private. Each of them has different usage for building descendants.

Public instance methods


Returns a list of modules included/prepended in current module.


Evaluates the string or block in the context of module, except that when a block is given, constant/class variable lookup is not affected. This can be used to add methods to a class. class_eval returns the result of evaluating its argument.


Evaluates the given block in the context of the class/module. The method defined in the block will belong to the receiver. Any arguments passed to the method will be passed to the block. This can be used if the block needs to access instance variables.


Returns true if the given class variable is defined in object.


Returns the value of the given class variable (or throws a NameError exception). The @@ part of the variable name should be included for regular class variables.


Sets the class variable named by symbol to the given object.


Returns an array of the names of class variables in current module. This includes the names of class variables in any included modules, unless the inherit parameter is set to false.


Says whether module or its ancestors have a constant with the given name: If module is a Module, additionally Object and its ancestors are checked. In each of the checked classes or modules, if the constant is not present but there is an autoload for it, true is returned directly without autoloading. If the constant is not found the callback const_missing is not called and the method returns false. If inherit is false, the lookup only checks the constants in the receiver. In this case, the same logic for autoloading applies. If the argument is not a valid constant name a NameError is raised with the message “wrong constant name name”.


Checks for a constant with the given name in module. If inherit is set, the lookup will also search the ancestors (and Object if module is a Module). The value of the constant is returned if a definition is found, otherwise a NameError is raised. This method will recursively look up constant names if a namespaced class name is provided.


Invoked when a reference is made to an undefined constant in module. It is passed a symbol for the undefined constant, and returns a value to be used for that constant. If found, it returns the loaded class. It therefore implements an autoload feature similar to Kernel#autoload and #autoload.


Sets the named constant to the given object, returning that object. Creates a new constant if no constant with the given name previously existed. If symbol or string is not a valid constant name a NameError will be raised with a warning “wrong constant name”.


Returns an array of the names of the constants accessible in module. This includes the names of constants in any included modules, unless the inherit parameter is set to false.


Returns an UnboundMethod representing the given instance method in module.


Returns an array containing the names of the public and protected instance methods in the receiver. For a module, these are the public and protected methods; for a class, they are the instance (not singleton) methods.


Returns true if the named method is defined by module (or its included modules and, if module is a class, its ancestors). Public and protected methods are matched. String arguments are converted to symbols.


Evaluates the string or block in the context of module, except that when a block is given, constant/class variable lookup is not affected. This can be used to add methods to a class. module_eval returns the result of evaluating its argument.


Evaluates the given block in the context of the class/module. The method defined in the block will belong to the receiver. Any arguments passed to the method will be passed to the block. This can be used if the block needs to access instance variables.


Returns the name of the module module. Returns nil for anonymous modules.


Invokes Module.prepend_features on each parameter in reverse order.


Makes existing class methods private. Often used to hide the default constructor new.


Makes a list of existing constants private.


Returns a list of the private instance methods defined in module. If the optional parameter is false, the methods of any ancestors are not included.


Returns true if the named private method is defined by _mod_ (or its included modules and, if module is a class, its ancestors).


Returns a list of the protected instance methods defined in module. If the optional parameter is false, the methods of any ancestors are not included.


Returns true if the named protected method is defined by module (or its included modules and, if module is a class, its ancestors).


Makes a list of existing class methods public.


Makes a list of existing constants public.


Similar to instance_method, searches public method only.


Returns a list of the public instance methods defined in module. If the optional parameter is false, the methods of any ancestors are not included.


Returns true if the named public method is defined by module (or its included modules and, if module is a class, its ancestors).


Removes the definition of the symbol, returning that constant’s value.


Returns true if module is a singleton class or false if it is an ordinary class or module.

Private instance methods

Private instance methods in Module are mainly used in internal classes level.


Makes new_name a new copy of the method old_name. This can be used to retain access to methods that are overridden.


When this module is included in another, Ruby calls append_features in this module, passing it the receiving module in module. Ruby’s default implementation is to add the constants, methods, and module variables of this module to module if this module has not already been added to module or one of its ancestors.


Defines an instance method in the receiver. The method parameter can be a Proc, a Method or an UnboundMethod object. If a block is specified, it is used as the method body. This block is evaluated using instance_eval, a point that is tricky to demonstrate because define_method is private.


Extends the specified object by adding this module’s constants and methods (which are added as singleton methods). This is the callback method used by Object#extend.


The equivalent of included, but for extended modules.


Callback invoked whenever the receiver is included in another module or class. This should be used in preference to Module.append_features if your code wants to perform some action when a module is included in another.


Invoked as a callback whenever an instance method is added to the receiver.


Invoked as a callback whenever an instance method is removed from the receiver.


Invoked as a callback whenever an instance method undefined but called from the receiver.


Creates module functions for the named methods. These functions may be called with the module as a receiver, and also become available as instance methods to classes that mix in the module. Module functions are copies of the original, and so may be changed independently. The instance-method versions are made private. If used with no arguments, subsequently defined methods become module functions. String arguments are converted to symbols. prepend_features When this module is prepended in another, Ruby calls prepend_features in this module, passing it the receiving module in module. Ruby’s default implementation is to overlay the constants, methods, and module variables of this module to mod if this module has not already been added to mod or one of its ancestors. See also Module#prepend.


The equivalent of included, but for prepended modules.


Refine klass in the receiver. Returns an overlaid module.


Removes the definition of the given constant, returning that constant’s previous value. If that constant referred to a module, this will not change that module’s name and can lead to confusion. remove_method Removes the method identified by symbol from the current class. For an example, see Module.undef_method.


Prevents the current class from responding to calls to the named method. Contrast this with remove_method, which deletes the method from the particular class; Ruby will still search superclasses and mixed-in modules for a possible receiver. String arguments are converted to symbols.


Metaprogramming Ruby: Core Concepts - Object

As the default root of all Rubric objects, Object holds quite a lot valuable instance methods for common usage. It mixes in the Kernel module to provide global accessibility of Kernel APIs for all inherited classes. This article will introduce Object definition.


Object only holds a few constants and instance methods for objects of descendants, all these methods are only used for instance level metaprogramming.


Gets class Constant of object.

define_singleton_method / new_method

Defines a singleton method in the receiver. The parameters can be a Proc, a Method or an UnboundMethod object. If a block is specified, it is used as the method body.


Enhance object with instance methods from modules given as a parameter.


Check if obj is an instance of the given class(Except ancestors).


Check if the given instance variable is defined in obj.


Gets the value of the given instance variable, or nil if the instance variable is not set. Just note that the @ part of the variable name should be included for regular instance variables.


Sets the instance variable named by symbol to the given object. The variable does not have to exist prior to this call.


Returns array of instance variables

is_a? / kind_of?

Returns true if class is the class of object, or if class is one of the superclasses of obj or modules included in obj.


returns object itself


Looks up the named method as a receiver in object, returning a Method object. The Method object acts as a closure in object’s object instance, so instance variables and the value of self remain available.


Returns a list of the names of public and protected methods of object. This will include all the methods accessible in obj’s ancestors. If the optional parameter is false, it returns an array of object’s public and protected singleton methods, the array will not include methods in modules included in object.


Returns the list of private methods accessible to object.


Returns the list of protected methods accessible to object.


Similar to method, searches public method only.


Returns the list of public methods accessible to obj.


Invokes the method identified by symbol, passing it any arguments specified. Unlike send, #public_send calls public methods only.


Removes the named instance variable from object, returning that variable’s value.


Hook method to return whether the object can respond to id method or not.

send / __send__

Invokes the method identified by symbol, passing it any arguments specified. You can use __send__ if the name send clashes with an existing method in obj.


Returns the singleton class of object. This method creates a new singleton class if obj does not have one. If object is nil, true, or false, it returns NilClass, TrueClass, or FalseClass, respectively. If object is a Fixnum or a Symbol, it raises a TypeError.


Similar to #method, searches singleton method only.


Returns an array of the names of singleton methods for object. Only public and protected singleton methods are returned.


Metaprogramming Ruby: Core Concepts - BasicObject

Metaprogramming is one of core features for ruby lang, it’s widely used from internal ruby to standard library, also endless magic gems. In next a few articles we will focus on those core stuff. I recommend for Metaprogramming ruby 2 as a reference, except a little verbose and may be only for primer usage. For more ascent knowledge, perhaps you need to track the trunk of ruby. This essay will concentrate on BasicObject, which is parent for all classes in ruby.


As the object oriented hierarchy in ruby core, each type of class is also object of Class except BasicObject, and All the objects of Class has root superclass BasicObject, the one is also object of Class. Thus we’ll have whole picture below.

Ruby OO hierarchy

i.class methods

BasicObject only has single public class method, names “new”.

ii.instance methods

logical operators, any instance of BasicObject is almost empty, with only a few methods, like logical operators !, !=, ==. Here == has same meaning with equal? for object level equality, The difference is that == is recommended for descendant overriding, but equal? should always be same as it is defined in BasicObject.

__id__ / object_id

An integer identifier of an object, should be unique for a given object. But some objects of builtin classes are reused for optimization, like immediate values (not passed by reference but value, like nil, true, false, Fixnums, Symbols, and some Floats) and frozen string literals.

__send__ / send

Double underscore gives a backup for pure alphabet version which may be overrode through other ways. Invokes the method, and passes all arguments using dynamic number of arguments.

instance_eval / instance_exec

instance_eval support passing a string of ruby source code, with file path and line number when compilation errors happen, also given block, within the context of receiver. Thus eval code will have access to instance variables and private methods.

instance_exec only support using block as an argument, but allows one more argument to be passed from outer scope into receiver.

iii.private instance methods


In BasicObject, method_missing belongs to private instance methods, any call for this method will raise an error. But descendant can override this method to do dynamic processing, according to user’s input like symbol name and arguments. If overrode method does not want to do any processing, super should be called to pass message bottom from up.

singleton_method_added / singleton_method_removed / singleton_method_undefined

Callback for singleton method operations. As we already know, ruby will not create the whole clone of the class for any objects. Only with a middle layer between object and class - singleton class. Singleton class is generated when object comes out, and any messages sent to object should be transferred to its singleton class first, then its own class if not matches in singleton class.

class’s singleton class is different to object’s singleton class. That’s because singleton class of a class should be inherited from its parent’s singleton class, until BasicObject’s singleton class, then it can reach non singleton class. But for object, singleton class should always have parent class of its own class.


Microsevices陷阱: 本质与陷阱


1. 微服务的本质



















2. 发觉陷阱


“这无疑又在扯过早做大型设计的蛋(That’s BDUF Baloney)。”

Uncle Bob更倾向于“迫使无知”,即好的架构应尽量保证组件对部署和内部通信方式的透明,这样就可以根据实际情况选择部署成微服务,或多个单一系统+应用服务器,亦或纯粹的单一系统。这种“实际情况”有时可能是需要大规模扩展的、只需要少量部署的、以及单个节点足矣的。


而对于“单一系统”的说法,Uncle Bob更认为这种广告式的宣传,使得采用非微服务形式的系统听起来就像是一块又大又丑的“石头”,造成受众对微服务架构的盲目崇拜,进而为布道者带来利益。

比起微服务,Uncle Bob更加倾向于一种“整洁架构”的风格,后者是对近年来一些流行系统架构的全面总结,焦点主要集中在代码架构方面,而对微服务强调的独立部署、异构数据库等持开放的观点。

3. 稳步向前





Microsevices陷阱: 层级演进(下)

8. 服务发现






9. 服务注册








Consul的RESTful HTTP接口覆盖了从服务注册、查询信息、以及健康检查等大部分功能,使其与现有系统集成变的十分简便。其底层依赖的Serf能够检测集群内节点,进行错误管理以及发出警告。良好的设计使Consul如今成为该领域极具竞争力的明星之一。





10. 服务文档化





HAL即Hypertext Application Language,是一种超媒体资源的描述标准,HAL同样提供用户界面和标准库。通过Web界面,用户不仅可以查看API信息,还能直接调用相关API。不同的是,HAL中所有的文档信息都基于超媒体控制,因此很容易就能够将信息对外展示。这就限制了用户只能使用超媒体描述系统内资源,而从现有系统迁移则远没那么容易。

11. 自描述系统