galaaz 0.4.10 → 0.5.0

data/blogs/manual/manual.tex

@@ -38,37 +38,37 @@
 \usepackage{framed}
 \definecolor{shadecolor}{RGB}{248,248,248}
 \newenvironment{Shaded}{\begin{snugshade}}{\end{snugshade}}
-\newcommand{\AlertTok}[1]{\textcolor[rgb]{0.94,0.16,0.16}{#1}}
-\newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
-\newcommand{\AttributeTok}[1]{\textcolor[rgb]{0.77,0.63,0.00}{#1}}
+\newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{\textbf{#1}}}
+\newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{#1}}
+\newcommand{\DecValTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
 \newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
-\newcommand{\BuiltInTok}[1]{#1}
+\newcommand{\FloatTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
+\newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
 \newcommand{\CharTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
+\newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
+\newcommand{\StringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
+\newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
+\newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
+\newcommand{\ImportTok}[1]{#1}
 \newcommand{\CommentTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textit{#1}}}
-\newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
-\newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
-\newcommand{\ControlFlowTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{\textbf{#1}}}
-\newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{#1}}
-\newcommand{\DecValTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
 \newcommand{\DocumentationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
-\newcommand{\ErrorTok}[1]{\textcolor[rgb]{0.64,0.00,0.00}{\textbf{#1}}}
-\newcommand{\ExtensionTok}[1]{#1}
-\newcommand{\FloatTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
+\newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
+\newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
+\newcommand{\OtherTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{#1}}
 \newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
-\newcommand{\ImportTok}[1]{#1}
-\newcommand{\InformationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
-\newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{\textbf{#1}}}
-\newcommand{\NormalTok}[1]{#1}
+\newcommand{\VariableTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
+\newcommand{\ControlFlowTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{\textbf{#1}}}
 \newcommand{\OperatorTok}[1]{\textcolor[rgb]{0.81,0.36,0.00}{\textbf{#1}}}
-\newcommand{\OtherTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{#1}}
+\newcommand{\BuiltInTok}[1]{#1}
+\newcommand{\ExtensionTok}[1]{#1}
 \newcommand{\PreprocessorTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textit{#1}}}
+\newcommand{\AttributeTok}[1]{\textcolor[rgb]{0.77,0.63,0.00}{#1}}
 \newcommand{\RegionMarkerTok}[1]{#1}
-\newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
-\newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
-\newcommand{\StringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
-\newcommand{\VariableTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
-\newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
+\newcommand{\InformationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
 \newcommand{\WarningTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
+\newcommand{\AlertTok}[1]{\textcolor[rgb]{0.94,0.16,0.16}{#1}}
+\newcommand{\ErrorTok}[1]{\textcolor[rgb]{0.64,0.00,0.00}{\textbf{#1}}}
+\newcommand{\NormalTok}[1]{#1}
 \usepackage{longtable,booktabs}
 \usepackage{graphicx,grffile}
 \makeatletter
@@ -216,11 +216,10 @@
 \maketitle
 
 {
-\setcounter{tocdepth}{2}
+\setcounter{tocdepth}{3}
 \tableofcontents
 }
-\hypertarget{introduction}{%
-\section{Introduction}\label{introduction}}
+\section{Introduction}\label{introduction}
 
 Galaaz is a system for tightly coupling Ruby and R. Ruby is a powerful
 language, with a large community, a very large set of libraries and
@@ -230,8 +229,111 @@ R is considered one of the most powerful languages for solving all of
 the above problems. Maybe the strongest competitor to R is Python with
 libraries such as NumPy, Panda, SciPy, SciKit-Learn and a couple more.
 
-\hypertarget{system-compatibility}{%
-\section{System Compatibility}\label{system-compatibility}}
+With Galaaz we do not intend to re-implement any of the scientific
+libraries in R, we allow for very tight coupling between the two
+languages to the point that the Ruby developer does not need to know
+that there is an R engine running.
+
+According to Wikipedia ``Ruby is a dynamic, interpreted, reflective,
+object-oriented, general-purpose programming language. It was designed
+and developed in the mid-1990s by Yukihiro''Matz" Matsumoto in Japan."
+It reached high popularity with the development of Ruby on Rails (RoR)
+by David Heinemeier Hansson. RoR is a web application framework first
+released around 2005. It makes extensive use of Ruby's metaprogramming
+features. With RoR, Ruby became very popular. According to
+\href{https://www.tiobe.com/tiobe-index/ruby/}{Ruby's Tiobe index} it
+peeked in popularity around 2008, then declined until 2015 when it
+started picking up again. At the time of this writing (November 2018),
+the Tiobe index puts Ruby in 16th position as most popular language.
+
+Python, a language similar to Ruby, ranks 4th in the index. Java, C and
+C++ take the first three positions. Ruby is often criticized for its
+focus on web applications. But Ruby can do
+\href{https://github.com/markets/awesome-ruby}{much more} than just web
+applications. Yet, for scientific computing, Ruby lags way behind Python
+and R. Python has Django framework for web, NumPy for numerical arrays,
+Pandas for data analysis. R is a free software environment for
+statistical computing and graphics with thousands of libraries for data
+analysis.
+
+Until recently, there was no real perspective for Ruby to bridge this
+gap. Implementing a complete scientific computing infrastructure would
+take too long. Enters \href{https://www.graalvm.org/}{Oracle's GraalVM}:
+
+\begin{quote}
+GraalVM is a universal virtual machine for running applications written
+in JavaScript, Python 3, Ruby, R, JVM-based languages like Java, Scala,
+Kotlin, and LLVM-based languages such as C and C++.
+
+GraalVM removes the isolation between programming languages and enables
+interoperability in a shared runtime. It can run either standalone or in
+the context of OpenJDK, Node.js, Oracle Database, or MySQL.
+
+GraalVM allows you to write polyglot applications with a seamless way to
+pass values from one language to another. With GraalVM there is no
+copying or marshaling necessary as it is with other polyglot systems.
+This lets you achieve high performance when language boundaries are
+crossed. Most of the time there is no additional cost for crossing a
+language boundary at all.
+
+Often developers have to make uncomfortable compromises that require
+them to rewrite their software in other languages. For example:
+
+\begin{itemize}
+\tightlist
+\item
+  That library is not available in my language. I need to rewrite it.
+\item
+  That language would be the perfect fit for my problem, but we cannot
+  run it in our environment.
+\item
+  That problem is already solved in my language, but the language is too
+  slow.
+\end{itemize}
+
+With GraalVM we aim to allow developers to freely choose the right
+language for the task at hand without making compromises.
+\end{quote}
+
+As stated above, GraalVM is a \emph{universal} virtual machine that
+allows Ruby and R (and other languages) to run on the same environment.
+GraalVM allows polyglot applications to \emph{seamlessly} interact with
+one another and pass values from one language to the other. Although a
+great idea, GraalVM still requires application writers to know several
+languages. To eliminate that requirement, we built Galaaz, a gem for
+Ruby, to tightly couple Ruby and R and allow those languages to interact
+in a way that the user will be unaware of such interaction. In other
+words, a Ruby programmer will be able to use all the capabilities of R
+without knowing the R syntax.
+
+Library wrapping is a usual way of bringing features from one language
+into another. To improve performance, Python often wraps more efficient
+C libraries. For the Python developer, the existence of such C libraries
+is hidden. The problem with library wrapping is that for any new
+library, there is the need to handcraft a new wrapper.
+
+Galaaz, instead of wrapping a single C or R library, wraps the whole R
+language in Ruby. Doing so, all thousands of R libraries are available
+immediately to Ruby developers without any new wrapping effort.
+
+\subsection{What does Galaaz mean}\label{what-does-galaaz-mean}
+
+Galaaz is the Portuguese name for ``Galahad''. From Wikipedia:
+
+\begin{verbatim}
+Sir Galahad (sometimes referred to as Galeas or Galath),
+in Arthurian legend, is a knight of King Arthur's Round Table and one
+of the three achievers of the Holy Grail. He is the illegitimate son
+of Sir Lancelot and Elaine of Corbenic, and is renowned for his
+gallantry and purity as the most perfect of all knights. Emerging quite
+late in the medieval Arthurian tradition, Sir Galahad first appears in the
+Lancelot–Grail cycle, and his story is taken up in later works such as
+the Post-Vulgate Cycle and Sir Thomas Malory's Le Morte d'Arthur.
+His name should not be mistaken with Galehaut, a different knight from
+Arthurian legend. 
+\end{verbatim}
+
+\section{System Compatibility}\label{system-compatibility}
 
 \begin{itemize}
 \tightlist
@@ -249,8 +351,7 @@ libraries such as NumPy, Panda, SciPy, SciKit-Learn and a couple more.
   macOS 10.13 (High Sierra)
 \end{itemize}
 
-\hypertarget{dependencies}{%
-\section{Dependencies}\label{dependencies}}
+\section{Dependencies}\label{dependencies}
 
 \begin{itemize}
 \tightlist
@@ -260,100 +361,1365 @@ libraries such as NumPy, Panda, SciPy, SciKit-Learn and a couple more.
   FastR
 \end{itemize}
 
-\hypertarget{installation}{%
-\section{Installation}\label{installation}}
+\section{Installation}\label{installation}
+
+\begin{itemize}
+\tightlist
+\item
+  Install GrallVM (\url{http://www.graalvm.org/})
+\item
+  Install Ruby (gu install Ruby)
+\item
+  Install FastR (gu install R)
+\item
+  Install rake if you want to run the specs and examples (gem install
+  rake)
+\end{itemize}
+
+\section{Usage}\label{usage}
+
+\begin{itemize}
+\tightlist
+\item
+  Interactive shell: use `gstudio' on the command line
+\end{itemize}
+
+\begin{quote}
+gstudio
+\end{quote}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{  vec = R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{)}
+\NormalTok{  puts vec}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3 4
+\end{verbatim}
+
+\begin{itemize}
+\tightlist
+\item
+  Run all specs
+\end{itemize}
+
+\begin{quote}
+galaaz specs:all
+\end{quote}
+
+\begin{itemize}
+\tightlist
+\item
+  Run graphics slideshow (80+ graphics)
+\end{itemize}
+
+\begin{quote}
+galaaz sthda:all
+\end{quote}
+
+\begin{itemize}
+\tightlist
+\item
+  Run labs from Introduction to Statistical Learning with R
+\end{itemize}
+
+\begin{quote}
+galaaz islr:all
+\end{quote}
 
 \begin{itemize}
 \tightlist
 \item
-  Install GrallVM (\url{http://www.graalvm.org/})
+  See all available examples
+\end{itemize}
+
+\begin{quote}
+galaaz -T
+\end{quote}
+
+Shows a list with all available executalbe tasks. To execute a task,
+substitute the `rake' word in the list with `galaaz'. For instance, the
+following line shows up after `galaaz -T'
+
+rake master\_list:scatter\_plot \# scatter\_plot from:\ldots{}.
+
+execute
+
+\begin{quote}
+galaaz master\_list:scatter\_plot
+\end{quote}
+
+\section{Accessing R from Ruby}\label{accessing-r-from-ruby}
+
+One of the nice aspects of Galaaz on GraalVM, is that variables and
+functions defined in R, can be easily accessed from Ruby. For instance,
+to access the `mtcars' data frame from R in Ruby, we use the `:mtcar'
+symbol preceded by the `\textasciitilde{}' operator, thus
+`\textasciitilde{}:r\_vec' retrieves the value of the `mtcars' variable.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts ~}\StringTok{:mtcars}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##                      mpg cyl  disp  hp drat    wt  qsec vs am gear carb
+## Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
+## Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
+## Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
+## Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
+## Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
+## Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
+## Duster 360          14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
+## Merc 240D           24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2
+## Merc 230            22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2
+## Merc 280            19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4
+## Merc 280C           17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4
+## Merc 450SE          16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3
+## Merc 450SL          17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3
+## Merc 450SLC         15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3
+## Cadillac Fleetwood  10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4
+## Lincoln Continental 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4
+## Chrysler Imperial   14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4
+## Fiat 128            32.4   4  78.7  66 4.08 2.200 19.47  1  1    4    1
+## Honda Civic         30.4   4  75.7  52 4.93 1.615 18.52  1  1    4    2
+## Toyota Corolla      33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1
+## Toyota Corona       21.5   4 120.1  97 3.70 2.465 20.01  1  0    3    1
+## Dodge Challenger    15.5   8 318.0 150 2.76 3.520 16.87  0  0    3    2
+## AMC Javelin         15.2   8 304.0 150 3.15 3.435 17.30  0  0    3    2
+## Camaro Z28          13.3   8 350.0 245 3.73 3.840 15.41  0  0    3    4
+## Pontiac Firebird    19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2
+## Fiat X1-9           27.3   4  79.0  66 4.08 1.935 18.90  1  1    4    1
+## Porsche 914-2       26.0   4 120.3  91 4.43 2.140 16.70  0  1    5    2
+## Lotus Europa        30.4   4  95.1 113 3.77 1.513 16.90  1  1    5    2
+## Ford Pantera L      15.8   8 351.0 264 4.22 3.170 14.50  0  1    5    4
+## Ferrari Dino        19.7   6 145.0 175 3.62 2.770 15.50  0  1    5    6
+## Maserati Bora       15.0   8 301.0 335 3.54 3.570 14.60  0  1    5    8
+## Volvo 142E          21.4   4 121.0 109 4.11 2.780 18.60  1  1    4    2
+\end{verbatim}
+
+To access an R function from Ruby, the R function needs to be preceeded
+by `R.' scoping. Bellow we see and example of creating a R::Vector by
+calling the `c' R function
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec = R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3 4
+\end{verbatim}
+
+Note that `vec' is an object of type R::Vector:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec.class}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## R::Vector
+\end{verbatim}
+
+Every object created by a call to an R function will be of a type that
+inherits from R::Object. In R, there is also a function `class'. In
+order to access that function we can call method `rclass' in the
+R::Object:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec.rclass}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] "numeric"
+\end{verbatim}
+
+When working with R::Object(s), it is possible to use the `.' operator
+to pipe operations. When using `.', the object to which the `.' is
+applied becomes the first argument of the corresponding R function. For
+instance, function `c' in R, can be used to concatenate two vectors or
+more vectors (in R, there are no scalar values, scalars are converted to
+vectors of size 1. Within Galaaz, scalar parameter is converted to a
+size one vector):
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts R.c(vec, }\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1]  1  2  3  4 10 20 30
+\end{verbatim}
+
+The call above to the `c' function can also be done using `.' notation:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec.c(}\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1]  1  2  3  4 10 20 30
+\end{verbatim}
+
+We will talk about vector indexing in a latter section. But notice here
+that indexing an R::Vector will return another R::Vector:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec[}\DecValTok{1}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1
+\end{verbatim}
+
+Sometimes we want to index an R::Object and get back a Ruby object that
+is not wrapped in an R::Object, but the native Ruby object. For this, we
+can index the R object with the `\textgreater{}\textgreater{}' operator:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec >> }\DecValTok{0}
+\NormalTok{puts vec >> }\DecValTok{2}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## 1.0
+## 3.0
+\end{verbatim}
+
+It is also possible to call an R function with named arguments, by
+creating the function in Galaaz with named parameters. For instance,
+here is an example of creating a `list' with named elements:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts R.list(}\StringTok{first_name: "Rodrigo"}\NormalTok{, }\StringTok{last_name: "Botafogo"}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## $first_name
+## [1] "Rodrigo"
+## 
+## $last_name
+## [1] "Botafogo"
+\end{verbatim}
+
+Many R functions receive another function as argument. For instance,
+method `map' applies a function to every element of a vector. With
+Galaaz, it is possible to pass a Proc, Method or Lambda in place of the
+expected R function. In this next example, we will add 2 to every
+element of our previously created vector:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts vec.map \{ |x| x + }\DecValTok{2}\NormalTok{ \}}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 3
+## [1] 4
+## [1] 5
+## [1] 6
+\end{verbatim}
+
+\section{gKnitting a Document}\label{gknitting-a-document}
+
+This manual has been formatted usign gKnit. gKnit uses Knitr and R
+markdown to knit a document in Ruby or R and output it in any of the
+available formats for R markdown. gKnit runs atop of GraalVM, and
+Galaaz. In gKnit, Ruby variables are persisted between chunks, making it
+an ideal solution for literate programming. Also, since it is based on
+Galaaz, Ruby chunks can have access to R variables and Polyglot
+Programming with Ruby and R is quite natural.
+
+The idea of ``literate programming'' was first introduced by Donald
+Knuth in the 1980's (Knuth 1984). The main intention of this approach
+was to develop software interspersing macro snippets, traditional source
+code, and a natural language such as English in a document that could be
+compiled into executable code and at the same time easily read by a
+human developer. According to Knuth ``The practitioner of literate
+programming can be regarded as an essayist, whose main concern is with
+exposition and excellence of style.''
+
+The idea of literate programming evolved into the idea of reproducible
+research, in which all the data, software code, documentation, graphics
+etc. needed to reproduce the research and its reports could be included
+in a single document or set of documents that when distributed to peers
+could be rerun generating the same output and reports.
+
+The R community has put a great deal of effort in reproducible research.
+In 2002, Sweave was introduced and it allowed mixing R code with Latex
+generating high quality PDF documents. A Sweave document could include
+code, the results of executing the code, graphics and text such that it
+contained the whole narrative to reproduce the research. In 2012, Knitr,
+developed by Yihui Xie from RStudio was released to replace Sweave and
+to consolidate in one single package the many extensions and add-on
+packages that were necessary for Sweave.
+
+With Knitr, \textbf{R markdown} was also developed, an extension to the
+Markdown format. With \textbf{R markdown} and Knitr it is possible to
+generate reports in a multitude of formats such as HTML, markdown,
+Latex, PDF, dvi, etc. \textbf{R markdown} also allows the use of
+multiple programming languages such as R, Ruby, Python, etc. in the same
+document.
+
+In \textbf{R markdown}, text is interspersed with code chunks that can
+be executed and both the code and its results can become part of the
+final report. Although \textbf{R markdown} allows multiple programming
+languages in the same document, only R and Python (with the reticulate
+package) can persist variables between chunks. For other languages, such
+as Ruby, every chunk will start a new process and thus all data is lost
+between chunks, unless it is somehow stored in a data file that is read
+by the next chunk.
+
+Being able to persist data between chunks is critical for literate
+programming otherwise the flow of the narrative is lost by all the
+effort of having to save data and then reload it. Although this might,
+at first, seem like a small nuisance, not being able to persist data
+between chunks is a major issue. For example, let's take a look at the
+following simple example in which we want to show how to create a list
+and the use it. Let's first assume that data cannot be persisted between
+chunks. In the next chunk we create a list, then we would need to save
+it to file, but to save it, we need somehow to marshal the data into a
+binary format:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{lst = R.list(}\StringTok{a: }\DecValTok{1}\NormalTok{, }\StringTok{b: }\DecValTok{2}\NormalTok{, }\StringTok{c: }\DecValTok{3}\NormalTok{)}
+\NormalTok{lst.saveRDS(}\StringTok{"lst.rds"}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+then, on the next chunk, where variable `lst' is used, we need to read
+back it's value
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{lst = R.readRDS(}\StringTok{"lst.rds"}\NormalTok{)}
+\NormalTok{puts lst}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## $a
+## [1] 1
+## 
+## $b
+## [1] 2
+## 
+## $c
+## [1] 3
+\end{verbatim}
+
+Now, any single code has dozens of variables that we might want to use
+and reuse between chunks. Clearly, such an approach becomes quickly
+unmanageable. Probably, because of this problem, it is very rare to see
+any \textbf{R markdown} document in the Ruby community.
+
+When variables can be used accross chunks, then no overhead is needed:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{lst = R.list(}\StringTok{a: }\DecValTok{1}\NormalTok{, }\StringTok{b: }\DecValTok{2}\NormalTok{, }\StringTok{c: }\DecValTok{3}\NormalTok{)}
+\CommentTok{# any other code can be added here}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts lst}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## $a
+## [1] 1
+## 
+## $b
+## [1] 2
+## 
+## $c
+## [1] 3
+\end{verbatim}
+
+In the Python community, the same effort to have code and text in an
+integrated environment started around the first decade of 2000. In 2006
+iPython 0.7.2 was released. In 2014, Fernando Pérez, spun off project
+Jupyter from iPython creating a web-based interactive computation
+environment. Jupyter can now be used with many languages, including Ruby
+with the iruby gem (\url{https://github.com/SciRuby/iruby}). In order to
+have multiple languages in a Jupyter notebook the SoS kernel was
+developed (\url{https://vatlab.github.io/sos-docs/}).
+
+\subsection{\texorpdfstring{gKnit and \textbf{R
+markdown}}{gKnit and R markdown}}\label{gknit-and-r-markdown}
+
+gKnit is based on knitr and \textbf{R markdown} and can knit a document
+written both in Ruby and/or R and output it in any of the available
+formats of \textbf{R markdown}. gKnit allows ruby developers to do
+literate programming and reproducible research by allowing them to have
+in a single document, text and code.
+
+In gKnit, Ruby variables are persisted between chunks, making it an
+ideal solution for literate programming in this language. Also, since it
+is based on Galaaz, Ruby chunks can have access to R variables and
+Polyglot Programming with Ruby and R is quite natural.
+
+This is not a blog post on \textbf{R markdown}, and the interested user
+is directed to the following links for detailed information on its
+capabilities and use.
+
+\begin{itemize}
+\tightlist
+\item
+  \url{https://rmarkdown.rstudio.com/} or
+\item
+  \url{https://bookdown.org/yihui/rmarkdown/}
+\end{itemize}
+
+In this post, we will describe just the main aspects of \textbf{R
+markdown}, so the user can start gKnitting Ruby and R documents quickly.
+
+\subsection{The Yaml header}\label{the-yaml-header}
+
+An \textbf{R markdown} document should start with a Yaml header and be
+stored in a file with `.Rmd' extension. This document has the following
+header for gKitting an HTML document.
+
+\begin{verbatim}
+---
+title: "How to do reproducible research in Ruby with gKnit"
+author: 
+    - "Rodrigo Botafogo"
+    - "Daniel Mossé - University of Pittsburgh"
+tags: [Tech, Data Science, Ruby, R, GraalVM]
+date: "20/02/2019"
+output:
+  html_document:
+    self_contained: true
+    keep_md: true
+  pdf_document:
+    includes:
+      in_header: ["../../sty/galaaz.sty"]
+    number_sections: yes
+---
+\end{verbatim}
+
+For more information on the options in the Yaml header,
+\href{https://bookdown.org/yihui/rmarkdown/html-document.html}{check
+here}.
+
+\subsection{\texorpdfstring{\textbf{R Markdown}
+formatting}{R Markdown formatting}}\label{r-markdown-formatting}
+
+Document formatting can be done with simple markups such as:
+
+\subsection{Headers}\label{headers}
+
+\begin{verbatim}
+# Header 1
+
+## Header 2
+
+### Header 3
+\end{verbatim}
+
+\subsection{Lists}\label{lists}
+
+\begin{verbatim}
+Unordered lists:
+
+* Item 1
+* Item 2
+    + Item 2a
+    + Item 2b
+\end{verbatim}
+
+\begin{verbatim}
+Ordered Lists
+
+1. Item 1
+2. Item 2
+3. Item 3
+    + Item 3a
+    + Item 3b
+\end{verbatim}
+
+For more R markdown formatting go to
+\url{https://rmarkdown.rstudio.com/authoring_basics.html}.
+
+\subsection{R chunks}\label{r-chunks}
+
+Running and executing Ruby and R code is actually what really interests
+us is this blog.\\
+Inserting a code chunk is done by adding code in a block delimited by
+three back ticks followed by an open curly brace (`\{') followed with
+the engine name (r, ruby, rb, include, \ldots{}), an any optional
+chunk\_label and options, as shown bellow:
+
+\begin{verbatim}
+```{engine_name [chunk_label], [chunk_options]}
+```
+\end{verbatim}
+
+for instance, let's add an R chunk to the document labeled
+`first\_r\_chunk'. This is a very simple code just to create a variable
+and print it out, as follows:
+
+\begin{verbatim}
+```{r first_r_chunk}
+vec <- c(1, 2, 3)
+print(vec)
+```
+\end{verbatim}
+
+If this block is added to an \textbf{R markdown} document and gKnitted
+the result will be:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec <-}\StringTok{ }\KeywordTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
+\KeywordTok{print}\NormalTok{(vec)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3
+\end{verbatim}
+
+Now let's say that we want to do some analysis in the code, but just
+print the result and not the code itself. For this, we need to add the
+option `echo = FALSE'.
+
+\begin{verbatim}
+```{r second_r_chunk, echo = FALSE}
+vec2 <- c(10, 20, 30)
+vec3 <- vec * vec2
+print(vec3)     
+```
+\end{verbatim}
+
+Here is how this block will show up in the document. Observe that the
+code is not shown and we only see the execution result in a white box
+
+\begin{verbatim}
+## [1] 10 40 90
+\end{verbatim}
+
+A description of the available chunk options can be found in
+\url{https://yihui.name/knitr/}.
+
+Let's add another R chunk with a function definition. In this example, a
+vector `r\_vec' is created and a new function `reduce\_sum' is defined.
+The chunk specification is
+
+\begin{verbatim}
+```{r data_creation}
+r_vec <- c(1, 2, 3, 4, 5)
+
+reduce_sum <- function(...) {
+  Reduce(sum, as.list(...))
+}
+```
+\end{verbatim}
+
+and this is how it will look like once executed. From now on, to be
+concise in the presentation we will not show chunk definitions any
+longer.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{r_vec <-}\StringTok{ }\KeywordTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{, }\DecValTok{5}\NormalTok{)}
+
+\NormalTok{reduce_sum <-}\StringTok{ }\ControlFlowTok{function}\NormalTok{(...) \{}
+  \KeywordTok{Reduce}\NormalTok{(sum, }\KeywordTok{as.list}\NormalTok{(...))}
+\NormalTok{\}}
+\end{Highlighting}
+\end{Shaded}
+
+We can, possibly in another chunk, access the vector and call the
+function as follows:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{print}\NormalTok{(r_vec)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3 4 5
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{print}\NormalTok{(}\KeywordTok{reduce_sum}\NormalTok{(r_vec))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 15
+\end{verbatim}
+
+\subsection{R Graphics with ggplot}\label{r-graphics-with-ggplot}
+
+In the following chunk, we create a bubble chart in R using ggplot and
+include it in this document. Note that there is no directive in the code
+to include the image, this occurs automatically. The `mpg' dataframe is
+natively available to R and to Galaaz as well.
+
+For the reader not knowledgeable of ggplot, ggplot is a graphics library
+based on ``the grammar of graphics'' (Wilkinson 2005). The idea of the
+grammar of graphics is to build a graphics by adding layers to the plot.
+More information can be found in
+\url{https://towardsdatascience.com/a-comprehensive-guide-to-the-grammar-of-graphics-for-effective-visualization-of-multi-dimensional-1f92b4ed4149}.
+
+In the plot bellow the `mpg' dataset from base R is used. ``The data
+concerns city-cycle fuel consumption in miles per gallon, to be
+predicted in terms of 3 multivalued discrete and 5 continuous
+attributes.'' (Quinlan, 1993)
+
+First, the `mpg' dataset if filtered to extract only cars from the
+following manumactures: Audi, Ford, Honda, and Hyundai and stored in the
+`mpg\_select' variable. Then, the selected dataframe is passed to the
+ggplot function specifying in the aesthetic method (aes) that
+`displacement' (disp) should be plotted in the `x' axis and `city
+mileage' should be on the `y' axis. In the `labs' layer we pass the
+`title' and `subtitle' for the plot. To the basic plot `g', geom\_jitter
+is added, that plots cars from the same manufactures with the same color
+(col=manufactures) and the size of the car point equal its high way
+consumption (size = hwy). Finally, a last layer is plotter containing a
+linear regression line (method = ``lm'') for every manufacturer.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# load package and data}
+\KeywordTok{library}\NormalTok{(ggplot2)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Message:
+##  Registered S3 methods overwritten by 'ggplot2':
+##   method         from 
+##   [.quosures     rlang
+##   c.quosures     rlang
+##   print.quosures rlang
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{data}\NormalTok{(mpg, }\DataTypeTok{package=}\StringTok{"ggplot2"}\NormalTok{)}
+
+\NormalTok{mpg_select <-}\StringTok{ }\NormalTok{mpg[mpg}\OperatorTok{$}\NormalTok{manufacturer }\OperatorTok{%in%}\StringTok{ }\KeywordTok{c}\NormalTok{(}\StringTok{"audi"}\NormalTok{, }\StringTok{"ford"}\NormalTok{, }\StringTok{"honda"}\NormalTok{, }\StringTok{"hyundai"}\NormalTok{), ]}
+
+\CommentTok{# Scatterplot}
+\KeywordTok{theme_set}\NormalTok{(}\KeywordTok{theme_bw}\NormalTok{())  }\CommentTok{# pre-set the bw theme.}
+\NormalTok{g <-}\StringTok{ }\KeywordTok{ggplot}\NormalTok{(mpg_select, }\KeywordTok{aes}\NormalTok{(displ, cty)) }\OperatorTok{+}\StringTok{ }
+\StringTok{  }\KeywordTok{labs}\NormalTok{(}\DataTypeTok{subtitle=}\StringTok{"mpg: Displacement vs City Mileage"}\NormalTok{,}
+       \DataTypeTok{title=}\StringTok{"Bubble chart"}\NormalTok{)}
+
+\NormalTok{g }\OperatorTok{+}\StringTok{ }\KeywordTok{geom_jitter}\NormalTok{(}\KeywordTok{aes}\NormalTok{(}\DataTypeTok{col=}\NormalTok{manufacturer, }\DataTypeTok{size=}\NormalTok{hwy)) }\OperatorTok{+}\StringTok{ }
+\StringTok{  }\KeywordTok{geom_smooth}\NormalTok{(}\KeywordTok{aes}\NormalTok{(}\DataTypeTok{col=}\NormalTok{manufacturer), }\DataTypeTok{method=}\StringTok{"lm"}\NormalTok{, }\DataTypeTok{se=}\NormalTok{F)}
+\end{Highlighting}
+\end{Shaded}
+
+\includegraphics{manual_files/figure-latex/bubble-1.png}
+
+\subsection{Ruby chunks}\label{ruby-chunks}
+
+Including a Ruby chunk is just as easy as including an R chunk in the
+document: just change the name of the engine to `ruby'. It is also
+possible to pass chunk options to the Ruby engine; however, this version
+does not accept all the options that are available to R chunks. Future
+versions will add those options.
+
+\begin{verbatim}
+```{ruby first_ruby_chunk}
+```
+\end{verbatim}
+
+In this example, the ruby chunk is called `first\_ruby\_chunk'. One
+important aspect of chunk labels is that they cannot be duplicated. If a
+chunk label is duplicated, gKnit will stop with an error.
+
+In the following chunk, variable `a', `b' and `c' are standard Ruby
+variables and `vec' and `vec2' are two vectors created by calling the
+`c' method on the R module.
+
+In Galaaz, the R module allows us to access R functions transparently.
+The `c' function in R, is a function that concatenates its arguments
+making a vector.
+
+It should be clear that there is no requirement in gknit to call or use
+any R functions. gKnit will knit standard Ruby code, or even general
+text without any code.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{a = [}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{]}
+\NormalTok{b = }\StringTok{"US$ 250.000"}
+\NormalTok{c = }\StringTok{"The 'outputs' function"}
+
+\NormalTok{vec = R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
+\NormalTok{vec2 = R.c(}\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+In the next block, variables `a', `vec' and `vec2' are used and printed.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts a}
+\NormalTok{puts vec * vec2}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## 1
+## 2
+## 3
+## [1] 10 40 90
+\end{verbatim}
+
+Note that `a' is a standard Ruby Array and `vec' and `vec2' are vectors
+that behave accordingly, where multiplication works as expected.
+
+\subsection{Inline Ruby code}\label{inline-ruby-code}
+
+When using a Ruby chunk, the code and the output are formatted in blocks
+as seen above. This formatting is not always desired. Sometimes, we want
+to have the results of the Ruby evaluation included in the middle of a
+phrase. gKnit allows adding inline Ruby code with the `rb' engine. The
+following chunk specification will create and inline Ruby text:
+
+\begin{verbatim}
+This is some text with inline Ruby accessing variable 'b' which has value:
+```{rb puts b}
+```
+and is followed by some other text!
+\end{verbatim}
+
+This is some text with inline Ruby accessing variable `b' which has
+value: US\$ 250.000 and is followed by some other text!
+
+Note that it is important not to add any new line before of after the
+code block if we want everything to be in only one line, resulting in
+the following sentence with inline Ruby code.
+
+\subsubsection{\texorpdfstring{The `outputs'
+function}{The outputs function}}\label{the-outputs-function}
+
+He have previously used the standard `puts' method in Ruby chunks in
+order produce output. The result of a `puts', as seen in all previous
+chunks that use it, is formatted inside a white box that follows the
+code block. Many times however, we would like to do some processing in
+the Ruby chunk and have the result of this processing generate and
+output that is ``included'' in the document as if we had typed it in
+\textbf{R markdown} document.
+
+For example, suppose we want to create a new heading in our document,
+but the heading phrase is the result of some code processing: maybe it's
+the first line of a file we are going to read. Method `outputs' adds its
+output as if typed in the \textbf{R markdown} document.
+
+Take now a look at variable `c' (it was defined in a previous block
+above) as `c = ``The 'outputs' function''. ``The 'outputs' function'' is
+actually the name of this section and it was created using the 'outputs'
+function inside a Ruby chunk.
+
+The ruby chunk to generate this heading is:
+
+\begin{verbatim}
+```{ruby heading}
+outputs "### #{c}"
+```
+\end{verbatim}
+
+The three `\#\#\#' is the way we add a Heading 3 in \textbf{R markdown}.
+
+\subsubsection{HTML Output from Ruby
+Chunks}\label{html-output-from-ruby-chunks}
+
+We've just seen the use of method `outputs' to add text to the the
+\textbf{R markdown} document. This technique can also be used to add
+HTML code to the document. In \textbf{R markdown}, any html code typed
+directly in the document will be properly rendered.\\
+Here, for instance, is a table definition in HTML and its output in the
+document:
+
+\begin{verbatim}
+<table style="width:100%">
+  <tr>
+    <th>Firstname</th>
+    <th>Lastname</th> 
+    <th>Age</th>
+  </tr>
+  <tr>
+    <td>Jill</td>
+    <td>Smith</td> 
+    <td>50</td>
+  </tr>
+  <tr>
+    <td>Eve</td>
+    <td>Jackson</td> 
+    <td>94</td>
+  </tr>
+</table>
+\end{verbatim}
+
+\begin{verbatim}
+<th>Firstname</th>
+<th>Lastname</th> 
+<th>Age</th>
+\end{verbatim}
+
+\begin{verbatim}
+<td>Jill</td>
+<td>Smith</td> 
+<td>50</td>
+\end{verbatim}
+
+\begin{verbatim}
+<td>Eve</td>
+<td>Jackson</td> 
+<td>94</td>
+\end{verbatim}
+
+But manually creating HTML output is not always easy or desirable,
+specially if we intend the document to be rendered in other formats, for
+example, as Latex. Also, The above table looks ugly. The `kableExtra'
+library is a great library for creating beautiful tables. Take a look at
+\url{https://cran.r-project.org/web/packages/kableExtra/vignettes/awesome_table_in_html.html}
+
+In the next chunk, we output the `mtcars' dataframe from R in a nicely
+formatted table. Note that we retrieve the mtcars dataframe by using
+`\textasciitilde{}:mtcars'.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{R.install_and_loads(}\StringTok{'kableExtra'}\NormalTok{)}
+\NormalTok{outputs (~}\StringTok{:mtcars}\NormalTok{).kable.kable_styling}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{table}[H]
+\centering
+\begin{tabular}{l|r|r|r|r|r|r|r|r|r|r|r}
+\hline
+  & mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
+\hline
+Mazda RX4 & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.620 & 16.46 & 0 & 1 & 4 & 4\\
+\hline
+Mazda RX4 Wag & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.875 & 17.02 & 0 & 1 & 4 & 4\\
+\hline
+Datsun 710 & 22.8 & 4 & 108.0 & 93 & 3.85 & 2.320 & 18.61 & 1 & 1 & 4 & 1\\
+\hline
+Hornet 4 Drive & 21.4 & 6 & 258.0 & 110 & 3.08 & 3.215 & 19.44 & 1 & 0 & 3 & 1\\
+\hline
+Hornet Sportabout & 18.7 & 8 & 360.0 & 175 & 3.15 & 3.440 & 17.02 & 0 & 0 & 3 & 2\\
+\hline
+Valiant & 18.1 & 6 & 225.0 & 105 & 2.76 & 3.460 & 20.22 & 1 & 0 & 3 & 1\\
+\hline
+Duster 360 & 14.3 & 8 & 360.0 & 245 & 3.21 & 3.570 & 15.84 & 0 & 0 & 3 & 4\\
+\hline
+Merc 240D & 24.4 & 4 & 146.7 & 62 & 3.69 & 3.190 & 20.00 & 1 & 0 & 4 & 2\\
+\hline
+Merc 230 & 22.8 & 4 & 140.8 & 95 & 3.92 & 3.150 & 22.90 & 1 & 0 & 4 & 2\\
+\hline
+Merc 280 & 19.2 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.30 & 1 & 0 & 4 & 4\\
+\hline
+Merc 280C & 17.8 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.90 & 1 & 0 & 4 & 4\\
+\hline
+Merc 450SE & 16.4 & 8 & 275.8 & 180 & 3.07 & 4.070 & 17.40 & 0 & 0 & 3 & 3\\
+\hline
+Merc 450SL & 17.3 & 8 & 275.8 & 180 & 3.07 & 3.730 & 17.60 & 0 & 0 & 3 & 3\\
+\hline
+Merc 450SLC & 15.2 & 8 & 275.8 & 180 & 3.07 & 3.780 & 18.00 & 0 & 0 & 3 & 3\\
+\hline
+Cadillac Fleetwood & 10.4 & 8 & 472.0 & 205 & 2.93 & 5.250 & 17.98 & 0 & 0 & 3 & 4\\
+\hline
+Lincoln Continental & 10.4 & 8 & 460.0 & 215 & 3.00 & 5.424 & 17.82 & 0 & 0 & 3 & 4\\
+\hline
+Chrysler Imperial & 14.7 & 8 & 440.0 & 230 & 3.23 & 5.345 & 17.42 & 0 & 0 & 3 & 4\\
+\hline
+Fiat 128 & 32.4 & 4 & 78.7 & 66 & 4.08 & 2.200 & 19.47 & 1 & 1 & 4 & 1\\
+\hline
+Honda Civic & 30.4 & 4 & 75.7 & 52 & 4.93 & 1.615 & 18.52 & 1 & 1 & 4 & 2\\
+\hline
+Toyota Corolla & 33.9 & 4 & 71.1 & 65 & 4.22 & 1.835 & 19.90 & 1 & 1 & 4 & 1\\
+\hline
+Toyota Corona & 21.5 & 4 & 120.1 & 97 & 3.70 & 2.465 & 20.01 & 1 & 0 & 3 & 1\\
+\hline
+Dodge Challenger & 15.5 & 8 & 318.0 & 150 & 2.76 & 3.520 & 16.87 & 0 & 0 & 3 & 2\\
+\hline
+AMC Javelin & 15.2 & 8 & 304.0 & 150 & 3.15 & 3.435 & 17.30 & 0 & 0 & 3 & 2\\
+\hline
+Camaro Z28 & 13.3 & 8 & 350.0 & 245 & 3.73 & 3.840 & 15.41 & 0 & 0 & 3 & 4\\
+\hline
+Pontiac Firebird & 19.2 & 8 & 400.0 & 175 & 3.08 & 3.845 & 17.05 & 0 & 0 & 3 & 2\\
+\hline
+Fiat X1-9 & 27.3 & 4 & 79.0 & 66 & 4.08 & 1.935 & 18.90 & 1 & 1 & 4 & 1\\
+\hline
+Porsche 914-2 & 26.0 & 4 & 120.3 & 91 & 4.43 & 2.140 & 16.70 & 0 & 1 & 5 & 2\\
+\hline
+Lotus Europa & 30.4 & 4 & 95.1 & 113 & 3.77 & 1.513 & 16.90 & 1 & 1 & 5 & 2\\
+\hline
+Ford Pantera L & 15.8 & 8 & 351.0 & 264 & 4.22 & 3.170 & 14.50 & 0 & 1 & 5 & 4\\
+\hline
+Ferrari Dino & 19.7 & 6 & 145.0 & 175 & 3.62 & 2.770 & 15.50 & 0 & 1 & 5 & 6\\
+\hline
+Maserati Bora & 15.0 & 8 & 301.0 & 335 & 3.54 & 3.570 & 14.60 & 0 & 1 & 5 & 8\\
+\hline
+Volvo 142E & 21.4 & 4 & 121.0 & 109 & 4.11 & 2.780 & 18.60 & 1 & 1 & 4 & 2\\
+\hline
+\end{tabular}
+\end{table}
+
+\subsection{Including Ruby files in a
+chunk}\label{including-ruby-files-in-a-chunk}
+
+R is a language that was created to be easy and fast for statisticians
+to use. As far as I know, it was not a language to be used for
+developing large systems. Of course, there are large systems and
+libraries in R, but the focus of the language is for developing
+statistical models and distribute that to peers.
+
+Ruby on the other hand, is a language for large software development.
+Systems written in Ruby will have dozens, hundreds or even thousands of
+files. To document a large system with literate programming, we cannot
+expect the developer to add all the files in a single `.Rmd' file. gKnit
+provides the `include' chunk engine to include a Ruby file as if it had
+being typed in the `.Rmd' file.
+
+To include a file, the following chunk should be created, where is the
+name of the file to be included and where the extension, if it is `.rb',
+does not need to be added. If the `relative' option is not included,
+then it is treated as TRUE. When `relative' is true, ruby's
+`require\_relative' semantics is used to load the file, when false,
+Ruby's \$LOAD\_PATH is searched to find the file and it is 'require'd.
+
+\begin{verbatim}
+```{include <filename>, relative = <TRUE/FALSE>}
+```
+\end{verbatim}
+
+Bellow we include file `model.rb', which is in the same directory of
+this blog.\\
+This code uses R `caret' package to split a dataset in a train and test
+sets. The `caret' package is a very important a useful package for doing
+Data Analysis, it has hundreds of functions for all steps of the Data
+Analysis workflow. To use `caret' just to split a dataset is like using
+the proverbial cannon to kill the fly. We use it here only to show that
+integrating Ruby and R and using even a very complex package as `caret'
+is trivial with Galaaz.
+
+A word of advice: the `caret' package has lots of dependencies and
+installing it in a Linux system is a time consuming operation. Method
+`R.install\_and\_loads' will install the package if it is not already
+installed and can take a while.
+
+\begin{verbatim}
+```{include model}
+```
+\end{verbatim}
+
+\begin{verbatim}
+require 'galaaz'
+
+# Loads the R 'caret' package.  If not present, installs it 
+R.install_and_loads 'caret'
+
+class Model
+  
+  attr_reader :data
+  attr_reader :test
+  attr_reader :train
+
+  #==========================================================
+  #
+  #==========================================================
+  
+  def initialize(data, percent_train:, seed: 123)
+
+    R.set__seed(seed)
+    @data = data
+    @percent_train = percent_train
+    @seed = seed
+    
+  end
+
+  #==========================================================
+  #
+  #==========================================================
+
+  def partition(field)
+
+    train_index =
+      R.createDataPartition(@data.send(field), p: @percet_train,
+                            list: false, times: 1)
+    @train = @data[train_index, :all]
+    @test = @data[-train_index, :all]
+    
+  end
+  
+end
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{mtcars = ~}\StringTok{:mtcars}
+\NormalTok{model = }\DataTypeTok{Model}\NormalTok{.new(mtcars, }\StringTok{percent_train: }\FloatTok{0.8}\NormalTok{)}
+\NormalTok{model.partition(}\StringTok{:mpg}\NormalTok{)}
+\NormalTok{puts model.train.head}
+\NormalTok{puts model.test.head}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##                mpg cyl  disp  hp drat    wt  qsec vs am gear carb
+## Mazda RX4     21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
+## Mazda RX4 Wag 21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
+## Valiant       18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
+## Merc 280      19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4
+## Merc 280C     17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4
+## Merc 450SE    16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3
+##                    mpg cyl  disp  hp drat    wt  qsec vs am gear carb
+## Datsun 710        22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
+## Hornet 4 Drive    21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
+## Hornet Sportabout 18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
+## Duster 360        14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
+## Merc 240D         24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2
+## Merc 230          22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2
+\end{verbatim}
+
+\subsection{Documenting Gems}\label{documenting-gems}
+
+gKnit also allows developers to document and load files that are not in
+the same directory of the `.Rmd' file.
+
+Here is an example of loading the `find.rb' file from TruffleRuby. In
+this example, relative is set to FALSE, so Ruby will look for the file
+in its \$LOAD\_PATH, and the user does not need to no it's directory.
+
+\begin{verbatim}
+```{include find, relative = FALSE}
+```
+\end{verbatim}
+
+\begin{verbatim}
+# frozen_string_literal: true
+#
+# find.rb: the Find module for processing all files under a given directory.
+#
+
+#
+# The +Find+ module supports the top-down traversal of a set of file paths.
+#
+# For example, to total the size of all files under your home directory,
+# ignoring anything in a "dot" directory (e.g. $HOME/.ssh):
+#
+#   require 'find'
+#
+#   total_size = 0
+#
+#   Find.find(ENV["HOME"]) do |path|
+#     if FileTest.directory?(path)
+#       if File.basename(path)[0] == ?.
+#         Find.prune       # Don't look any further into this directory.
+#       else
+#         next
+#       end
+#     else
+#       total_size += FileTest.size(path)
+#     end
+#   end
+#
+module Find
+
+  #
+  # Calls the associated block with the name of every file and directory listed
+  # as arguments, then recursively on their subdirectories, and so on.
+  #
+  # Returns an enumerator if no block is given.
+  #
+  # See the +Find+ module documentation for an example.
+  #
+  def find(*paths, ignore_error: true) # :yield: path
+    block_given? or return enum_for(__method__, *paths, ignore_error: ignore_error)
+
+    fs_encoding = Encoding.find("filesystem")
+
+    paths.collect!{|d| raise Errno::ENOENT, d unless File.exist?(d); d.dup}.each do |path|
+      path = path.to_path if path.respond_to? :to_path
+      enc = path.encoding == Encoding::US_ASCII ? fs_encoding : path.encoding
+      ps = [path]
+      while file = ps.shift
+        catch(:prune) do
+          yield file.dup.taint
+          begin
+            s = File.lstat(file)
+          rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+            raise unless ignore_error
+            next
+          end
+          if s.directory? then
+            begin
+              fs = Dir.children(file, encoding: enc)
+            rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+              raise unless ignore_error
+              next
+            end
+            fs.sort!
+            fs.reverse_each {|f|
+              f = File.join(file, f)
+              ps.unshift f.untaint
+            }
+          end
+        end
+      end
+    end
+    nil
+  end
+
+  #
+  # Skips the current file or directory, restarting the loop with the next
+  # entry. If the current file is a directory, that directory will not be
+  # recursively entered. Meaningful only within the block associated with
+  # Find::find.
+  #
+  # See the +Find+ module documentation for an example.
+  #
+  def prune
+    throw :prune
+  end
+
+  module_function :find, :prune
+end
+\end{verbatim}
+
+\subsection{Converting to PDF}\label{converting-to-pdf}
+
+One of the beauties of knitr is that the same input can be converted to
+many different outputs. One very useful format, is, of course, PDF. In
+order to converted an \textbf{R markdown} file to PDF it is necessary to
+have LaTeX installed on the system. We will not explain here how to
+install LaTeX as there are plenty of documents on the web showing how to
+proceed.
+
+gKnit comes with a simple LaTeX style file for gknitting this blog as a
+PDF document. Here is the Yaml header to generate this blog in PDF
+format instead of HTML:
+
+\begin{verbatim}
+---
+title: "gKnit - Ruby and R Knitting with Galaaz in GraalVM"
+author: "Rodrigo Botafogo"
+tags: [Galaaz, Ruby, R, TruffleRuby, FastR, GraalVM, knitr, gknit]
+date: "29 October 2018"
+output:
+  pdf\_document:
+    includes:
+      in\_header: ["../../sty/galaaz.sty"]
+    number\_sections: yes
+---
+\end{verbatim}
+
+\subsection{Template based documents
+generation}\label{template-based-documents-generation}
+
+When a document is converted to PDF it follows a certain convertion
+template. We've seen above the use of `galaaz.sty' as a basic template
+to generate a PDF document. Using the `gknit-draft' app that comes with
+Galaaz, the same .Rmd file can be compiled to different looking PDF
+documents. Galaaz automatically loads the `rticles' R package that comes
+with templates for the following journals with the respective template
+name:
+
+\begin{itemize}
+\tightlist
+\item
+  ACM articles: acm\_article
+\item
+  ACS articles: acs\_article
+\item
+  AEA journal submissions: aea\_article
+\item
+  AGU journal submissions: ????
+\item
+  AMS articles: ams\_article
+\item
+  American Statistical Association: asa\_article
+\item
+  Biometrics articles: biometrics\_article
+\item
+  Bulletin de l'AMQ journal submissions: amq\_article
+\item
+  CTeX documents: ctex
+\item
+  Elsevier journal submissions: elsevier\_article
+\item
+  IEEE Transaction journal submissions: ieee\_article
+\item
+  JSS articles: jss\_article
+\item
+  MDPI journal submissions: mdpi\_article
+\item
+  Monthly Notices of the Royal Astronomical Society articles:
+  mnras\_article
+\item
+  NNRAS journal submissions: nmras\_article
+\item
+  PeerJ articles: peerj\_article
+\item
+  Royal Society Open Science journal submissions: rsos\_article
+\item
+  Royal Statistical Society: rss\_article
+\item
+  Sage journal submissions: sage\_article
+\item
+  Springer journal submissions: springer\_article
+\item
+  Statistics in Medicine journal submissions: sim\_article
 \item
-  Install Ruby (gu install Ruby)
+  Copernicus Publications journal submissions: copernicus\_article
 \item
-  Install FastR (gu install R)
+  The R Journal articles: rjournal\_article
 \item
-  Install rake if you want to run the specs and examples (gem install
-  rake)
-\end{itemize}
-
-\hypertarget{usage}{%
-\section{Usage}\label{usage}}
-
-\begin{itemize}
+  Frontiers articles: ???
 \item
-  Interactive shell: use `gstudio' on the command line
-
-  \begin{quote}
-  gstudio
-  \end{quote}
-\end{itemize}
-
-\begin{Shaded}
-\begin{Highlighting}[]
-\NormalTok{  vec = R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{)}
-\NormalTok{  puts vec}
-\end{Highlighting}
-\end{Shaded}
-
-\begin{verbatim}
-## [1] 1 2 3 4
-\end{verbatim}
-
-\begin{itemize}
+  Taylor \& Francis articles: ???
 \item
-  Run all specs
-
-  \begin{quote}
-  galaaz specs:all
-  \end{quote}
+  Bulletin De L'AMQ: amq\_article
 \item
-  Run graphics slideshow (80+ graphics)
-
-  \begin{quote}
-  galaaz sthda:all
-  \end{quote}
+  PLOS journal: plos\_article
 \item
-  Run labs from Introduction to Statistical Learning with R
+  Proceedings of the National Academy of Sciences of the USA:
+  pnas\_article
+\end{itemize}
 
-  \begin{quote}
-  galaaz islr:all
-  \end{quote}
-\item
-  See all available examples
+In order to create a document with one of those templates, use the
+following command:
 
-  \begin{quote}
-  galaaz -T
-  \end{quote}
+\begin{verbatim}
+gknit-draft --filename <my_document> --template <template> --package <package>
+            --create_dir
+\end{verbatim}
 
-  Shows a list with all available executalbe tasks. To execute a task,
-  substitute the `rake' word in the list with `galaaz'. For instance,
-  the following line shows up after `galaaz -T'
+So, in order to create a template for writing an R Journal, use:
 
-  rake master\_list:scatter\_plot \# scatter\_plot from:\ldots{}.
+\begin{verbatim}
+gknit-draft --filename my_r_article --template rjournal_article --package rticles
+            --create_dir
+\end{verbatim}
 
-  execute
+\section{Accessing R variables}\label{accessing-r-variables}
 
-  \begin{quote}
-  galaaz master\_list:scatter\_plot
-  \end{quote}
-\end{itemize}
+Galaaz allows Ruby to access variables created in R. For example, the
+`mtcars' data set is available in R and can be accessed from Ruby by
+using the `tilda' operator followed by the symbol for the variable, in
+this case `:mtcar'. In the code bellow method `outputs' is used to
+output the `mtcars' data set nicely formatted in HTML by use of the
+`kable' and `kable\_styling' functions. Method `outputs' is only
+available when used with `gknit'.
 
-\hypertarget{gknitting-a-document}{%
-\section{gKnitting a Document}\label{gknitting-a-document}}
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{outputs (~}\StringTok{:mtcars}\NormalTok{).kable.kable_styling}
+\end{Highlighting}
+\end{Shaded}
 
-This manual has been formatted usign gKnit. gKnit uses Knitr and R
-markdown to knit a document in Ruby or R and output it in any of the
-available formats for R markdown. gKnit runs atop of GraalVM, and
-Galaaz. In gKnit, Ruby variables are persisted between chunks, making it
-an ideal solution for literate programming. Also, since it is based on
-Galaaz, Ruby chunks can have access to R variables and Polyglot
-Programming with Ruby and R is quite natural.
+\begin{table}[H]
+\centering
+\begin{tabular}{l|r|r|r|r|r|r|r|r|r|r|r}
+\hline
+  & mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
+\hline
+Mazda RX4 & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.620 & 16.46 & 0 & 1 & 4 & 4\\
+\hline
+Mazda RX4 Wag & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.875 & 17.02 & 0 & 1 & 4 & 4\\
+\hline
+Datsun 710 & 22.8 & 4 & 108.0 & 93 & 3.85 & 2.320 & 18.61 & 1 & 1 & 4 & 1\\
+\hline
+Hornet 4 Drive & 21.4 & 6 & 258.0 & 110 & 3.08 & 3.215 & 19.44 & 1 & 0 & 3 & 1\\
+\hline
+Hornet Sportabout & 18.7 & 8 & 360.0 & 175 & 3.15 & 3.440 & 17.02 & 0 & 0 & 3 & 2\\
+\hline
+Valiant & 18.1 & 6 & 225.0 & 105 & 2.76 & 3.460 & 20.22 & 1 & 0 & 3 & 1\\
+\hline
+Duster 360 & 14.3 & 8 & 360.0 & 245 & 3.21 & 3.570 & 15.84 & 0 & 0 & 3 & 4\\
+\hline
+Merc 240D & 24.4 & 4 & 146.7 & 62 & 3.69 & 3.190 & 20.00 & 1 & 0 & 4 & 2\\
+\hline
+Merc 230 & 22.8 & 4 & 140.8 & 95 & 3.92 & 3.150 & 22.90 & 1 & 0 & 4 & 2\\
+\hline
+Merc 280 & 19.2 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.30 & 1 & 0 & 4 & 4\\
+\hline
+Merc 280C & 17.8 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.90 & 1 & 0 & 4 & 4\\
+\hline
+Merc 450SE & 16.4 & 8 & 275.8 & 180 & 3.07 & 4.070 & 17.40 & 0 & 0 & 3 & 3\\
+\hline
+Merc 450SL & 17.3 & 8 & 275.8 & 180 & 3.07 & 3.730 & 17.60 & 0 & 0 & 3 & 3\\
+\hline
+Merc 450SLC & 15.2 & 8 & 275.8 & 180 & 3.07 & 3.780 & 18.00 & 0 & 0 & 3 & 3\\
+\hline
+Cadillac Fleetwood & 10.4 & 8 & 472.0 & 205 & 2.93 & 5.250 & 17.98 & 0 & 0 & 3 & 4\\
+\hline
+Lincoln Continental & 10.4 & 8 & 460.0 & 215 & 3.00 & 5.424 & 17.82 & 0 & 0 & 3 & 4\\
+\hline
+Chrysler Imperial & 14.7 & 8 & 440.0 & 230 & 3.23 & 5.345 & 17.42 & 0 & 0 & 3 & 4\\
+\hline
+Fiat 128 & 32.4 & 4 & 78.7 & 66 & 4.08 & 2.200 & 19.47 & 1 & 1 & 4 & 1\\
+\hline
+Honda Civic & 30.4 & 4 & 75.7 & 52 & 4.93 & 1.615 & 18.52 & 1 & 1 & 4 & 2\\
+\hline
+Toyota Corolla & 33.9 & 4 & 71.1 & 65 & 4.22 & 1.835 & 19.90 & 1 & 1 & 4 & 1\\
+\hline
+Toyota Corona & 21.5 & 4 & 120.1 & 97 & 3.70 & 2.465 & 20.01 & 1 & 0 & 3 & 1\\
+\hline
+Dodge Challenger & 15.5 & 8 & 318.0 & 150 & 2.76 & 3.520 & 16.87 & 0 & 0 & 3 & 2\\
+\hline
+AMC Javelin & 15.2 & 8 & 304.0 & 150 & 3.15 & 3.435 & 17.30 & 0 & 0 & 3 & 2\\
+\hline
+Camaro Z28 & 13.3 & 8 & 350.0 & 245 & 3.73 & 3.840 & 15.41 & 0 & 0 & 3 & 4\\
+\hline
+Pontiac Firebird & 19.2 & 8 & 400.0 & 175 & 3.08 & 3.845 & 17.05 & 0 & 0 & 3 & 2\\
+\hline
+Fiat X1-9 & 27.3 & 4 & 79.0 & 66 & 4.08 & 1.935 & 18.90 & 1 & 1 & 4 & 1\\
+\hline
+Porsche 914-2 & 26.0 & 4 & 120.3 & 91 & 4.43 & 2.140 & 16.70 & 0 & 1 & 5 & 2\\
+\hline
+Lotus Europa & 30.4 & 4 & 95.1 & 113 & 3.77 & 1.513 & 16.90 & 1 & 1 & 5 & 2\\
+\hline
+Ford Pantera L & 15.8 & 8 & 351.0 & 264 & 4.22 & 3.170 & 14.50 & 0 & 1 & 5 & 4\\
+\hline
+Ferrari Dino & 19.7 & 6 & 145.0 & 175 & 3.62 & 2.770 & 15.50 & 0 & 1 & 5 & 6\\
+\hline
+Maserati Bora & 15.0 & 8 & 301.0 & 335 & 3.54 & 3.570 & 14.60 & 0 & 1 & 5 & 8\\
+\hline
+Volvo 142E & 21.4 & 4 & 121.0 & 109 & 4.11 & 2.780 & 18.60 & 1 & 1 & 4 & 2\\
+\hline
+\end{tabular}
+\end{table}
 
-\href{https://towardsdatascience.com/how-to-do-reproducible-research-in-ruby-with-gknit-c26d2684d64e}{gknit
-is described in more details here}
+\section{Basic Data Types}\label{basic-data-types}
 
-\hypertarget{vector}{%
-\section{Vector}\label{vector}}
+\subsection{Vector}\label{vector}
 
 Vectors can be thought of as contiguous cells containing data. Cells are
 accessed through indexing operations such as x{[}5{]}. Galaaz has six
@@ -401,7 +1767,7 @@ printing it out. A data frame, for those not familiar with it, is
 basically a table. Here we create the data frame and add the column name
 by passing named parameters for each column, such as `typeof:', `mode:'
 and 'storage\_\_mode?`. You should also note here that the double
-underscore is converted to a'.'. So, when printed `storage\_\_mode' will
+underscore is converted to a'.`. So, when printed 'storage\_\_mode' will
 actually print as `storage.mode'.
 
 Data frames will later be more carefully described. In R, the method
@@ -469,7 +1835,7 @@ error.
 
 \begin{verbatim}
 ## Message:
-##  undefined local variable or method `hello' for #<RC:0x2e0 @out_list=nil>:RC
+##  undefined local variable or method `hello' for #<RC:0x3d8 @out_list=nil>:RC
 \end{verbatim}
 
 \begin{verbatim}
@@ -482,18 +1848,15 @@ error.
 ## /home/rbotafogo/desenv/galaaz/lib/R_interface/ruby_callback.rb:77:in `callback'
 ## (eval):3:in `function(...) {\n          rb_method(...)'
 ## unknown.r:1:in `in_dir'
-## unknown.r:1:in `block_exec:BLOCK0'
-## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/block.R:102:in `block_exec'
-## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/block.R:92:in `call_block'
-## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/block.R:6:in `process_group.block'
-## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/block.R:3:in `<no source>'
+## unknown.r:1:in `block_exec'
+## /usr/local/lib/graalvm-ce-java11-20.0.0/languages/R/library/knitr/R/block.R:92:in `call_block'
+## /usr/local/lib/graalvm-ce-java11-20.0.0/languages/R/library/knitr/R/block.R:6:in `process_group.block'
+## /usr/local/lib/graalvm-ce-java11-20.0.0/languages/R/library/knitr/R/block.R:3:in `<no source>'
 ## unknown.r:1:in `withCallingHandlers'
 ## unknown.r:1:in `process_file'
-## unknown.r:1:in `<no source>:BLOCK1'
-## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/knitr/R/output.R:129:in `<no source>'
-## unknown.r:1:in `<no source>:BLOCK1'
-## /home/rbotafogo/lib/graalvm-ce-1.0.0-rc16/jre/languages/R/library/rmarkdown/R/render.R:162:in `<no source>'
-## <REPL>:5:in `<repl wrapper>'
+## unknown.r:1:in `<no source>'
+## unknown.r:1:in `<no source>'
+## <REPL>:4:in `<repl wrapper>'
 ## <REPL>:1
 \end{verbatim}
 
@@ -510,8 +1873,7 @@ Here is a vector with logical values
 ## [1]  TRUE  TRUE FALSE FALSE  TRUE
 \end{verbatim}
 
-\hypertarget{combining-vectors}{%
-\subsection{Combining Vectors}\label{combining-vectors}}
+\subsubsection{Combining Vectors}\label{combining-vectors}
 
 The `c' functions used to create vectors can also be used to combine two
 vectors:
@@ -549,8 +1911,7 @@ converted to the code above.
 ## [1] 10 20 30  4  5  6
 \end{verbatim}
 
-\hypertarget{vector-arithmetic}{%
-\subsection{Vector Arithmetic}\label{vector-arithmetic}}
+\subsubsection{Vector Arithmetic}\label{vector-arithmetic}
 
 Arithmetic operations on vectors are performed element by element:
 
@@ -588,8 +1949,7 @@ shorter vector:
 ## [1] 11 22 33 14 25 36 17 28 39
 \end{verbatim}
 
-\hypertarget{vector-indexing}{%
-\subsection{Vector Indexing}\label{vector-indexing}}
+\subsubsection{Vector Indexing}\label{vector-indexing}
 
 Vectors can be indexed by using the `{[}{]}' operator:
 
@@ -698,9 +2058,8 @@ paramenters:
 ##  "Rodrigo"        "A" "Botafogo"
 \end{verbatim}
 
-\hypertarget{extracting-native-ruby-types-from-a-vector}{%
-\subsection{Extracting Native Ruby Types from a
-Vector}\label{extracting-native-ruby-types-from-a-vector}}
+\subsubsection{Extracting Native Ruby Types from a
+Vector}\label{extracting-native-ruby-types-from-a-vector}
 
 Vectors created with `R.c' are of class R::Vector. You might have
 noticed that when indexing a vector, a new vector is returned, even if
@@ -726,98 +2085,7 @@ type from the vector. In order to do this extraction the
 Note that indexing with `\textgreater{}\textgreater{}' starts at 0 and
 not at 1, also, we cannot do negative indexing.
 
-\hypertarget{accessing-r-variables}{%
-\section{Accessing R variables}\label{accessing-r-variables}}
-
-Galaaz allows Ruby to access variables created in R. For example, the
-`mtcars' data set is available in R and can be accessed from Ruby by
-using the `tilda' operator followed by the symbol for the variable, in
-this case `:mtcar'. In the code bellow method `outputs' is used to
-output the `mtcars' data set nicely formatted in HTML by use of the
-`kable' and `kable\_styling' functions. Method `outputs' is only
-available when used with `gknit'.
-
-\begin{Shaded}
-\begin{Highlighting}[]
-\NormalTok{outputs (~}\StringTok{:mtcars}\NormalTok{).kable.kable_styling}
-\end{Highlighting}
-\end{Shaded}
-
-\begin{table}[H]
-\centering
-\begin{tabular}{l|r|r|r|r|r|r|r|r|r|r|r}
-\hline
-  & mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
-\hline
-Mazda RX4 & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.620 & 16.46 & 0 & 1 & 4 & 4\\
-\hline
-Mazda RX4 Wag & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.875 & 17.02 & 0 & 1 & 4 & 4\\
-\hline
-Datsun 710 & 22.8 & 4 & 108.0 & 93 & 3.85 & 2.320 & 18.61 & 1 & 1 & 4 & 1\\
-\hline
-Hornet 4 Drive & 21.4 & 6 & 258.0 & 110 & 3.08 & 3.215 & 19.44 & 1 & 0 & 3 & 1\\
-\hline
-Hornet Sportabout & 18.7 & 8 & 360.0 & 175 & 3.15 & 3.440 & 17.02 & 0 & 0 & 3 & 2\\
-\hline
-Valiant & 18.1 & 6 & 225.0 & 105 & 2.76 & 3.460 & 20.22 & 1 & 0 & 3 & 1\\
-\hline
-Duster 360 & 14.3 & 8 & 360.0 & 245 & 3.21 & 3.570 & 15.84 & 0 & 0 & 3 & 4\\
-\hline
-Merc 240D & 24.4 & 4 & 146.7 & 62 & 3.69 & 3.190 & 20.00 & 1 & 0 & 4 & 2\\
-\hline
-Merc 230 & 22.8 & 4 & 140.8 & 95 & 3.92 & 3.150 & 22.90 & 1 & 0 & 4 & 2\\
-\hline
-Merc 280 & 19.2 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.30 & 1 & 0 & 4 & 4\\
-\hline
-Merc 280C & 17.8 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.90 & 1 & 0 & 4 & 4\\
-\hline
-Merc 450SE & 16.4 & 8 & 275.8 & 180 & 3.07 & 4.070 & 17.40 & 0 & 0 & 3 & 3\\
-\hline
-Merc 450SL & 17.3 & 8 & 275.8 & 180 & 3.07 & 3.730 & 17.60 & 0 & 0 & 3 & 3\\
-\hline
-Merc 450SLC & 15.2 & 8 & 275.8 & 180 & 3.07 & 3.780 & 18.00 & 0 & 0 & 3 & 3\\
-\hline
-Cadillac Fleetwood & 10.4 & 8 & 472.0 & 205 & 2.93 & 5.250 & 17.98 & 0 & 0 & 3 & 4\\
-\hline
-Lincoln Continental & 10.4 & 8 & 460.0 & 215 & 3.00 & 5.424 & 17.82 & 0 & 0 & 3 & 4\\
-\hline
-Chrysler Imperial & 14.7 & 8 & 440.0 & 230 & 3.23 & 5.345 & 17.42 & 0 & 0 & 3 & 4\\
-\hline
-Fiat 128 & 32.4 & 4 & 78.7 & 66 & 4.08 & 2.200 & 19.47 & 1 & 1 & 4 & 1\\
-\hline
-Honda Civic & 30.4 & 4 & 75.7 & 52 & 4.93 & 1.615 & 18.52 & 1 & 1 & 4 & 2\\
-\hline
-Toyota Corolla & 33.9 & 4 & 71.1 & 65 & 4.22 & 1.835 & 19.90 & 1 & 1 & 4 & 1\\
-\hline
-Toyota Corona & 21.5 & 4 & 120.1 & 97 & 3.70 & 2.465 & 20.01 & 1 & 0 & 3 & 1\\
-\hline
-Dodge Challenger & 15.5 & 8 & 318.0 & 150 & 2.76 & 3.520 & 16.87 & 0 & 0 & 3 & 2\\
-\hline
-AMC Javelin & 15.2 & 8 & 304.0 & 150 & 3.15 & 3.435 & 17.30 & 0 & 0 & 3 & 2\\
-\hline
-Camaro Z28 & 13.3 & 8 & 350.0 & 245 & 3.73 & 3.840 & 15.41 & 0 & 0 & 3 & 4\\
-\hline
-Pontiac Firebird & 19.2 & 8 & 400.0 & 175 & 3.08 & 3.845 & 17.05 & 0 & 0 & 3 & 2\\
-\hline
-Fiat X1-9 & 27.3 & 4 & 79.0 & 66 & 4.08 & 1.935 & 18.90 & 1 & 1 & 4 & 1\\
-\hline
-Porsche 914-2 & 26.0 & 4 & 120.3 & 91 & 4.43 & 2.140 & 16.70 & 0 & 1 & 5 & 2\\
-\hline
-Lotus Europa & 30.4 & 4 & 95.1 & 113 & 3.77 & 1.513 & 16.90 & 1 & 1 & 5 & 2\\
-\hline
-Ford Pantera L & 15.8 & 8 & 351.0 & 264 & 4.22 & 3.170 & 14.50 & 0 & 1 & 5 & 4\\
-\hline
-Ferrari Dino & 19.7 & 6 & 145.0 & 175 & 3.62 & 2.770 & 15.50 & 0 & 1 & 5 & 6\\
-\hline
-Maserati Bora & 15.0 & 8 & 301.0 & 335 & 3.54 & 3.570 & 14.60 & 0 & 1 & 5 & 8\\
-\hline
-Volvo 142E & 21.4 & 4 & 121.0 & 109 & 4.11 & 2.780 & 18.60 & 1 & 1 & 4 & 2\\
-\hline
-\end{tabular}
-\end{table}
-
-\hypertarget{matrix}{%
-\section{Matrix}\label{matrix}}
+\subsection{Matrix}\label{matrix}
 
 A matrix is a collection of elements organized as a two dimensional
 table. A matrix can be created by the `matrix' function:
@@ -861,8 +2129,7 @@ organize the matrix memory by row first passing an extra argument to the
 ## [3,]    7    8    9
 \end{verbatim}
 
-\hypertarget{indexing-a-matrix}{%
-\subsection{Indexing a Matrix}\label{indexing-a-matrix}}
+\subsubsection{Indexing a Matrix}\label{indexing-a-matrix}
 
 A matrix can be indexed by {[}row, column{]}:
 
@@ -941,8 +2208,7 @@ and `cbind':
 ## [3,]    7    8    9    3    6    9
 \end{verbatim}
 
-\hypertarget{list}{%
-\section{List}\label{list}}
+\subsection{List}\label{list}
 
 A list is a data structure that can contain sublists of different types,
 while vector and matrix can only hold one type of element.
@@ -970,8 +2236,7 @@ while vector and matrix can only hold one type of element.
 
 Note that `lst' elements are named elements.
 
-\hypertarget{list-indexing}{%
-\subsection{List Indexing}\label{list-indexing}}
+\subsubsection{List Indexing}\label{list-indexing}
 
 List indexing, also called slicing, is done using the `{[}{]}' operator
 and the `{[}{[}{]}{]}' operator. Let's first start with the `{[}{]}'
@@ -1022,8 +2287,7 @@ extracted (note that vectors also accept the `{[}{[}{]}{]}' operator)
 and then the vector was indexed by its first element, extracting the
 native Ruby type.
 
-\hypertarget{data-frame}{%
-\section{Data Frame}\label{data-frame}}
+\subsection{Data Frame}\label{data-frame}
 
 A data frame is a table like structure in which each column has the same
 number of rows. Data frames are the basic structure for storing data for
@@ -1048,8 +2312,7 @@ frame, function 'data\_\_frame' is used:
 ## 3 2012   2000
 \end{verbatim}
 
-\hypertarget{data-frame-indexing}{%
-\subsection{Data Frame Indexing}\label{data-frame-indexing}}
+\subsubsection{Data Frame Indexing}\label{data-frame-indexing}
 
 A data frame can be indexed the same way as a matrix, by using `{[}row,
 column{]}', where row and column can either be a numeric or the name of
@@ -1192,17 +2455,15 @@ data frame in which all cars have automatic transmission.
 ## Pontiac Firebird    19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2
 \end{verbatim}
 
-\hypertarget{writing-expressions-in-galaaz}{%
 \section{Writing Expressions in
-Galaaz}\label{writing-expressions-in-galaaz}}
+Galaaz}\label{writing-expressions-in-galaaz}
 
 Galaaz extends Ruby to work with complex expressions, similar to R's
 expressions build with `quote' (base R) or `quo' (tidyverse). Let's take
 a look at some of those expressions.
 
-\hypertarget{expressions-from-operators}{%
 \subsection{Expressions from
-operators}\label{expressions-from-operators}}
+operators}\label{expressions-from-operators}
 
 The code bellow creates an expression summing two symbols
 
@@ -1297,13 +2558,6 @@ expressions such as
 \end{Highlighting}
 \end{Shaded}
 
-\begin{verbatim}
-## Message:
-##  Error in function (x, y, num.eq = TRUE, single.NA = TRUE, attrib.as.set = TRUE,  :
-##   object 'a' not found (RError)
-## Translated to internal error
-\end{verbatim}
-
 and it might be difficult to understand what is going on here. The
 problem lies with the fact that when using `==' we are comparing
 expression (:a + :b) to expression :z with `=='. When the comparison is
@@ -1312,9 +2566,8 @@ at this time are not bound to anything and we get a ``object `a' not
 found'' message. If we only use functional notation, this type of error
 will not occur.
 
-\hypertarget{expressions-with-r-methods}{%
 \subsection{Expressions with R
-methods}\label{expressions-with-r-methods}}
+methods}\label{expressions-with-r-methods}
 
 It is often necessary to create an expression that uses a method or
 function. For instance, in mathematics, it's quite natural to write an
@@ -1363,8 +2616,7 @@ the `.':
 ## c(x, y)
 \end{verbatim}
 
-\hypertarget{evaluating-an-expression}{%
-\subsection{Evaluating an Expression}\label{evaluating-an-expression}}
+\subsection{Evaluating an Expression}\label{evaluating-an-expression}
 
 Expressions can be evaluated by calling function `eval' with a binding.
 A binding can be provided with a list:
@@ -1398,8 +2650,7 @@ A binding can be provided with a list:
 ## [1] 32 64 96
 \end{verbatim}
 
-\hypertarget{manipulating-data}{%
-\section{Manipulating Data}\label{manipulating-data}}
+\section{Manipulating Data}\label{manipulating-data}
 
 One of the major benefits of Galaaz is to bring strong data manipulation
 to Ruby. The following examples were extracted from Hardley's ``R for
@@ -1415,6 +2666,11 @@ and if not, installs it. This data frame contains all 336,776 flights
 that departed from New York City in 2013. The data comes from the US
 Bureau of Transportation Statistics.
 
+Dplyr uses `tibbles' in place of data frames; unfortunately, tibbles do
+not print yet properly in Galaaz due to a bug in fastR. In order to
+print a tibble we need to convert it to a data frame using the
+'as\_\_data\_\_frame' method.
+
 \begin{Shaded}
 \begin{Highlighting}[]
 \NormalTok{R.install_and_loads(}\StringTok{'nycflights13'}\NormalTok{)}
@@ -1425,145 +2681,110 @@ Bureau of Transportation Statistics.
 \begin{Shaded}
 \begin{Highlighting}[]
 \NormalTok{flights = ~}\StringTok{:flights}
-\NormalTok{puts flights.head.as__data__frame}
-\end{Highlighting}
-\end{Shaded}
-
-\begin{verbatim}
-##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
-## 1 2013     1   1      517            515         2      830            819
-## 2 2013     1   1      533            529         4      850            830
-## 3 2013     1   1      542            540         2      923            850
-## 4 2013     1   1      544            545        -1     1004           1022
-## 5 2013     1   1      554            600        -6      812            837
-## 6 2013     1   1      554            558        -4      740            728
-##   arr_delay carrier flight tailnum origin dest air_time distance hour
-## 1        11      UA   1545  N14228    EWR  IAH      227     1400    5
-## 2        20      UA   1714  N24211    LGA  IAH      227     1416    5
-## 3        33      AA   1141  N619AA    JFK  MIA      160     1089    5
-## 4       -18      B6    725  N804JB    JFK  BQN      183     1576    5
-## 5       -25      DL    461  N668DN    LGA  ATL      116      762    6
-## 6        12      UA   1696  N39463    EWR  ORD      150      719    5
-##   minute           time_hour
-## 1     15 2013-01-01 05:00:00
-## 2     29 2013-01-01 05:00:00
-## 3     40 2013-01-01 05:00:00
-## 4     45 2013-01-01 05:00:00
-## 5      0 2013-01-01 06:00:00
-## 6     58 2013-01-01 05:00:00
-\end{verbatim}
-
-\hypertarget{filtering-rows-with-filter}{%
+\NormalTok{puts flights.head}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## # A tibble: 6 x 19
+##    year month   day dep_time sched_dep_time dep_delay arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
+## 1  2013     1     1      517            515         2      830
+## 2  2013     1     1      533            529         4      850
+## 3  2013     1     1      542            540         2      923
+## 4  2013     1     1      544            545        -1     1004
+## 5  2013     1     1      554            600        -6      812
+## 6  2013     1     1      554            558        -4      740
+## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
+## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
+## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
+## #   time_hour <dttm>
+\end{verbatim}
+
 \subsection{Filtering rows with
-Filter}\label{filtering-rows-with-filter}}
+Filter}\label{filtering-rows-with-filter}
 
 In this example we filter the flights data set by giving to the filter
 function two expressions: the first :month.eq 1
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.filter((}\StringTok{:month}\NormalTok{.eq }\DecValTok{1}\NormalTok{), (}\StringTok{:day}\NormalTok{.eq }\DecValTok{1}\NormalTok{)).head.as__data__frame}
+\NormalTok{puts flights.filter((}\StringTok{:month}\NormalTok{.eq }\DecValTok{1}\NormalTok{), (}\StringTok{:day}\NormalTok{.eq }\DecValTok{1}\NormalTok{)).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
-## 1 2013     1   1      517            515         2      830            819
-## 2 2013     1   1      533            529         4      850            830
-## 3 2013     1   1      542            540         2      923            850
-## 4 2013     1   1      544            545        -1     1004           1022
-## 5 2013     1   1      554            600        -6      812            837
-## 6 2013     1   1      554            558        -4      740            728
-##   arr_delay carrier flight tailnum origin dest air_time distance hour
-## 1        11      UA   1545  N14228    EWR  IAH      227     1400    5
-## 2        20      UA   1714  N24211    LGA  IAH      227     1416    5
-## 3        33      AA   1141  N619AA    JFK  MIA      160     1089    5
-## 4       -18      B6    725  N804JB    JFK  BQN      183     1576    5
-## 5       -25      DL    461  N668DN    LGA  ATL      116      762    6
-## 6        12      UA   1696  N39463    EWR  ORD      150      719    5
-##   minute           time_hour
-## 1     15 2013-01-01 05:00:00
-## 2     29 2013-01-01 05:00:00
-## 3     40 2013-01-01 05:00:00
-## 4     45 2013-01-01 05:00:00
-## 5      0 2013-01-01 06:00:00
-## 6     58 2013-01-01 05:00:00
+## # A tibble: 6 x 19
+##    year month   day dep_time sched_dep_time dep_delay arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
+## 1  2013     1     1      517            515         2      830
+## 2  2013     1     1      533            529         4      850
+## 3  2013     1     1      542            540         2      923
+## 4  2013     1     1      544            545        -1     1004
+## 5  2013     1     1      554            600        -6      812
+## 6  2013     1     1      554            558        -4      740
+## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
+## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
+## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
+## #   time_hour <dttm>
 \end{verbatim}
 
-\hypertarget{logical-operators}{%
-\subsection{Logical Operators}\label{logical-operators}}
+\subsection{Logical Operators}\label{logical-operators}
 
 All flights that departed in November of December
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.filter((}\StringTok{:month}\NormalTok{.eq }\DecValTok{11}\NormalTok{) | (}\StringTok{:month}\NormalTok{.eq }\DecValTok{12}\NormalTok{)).head.as__data__frame}
+\NormalTok{puts flights.filter((}\StringTok{:month}\NormalTok{.eq }\DecValTok{11}\NormalTok{) | (}\StringTok{:month}\NormalTok{.eq }\DecValTok{12}\NormalTok{)).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
-## 1 2013    11   1        5           2359         6      352            345
-## 2 2013    11   1       35           2250       105      123           2356
-## 3 2013    11   1      455            500        -5      641            651
-## 4 2013    11   1      539            545        -6      856            827
-## 5 2013    11   1      542            545        -3      831            855
-## 6 2013    11   1      549            600       -11      912            923
-##   arr_delay carrier flight tailnum origin dest air_time distance hour
-## 1         7      B6    745  N568JB    JFK  PSE      205     1617   23
-## 2        87      B6   1816  N353JB    JFK  SYR       36      209   22
-## 3       -10      US   1895  N192UW    EWR  CLT       88      529    5
-## 4        29      UA   1714  N38727    LGA  IAH      229     1416    5
-## 5       -24      AA   2243  N5CLAA    JFK  MIA      147     1089    5
-## 6       -11      UA    303  N595UA    JFK  SFO      359     2586    6
-##   minute           time_hour
-## 1     59 2013-11-01 23:00:00
-## 2     50 2013-11-01 22:00:00
-## 3      0 2013-11-01 05:00:00
-## 4     45 2013-11-01 05:00:00
-## 5     45 2013-11-01 05:00:00
-## 6      0 2013-11-01 06:00:00
+## # A tibble: 6 x 19
+##    year month   day dep_time sched_dep_time dep_delay arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
+## 1  2013    11     1        5           2359         6      352
+## 2  2013    11     1       35           2250       105      123
+## 3  2013    11     1      455            500        -5      641
+## 4  2013    11     1      539            545        -6      856
+## 5  2013    11     1      542            545        -3      831
+## 6  2013    11     1      549            600       -11      912
+## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
+## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
+## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
+## #   time_hour <dttm>
 \end{verbatim}
 
 The same as above, but using the `in' operator. In R, it is possible to
 define many operators by doing \%\%. The \%in\% operator checks if a
 value is in a vector. In order to use those operators from Galaaz the
-`.\_' method is used, where the first argument is the operator's symbol,
-in this case `:in' and the second argument is the vector:
+'.\_`method is used, where the first argument is the operator's symbol,
+in this case':in' and the second argument is the vector:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.filter(}\StringTok{:month}\NormalTok{._ }\StringTok{:in}\NormalTok{, R.c(}\DecValTok{11}\NormalTok{, }\DecValTok{12}\NormalTok{)).head.as__data__frame}
+\NormalTok{puts flights.filter(}\StringTok{:month}\NormalTok{._ }\StringTok{:in}\NormalTok{, R.c(}\DecValTok{11}\NormalTok{, }\DecValTok{12}\NormalTok{)).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
-## 1 2013    11   1        5           2359         6      352            345
-## 2 2013    11   1       35           2250       105      123           2356
-## 3 2013    11   1      455            500        -5      641            651
-## 4 2013    11   1      539            545        -6      856            827
-## 5 2013    11   1      542            545        -3      831            855
-## 6 2013    11   1      549            600       -11      912            923
-##   arr_delay carrier flight tailnum origin dest air_time distance hour
-## 1         7      B6    745  N568JB    JFK  PSE      205     1617   23
-## 2        87      B6   1816  N353JB    JFK  SYR       36      209   22
-## 3       -10      US   1895  N192UW    EWR  CLT       88      529    5
-## 4        29      UA   1714  N38727    LGA  IAH      229     1416    5
-## 5       -24      AA   2243  N5CLAA    JFK  MIA      147     1089    5
-## 6       -11      UA    303  N595UA    JFK  SFO      359     2586    6
-##   minute           time_hour
-## 1     59 2013-11-01 23:00:00
-## 2     50 2013-11-01 22:00:00
-## 3      0 2013-11-01 05:00:00
-## 4     45 2013-11-01 05:00:00
-## 5     45 2013-11-01 05:00:00
-## 6      0 2013-11-01 06:00:00
+## # A tibble: 6 x 19
+##    year month   day dep_time sched_dep_time dep_delay arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
+## 1  2013    11     1        5           2359         6      352
+## 2  2013    11     1       35           2250       105      123
+## 3  2013    11     1      455            500        -5      641
+## 4  2013    11     1      539            545        -6      856
+## 5  2013    11     1      542            545        -3      831
+## 6  2013    11     1      549            600       -11      912
+## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
+## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
+## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
+## #   time_hour <dttm>
 \end{verbatim}
 
-\hypertarget{filtering-with-na-not-available}{%
 \subsection{Filtering with NA (Not
-Available)}\label{filtering-with-na-not-available}}
+Available)}\label{filtering-with-na-not-available}
 
 Let's first create a `tibble' with a Not Available value (R::NA).
 Tibbles are a modern version of a data frame and operate very similarly
@@ -1574,15 +2795,17 @@ from data frame.
 \begin{Shaded}
 \begin{Highlighting}[]
 \NormalTok{df = R.tibble(}\StringTok{x: }\NormalTok{R.c(}\DecValTok{1}\NormalTok{, R::}\DataTypeTok{NA}\NormalTok{, }\DecValTok{3}\NormalTok{))}
-\NormalTok{puts df.as__data__frame}
+\NormalTok{puts df}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##    x
-## 1  1
-## 2 NA
-## 3  3
+## # A tibble: 3 x 1
+##       x
+##   <int>
+## 1     1
+## 2      
+## 3     3
 \end{verbatim}
 
 Now filtering by :x \textgreater{} 1 shows all lines that satisfy this
@@ -1590,145 +2813,137 @@ condition, where the row with R:NA does not.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts df.filter(}\StringTok{:x}\NormalTok{ > }\DecValTok{1}\NormalTok{).as__data__frame}
+\NormalTok{puts df.filter(}\StringTok{:x}\NormalTok{ > }\DecValTok{1}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   x
-## 1 3
+## # A tibble: 1 x 1
+##       x
+##   <int>
+## 1     3
 \end{verbatim}
 
 To match an NA use method 'is\_\_na'
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts df.filter((}\StringTok{:x}\NormalTok{.is__na) | (}\StringTok{:x}\NormalTok{ > }\DecValTok{1}\NormalTok{)).as__data__frame}
+\NormalTok{puts df.filter((}\StringTok{:x}\NormalTok{.is__na) | (}\StringTok{:x}\NormalTok{ > }\DecValTok{1}\NormalTok{))}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##    x
-## 1 NA
-## 2  3
+## # A tibble: 2 x 1
+##       x
+##   <int>
+## 1      
+## 2     3
 \end{verbatim}
 
-\hypertarget{arrange-rows-with-arrange}{%
-\subsection{Arrange Rows with arrange}\label{arrange-rows-with-arrange}}
+\subsection{Arrange Rows with arrange}\label{arrange-rows-with-arrange}
 
 Arrange reorders the rows of a data frame by the given arguments.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.arrange(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{).head.as__data__frame}
+\NormalTok{puts flights.arrange(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
-## 1 2013     1   1      517            515         2      830            819
-## 2 2013     1   1      533            529         4      850            830
-## 3 2013     1   1      542            540         2      923            850
-## 4 2013     1   1      544            545        -1     1004           1022
-## 5 2013     1   1      554            600        -6      812            837
-## 6 2013     1   1      554            558        -4      740            728
-##   arr_delay carrier flight tailnum origin dest air_time distance hour
-## 1        11      UA   1545  N14228    EWR  IAH      227     1400    5
-## 2        20      UA   1714  N24211    LGA  IAH      227     1416    5
-## 3        33      AA   1141  N619AA    JFK  MIA      160     1089    5
-## 4       -18      B6    725  N804JB    JFK  BQN      183     1576    5
-## 5       -25      DL    461  N668DN    LGA  ATL      116      762    6
-## 6        12      UA   1696  N39463    EWR  ORD      150      719    5
-##   minute           time_hour
-## 1     15 2013-01-01 05:00:00
-## 2     29 2013-01-01 05:00:00
-## 3     40 2013-01-01 05:00:00
-## 4     45 2013-01-01 05:00:00
-## 5      0 2013-01-01 06:00:00
-## 6     58 2013-01-01 05:00:00
+## # A tibble: 6 x 19
+##    year month   day dep_time sched_dep_time dep_delay arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
+## 1  2013     1     1      517            515         2      830
+## 2  2013     1     1      533            529         4      850
+## 3  2013     1     1      542            540         2      923
+## 4  2013     1     1      544            545        -1     1004
+## 5  2013     1     1      554            600        -6      812
+## 6  2013     1     1      554            558        -4      740
+## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
+## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
+## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
+## #   time_hour <dttm>
 \end{verbatim}
 
 To arrange in descending order, use function `desc'
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.arrange(}\StringTok{:dep_delay}\NormalTok{.desc).head.as__data__frame}
+\NormalTok{puts flights.arrange(}\StringTok{:dep_delay}\NormalTok{.desc).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
-## 1 2013     1   9      641            900      1301     1242           1530
-## 2 2013     6  15     1432           1935      1137     1607           2120
-## 3 2013     1  10     1121           1635      1126     1239           1810
-## 4 2013     9  20     1139           1845      1014     1457           2210
-## 5 2013     7  22      845           1600      1005     1044           1815
-## 6 2013     4  10     1100           1900       960     1342           2211
-##   arr_delay carrier flight tailnum origin dest air_time distance hour
-## 1      1272      HA     51  N384HA    JFK  HNL      640     4983    9
-## 2      1127      MQ   3535  N504MQ    JFK  CMH       74      483   19
-## 3      1109      MQ   3695  N517MQ    EWR  ORD      111      719   16
-## 4      1007      AA    177  N338AA    JFK  SFO      354     2586   18
-## 5       989      MQ   3075  N665MQ    JFK  CVG       96      589   16
-## 6       931      DL   2391  N959DL    JFK  TPA      139     1005   19
-##   minute           time_hour
-## 1      0 2013-01-09 09:00:00
-## 2     35 2013-06-15 19:00:00
-## 3     35 2013-01-10 16:00:00
-## 4     45 2013-09-20 18:00:00
-## 5      0 2013-07-22 16:00:00
-## 6      0 2013-04-10 19:00:00
+## # A tibble: 6 x 19
+##    year month   day dep_time sched_dep_time dep_delay arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
+## 1  2013     1     9      641            900      1301     1242
+## 2  2013     6    15     1432           1935      1137     1607
+## 3  2013     1    10     1121           1635      1126     1239
+## 4  2013     9    20     1139           1845      1014     1457
+## 5  2013     7    22      845           1600      1005     1044
+## 6  2013     4    10     1100           1900       960     1342
+## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
+## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
+## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
+## #   time_hour <dttm>
 \end{verbatim}
 
-\hypertarget{selecting-columns}{%
-\subsection{Selecting columns}\label{selecting-columns}}
+\subsection{Selecting columns}\label{selecting-columns}
 
 To select specific columns from a dataset we use function `select':
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{).head.as__data__frame}
+\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day
-## 1 2013     1   1
-## 2 2013     1   1
-## 3 2013     1   1
-## 4 2013     1   1
-## 5 2013     1   1
-## 6 2013     1   1
+## # A tibble: 6 x 3
+##    year month   day
+##   <int> <int> <int>
+## 1  2013     1     1
+## 2  2013     1     1
+## 3  2013     1     1
+## 4  2013     1     1
+## 5  2013     1     1
+## 6  2013     1     1
 \end{verbatim}
 
 It is also possible to select column in a given range
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{.up_to }\StringTok{:day}\NormalTok{).head.as__data__frame}
+\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{.up_to }\StringTok{:day}\NormalTok{).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day
-## 1 2013     1   1
-## 2 2013     1   1
-## 3 2013     1   1
-## 4 2013     1   1
-## 5 2013     1   1
-## 6 2013     1   1
+## # A tibble: 6 x 3
+##    year month   day
+##   <int> <int> <int>
+## 1  2013     1     1
+## 2  2013     1     1
+## 3  2013     1     1
+## 4  2013     1     1
+## 5  2013     1     1
+## 6  2013     1     1
 \end{verbatim}
 
 Select all columns that start with a given name sequence
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.select(E.starts_with(}\StringTok{'arr'}\NormalTok{)).head.as__data__frame}
+\NormalTok{puts flights.select(E.starts_with(}\StringTok{'arr'}\NormalTok{)).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
+## # A tibble: 6 x 2
 ##   arr_time arr_delay
+##      <int>     <dbl>
 ## 1      830        11
 ## 2      850        20
 ## 3      923        33
@@ -1757,37 +2972,28 @@ column order is `Everything':
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{, E.everything).head.as__data__frame}
+\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{, E.everything).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day dep_time sched_dep_time dep_delay arr_time sched_arr_time
-## 1 2013     1   1      517            515         2      830            819
-## 2 2013     1   1      533            529         4      850            830
-## 3 2013     1   1      542            540         2      923            850
-## 4 2013     1   1      544            545        -1     1004           1022
-## 5 2013     1   1      554            600        -6      812            837
-## 6 2013     1   1      554            558        -4      740            728
-##   arr_delay carrier flight tailnum origin dest air_time distance hour
-## 1        11      UA   1545  N14228    EWR  IAH      227     1400    5
-## 2        20      UA   1714  N24211    LGA  IAH      227     1416    5
-## 3        33      AA   1141  N619AA    JFK  MIA      160     1089    5
-## 4       -18      B6    725  N804JB    JFK  BQN      183     1576    5
-## 5       -25      DL    461  N668DN    LGA  ATL      116      762    6
-## 6        12      UA   1696  N39463    EWR  ORD      150      719    5
-##   minute           time_hour
-## 1     15 2013-01-01 05:00:00
-## 2     29 2013-01-01 05:00:00
-## 3     40 2013-01-01 05:00:00
-## 4     45 2013-01-01 05:00:00
-## 5      0 2013-01-01 06:00:00
-## 6     58 2013-01-01 05:00:00
+## # A tibble: 6 x 19
+##    year month   day dep_time sched_dep_time dep_delay arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
+## 1  2013     1     1      517            515         2      830
+## 2  2013     1     1      533            529         4      850
+## 3  2013     1     1      542            540         2      923
+## 4  2013     1     1      544            545        -1     1004
+## 5  2013     1     1      554            600        -6      812
+## 6  2013     1     1      554            558        -4      740
+## # ... with 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
+## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
+## #   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>,
+## #   time_hour <dttm>
 \end{verbatim}
 
-\hypertarget{add-variables-to-a-dataframe-with-mutate}{%
-\subsection{Add variables to a dataframe with
-`mutate'}\label{add-variables-to-a-dataframe-with-mutate}}
+\subsection{\texorpdfstring{Add variables to a dataframe with
+`mutate'}{Add variables to a dataframe with mutate}}\label{add-variables-to-a-dataframe-with-mutate}
 
 \begin{Shaded}
 \begin{Highlighting}[]
@@ -1797,18 +3003,20 @@ column order is `Everything':
                       \StringTok{:distance}\NormalTok{,}
                       \StringTok{:air_time}\NormalTok{)}
 
-\NormalTok{puts flights_sm.head.as__data__frame}
+\NormalTok{puts flights_sm.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day dep_delay arr_delay distance air_time
-## 1 2013     1   1         2        11     1400      227
-## 2 2013     1   1         4        20     1416      227
-## 3 2013     1   1         2        33     1089      160
-## 4 2013     1   1        -1       -18     1576      183
-## 5 2013     1   1        -6       -25      762      116
-## 6 2013     1   1        -4        12      719      150
+## # A tibble: 6 x 7
+##    year month   day dep_delay arr_delay distance air_time
+##   <int> <int> <int>     <dbl>     <dbl>    <dbl>    <dbl>
+## 1  2013     1     1         2        11     1400      227
+## 2  2013     1     1         4        20     1416      227
+## 3  2013     1     1         2        33     1089      160
+## 4  2013     1     1        -1       -18     1576      183
+## 5  2013     1     1        -6       -25      762      116
+## 6  2013     1     1        -4        12      719      150
 \end{verbatim}
 
 \begin{Shaded}
@@ -1816,55 +3024,61 @@ column order is `Everything':
 \NormalTok{flights_sm = flights_sm.}
 \NormalTok{               mutate(}\StringTok{gain: :dep_delay}\NormalTok{ - }\StringTok{:arr_delay}\NormalTok{,}
                       \StringTok{speed: :distance}\NormalTok{ / }\StringTok{:air_time}\NormalTok{ * }\DecValTok{60}\NormalTok{)}
-\NormalTok{puts flights_sm.head.as__data__frame}
+\NormalTok{puts flights_sm.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day dep_delay arr_delay distance air_time gain    speed
-## 1 2013     1   1         2        11     1400      227   -9 370.0441
-## 2 2013     1   1         4        20     1416      227  -16 374.2731
-## 3 2013     1   1         2        33     1089      160  -31 408.3750
-## 4 2013     1   1        -1       -18     1576      183   17 516.7213
-## 5 2013     1   1        -6       -25      762      116   19 394.1379
-## 6 2013     1   1        -4        12      719      150  -16 287.6000
+## # A tibble: 6 x 9
+##    year month   day dep_delay arr_delay distance air_time  gain speed
+##   <int> <int> <int>     <dbl>     <dbl>    <dbl>    <dbl> <dbl> <dbl>
+## 1  2013     1     1         2        11     1400      227    -9  370.
+## 2  2013     1     1         4        20     1416      227   -16  374.
+## 3  2013     1     1         2        33     1089      160   -31  408.
+## 4  2013     1     1        -1       -18     1576      183    17  517.
+## 5  2013     1     1        -6       -25      762      116    19  394.
+## 6  2013     1     1        -4        12      719      150   -16  288.
 \end{verbatim}
 
-\hypertarget{summarising-data}{%
-\subsection{Summarising data}\label{summarising-data}}
+\subsection{Summarising data}\label{summarising-data}
 
 Function `summarise' calculates summaries for the data frame. When no
 `group\_by' is used a single value is obtained from the data frame:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.summarise(}\StringTok{delay: }\NormalTok{E.mean(}\StringTok{:dep_delay}\NormalTok{, }\StringTok{na__rm: }\DecValTok{true}\NormalTok{)).as__data__frame}
+\NormalTok{puts flights.summarise(}\StringTok{delay: }\NormalTok{E.mean(}\StringTok{:dep_delay}\NormalTok{, }\StringTok{na__rm: }\DecValTok{true}\NormalTok{))}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##      delay
-## 1 12.63907
+## # A tibble: 1 x 1
+##   delay
+##   <dbl>
+## 1  12.6
 \end{verbatim}
 
-When a data frame is groupe with `group\_by' summaries apply to the
+When a data frame is grouped with `group\_by' summaries apply to the
 given group:
 
 \begin{Shaded}
 \begin{Highlighting}[]
 \NormalTok{by_day = flights.group_by(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{)}
-\NormalTok{puts by_day.summarise(}\StringTok{delay: :dep_delay}\NormalTok{.mean(}\StringTok{na__rm: }\DecValTok{true}\NormalTok{)).head.as__data__frame}
+\NormalTok{puts by_day.summarise(}\StringTok{delay: :dep_delay}\NormalTok{.mean(}\StringTok{na__rm: }\DecValTok{true}\NormalTok{)).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   year month day     delay
-## 1 2013     1   1 11.548926
-## 2 2013     1   2 13.858824
-## 3 2013     1   3 10.987832
-## 4 2013     1   4  8.951595
-## 5 2013     1   5  5.732218
-## 6 2013     1   6  7.148014
+## # A tibble: 6 x 4
+## # Groups:   year, month [1]
+##    year month   day delay
+## * <int> <int> <int> <dbl>
+## 1  2013     1     1 11.5 
+## 2  2013     1     2 13.9 
+## 3  2013     1     3 11.0 
+## 4  2013     1     4  8.95
+## 5  2013     1     5  5.73
+## 6  2013     1     6  7.15
 \end{verbatim}
 
 Next we put many operations together by pipping them one after the
@@ -1880,22 +3094,23 @@ other:
              \StringTok{delay: :arr_delay}\NormalTok{.mean(}\StringTok{na__rm: }\DecValTok{true}\NormalTok{)).}
 \NormalTok{           filter(}\StringTok{:count}\NormalTok{ > }\DecValTok{20}\NormalTok{, }\StringTok{:dest}\NormalTok{ != }\StringTok{"NHL"}\NormalTok{)}
 
-\NormalTok{puts delays.as__data__frame.head}
+\NormalTok{puts delays.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   dest count      dist     delay
-## 1  ABQ   254 1826.0000  4.381890
-## 2  ACK   265  199.0000  4.852273
-## 3  ALB   439  143.0000 14.397129
-## 4  ATL 17215  757.1082 11.300113
-## 5  AUS  2439 1514.2530  6.019909
-## 6  AVL   275  583.5818  8.003831
+## # A tibble: 6 x 4
+##   dest  count  dist delay
+##   <chr> <int> <dbl> <dbl>
+## 1 ABQ     254 1826   4.38
+## 2 ACK     265  199   4.85
+## 3 ALB     439  143  14.4 
+## 4 ATL   17215  757. 11.3 
+## 5 AUS    2439 1514.  6.02
+## 6 AVL     275  584.  8.00
 \end{verbatim}
 
-\hypertarget{using-data-table}{%
-\section{Using Data Table}\label{using-data-table}}
+\section{Using Data Table}\label{using-data-table}
 
 \begin{Shaded}
 \begin{Highlighting}[]
@@ -2032,8 +3247,7 @@ other:
 ## 6:         0
 \end{verbatim}
 
-\hypertarget{graphics-in-galaaz}{%
-\section{Graphics in Galaaz}\label{graphics-in-galaaz}}
+\section{Graphics in Galaaz}\label{graphics-in-galaaz}
 
 Creating graphics in Galaaz is quite easy, as it can use all the power
 of ggplot2. There are many resources in the web that teaches ggplot, so
@@ -2125,10 +3339,9 @@ so we add `coord\_flip'.
 \end{Highlighting}
 \end{Shaded}
 
-\includegraphics{/home/rbotafogo/desenv/galaaz/blogs/manual/manual_files/figure-latex/diverging_bar.pdf}
+\includegraphics{manual_files/figure-latex/diverging_bar.pdf}
 
-\hypertarget{coding-with-tidyverse}{%
-\section{Coding with Tidyverse}\label{coding-with-tidyverse}}
+\section{Coding with Tidyverse}\label{coding-with-tidyverse}
 
 In R, and when coding with `tidyverse', arguments to a function are
 usually not \emph{referencially transparent}. That is, you can't replace
@@ -2158,7 +3371,7 @@ and now, let's look at this code:
 \end{Highlighting}
 \end{Shaded}
 
-It generates the following error: "object `x' not found.
+It generates the following error: ``object `x' not found.
 
 However, in Galaaz, arguments are referencially transparent as can be
 seen by the code bellow. Note initally that `my\_var = :x' will not give
@@ -2229,9 +3442,8 @@ chunks of code:
 ## 1 1 3
 \end{verbatim}
 
-\hypertarget{writing-a-function-that-applies-to-different-data-sets}{%
 \subsection{Writing a function that applies to different data
-sets}\label{writing-a-function-that-applies-to-different-data-sets}}
+sets}\label{writing-a-function-that-applies-to-different-data-sets}
 
 Let's suppose that we want to write a function that receives as the
 first argument a data frame and as second argument an expression that
@@ -2308,8 +3520,7 @@ no relationship with the symbol `:a' used in the definition of
 ## Translated to internal error
 \end{verbatim}
 
-\hypertarget{different-expressions}{%
-\subsection{Different expressions}\label{different-expressions}}
+\subsection{Different expressions}\label{different-expressions}
 
 Let's move to the next problem as presented by Hardley where trying to
 write a function in R that will receive two argumens, the first a
@@ -2334,11 +3545,11 @@ variable and summarises it by an expression:
 
 \begin{verbatim}
 ##   g1 g2 a b
-## 1  1  1 2 1
-## 2  1  2 4 3
-## 3  2  1 5 4
-## 4  2  2 3 2
-## 5  2  1 1 5
+## 1  1  1 3 3
+## 2  1  2 2 1
+## 3  2  1 5 2
+## 4  2  2 4 5
+## 5  2  1 1 4
 \end{verbatim}
 
 \begin{Shaded}
@@ -2352,9 +3563,9 @@ variable and summarises it by an expression:
 \end{Shaded}
 
 \begin{verbatim}
-##   g1 a
-## 1  1 3
-## 2  2 3
+##   g1        a
+## 1  1 2.500000
+## 2  2 3.333333
 \end{verbatim}
 
 \begin{Shaded}
@@ -2368,9 +3579,9 @@ variable and summarises it by an expression:
 \end{Shaded}
 
 \begin{verbatim}
-##   g2        a
-## 1  1 2.666667
-## 2  2 3.500000
+##   g2 a
+## 1  1 3
+## 2  2 3
 \end{verbatim}
 
 As shown by Hardley, one might expect this function to do the trick:
@@ -2407,11 +3618,11 @@ access an R variable from Galaaz, we use the tilda operator
 
 \begin{verbatim}
 ##   g1 g2 a b
-## 1  1  1 2 1
-## 2  1  2 4 3
-## 3  2  1 5 4
-## 4  2  2 3 2
-## 5  2  1 1 5
+## 1  1  1 3 3
+## 2  1  2 2 1
+## 3  2  1 5 2
+## 4  2  2 4 5
+## 5  2  1 1 4
 \end{verbatim}
 
 We then create the `my\_summarize' method and call it passing the R data
@@ -2424,36 +3635,39 @@ frame and the group by variable `:g1':
 \NormalTok{    summarize(}\StringTok{a: :a}\NormalTok{.mean)}
 \KeywordTok{end}
 
-\NormalTok{puts my_summarize(}\StringTok{:df}\NormalTok{, }\StringTok{:g1}\NormalTok{).as__data__frame}
+\NormalTok{puts my_summarize(}\StringTok{:df}\NormalTok{, }\StringTok{:g1}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   g1 a
-## 1  1 3
-## 2  2 3
+## # A tibble: 2 x 2
+##      g1     a
+##   <dbl> <dbl>
+## 1     1  2.5 
+## 2     2  3.33
 \end{verbatim}
 
 It works!!! Well, let's make sure this was not just some coincidence
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts my_summarize(}\StringTok{:df}\NormalTok{, }\StringTok{:g2}\NormalTok{).as__data__frame}
+\NormalTok{puts my_summarize(}\StringTok{:df}\NormalTok{, }\StringTok{:g2}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   g2        a
-## 1  1 2.666667
-## 2  2 3.500000
+## # A tibble: 2 x 2
+##      g2     a
+##   <dbl> <dbl>
+## 1     1     3
+## 2     2     3
 \end{verbatim}
 
 Great, everything is fine! No magic, no new functions, no complexities,
 just normal, standard Ruby code. If you've ever done NSE in R, this
 certainly feels much safer and easy to implement.
 
-\hypertarget{different-input-variables}{%
-\subsection{Different input variables}\label{different-input-variables}}
+\subsection{Different input variables}\label{different-input-variables}
 
 In the previous section we've managed to get rid of all NSE formulation
 for a simple example, but does this remain true for more complex
@@ -2508,9 +3722,8 @@ Once again, there is no need to use any special theory or functions. The
 only point to be careful about is the use of `E' to build expressions
 from functions `mean', `sum' and `n'.
 
-\hypertarget{different-input-and-output-variable}{%
 \subsection{Different input and output
-variable}\label{different-input-and-output-variable}}
+variable}\label{different-input-and-output-variable}
 
 Now the next challenge presented by Hardley is to vary the name of the
 output variables based on the received expression. So, if the input
@@ -2564,18 +3777,18 @@ Here is our Ruby code:
 
 \begin{verbatim}
 ##   g1 g2 a b mean_a sum_a
-## 1  1  1 2 1      3    15
-## 2  1  2 4 3      3    15
-## 3  2  1 5 4      3    15
-## 4  2  2 3 2      3    15
-## 5  2  1 1 5      3    15
+## 1  1  1 3 3      3    15
+## 2  1  2 2 1      3    15
+## 3  2  1 5 2      3    15
+## 4  2  2 4 5      3    15
+## 5  2  1 1 4      3    15
 ## 
 ##   g1 g2 a b mean_b sum_b
-## 1  1  1 2 1      3    15
-## 2  1  2 4 3      3    15
-## 3  2  1 5 4      3    15
-## 4  2  2 3 2      3    15
-## 5  2  1 1 5      3    15
+## 1  1  1 3 3      3    15
+## 2  1  2 2 1      3    15
+## 3  2  1 5 2      3    15
+## 4  2  2 4 5      3    15
+## 5  2  1 1 4      3    15
 \end{verbatim}
 
 It really seems that ``Non Standard Evaluation'' is actually quite
@@ -2589,9 +3802,8 @@ This is standard Ruby notation.
 
 {[}explain\ldots{}.{]}
 
-\hypertarget{capturing-multiple-variables}{%
 \subsection{Capturing multiple
-variables}\label{capturing-multiple-variables}}
+variables}\label{capturing-multiple-variables}
 
 Moving on with new complexities, Hardley proposes us to solve the
 problem in which the summarise function will receive any number of
@@ -2607,21 +3819,23 @@ number of paramenters the paramenter is preceded by '*':
 \NormalTok{    summarise(}\StringTok{a: }\NormalTok{E.mean(}\StringTok{:a}\NormalTok{))}
 \KeywordTok{end}
 
-\NormalTok{puts my_summarise3((~}\StringTok{:df}\NormalTok{), }\StringTok{:g1}\NormalTok{, }\StringTok{:g2}\NormalTok{).as__data__frame}
+\NormalTok{puts my_summarise3((~}\StringTok{:df}\NormalTok{), }\StringTok{:g1}\NormalTok{, }\StringTok{:g2}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##   g1 g2 a
-## 1  1  1 2
-## 2  1  2 4
-## 3  2  1 3
-## 4  2  2 3
+## # A tibble: 4 x 3
+## # Groups:   g1 [?]
+##      g1    g2     a
+##   <dbl> <dbl> <dbl>
+## 1     1     1     3
+## 2     1     2     2
+## 3     2     1     3
+## 4     2     2     4
 \end{verbatim}
 
-\hypertarget{why-does-r-require-nse-and-galaaz-does-not}{%
 \subsection{Why does R require NSE and Galaaz does
-not?}\label{why-does-r-require-nse-and-galaaz-does-not}}
+not?}\label{why-does-r-require-nse-and-galaaz-does-not}
 
 NSE introduces a number of new concepts, such as `quoting',
 `quasiquotation', `unquoting' and `unquote-splicing', while in Galaaz
@@ -2654,8 +3868,7 @@ should call the function passing the value `true' if variable `a' is
 equal to variable `b' or if it should call the function passing the
 expression `:a.eq :b'.
 
-\hypertarget{advanced-dplyr-features}{%
-\subsection{Advanced dplyr features}\label{advanced-dplyr-features}}
+\subsection{Advanced dplyr features}\label{advanced-dplyr-features}
 
 In the blog: Programming with dplyr by using dplyr
 (\url{https://www.r-bloggers.com/programming-with-dplyr-by-using-dplyr/})
@@ -2682,39 +3895,22 @@ the Starwars movies:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts (~}\StringTok{:starwars}\NormalTok{).head.as__data__frame}
+\NormalTok{puts (~}\StringTok{:starwars}\NormalTok{).head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##             name height mass  hair_color  skin_color eye_color birth_year
-## 1 Luke Skywalker    172   77       blond        fair      blue       19.0
-## 2          C-3PO    167   75        <NA>        gold    yellow      112.0
-## 3          R2-D2     96   32        <NA> white, blue       red       33.0
-## 4    Darth Vader    202  136        none       white    yellow       41.9
-## 5    Leia Organa    150   49       brown       light     brown       19.0
-## 6      Owen Lars    178  120 brown, grey       light      blue       52.0
-##   gender homeworld species
-## 1   male  Tatooine   Human
-## 2   <NA>  Tatooine   Droid
-## 3   <NA>     Naboo   Droid
-## 4   male  Tatooine   Human
-## 5 female  Alderaan   Human
-## 6   male  Tatooine   Human
-##                                                                                                                                       films
-## 1                                           Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope, The Force Awakens
-## 2                    Attack of the Clones, The Phantom Menace, Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope
-## 3 Attack of the Clones, The Phantom Menace, Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope, The Force Awakens
-## 4                                                              Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope
-## 5                                           Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope, The Force Awakens
-## 6                                                                                     Attack of the Clones, Revenge of the Sith, A New Hope
-##                             vehicles                starships
-## 1 Snowspeeder, Imperial Speeder Bike X-wing, Imperial shuttle
-## 2                                                            
-## 3                                                            
-## 4                                             TIE Advanced x1
-## 5              Imperial Speeder Bike                         
-## 6
+## # A tibble: 6 x 13
+##   name  height  mass hair_color skin_color eye_color birth_year gender
+##   <chr>  <int> <dbl> <chr>      <chr>      <chr>          <dbl> <chr> 
+## 1 Luke~    172    77 blond      fair       blue            19   male  
+## 2 C-3PO    167    75 <NA>       gold       yellow         112   <NA>  
+## 3 R2-D2     96    32 <NA>       white, bl~ red             33   <NA>  
+## 4 Dart~    202   136 none       white      yellow          41.9 male  
+## 5 Leia~    150    49 brown      light      brown           19   female
+## 6 Owen~    178   120 brown, gr~ light      blue            52   male  
+## # ... with 5 more variables: homeworld <chr>, species <chr>, films <list>,
+## #   vehicles <list>, starships <list>
 \end{verbatim}
 
 The grouped\_mean function bellow will receive a grouping variable and
@@ -2768,33 +3964,34 @@ The same code with Galaaz, becomes:
 \NormalTok{    rename_at(value_variables, E.funs(E.paste0(}\StringTok{"mean_"}\NormalTok{, value_variables)))}
 \KeywordTok{end}
 
-\NormalTok{puts grouped_mean((~}\StringTok{:starwars}\NormalTok{), }\StringTok{"eye_color"}\NormalTok{, E.c(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth_year"}\NormalTok{)).as__data__frame}
+\NormalTok{puts grouped_mean((~}\StringTok{:starwars}\NormalTok{), }\StringTok{"eye_color"}\NormalTok{, E.c(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth_year"}\NormalTok{))}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##        eye_color mean_mass mean_birth_year count
-## 1          black  76.28571        33.00000    10
-## 2           blue  86.51667        67.06923    19
-## 3      blue-gray  77.00000        57.00000     1
-## 4          brown  66.09231       108.96429    21
-## 5           dark       NaN             NaN     1
-## 6           gold       NaN             NaN     1
-## 7  green, yellow 159.00000             NaN     1
-## 8          hazel  66.00000        34.50000     3
-## 9         orange 282.33333       231.00000     8
-## 10          pink       NaN             NaN     1
-## 11           red  81.40000        33.66667     5
-## 12     red, blue       NaN             NaN     1
-## 13       unknown  31.50000             NaN     3
-## 14         white  48.00000             NaN     1
-## 15        yellow  81.11111        76.38000    11
+## # A tibble: 15 x 4
+##    eye_color     mean_mass mean_birth_year count
+##    <chr>             <dbl>           <dbl> <dbl>
+##  1 black              76.3            33      10
+##  2 blue               86.5            67.1    19
+##  3 blue-gray          77              57       1
+##  4 brown              66.1           109.     21
+##  5 dark              NaN             NaN       1
+##  6 gold              NaN             NaN       1
+##  7 green, yellow     159             NaN       1
+##  8 hazel              66              34.5     3
+##  9 orange            282.            231       8
+## 10 pink              NaN             NaN       1
+## 11 red                81.4            33.7     5
+## 12 red, blue         NaN             NaN       1
+## 13 unknown            31.5           NaN       3
+## 14 white              48             NaN       1
+## 15 yellow             81.1            76.4    11
 \end{verbatim}
 
 {[}TO BE CONTINUED\ldots{}{]}
 
-\hypertarget{contributing}{%
-\section{Contributing}\label{contributing}}
+\section{Contributing}\label{contributing}
 
 \begin{itemize}
 \tightlist
@@ -2812,5 +4009,18 @@ The same code with Galaaz, becomes:
   Create new Pull Request
 \end{itemize}
 
+\section*{References}\label{references}
+\addcontentsline{toc}{section}{References}
+
+\hypertarget{refs}{}
+\hypertarget{ref-Knuth:literate_programming}{}
+Knuth, Donald E. 1984. ``Literate Programming.'' \emph{Comput. J.} 27
+(2). Oxford, UK: Oxford University Press: 97--111.
+doi:\href{https://doi.org/10.1093/comjnl/27.2.97}{10.1093/comjnl/27.2.97}.
+
+\hypertarget{ref-Wilkinson:grammar_of_graphics}{}
+Wilkinson, Leland. 2005. \emph{The Grammar of Graphics (Statistics and
+Computing)}. Berlin, Heidelberg: Springer-Verlag.
+
 
 \end{document}