DEV Community: Lucas Stoller

Getting Started with Ruby: A Beginner's Guide to Installation and Basic Programs

Lucas Stoller — Mon, 26 Feb 2024 11:47:57 +0000

Welcome to my ruby course. After a long time, I decided to teach Ruby here on my blog! I divided the course between weekly chapters. At the end of each chapter, I will let the last and next one link (if they exist at the moment).

Just to mention that Im not a Ruby guru (not yet 🤔) Im just a dev trying to help the community the way I know so, Experienced Ruby Devs reading these articles, if you find something that needs a fix or complementation, let comment bellow or DM me on Linkedin/Twitter. Hope you enjoy it! Let's go!

Ruby overview

First of all, Ruby is not Ruby on Rails. Ruby is a whole language and Rails is a famous Framework built on top of that. Here in this course, we are gonna learn the Ruby Language.

Another thing you need to learn to know about ruby is that it is very very object-oriented. Everything in ruby is an object. You dont know what an is object? Dont worry. Im gonna explain to you further. All you need to know now is that.

Last but not least, if you have programmed in other languages before youre gonna see that ruby is a very fun language to program. That is at most because Ruby has an elegant syntax designed to be intuitive and readable by humans. Its design philosophy emphasizes simplicity and productivity, which means you can accomplish more with fewer lines of code compared to many other languages.

Now that youre contextualized about Ruby, let's jump into the Ruby Dev Env setup!

Setting up the Ruby dev environment

To set up the Ruby development environment in your machine were gonna use asdf, my favorite tool to manage programming languages. Instead of using each language version manager (rbenv for Ruby, nvm for node.js, etc) the ASDF tool enables you to manage all (or almost all) language versions using only one tool. To set your ruby env using asdf do the following:

1. Install `asdf`

First, you'll need to install asdf. The method varies depending on your operating system.

For macOS:

You can use Homebrew by running:

brew install asdf

After installation, add asdf to your shell by adding the following lines to your .bashrc, .zshrc, or equivalent configuration file:

. $(brew --prefix asdf)/asdf.sh

For Ubuntu/Linux:

First, clone the asdf repository from GitHub and check out the latest version:

git clone <https://github.com/asdf-vm/asdf.git> ~/.asdf --branch v0.10.0

Then, add the following lines to your .bashrc, .zshrc, or equivalent configuration file to initialize asdf with your shell:

. $HOME/.asdf/asdf.sh. $HOME/.asdf/completions/asdf.bash

After adding the lines, either restart your terminal or source your profile file (e.g., source ~/.bashrc).

Install Dependencies : Depending on your system and the Ruby version you're installing, you might need to install some dependencies. For example, on Ubuntu, you might need to install build-essentials and other libraries:

sudo apt-get updatesudo apt-get install autoconf bison build-essential libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libncurses5-dev libffi-dev libgdbm6 libgdbm-dev libdb-dev

2. Install the Ruby Plugin

With asdf installed, you can now add the Ruby plugin:

asdf plugin add ruby

3. Install Ruby

To install Ruby, first, list all the available versions with:

asdf list-all ruby

Choose a version to install (for example, 3.0.2), and then install it by running:

asdf install ruby 3.0.2

4. Set a Global Ruby Version

After the installation, you can set a global Ruby version with:

asdf global ruby 3.0.2

This sets the Ruby version for all your projects. You can also set a Ruby version on a per-project basis by using asdf local ruby 3.0.2 the project directory.

5. Verify Installation

Finally, verify that the correct version of Ruby is installed by running:

ruby -v

And verify asdf is correctly managing the Ruby version:

asdf current ruby

Your first program in Ruby

Know that youre with your ruby dev env set, let's play a little bit. Let's create your first code in ruby: The classic Hello Word for sure.

Open your terminal and create a file named hello_world.rb

touch hello_world.rb

Now, open this file in your favorite code editor (mine is vscode) and edit it like this:

puts "What is your name?"name = gets.chompputs "Hello World, #{name}!"

Now run the code in your terminal

    ruby hello_world.rb

The code will ask you for your name and right after will respond to you with Hello World, !

Explaining the code

line 1: puts "What is your name?

Print the "What is your name? on the screen

line 2: name = gets.chomp

Make the terminal wait for your answer and when you press Enter, it gets what you typed (gets), removes any trailing newline (.chomp) and saves it into the computer memory for use later (name =)

line 4: puts "Hello World, #{name}!

Use the value saved in memory to print the "Hello World, ! on the screen

It is just a little bit of the power of the Ruby. If you dont understand all I said dont whory, more details are coming in the next chapter. Here is just for you to play a little bit with the language and test the environment you set.

IRB

Before we finish this chapter you must know about the IRB existence. Its a very helpful tool for beginner and even advanced ruby programmers.

IRB stands for Interactive Ruby, it is a tool that came in the ruby package and enables you to execute ruby code, as its name says, in an interactive way. You enter a line of ruby code, ruby interprets it, and returns the response right after.

To test irb you can do the following:

Open your terminal and type irb

irb

It will open the ruby in interactive mode. Now you can ask for Ruby to print some hello world messages for you for example:

puts "Hello world from IRB!"

Ruby will interpret your command and return the message Hello world from IRB! right next.

That is it. Know you have learned the overview about ruby language, how to set up a dev env in your local machine, how to write your first program in ruby and how to use IRB. Hope you have enjoyed it and see you in the next chapter.

How to improve the documentation of your Ruby on Rails app

Lucas Stoller — Sun, 25 Feb 2024 18:55:43 +0000

When creating a Rails application is very easy, due to the Rails conventions, the application gets big and with messy contexts. Today I’m going to bring two gems to avoid this happening, at least in the documentation aspect: rails-erd and annotations.

Rails Erd

Creating Entity Relationship Diagram of the app

The rails-erd gem is a gem that enables you to generate an ERD (Entity Relation Diagram) of or Rails app using your application schema.rb and the ActiveRecord.

For those who don’t know what an ERD is, in simple words, an ERD is a diagram that picks every entity of your application (in Rails: the models) and creates a diagram showing each one’s attributes and how they interact with each other. It’s a very common tool to understand how the application works behind the scenes. Here is an example of an ERD generated by the rails-erd:

To install and use the rails-erd just follow the instructions here:

add gem rails-erd inside the :development section of your Gemfile.rb
exec bundle install on your terminal
exec bundle exec erd on your terminal to generate the erd
(optional) exec bundle exec rails g erd:install on your terminal, this way every time you make a migration it will update the ERD.

Annotations

Enhancing code readability with inline documentation

The annotations gem is a powerful tool for Ruby on Rails developers aiming to improve the readability and maintainability of their codebase. This gem allows you to add descriptive annotations directly in your models, tests, fixtures, and factories, essentially anywhere in your code where clarification might be beneficial for future reference or for other developers working on the project.

Here is an example of how a example Post model is annotated using this gem:

# == Schema Information
#
# Table name: posts
#
#  id         :integer          not null, primary key
#  title      :string
#  body       :text
#  user_id    :integer
#  created_at :datetime         not null
#  updated_at :datetime         not null
#
# Indexes
#
#  index_posts_on_user_id  (user_id)
#
# Foreign Keys
#
#  user_id  (user_id => users.id)
#
# Annotations:
#  This model represents a blog post in the application. Each post belongs to a user.
#  - title: the title of the post
#  - body: the body/content of the post
#  - user_id: reference to the user that created the post
#

class Post < ApplicationRecord
  # Associations
  belongs_to :user

  # Validations
  validates :title, presence: true
  validates :body, presence: true

  # Additional logic, such as custom methods or scopes, can be added below.
end

Annotations can serve as a quick reminder of the purpose of a specific piece of code, explain why a particular decision was made, or provide a brief overview of how a complex function works. This practice encourages writing self-documenting code, reducing the need for external documentation and making the codebase much more approachable for new developers or when revisiting old code.

Getting Started with Annotations in Your Rails App

Add gem annotate to your Gemfile.
Run bundle install to install the gem.
Use the command bundle exec annotate to automatically generate annotations for your models and tests based on the current schema and existing test cases.
Optionally, you can customize the behavior of the annotate gem by modifying its configuration file. This allows you to control which files are annotated and how the annotations are formatted.

That’s it, hope this helps you keep your Rails app better documented. See you next time!

What is Java Stream and why does it exist?

Lucas Stoller — Sat, 04 Feb 2023 21:37:02 +0000

A Stream is a sequence of values. The java.util.stream package defines types for streams of reference values (Stream) and some primitive values (IntStream, LongStream, and DoubleStream).

Streams are like iterators in the way they supply their elements as needed for processing.

Streams were introduced in Java 8 as a way to add manageability to existing data structures. With them, we can use some very interesting methods for our structures:

Map
Reduce
Filter
Find
Foreach
Among others.

For this, it is important to create a stream pipeline. A stream pipeline is used to manage actions on a stream. It is composed of iterators and finalizers, where iterators are methods that return stream and finalizers do not return streams and still close it. Example:

To use Java streams we need to convert the data structure we are working on to a Stream, assemble and run our pipeline. Finally, we can convert the stream pipeline output back to the source structure if necessary.

You might be wondering: "Why weren't such methods declared directly in the data structures?"

As you can see, we need to convert the structure we are working on to a stream before using the utility methods because they are not present in the Collections API but have been externalized in their own Streams API. And these are some of the reasons why Java Architects proposed this solution:

The Collections API is more concerned with storing the data than with the actions and work that we are going to do on the data itself;
Manipulation X Management of the Data Structure
Eager Loading X Lazy Loading
Even though those methods we declared in Collections API we would still need to do a conversion to work with asynchronous processing, see:
The risk of collision in method names increases every time we insert a new method in an API with hierarchically ordered classes.