What's REPL?

• • * The read function accepts an expression from the user and parses it into a data structure in memory. For instance, the user may enter the s-expression (+ 1 2 3), which is parsed into a linked list containing four data elements.
  • * The eval function takes this internal data structure and evaluates it. In Lisp, considering an s-expression beginning with the name of a function means calling that function on the arguments that make up the rest of the expression. So the function + is called on the arguments 1 2 3, yielding the result 6.
  • * The print function takes the evaluation result and prints it out to the user. It may be pretty printed to make it easier to understand if it is a complex expression.
• 
  Please refer to this article for more details about REPL

• 
  
• * User or developer is the one who needs to enter some expressions inside the REPL
• * REPL only lives in memory, so once you shut down the REPL, the data disappear
• * REPL is an evaluator of the expressions given by the developer and shows a result of an error, so for that reason, some developers call it: an interpreter
• * It is possible to build a REPL for almost any programming language (even you can create one if you want), and so for pretty much every popular language, there is one that exists (but you don't have to write one by yourself because of this). However, not all languages are distributed originally with a REPL (almost all modern programming languages have a REPL, so don't worry about it)
• * There are cloud REPLs and REPLs that come with your favorite language as a default, like in our case with Ruby (IRB).

Text Editors in Coding

• 
  
• * Step #1: You have installed a console or terminal in your machine (it comes by default with any Operating System), and you know the primary usage of it. A console or terminal traditionally refers to a computer terminal where a developer may input commands and view output such as inputted commands or status messages from the computer.
• 
  
• * Step #2: Inside the terminal, you'll use a REPL program like IRB to test some Ruby code quickly, then you like the way ruby works, and finally you decide to create a more robust program, like a web app, so you would need to use a text editor to create, save or update the bunch of lines of code you want to build
• 
  
• * Step #3: You have downloaded a text editor. A text editor is a software program to create, read, update, delete, save or debug your code. So yes, you'll need to install another tool in your machine called Text Editor. A text editor can be as simple as a Word document or a more complex one like Visual Studio Code. Complex text editors like Visual Studio Code can highlight the syntax of the programming language you choose, you can organize your project, you can find errors easily, or you can even install 3rd party packages or libraries that can help you with different tasks while you're coding. It's important to mention here that editors like Word have been built for other purposes in mind, but it helps us to make this analogy (because almost nobody uses Word to write code on it)
• 
  
• * Step #4: Once you have your code ready in the text editor you choose, you'll have to execute that code in some way, so here you have to go again to your terminal, access to the folder where you have your newly created program and then execute that code and get a tangible output or result

Now, what are the best text editors out there?

Step #1- Using the Terminal

Step #2- Execute Ruby code with IRB (as we’ve learned in previous posts)

Step #3- Using a Text Editor

Step #4- Executing the code that has been created inside the text editor

$ ruby file_name.rb

class User < ApplicationRecord
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable


  has_many :posts
  has_many :links
  has_many :items, dependent: :destroy
  
  ## Set Role
  enum role: [:user, :admin]

  before_create :set_default_user
  # after_create :send_welcome_email
  # after_create :send_welcome_email_job

  def set_default_user
   self.role = :user
  end

  # Replaced by BackgroudJob
  # def send_welcome_email
  #  UserNotifierMailer.welcome_user(self).deliver_now
  # end

  #def send_welcome_email_job
  #  WelcomeEmailJob.perform_later(self.id)
  #end
end