So far we've been talking about the initial setup or configurations you've to have in your machine just to start creating your code in any programming language you want. For that reason we have talked about Versionig, Package Managers, different Operating Systems, Text Editors, Console or Terminal and Git & GitHub. All of these stuff seems irrelevant separated, but now we have to make sense of all of this once we see a programming language like Ruby

But to understand Ruby, as always, we'll need to figure out the basic and theoretical concepts behind it, and with that we'll have enough context about what we wanna to study today.

First things first, what's a programming language? A programming language is any set of rules that converts strings, or graphical program elements in the case of visual programming language, to various kinds of machine code output. Programming languages are one kind of computer language, and are used in computer programming to implement algorithms.

Most programming languages consist of instructions for computers. There are programmable machines that use a set of specific instructions, rather than general programming languages. 

Thousands of different programming languages have been created, and more are being created every year. Many programming languages are written in an imperative form (i.e., as a sequence of operations to perform) while other languages use the declarative form (i.e. the desired result is specified, not how to achieve it).

The description of a programming language is usually split into the two components of syntax (form) and semantics (meaning), which are usually defined by a formal language. Some languages are defined by a specification document (for example, the C programming language is specified by an ISO Standard) while other languages (such as Perl) have a dominant implementation that is treated as a reference. Some languages have both, with the basic language defined by a standard and extensions taken from the dominant implementation being common.

Programming language theory is a subfield of computer science that deals with the design, implementation, analysis, characterization, and classification of programming languages. If you want to study more in detail this theory please refer to this link: https://en.wikipedia.org/wiki/Programming_language

Now that we know a bit more about programming languages, the next question to answer is what is an algorithm. IS far enough to say that the algorithms are the set of instructions that we create with a programming language. It’s like if we are studying a new language like French: you have all the possible vocabulary at your hand (that’s the programming language), but you start building stories. Each story is like an algorithm. If want to tell a story to your friends in French now you have to create an algorithm (create your story) that makes sense and get some output

More theoretically speaking, In computer science, an algorithm is a finite sequence of well-defined instructions, typically used to solve a class of specific problems or to perform a computation.

Algorithms are used as specifications for performing calculations, data processing, automated reasoning, automated decision-making and other tasks. In contrast, a heuristic is an approach to problem solving that may not be fully specified or may not guarantee correct or optimal results, especially in problem domains where there is no well-defined correct or optimal result.

As an effective method, an algorithm can be expressed within a finite amount of space and time, and in a well-defined formal language for calculating a function. Starting from an initial state and initial input (perhaps empty), the instructions describe a computation that, when executed, proceeds through a finite number of well-defined successive states, eventually producing "output" and terminating at a final ending state. The transition from one state to the next is not necessarily deterministic; some algorithms, known as randomized algorithms, incorporate random input. If you want to know more details, please hit this link.

Another important concept we’ve to know inside the programming world is about the difference between compiled languages and interpreted languages. To understand this concept we have to pay attention to the most important step here: “Compilation”. 

Let’s make an example of a compiled language

Let’s make same example but with an interpreted language

We can see now some differences and similarities between the two. But take care, each one of them has their own pros and cons, so it’s better to understand both in more detail. BTW, Ruby is an Interpreted Language. 

In computing, a compiler is a computer program that translates computer code written in one programming language (the source language) into another language (the target language). The name "compiler" is primarily used for programs that translate source code from a high-level programming language to a lower level language (e.g. assembly language, object code, or machine code) to create an executable program.

A compiled language is a programming language whose implementations are typically compilers (translators that generate machine code from source code), and not interpreters (step-by-step executors of source code, where no pre-runtime translation takes place).

The term is somewhat vague. In principle, any language can be implemented with a compiler or with an interpreter. A combination of both solutions is also common: a compiler can translate the source code into some intermediate form (often called p-code or bytecode), which is then passed to an interpreter which executes it.

An interpreter is a computer program that directly executes instructions written in a programming or scripting language, without requiring them previously to have been compiled into a machine language program. An interpreter generally uses one of the following strategies for program execution:

While interpretation and compilation are the two main means by which programming languages are implemented, they are not mutually exclusive, as most interpreting systems also perform some translation work, just like compilers. The terms "interpreted language" or "compiled language" signify that the canonical implementation of that language is an interpreter or a compiler, respectively. A high-level language is ideally an abstraction independent of particular implementations. For more details about this, please refer to this link.

Also you can find a good blog post about more  differences here: https://www.freecodecamp.org/news/compiled-versus-interpreted-languages/

With all of this stuff related to compiled and interpreted languages clearly, we can now define and understand a bit better what Ruby is: 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

I know, a lot of new fancy keywords here to define the language, let’s digest it a little bit:

 

As you can see there are a lot of terms we referred to here, and maybe we’ll need more, but for now it is very clear what kind of category of programming language is Ruby. With all of this theory in place, now we can start coding some basic commands in Ruby. 

I hope you learnt a lot, see you in next post

Thanks for reading

DanielM