DEV Community: Thinh Tran

[ Classes of Ruby ] Things are Classified for Convenience of Life Management, Not by Their Values

Thinh Tran — Mon, 07 Nov 2022 04:31:33 +0000

And then, our new concern is about how to create custom structured boxes.

So far, we've known that an application is nothing more than some blocks of code which are so called procedures and get called at some time to perform certain tasks.

~/Desktop/main.rb

main = Proc.new { |name, age, online|
   if online
      puts "Hello, World!"
      puts "I'm #{name} and #{age} times cycled around the Sun."
   else
      puts "You're offline now."
      puts "Go online first."
   end
}

main.call "Semi-Art", 32, true

And we also get that any box may contains information and other boxes as main. And if we simplify the example code above in an abstract view with the block of custom code replaced like this:

~/Desktop/main.rb

main = Proc.new custom_code_block

main.call "Semi-Art", 32, true

Now, we see that the Proc.new is the actual action to create a bundle which encloses our custom code and the box call. So, something like the definition of Proc.new is what we truly seek.

~/Desktop/main.rb

main = Proc.new { |name, age, online|
   semi = Person.new name, age, online
   semi.greet
}

main.call "Semi-Art", 32, true

CMD|Terminal.io

main.rb:2:in `block in <main>': uninitialized constant Person (NameError)
    from main.rb:6:in `<main>'

Oh.. that's Person.new is just a feeble wish and not yet to be defined. And now, we're gonna learn the basic grammar to express stuff like so.

The Class

class Person

   # - Person.new name, age, online
   def initialize (name, age, online)
      @name = name
      @age = age
      @online = online
   end

   # - Person.greet
   def greet
      if @online
         puts "Hello, World!"
         puts "I'm #{@name} and #{@age} times cycled around the Sun."
      else
         puts "You're offline now."
         puts "Go online first."
      end # if
   end

end # Person


# - main - - - - - - - - - - - - - - - - - -

main = Proc.new { |name, age, online|
   semi = Person.new name, age, online
   semi.greet
}

main.call "Semi-Art", 32, true

The hash symbols # are used to write comments in the code so that the computer will just ignore some words. So, you may need some moments to get familiar with those comments to exclude them from the real code.

There we have a class Person.

class Person
end

And a couple of definitions for new and greet.

class Person

   def initialize (name, age, online)
   end

   def greet
   end

end # Person

These all are just parts of a sketch to describe a person who has a name, is currently at some age, v.v... and has ability to perform an act of greet-ing.

And all these things just come a little more real when we invoke the code at main:

semi = Person.new name, age, online
semi.greet

Before the greet is invoked. All the information we gave into the new is bundled with the pattern we've sketched before.

def initialize (name, age, online)
   @name = name
   @age = age
   @online = online
end

So, the inner boxes are just a little more special because of the prefix symbol @. It means that all of these boxes are stored at the same particular outer box which is created when we invoke Person.new.

And that prefix symbol is also the way we access those boxes in the definition of greet.

def greet
   if @online
      puts "Hello, World!"
      puts "I'm #{@name} and #{@age} times cycled around the Sun."
   else
      puts "You're offline now."
      puts "Go online first."
   end # if
end

And Classification of The Mind

Then information may come from other sources like static files on the Desktop folder. And an application may stimulate different lifetimes to work towards the liberation plane.

main = Proc.new { |*options|
   semi = Person.new "Semi", 32, true
   semi.greet
   puts "- - - - - - - - - -"
   marc = Crafter.new "Marc", 21, true
   marc.greet
   marc.craft
   puts "- - - - - - - - - -"
   fred = Teacher.new "Steven", 21, true
   fred.greet
   fred.teach
}

main.call

Yes, we know that Crafter and Teacher are just Person to be classified. And each of these people may perform different labor act like craft and teach.

class Person
   def initialize ...
   def greet ...
end # Person


class Crafter < Person
   def craft
      puts "#{@name} is crafting..."
   end
end # Crafter


class Teacher < Person
   def teach
      puts "#{@name} is teaching..."
   end
end # Teacher

CMD|Terminal.io

Hello, World!
I'm Semi and 32 times cycled around the Sun.
- - - - - - - - - -
Hello, World!
I'm Marc and 21 times cycled around the Sun.
Marc is crafting...
- - - - - - - - - -
Hello, World!
I'm Steven and 21 times cycled around the Sun.
Steven is teaching...

Yet, like the Proc.new we've seen at first. The classes are not only used to stimulate real world entities but also used to construct applications with conceptual elements of code. Things should go well when we have a little purpose to write more code of the uses. Do you want to create a simple Tic-Tac-Toe console app?

Technical Terms

class - a definition of a class which group a certain kind of entities which have the same properties and abilities to perform acts.

instance or object - an actual box encloses real information which is created by Class.new.

property - an inner box which represent a piece of information stored @t a certain object.

method - a definition of a block of code which describe the ability to perform an act.

inheritance - the possibility of defining a new class which make use of the definition of an existing class to reduce repetitive code.

See you in the next chapter: [ Gets in Ruby ]

[ Boxes of Ruby ] The Starter Way to Manage Living Information in Applications

Thinh Tran — Mon, 07 Nov 2022 04:29:26 +0000

Previous chapter: [ Introduction to Ruby ]

So, we pop up the calculator app, push some buttons to input some information related to our living situations, and expect some output results. What's really happened behind the screen?

For most of us who are using a tech gadget in daily life, the common reason behind the whole world of technology is information. I mean what we're truly seeking in the functions of the gadgets is always the ability to take care of our living information in various aspects.

Some may want a gadget to help simplifying calculations that ones need to perform on a living information block. Some may want a gadget to help updating information of the world around the Sun. And in our current time these all tasks may be taken of by a single device like a phone or a laptop.

The Box of Information

It's hard to guess what's really happened behind the screen when we've not seen the Hello, World! app. But, later then, things are simplified down as just a single tiny box which can enclose almost every kind of information that we put there.

~/Desktop/main.rb

main = Proc.new { |box|
   puts "Hello, #{box}!"
}

main.call 2023

CMD|Terminal.io

ruby main.js

Hello, 2023!

So, to write code to create a program may have the slimmest meaning as we're gonna create boxes after boxes to transmit and manipulate all kinds of information.

Basic Types of Information

It's all started from our daily life and all the tasks that our mind has to engaged in. By updating and analyzing information, our mind is generally dealing with some words, numbers, and sometimes logical identification results.

~/Desktop/main.rb

main = Proc.new { |name, age, online|
   if online
      puts "Hello, World!"
      puts "I'm #{name} and #{age} times cycled around the Sun."
   else
      puts "You're offline now."
      puts "Go online first."
   end
}

main.call "Semi-Art", 32, true

CMD|Terminal.io

ruby main.js

Hello, World!
I'm Semi-Art and 32 times cycled around the Sun.

Structured Types for Convenience

Things like the main in the example code is also a box. We've used it to store an instance of a procedure at first. And then we've use the dot notation . to make a call using the procedure.

The call itself is a box, too. It stored the core definition of the procedure instance that we can apply to the listed pieces of information there. What a magical box.

It also means that we can use one box to wrap some others to represent things in our nature living world and things in software environment. And then that one box which enclosed others is now called a structured type for convenience to express our mind into the code.

Nope. We're not gonna make an example or the structured one here. These all are just to make our mind more comfortable with the unknown elements of the code. Just call everything box until we start specify things by their own convenience.

Technical Terms

Since we're learning technical stuff, then technical terms are just necessary as slang words in our local living. And we'll just settle these words at the end of each posts to use in the next.

[ Basic Types ]

number - a technical name of the type to represent information in numbers.
string - a technical name of the type to represent text information.
boolean - a technical name of the type to represent logical identification results as true or false.
nil - a technical name of the type to represent the absence of information as nil.

[ Some Boxes ]

variable - a box which is created on the flow of a series of statements anywhere in the code.
parameter - a box which is created in the definition of a code block to take input information when the block gets called.
object - a box which enclosed other boxes then can be accessed using dot notation .

See you in the next chapter: [ Classes of Ruby ]

[ Introduction to Ruby ] The Programming Language Designed for Humanity by Japanese Snr.

Thinh Tran — Mon, 07 Nov 2022 03:41:09 +0000

So, someone on Earth has told you to learn coding?

There are a numerous doorways to get started with the code. But, you know, there's always some special choices which are preferred by lucky people. And one of those is Ruby - the programming language is designed for humanity by Japanese souls.

For anyone who is starting to learn the code, the most important aspect of the starter tools is always about friendliness. And by the word "friendliness", what really I means is "human readability". The closer the language is to our nature tongue, the easier it is for us to engage in learning to express the logical thinking in the code.

Hello, Ruby!

And the first program that people ever wrote in any programming language is "Hello, World!". Just a seamless transient from our nature speaking language to a computer's one: "Hello, Ruby!"

~/Desktop/main.rb

main = Proc.new {
   puts "Hello, Ruby!"
}

main.call

Does that make a sense? Just like the progress to do any task in our daily life, here we've given the computer a Proc(edure) - a series of the steps needed to do to cause a result that we wished.

It may end up with a change happened on the level of a Graphical User Interface application at some point on our learning progress. But, for the start time, it happens with a mere sign of a subtle message which is put on our Command Line Interface window.

Installing Ruby

Feeling eager to run your very first program written in Ruby? Here's the link where you can download the installer for Ruby Runtime Tools: Downloads Ruby Installer for Windows.

If you're a Linux user then you can search and install it from the default repository. Just a single command in the Terminal, I guess. Some thing like sudo apt install ruby should work for a Ubuntu user, or sudo dnf install ruby for a Fedora fellow.

Got it installed? Then we can just run our very first program:

CMD|Terminal.io

cd Desktop
ruby main.rb

Hello, fellows coders!

Noticed the point we call our very first procedure? That's the place where we can make our very first program a little more flexible. What if we can just bind a name or a kind of friendly word at that place and then the result just happens according to the object of the greeting phrase?

main.rb

main = Proc.new { |name|
   puts "Hello, " + name + "!"
}

main.call "fellow coders"

CMD|Terminal.io

clear
ruby main.rb

Hello, fellow coders!

Is that just a simple shiny tweak? We've added an input |name| and use it in the greeting phrase to inject the to-be-bound value at the place when we call the procedure. And by the time you've got familiar with some only Command Line basics that we ever need. It's good to move on and just learn more stuff only of the language Ruby itself.

See you in the next chapter: [ Boxes of Ruby ]