Gain insights into Ruby development with 78 tasks tailored for beginners and experienced coders. Explore object-oriented concepts, debug programs, and advance your freelance coding career.

Ruby Is for Fun by Roman Pushkin_468 x 60 copy.png

Dockefile.tar.gz

ruby_emulator

ruby_slot_machine

ruby_roboWar

ruby_Robot-copy

ruby_load

ruby_load-copy

ruby_app

This self-study course written as a book is your first step towards making money by coding and programming from home, and having fun doing it. You will understand how the Ruby language works, and establish a foundation for being a successful freelance developer. This course gives you not only technical detail, but presents knowledge in a friendly format, understandable by all ages, providing a thorough explanation of modern concepts for absolute beginners.

In this course you will find 78 easy to follow tasks, so even people without any programming skill can solve them. Beginners will learn how to create, debug, and understand programs in Ruby. Those who are already familiar with the language will rediscover object-oriented concepts, memory organization, find career advice, and save the planet from a nuclear apocalypse.

Ready to dive into one of the most influential and demanding third generation programming languages? Let's tune in!

The Handbook for Ruby Developers

## The inspect method
This is one of the easiest and most efficient ways to debug a program.

```ruby
puts something.inspect
```

We can implement the `inspect` method for every object in any part of a program. It then returns a string representation of the object. Here, we may ask why we need to use `puts something.inspect` while we could use `puts something`.

The answer is that `inspect` is more verbose, and its primary purpose is to inspect. For example, `puts nil` and `puts ""` statements return an empty output on the screen,  while `.inspect` gives us a better idea of what the object is:

```ruby
$ pry
> puts nil

> puts nil.inspect
nil
> puts ""

> puts "".inspect
""
```
For programs that produce a lot of information to our terminal, e.g., all Ruby on Rails applications, we can use the following trick:

```ruby
puts '=' * 80
puts something.inspect
puts '=' * 80
```

The above code will print `=` eighty times, with the inspection of the variable on the next line. We can easily spot this debugging statement in a lengthy output of other unrelated debug messages. The following is such an example, where we can see that our `something` variables equal `123`:

## The `raise` method
To “stop the world” at a certain point, we can use the `raise` statement. Ruby will generate a “standard error” exception and the program will terminate, while the Rails framework will terminate only the current request:


```ruby
puts '=' * 80
puts something.inspect
puts '=' * 80
raise
```

Ruby is a dynamically typed language. It is not always possible to determine where exactly the `raise` method or another method is defined until we run a program. RubyMine IDE from Jetbrains (subscription-based) has the fantastic “Go to declaration” feature we can usually use through the Cmd+B shortcut on macOS, and Ctrl+B on other operating systems. It allows us to jump to the place where the method is defined. However, even sophisticated IDEs sometimes can’t understand where the method is defined due to the dynamic nature of Ruby runtime.
 
In this case, we can use the following trick:


```ruby
puts method(:something).source_location
```

If an object has the `something` method, the path will be displayed alongside the line number.
 
When code gets executed multiple times, a single debugging statement can pollute our screen. Therefore, having the `puts` conditional is useful:


```ruby
puts something.inspect if i == 100
```
## Using stack trace

Sometimes, we may need to print a stack trace. A **stack trace** is the exact picture and evidence of how and why a particular line got executed. Using Ruby’s `caller` statement, the following program returns the exponentiation for a random number:

# The inspect method
This is one of the easiest and most efficient ways to debug a program.

```ruby
puts something.inspect
```

We can implement the `inspect` method for every object in any part of a program. It then returns a string representation of the object. Here, we may ask why we need to use `puts something.inspect` while we could use `puts something`.

The answer is that `inspect` is more verbose, and its primary purpose is to inspect. For example, `puts nil` and `puts ""` statements return an empty output on the screen,  while `.inspect` gives us a better idea of what the object is:

```ruby
$ pry
> puts nil

> puts nil.inspect
nil
> puts ""

> puts "".inspect
""
```
For programs that produce a lot of information to our terminal, e.g., all Ruby on Rails applications, we can use the following trick:

```ruby
puts '=' * 80
puts something.inspect
puts '=' * 80
```

The above code will print `=` eighty times, with the inspection of the variable on the next line. We can easily spot this debugging statement in a lengthy output of other unrelated debug messages. The following is such an example, where we can see that our `something` variables equal `123`:

# The `raise` method
To “stop the world” at a certain point, we can use the `raise` statement. Ruby will generate a “standard error” exception and the program will terminate, while the Rails framework will terminate only the current request:


```ruby
puts '=' * 80
puts something.inspect
puts '=' * 80
raise
```

Ruby is a dynamically typed language. It is not always possible to determine where exactly the `raise` method or another method is defined until we run a program. RubyMine IDE from Jetbrains (subscription-based) has the fantastic “Go to declaration” feature we can usually use through the Cmd+B shortcut on macOS, and Ctrl+B on other operating systems. It allows us to jump to the place where the method is defined. However, even sophisticated IDEs sometimes can’t understand where the method is defined due to the dynamic nature of Ruby runtime.
 
In this case, we can use the following trick:


```ruby
puts method(:something).source_location
```

If an object has the `something` method, the path will be displayed alongside the line number.
 
When code gets executed multiple times, a single debugging statement can pollute our screen. Therefore, having the `puts` conditional is useful:


```ruby
puts something.inspect if i == 100
```
# Using stack trace

Sometimes, we may need to print a stack trace. A **stack trace** is the exact picture and evidence of how and why a particular line got executed. Using Ruby’s `caller` statement, the following program returns the exponentiation for a random number:

Learn to debug a Ruby program using the output to our console.


Debugging Using the Output to the Console


Learn to debug a Ruby program using the output to our console.

Before We Begin

First Steps

Fundamentals of Ruby

Conditional Statements

Operators and Methods

Arrays

Hash

Fun with Object Oriented Programming

Debugging in Ruby

Ruby Version Manager

Testing Ruby Programs

Wrap Up!

Appendix

Debugging Using the Output to the Console

The inspect method