Ruby is currently one of the 10 most popular programming languages on the market. It is used in an estimated 2.7% of all websites, although this figure is growing year by year.
First of all, I want to clarify that the reason for this article is not to convince you that Ruby is a better language than others. The purpose is to illustrate some characteristics that might interest you if you want to learn the Ruby language.
Ruby is a language I work with every day, but I don’t consider myself an expert. I know some things I found interesting to share, if some Ruby expert wants to correct some of the code I write here, I would appreciate it. If you want to add things, that would be great too.
Ruby is a language that focuses more on the developer than the machine. This means two things:
- The syntax is very friendly and reads almost like natural language.
- The performance is not the same as in lower level languages.
This does not mean that Ruby is a poor performance language, since it is used in applications (especially web) that handle many requests per second (like Basecamp). But there is a difference between the execution time of Ruby and other languages such as C++, JAVA and not to mention C.
Ruby is very popular in web applications because there is Ruby on Rails a very popular framework to make web applications that one day used or continue to use sites like Twitter, Github, Airnbn and SoundCloud. Rails is the most popular web framework in the Ruby community, although there are also others like Sinatra. In Ruby you can also create desktop applications, as it is multi-platform, plus you can write mobile applications for different platforms with RubyMotion.
After a little introduction to the language, let’s talk code about Ruby.
EVERYTHING IS AN OBJECT (ALMOST)
Ruby is an object-oriented language, such as JAVA, C++, Python, etc. With the characteristic that Ruby takes very seriously its role on being object-oriented. In Ruby, for example, there are no primitives, like int, everything is an object, even operators like +, < are objects.
What is not an object in Ruby? Blocks, although they can be (what!), flow controls like if else while and some others, are not objects either, {and } they are not objects either.
Is this interesting? Personally it is, for example you can execute methods on what in other languages would be primitive, something like converting a number to string:
In Ruby
number = 1
number.to_s
In JAVA(for example)
int number = 1;
Integer.toString(number);
YOU CAN ABOUT WRITING THE LANGUAGE.
This is interesting, although in the real productive world I don’t know how much it is used, but here it goes. Imagine that for some strange reason you want to over write the method that converts integers to strings, you could do something like that:
class Fixnum
def to_s
self + 1
end
end
1. to_s # Returns 2 instead of “1”
If you used this syntax, you have overwritten a method of a language class to make it work the way you want. In this case, instead of converting the value to string, it adds a 1 đŸ˜›
Note, this only applies to the execution of your program, so don’t be afraid to ruin your interpreter.
THE SYMBOLS
This section was added at the recommendation of @IvanChukitow on Twitter, so stop by and thank him for giving his feedback during my Twitter conversation with him!
In Ruby we have symbols, they are written like this :symbol_name and they are, chains not mutable, that is to say that the differences with a String are that they cannot change their value, unlike strings, which can.
Symbols are a very particular feature of Ruby and I don’t know if they are used in other languages as such. What are they for? In the first place they are used when you are declaring a string that is not going to change, in the second place they have a much higher performance than a normal String by… let’s see some code before we explain why:
:hello_wordo.object_id == :hello_wordo.object_id #True
“hello world”.object_id == “hello world”.object_id # False
Let’s analyze the code we just wrote. First of all, we are not comparing the strings as such, because in that case “hello world” == “hello_world” is true. We are instead comparing the object ID, an ID that Ruby uses to identify the object in memory.
Why does one give true and the other false? Because when Ruby sees 2 identical symbols he doesn’t create another object, if he didn’t refer to the one already created, while in chains, Ruby doesn’t know if 2 chains “say the same thing” so he keeps creating more objects in memory per string we create.
This translates into better language performance, basically executions with strings are slower than with symbols.