Ruby Programming Language

Ruby is an interpreted, high-level, general-purpose programming language which supports

multiple programming paradigms. It was designed with an emphasis on programming
productivity and simplicity. In Ruby, everything is an object, including primitive data types. It
was developed in the mid-1990s by Yukihiro "Matz" Matsumoto in Japan.
Ruby is dynamically typed and uses garbage collection and just-in-time compilation. It supports
multiple programming paradigms, including procedural, object-oriented, and functional
programming. According to the creator, Ruby was influenced
by Perl, Smalltalk, Eiffel, Ada, BASIC, and Lisp.
Ruby is a true object-oriented programming language. Ruby is a server-side scripting language
similar to Python and PERL. Ruby can be used to write Common Gateway Interface (CGI)
scripts. Ruby can be embedded into Hypertext Markup Language (HTML).
The Ruby programming language is a highly portable general-purpose language that serves many
purposes. Ruby is great for building desktop applications, static websites, data processing
services, and even automation tools. It's used for web servers, DevOps, and web scraping and
crawling.
Early concept
Matsumoto has said that Ruby was conceived in 1993. In a 1999 post to the ruby-talk mailing
list, he describes some of his early ideas about the language:
I was talking with my colleague about the possibility of an object-oriented scripting language. I
knew Perl (Perl4, not Perl5), but I didn't like it really, because it had the smell of a toy
language (it still has). The object-oriented language seemed very promising. I knew Python then.
But I didn't like it, because I didn't think it was a true object-oriented language – OO features
appeared to be add-on to the language. As a language maniac and OO fan for 15 years, I really
wanted a genuine object-oriented, easy-to-use scripting language. I looked for but couldn't find
one. So I decided to make it.
Matsumoto describes the design of Ruby as being like a simple Lisp language at its core, with an
object system like that of Smalltalk, blocks inspired by higher-order functions, and practical
utility like that of Perl.
The name "Ruby" originated during an online chat session between Matsumoto and Keiju
Ishitsuka on February 24, 1993, before any code had been written for the language.[14] Initially
two names were proposed: "Coral" and "Ruby". Matsumoto chose the latter in a later e-mail to
Ishitsuka.[15] Matsumoto later noted a factor in choosing the name "Ruby" – it was
the birthstone of one of his colleagues.
Early releases
The first public release of Ruby 0.95 was announced on Japanese domestic newsgroups on
December 21, 1995.[18][19] Subsequently, three more versions of Ruby were released in two days.
[14]
 The release coincided with the launch of the Japanese-language ruby-list mailing list, which
was the first mailing list for the new language.
Already present at this stage of development were many of the features familiar in later releases
of Ruby, including object-oriented design, classes with
inheritance, mixins, iterators, closures, exception handling and garbage collection.[20]
Following the release of Ruby 0.95 in 1995, several stable versions of Ruby were released in the
following years:

 Ruby 1.0: December 25, 1996

 Ruby 1.2: December 1998
 Ruby 1.4: August 1999
 Ruby 1.6: September 2000
In 1997, the first article about Ruby was published on the Web. In the same year, Matsumoto
was hired by netlab.jp to work on Ruby as a full-time developer.
In 1998, the Ruby Application Archive was launched by Matsumoto, along with a simple
English-language homepage for Ruby.
In 1999, the first English language mailing list ruby-talk began, which signaled a growing
interest in the language outside Japan. In this same year, Matsumoto and Keiju Ishitsuka wrote
the first book on Ruby, The Object-oriented Scripting Language Ruby (オブジェクト指向スク
リプト言語 Ruby), which was published in Japan in October 1999. It would be followed in the
early 2000s by around 20 books on Ruby published in Japanese.
By 2000, Ruby was more popular than Python in Japan. In September 2000, the first English
language book Programming Ruby was printed, which was later freely released to the public,
further widening the adoption of Ruby amongst English speakers. In early 2002, the English-
language ruby-talk mailing list was receiving more messages than the Japanese-language ruby-
list, demonstrating Ruby's increasing popularity in the non-Japanese speaking world.
Ruby 1.8 and 1.9
Ruby 1.8 was initially released August 2003, was stable for a long time, and was retired June
2013. Although deprecated, there is still code based on it. Ruby 1.8 is only partially compatible
with Ruby 1.9.
Ruby 1.8 has been the subject of several industry standards. The language specifications for
Ruby were developed by the Open Standards Promotion Center of the Information-Technology
Promotion Agency (a Japanese government agency) for submission to the Japanese Industrial
Standards Committee (JISC) and then to the International Organization for
Standardization (ISO). It was accepted as a Japanese Industrial Standard (JIS X 3017) in
2011[24] and an international standard (ISO/IEC 30170) in 2012.[25][26]
Around 2005, interest in the Ruby language surged in tandem with Ruby on Rails, a web
framework written in Ruby. Rails is frequently credited with increasing awareness of Ruby.
Effective with Ruby 1.9.3, released October 31, 2011, Ruby switched from being dual-licensed
under the Ruby License and the GPL to being dual-licensed under the Ruby License and the two-
clause BSD license. Adoption of 1.9 was slowed by changes from 1.8 that required many popular
third party gems to be rewritten. Ruby 1.9 introduces many significant changes over the 1.8
series. Examples include:

 block local variables (variables that are local to the block in which they are declared)
 an additional lambda syntax:  f = ->(a,b) { puts a + b }
 an additional Hash literal syntax using colons for symbol
keys:  {symbol_key: "value"} == {:symbol_key => "value"}
 per-string character encodings are supported
 new socket API (IPv6 support)
 require_relative  import security
Ruby 2
Ruby 2.0 was intended to be fully backward compatible with Ruby 1.9.3. As of the official 2.0.0
release on February 24, 2013, there were only five known (minor) incompatibilities.[31] Ruby 2.0
added several new features, including:

 method keyword arguments,

 a new method,  Module#prepend , for extending a class,
 a new literal for creating an array of symbols,
 new API for the lazy evaluation of Enumerables, and
 a new convention of using #to_h to convert objects to Hashes.[32]
Starting with 2.1.0, Ruby's versioning policy changed to be more similar to semantic versioning.
Ruby 2.2.0 includes speed-ups, bugfixes, and library updates and removes some deprecated
APIs. Most notably, Ruby 2.2.0 introduces changes to memory handling – an incremental
garbage collector, support for garbage collection of symbols and the option to compile directly
against jemalloc. It also contains experimental support for using vfork(2) with system() and
spawn(), and added support for the Unicode 7.0 specification. Since version 2.2.1, Ruby MRI
performance on PowerPC64 was improved.[35][36][37] Features that were made obsolete or removed
include callcc, the DL library, Digest::HMAC, lib/rational.rb, lib/complex.rb, GServer,
Logger::Application as well as various C API functions.[38]
Ruby 2.3.0 includes many performance improvements, updates, and bugfixes including changes
to Proc#call, Socket and IO use of exception keywords, Thread#name handling, default passive
Net::FTP connections, and Rake being removed from stdlib.[39] Other notable changes include:

 The ability to mark all string literals as frozen by default with a consequently large
performance increase in string operations.
 Hash comparison to allow direct checking of key/value pairs instead of just keys.
 A new safe navigation operator  &.  that can ease nil handling (e.g. instead
of  if obj && obj.foo && obj.foo.bar , we can use  if obj&.foo&.bar ).
 The did_you_mean gem is now bundled by default and required on startup to automatically
suggest similar name matches on a NameError or NoMethodError.
 Hash#dig and Array#dig to easily extract deeply nested values (e.g.
given  profile = { social: { wikipedia: { name: 'Foo Baz' } } } , the value Foo Baz can now be
retrieved by  profile.dig(:social, :wikipedia, :name) ).
 .grep_v(regexp)  which will match all negative examples of a given regular expression in
addition to other new features.
Ruby 2.4.0 includes performance improvements to hash table, Array#max, Array#min, and
instance variable access. Other notable changes include:

 Binding#irb: Start a REPL session similar to binding.pry

 Unify Fixnum and Bignum into Integer class
 String supports Unicode case mappings, not just ASCII
 A new method, Regexp#match?, which is a faster boolean version of Regexp#match
 Thread deadlock detection now shows threads with their backtrace and dependency
A few notable changes in Ruby 2.5.0 include rescue and ensure statements automatically use a
surrounding do-end block (less need for extra begin-end blocks), method-chaining
with yield_self, support for branch coverage and method coverage measurement, and easier Hash
transformations with Hash#slice and Hash#transform_keys On top of that come a lot of
performance improvements like faster block passing (3 times faster), faster Mutexes, faster ERB
templates and improvements on some concatenation methods.
A few notable changes in Ruby 2.6.0 include an experimental just-in-time compiler (JIT),
and RubyVM::AbstractSyntaxTree (experimental).
A few notable changes in Ruby 2.7.0 include pattern Matching (experimental), REPL
improvements, a compaction GC, and separation of positional and keyword arguments.
Ruby 3
Ruby 3.0.0 was released on Christmas Day in 2020.[42] It is known as Ruby 3x3 which means that
programs would run three times faster in Ruby 3.0 comparing to Ruby 2.0.[43] and some had
already implemented in intermediate releases on the road from 2 to 3. To achieve 3x3, Ruby 3
equips with MJIT, a Just-In-Time Compiler, to make programs faster, but it is still not ready for
optimizing workloads like Ruby on Rails and programmers have to wait for Ruby 3.1 for further
improvement. MJIT is disabled by default and could be enabled by flags at runtime.
Another goal of Ruby 3.0 is to improve concurrency and two more utilities Fibre Scheduler, and
experimental Ractor facilitate the goal. Ractor is light-weight and thread-safe as it is achieved by
exchanging messages rather than shared objects.
Ruby 3.0 introduces RBS language to describe the types of Ruby programs for static analysis. It
is separated from general Ruby programs.
There are some syntax enhancements and library changes in Ruby 3.0 as well.
Ruby 3.1 was released on Christmas Day in 2021.[44] It includes YJIT, a new Just-In-Time
Compiler developed by Shopify, to enhance the performance of real world business applications.
A new debugger is also included. There are some syntax enhancements and other improvements
in this release. Network libraries for FTP, SMTP, IMAP, and POP are moved from default gems
to bundled gems.
Here are the characteristics of Ruby:

High-level - developer-friendly, with strong abstraction and use of natural or human language
constructs;

Dynamic - data types are determined at the stage of program execution. This increases the speed
of development;

Interpreted - Ruby code is processed by the interpreter at the time of execution without
preliminary compilation. This provides platform independence and reduces the size of executable
programs.

It’s a general-purpose programming language. Unlike domain-specific programming languages,

general-purpose programming languages are not created for use in specific areas. Yukihiro
Matsumoto started working on Ruby in the early 90s. Matz knew Perl and Python but decided to
create a new object-oriented programming language. Matsumoto didn’t like Perl, as in his
opinion it was a toy and even esoteric language. According to Matsumoto, Python was not
object-oriented enough. Matz is a fan of the object-oriented approach, so he started working on a
truly object-oriented and simple language.

Matz introduced the language in 1995. Ruby has become popular with Japanese developers.
Already in the first versions of Ruby, there were distinctive features that have survived in the
language up to this day. These are object-oriented design, use of classes and inheritance, mixins,
iterators, closures, a garbage collector, exception handling. In the late 90s, Ruby documentation
and the English-language forum ruby-talk appeared in English. This made the language popular
outside of Japan. Matz says that he created Ruby to make developers happy. To understand what
we are talking about, you need to get acquainted with the features of this language.

Advantages of Ruby on Rails

Pro #1: Time efficiency
Although it is relatively easy to learn the basics of this framework, it will take some time for you
to unlock its true potential. However, if you’re ready to invest some time in this, you will
definitely be amazed at how fast and effective you’ve become.
Pro #2: A great number of helpful tools and libraries There are hundreds of different helpful
community-created “gems” and libraries that you can use as a part of your own software.
Pro #3: Huge and active community There is a huge community of RoR developers on GitHub.
And, it is really active – there are many snippets of software with specific functions. You can
easily use these snippets, better known as “gems”, as a basis for your own project – so you can
focus on more difficult tasks.
Pro #4: Strong adherence to standards
One of RoR’s advantages is a strong backing of web standards for every part of an application,
from the user interface to data transfer.
Applications that are made with Ruby on Rails are expected to follow established software
design paradigms, such as “coding by convention” (developer needs to specify the app features
that are unconventional), “don’t repeat yourself” (encouragement to avoid code duplication and
to create abstractions instead) and “active record pattern” (specific way of accessing data in the
database).
Disadvantages of Ruby on Rails
Con #1: Shortage of flexibility
When it comes to basic tasks and features, RoR is almost unchallenged. However, because there
is a lot of default, set objects, there is not a lot of room for creativity. So, before you make your
decision about the framework you want to use for a particular project, you need to think about its
basic elements and whether they are standard or more unique.
Con #2: Continuous evolvement It is hard to say where you should put this point in the list of
pros and cons of Ruby on Rails and Ruby language. Obviously, when something changes for the
better, it’s great, and it’s a natural process, especially for a language with such a big and vocal
community. However, it is something that can be very difficult to adjust to, especially for
newcomers and beginners.
Con #3: Performance time This con of RoR is always debated and it is a subject for discussion
and comparison with other web application frameworks. The boot time of the framework is quite
long, especially when you work with a massive project, but does it also concern the runtime
speed? Well, a lot of developers would argue that this is not the case for apps with proper
optimization.
Con #4: Price of a mistake The price of a mistake in developing with Ruby on Rails is heavily
connected to the performance time. If you’re able to be thorough and pay attention to all the
small details during the development, Ruby on Rails will definitely be your helpful friend.
Common Data Structures and Concepts on making program in Ruby Language

*Printing
*Variables
*Casting and converting
*Strings *Numbers
*User Input
*Arrays
*N Dimensional Arrays
*Array Methods
* Methods
* If Else
* Switch Statements
* Dictionaries
* While Loops
* For Loops
* Exception Catching
* Constructors
* Getter and Setters
* Inheritance