Algorithmic Design

When faced with a problem, the first step is to devise an algorithm for its solution and express it in writing, for example, in Spanish, but adapting human language to logical forms that resemble the tasks a computer can perform. In programming, the artificial and informal language that developers use in creating algorithms is called pseudocode. It is the tool we use to describe algorithms by mixing common language with programming instructions. It is not a programming language itself, meaning the computer is not capable of understanding it. The purpose of pseudocode is to allow the programmer to focus on the logical solution and then use it as a guide when writing the program. In this tutorial, we will not be providing examples of pseudocode writing. However, it is important to understand that before attempting to program, it is essential to think ahead and plan the algorithm, i.e., all the steps required to reach the solution, and jot them down on paper with a pen while devising a strategy. This can be a great aid in the process.

Coding

An algorithm presented in pseudocode could use terms taken from the Spanish language, which is a reasonable choice for sharing this strategy among people who communicate in this language. However, if we want to present our algorithm to someone who only speaks French, Spanish would no longer be a good choice, let alone if we want to present the algorithm to a computer. In order for a computer to understand our algorithm, we need to translate it into a programming language, which, as mentioned before, is an artificial language designed to express computations that can be carried out by electronic devices; in other words, it is a means of communication between humans and machines.

There are two types of errors: logical and syntactic. The latter have to do with when instructions or variable names are not written correctly and the program cannot “interpret” them. Logic errors are generated with instructions that the program can interpret, but that do things that we do not want.

Each of the actions that make up the algorithm are encoded with one or several instructions, expressed in the chosen programming language, and the set of all of them constitutes a program. The program encoding is saved in a plain text file with an identifier usually divided into two parts by a dot, for example: my_first_program.R. The first part is the file name. The second part is indicative of the language that can interpret the instructions, for example, .R indicates that it contains a program written in the R language. The general process of writing or modifying the instructions in a file is called editing.

Organization of RStudio

When you open RStudio, you will see four panels:

Captura de pantalla de RStudio

• On the left:

  • At the top is the file editor. This is where we will write and edit our programs, and then save them. The first time you open RStudio after installation, this panel may not be present, but it appears if you go to File > New File > R Script, use the shortcut Ctrl + Shift + N, or click on the first icon in the toolbar. You can open multiple files at once.

  • Below is the console. The console is the interactive environment between R and the user. Through the console, we send instructions to R for evaluation (also known as running or executing them), and the results are displayed there.

• In the top-right corner, there is a panel with several tabs:

  • Environment (environment): shows the elements created in the current work session, which make up the environment.

  • History: lists all the instructions that the user has executed.

  • Other tabs that are not relevant for now.

• In the bottom-right corner, there is another panel with additional tabs:

  • Files: file explorer for your computer.

  • Plots: window where graphics appear if your code produces any.

  • Packages: tool for installing, updating and loading R packages (later we will talk about “packages” again).

  • Help: help manual covering all the functions of R.

  • Viewer: space to view program outputs with dynamic or interactive components.

Using the Console

We can use the R console found in the left panel to enter our instructions there, and when we press Enter, they will be evaluated, producing some results. For example, we can perform mathematical calculations such as division, multiplication, addition, subtraction, exponentiation, logarithms, square roots, and more:

> 1 + 2
[1] 3
> 5 * 3
[1] 15
> exp(2)
[1] 7.389056
> sqrt(100)
[1] 10
> 1 / 0
[1] Inf
> (2 + 3i) * (3 + 6i)
[1] -12+21i
> 1i ^ 2
[1] -1+0i

In the block above the lines starting with > represent code written by the user in the console. The result is shown below and in these cases they are lines that start with [1], something that we can ignore for the moment.

While we can write our instructions in the console and press Enter to execute them, generally, we want to write and save them in a code file. That’s why we will write our programs in the top-left panel. Once we write an instruction in the script, we can run it (i.e., send it to the console for execution) by clicking the Run button or using the shortcut Ctrl + Enter. This way, the line where the cursor is or the selected lines will be run.

In every programming language, there is a special character that, when placed at the beginning of a code line, tells the software that the line should not be evaluated. This is used to include comments, which are lines that express explanations or clarifications in natural language for ourselves or others who may use our code. Comments are also used to add headers with descriptions of the script or indicate different sections or parts of the program. In R, this special character is the number symbol (#). If we run lines that begin with #, R will ignore them and skip them. For example:

> 5^1
[1] 5
> # 5^2   this is not evaluated
> 5^3
[1] 125

R System Design

R is divided into two parts:

• The base (R Base), which is installed when we download the program from CRAN (Comprehensive R Archive Network). It contains, among other things, a set of basic and fundamental tools of R.

• Additional packages. A package is a set of files that can be optionally downloaded from CRAN or other repositories and is used to perform specific tasks. For example, to work with Karel, we need to install the package that contains its implementation, called karel.

As mentioned earlier, the Packages tab in the bottom-right panel displays a list of all the packages that are already installed (many of them come with R Base). There is also a button there to install new packages from CRAN. Alternatively, you can run the command install.packages("packagename") to install a package:

> # Instalar desde CRAN el paquete karel
> install.packages("karel")

It is also possible to install packages published in other repositories. For example, it is common to download packages under development or experimentation that are available on the GitHub platform. These packages can be installed by specifying the GitHub account name of the package author and the package name. If we want to install the development version of the karel package (not necessary), we would do the following:

> # Instalar desde CRAN el paquete devtools
> install.packages("devtools")
> # Instalar desde GitHub el paquete karel
> devtools::install_github("ropensci/karel")

A package is installed only once, but every time we want to use it, we need to load it so that its tools become available to us. This is done with the library("packagename") command, for example, library("karel").