Published in


Context Binding in Ruby

In this article we’re going to explore the following topics:

  • The Binding class
  • The TOPLEVEL_BINDING constant
  • ERB Templates

Before to start is now live!

RubyCademy is a learning center for developers who are in their first or second professional experience such as

  • self-taught Rubyist
  • post-bootcamp dev
  • looking for your first job
  • young graduate
  • junior or mid-level dev

and who want to consolidate their knowledge of Ruby and Ruby on Rails.

So at RubyCademy, our content is designed to help you learn important notions in record time that you can directly apply on your day-to-day work.

Feel free to visit our website and subscribe to start your journey to become a better Rubyist! 💯👇😉

Thank you for your time!

The Binding class

An instance of the Binding class is able to encapsulate the execution context of the receiver object.

The execution context is the entire environment needed for a given piece of code to be executed. A code without execution context cannot be properly executed.

The execution context contains the variables, the methods and self for a given scope.

The Execution Context is a bit more complicated than this. Anyway, let’s keep it simple as it’s not the main topic of this article.

I’ll detail this key-concept in another article.

The Binding class is not publicly instantiable — as the new method is undefined during the Binding class initialization.

Otherwise, this class can be internally instantiated via the Kernel#binding method.

As the Kernel#binding method is private, we access this method through the Context#get_binding method.

So the real purpose of this class is:

Encapsulating an Execution Context and being able to access it from another Execution Context.

I know that this notion can be a bit tricky to understand.

Anyway, we’re going to detail 2 concrete examples in the next two sections.

NB: feel free to have a look to the private and protected: a matter of message article if you’re unfamiliar with the private keyword in Ruby.


The main object is the top-level scope. Any object in Ruby is instantiated, at least, under this scope.

NB: feel free to have a look to the Ruby Object Model article if you’re unfamiliar with the main object in Ruby.

In order to access the Execution Context of the main object at any time, Ruby provides a global constant named as TOPLEVEL_BINDING

The Binding#receiver method returns the receiver of the Kernel#binding message. So, the calling Execution Context is retained — in our case, the main object.

Then we access the @a variable within an instance of the Addition class using the TOPLEVEL_BINDING global constant.

ERB templates

Let’s illustrate the use of the Binding concept by breaking down a Ruby on Rails concept that you’ve surely worked with: the ERB templates

In app/controllers/users_controller.rb

In app/views/users/show.html.erb

Here the show.html.erb template gets access to the @user instance variable from the UsersController class.

So, how it works behind the scene?

The ERB class provides a result method that takes an instance of the Binding class as parameter.

So let’s redo the previous example by explicitly instantiating the ERB class to make you understand what happens behind the scene

So, in this example, the instance of ERB can access the @user variable defined in the UsersController instance via the Binding instance passed as parameter of the ERB#result method.


Thank you for taking the time to read this post :-)

Feel free to 👏 and share this article if it has been useful for you. 🚀

Here is a link to my last article: The Enumerable module in Ruby: Part II.



Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store