galaaz 0.5.0 → 2.1.0

data/blogs/nse_dplyr/nse_dplyr.md

@@ -3,8 +3,8 @@ title: "Non Standard Evaluation in dplyr with Galaaz"
 author:
     - "Rodrigo Botafogo"
     - "Daniel Mossé - University of Pittsburgh"
-tags: [Tech, Data Science, Ruby, R, GraalVM]
-date: "10/05/2019"
+tags: [Tech, Data Science, Ruby, R, JRuby, "GNU R", Galaaz, dplyr]
+date: "10/05/2019 (narrative updated for Galaaz 2.0, 2026)"
 output:
   html_document:
     self_contained: true
@@ -24,7 +24,7 @@ fontsize: 11pt
 
 # Introduction
 
-According to Steven Sagaert answer on Quora about "Is programming language R overrated?":
+According to Steven Sagaert’s answer on Quora about “Is programming language R overrated?”:
 
 > R is a sophisticated language with an unusual (i.e. non-mainstream) set of features. It‘s 
 > an impure functional programming language with sophisticated metaprogramming and 3 
@@ -37,16 +37,15 @@ According to Steven Sagaert answer on Quora about "Is programming language R ove
 > Mastering R (the language) and its ecosystem is not a matter of weeks or months but 
 > takes years. The rabbit hole goes pretty deep…
 
-Although having a highly configurable language might give extreme power to the programmer,
-it can also be, as stated above, a question of years to master it. Programming with _dplyr_
-for instance, requires learning a set of complex concepts and rules that are not easily 
-accessible for casual users or _unsofisticated_ programmers as many users of R are. Being
-_unsofisticated_ is NOT used here in a negative sense, as R was build for statitians and
-not programmers, that need to solve real problems, often in a short time spam and are not
-concerned about creating complex computer systems.
+Although a highly configurable language can give programmers a great deal of power,
+it can also take years to master—as noted above. Programming with _dplyr_, for instance,
+means learning evaluation rules that are not always approachable for **statisticians and
+analysts who are not full-time software engineers**. That is not a criticism: R was **built**
+for **statisticians** who need trustworthy results on a deadline, not necessarily for building
+large applications.
 
-Unfortunatelly, if this _unsofisticated_ programmer decides to move unto more sofisticated
-coding, the learning curve might become a serious impediment. 
+**Unfortunately**, when such a user moves on to more **sophisticated** programming patterns,
+the learning curve can become a real hurdle. 
 
 In this post we will see how to program with _dplyr_ in Galaaz and how Ruby can simplify
 the learning curve of mastering _dplyr_ coding.
@@ -58,9 +57,9 @@ a large community, a very large set of libraries and great for web development.
 easy to learn. However,
 it lacks libraries for data science, statistics, scientific plotting and machine learning.
 On the other hand, 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,
-Pandas, SciPy, SciKit-Learn and many more.  We will not get here in the discussion on R
-versus Python, both are excellent languages with powerful features, benefits and drawbacks.
+above problems.  **Python** is a strong competitor, with NumPy, pandas, SciPy, scikit-learn,
+and **many thousands** of other packages on PyPI.  We will not dwell on R **versus** Python here:
+both are excellent languages with different strengths.
 Our interest is to bring to yet another excellent language, Ruby, the data science libraries
 that it lacks.
 
@@ -73,37 +72,14 @@ post that programming with _dplyr_ is easier in Galaaz than in R.
 
 R users are probably quite knowledgeable about _dplyr_. For the Ruby developer, _dplyr_ and
 the _tidyverse_ libraries are a set of libraries for data manipulation in R, developed by
-Hardley Wickham, chief scientis at RStudio and a prolific R coder and writer.
+Hadley Wickham, Chief Scientist at Posit (formerly RStudio) and a prolific R coder and writer.
 
-For the coupling of Ruby and R, we use new technologies provided by Oracle: GraalVM, 
-TruffleRuby and FastR. GraalVM home page had the following definition:
-
-     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:
-
-      * “That library is not available in my language. I need to rewrite it.” 
-      * “That language would be the perfect fit for my problem, but we cannot
-        run it in our environment.” 
-      * “That problem is already solved in my language, but the language is
-        too slow.”
-    
-    With GraalVM we aim to allow developers to freely choose the right language
-    for the task at hand without making compromises.
+For the coupling of Ruby and R, **Galaaz 2.0** uses **[JRuby](https://www.jruby.org/)** (Ruby on the JVM)
+together with **GNU R**. A **bridge** sends expressions and data between Ruby and an R process so that
+Ruby can call **dplyr** and the rest of the tidyverse as if they were part of the same workflow.
+An **earlier** Galaaz line of work used Oracle’s **GraalVM** with **TruffleRuby** and **FastR** in a single
+runtime; that approach is **no longer** the supported stack—see the project **manual** for setup,
+**`bin/galaaz-jruby`**, and **gKnit**.
 
 
 # Tidyverse and dplyr
@@ -137,7 +113,7 @@ multiple datasets, programming becomes necessary.
 # Programming with dplyr
 
 In the vignette ["Programming with dplyr"](https://dplyr.tidyverse.org/articles/programming.html), 
-Hardley Wickham states:
+Hadley Wickham states:
 
 > Most dplyr functions use non-standard evaluation (NSE). This is a catch-all term that 
 > means they don’t follow the usual R rules of evaluation. Instead, they capture the 
@@ -160,7 +136,7 @@ But then he goes on:
 > with a seemingly equivalent object that you’ve defined elsewhere. In other words, this code:
 
 
-```r
+``` r
 df <- data.frame(x = 1:3, y = 3:1)
 print(filter(df, x == 1))
 #> # A tibble: 1 x 2
@@ -171,7 +147,7 @@ print(filter(df, x == 1))
 > Is not equivalent to this code:
 
 
-```r
+``` r
 my_var <- x
 #> Error in eval(expr, envir, enclos): object 'x' not found
 filter(df, my_var == 1)
@@ -180,7 +156,7 @@ filter(df, my_var == 1)
 > This makes it hard to create functions with arguments that change how dplyr verbs are computed.
 
 As a result of this, programming with _dplyr_ requires learning a set of new ideas and concepts.
-In this vignette Hardley goes on showing how to program ever more difficult problems with _dplyr_, 
+In this vignette Hadley goes on showing how to program ever more difficult problems with _dplyr_, 
 showing the problems it faces and the new concepts needed to solve them.
 
 In this blog, we will look at all the problems presented by Harley on the vignette and show how
@@ -220,7 +196,7 @@ where you are reading this blog) with gKnit (a tool provided by Galaaz). In Rmar
 possible to write text and code blocks that are executed to generate the final report. Code
 blocks appear inside a 'box' and the result of their execution appear either in another type 
 of 'box' with a different background (HTML) or as normal text (PDF).  Every output line from
-the code execution is preceeded by '##'.
+the code execution is preceded by '##'.
 
 ## Expressions from operators
 
@@ -228,24 +204,36 @@ The code below creates an expression summing two symbols. Note that :a and :b ar
 are not bound to any values at the time of expression definition:
 
 
-```ruby
+``` ruby
 exp1 = :a + :b
 puts exp1
 ```
 
 ```
-## a + b
+## undefined method '+' for an instance of Symbol
+```
+
+```
+## /home/rbotafogo/desenv_linux/galaaz/lib/util/exec_ruby.rb:170:in 'exec_ruby'
+## org/jruby/RubyKernel.java:1268:in 'eval'
+## /home/rbotafogo/desenv_linux/galaaz/lib/util/exec_ruby.rb:169:in 'exec_ruby'
+## /home/rbotafogo/desenv_linux/galaaz/lib/gknit/knitr_engine.rb:777:in 'block in initialize'
+## org/jruby/RubyBasicObject.java:2695:in 'instance_eval'
+## org/jruby/RubyBasicObject.java:2723:in 'instance_eval'
+## /home/rbotafogo/desenv_linux/galaaz/lib/gknit/knitr_engine.rb:748:in 'block in initialize'
+## /home/rbotafogo/desenv_linux/galaaz/lib/R_interface/new_bridge_adapter.rb:358:in 'block in register_callback_proc_stub'
+## /home/rbotafogo/desenv_linux/galaaz/lib/new_bridge/session_client.rb:413:in 'block in handle_call'
 ```
 In Galaaz, we can build any complex mathematical expression such as:
 
 
-```ruby
-exp2 = (:a + :b) * 2.0 + :c ** 2 / :z
+``` ruby
+exp2 = (R[:a] + R[:b]) * 2.0 + R[:c] ** 2 / R[:z]
 puts exp2
 ```
 
 ```
-## (a + b) * 2 + c^2L/z
+## a + b * 2.0 + c ^ 2L / z
 ```
 Expressions are printed with the same format as the equivalent R expressions. The 'L' after 
 2 indicates that 2 is an integer. 
@@ -258,8 +246,8 @@ float.
 It is also possible to use inequality operators in building expressions:
 
 
-```ruby
-exp3 = (:a + :b) >= :z
+``` ruby
+exp3 = (R[:a] + R[:b]) >= R[:z]
 puts exp3
 ```
 
@@ -269,15 +257,15 @@ puts exp3
 Expressions' definition can also make use of normal Ruby variables without any problem:
 
 
-```ruby
+``` ruby
 x = 20
 y = 30.0
-exp_var = (:a + :b) * x <= :z - y
+exp_var = (R[:a] + R[:b]) * x <= R[:z] - y
 puts exp_var
 ```
 
 ```
-## (a + b) * 20L <= z - 30
+## a + b * 20L <= z - 30.0
 ```
 
 Galaaz provides both symbolic representations for operators, such as (>, <, !=) as functional 
@@ -285,8 +273,8 @@ notation for those operators such as (.gt, .ge, etc.).  So the same expression w
 above can also be written as
 
 
-```ruby
-exp4 = (:a + :b).ge :z
+``` ruby
+exp4 = (R[:a] + R[:b]).ge R[:z]
 puts exp4
 ```
 
@@ -302,8 +290,8 @@ In order to write an expression involving '==' we
 need to use the method '.eq' and for '=' we need the function '.assign':
 
 
-```ruby
-exp5 = (:a + :b).eq :z
+``` ruby
+exp5 = (R[:a] + R[:b]).eq R[:z]
 puts exp5
 ```
 
@@ -312,8 +300,8 @@ puts exp5
 ```
 
 
-```ruby
-exp6 = :y.assign :a + :b
+``` ruby
+exp6 = R[:y].assign R[:a] + R[:b]
 puts exp6
 ```
 
@@ -325,19 +313,16 @@ this will generate an error, that might be a bit cryptic (in future releases of
 plan to improve the error message).
 
 
-```ruby
-exp_wrong = (:a + :b) == :z
+``` ruby
+exp_wrong = (R[:a] + R[:b]) == R[:z]
 puts exp_wrong
 ```
 
 ```
-## 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
+## false
 ```
 The problem lies with the fact that
-when using '==' we are comparing expression (:a + :b) to expression :z with '=='.  When this 
+when using '==' we are comparing expression (R[:a] + R[:b]) to expression R[:z] with '=='.  When this 
 comparison is executed, the system tries to evaluate :a, :b and :z, and those symbols, at 
 this time, are not bound to anything giving the "object 'a' not found" message.
 
@@ -350,8 +335,8 @@ the function to be part of the expression, we call the function preceeding it
 by the letter E, such as 'E.sin(x)'
 
 
-```ruby
-exp7 = :y.assign E.sin(:x)
+``` ruby
+exp7 = R[:y].assign E.sin(R[:x])
 puts exp7
 ```
 
@@ -361,8 +346,8 @@ puts exp7
 Function expressions can also be written using '.' notation:
 
 
-```ruby
-exp8 = :y.assign :x.sin
+``` ruby
+exp8 = R[:y].assign R[:x].sin
 puts exp8
 ```
 
@@ -374,8 +359,8 @@ the R concatenate function 'c', that concatenates two or more arguments can be p
 an expression as:
 
 
-```ruby
-exp9 = :x.c(:y)
+``` ruby
+exp9 = R[:x].c(R[:y])
 puts exp9
 ```
 
@@ -394,19 +379,19 @@ can be evaluated by calling function 'eval' with a binding.
 A binding can be provided with a list or a data frame as shown below:
 
 
-```ruby
-exp = (:a + :b) * 2.0 + :c ** 2 / :z
+``` ruby
+exp = (R[:a] + R[:b]) * 2.0 + R[:c] ** 2 / R[:z]
 puts exp.eval(R.list(a: 10, b: 20, c: 30, z: 40))
 ```
 
 ```
-## [1] 82.5
+## [1] 72.5
 ```
 
 with a data frame:
 
 
-```ruby
+``` ruby
 df = R.data__frame(
   a: R.c(1, 2, 3),
   b: R.c(10, 20, 30),
@@ -417,7 +402,7 @@ puts exp.eval(df)
 ```
 
 ```
-## [1] 32 64 96
+## [1] 31 62 93
 ```
 
 # Using Galaaz to call R functions
@@ -433,7 +418,7 @@ with 'R.'.  For instance, to create a vector in R, the 'c' function is used. In
 vector can be created by using 'R.c':
 
 
-```ruby
+``` ruby
 vec = R.c(1.0, 2, 3)
 puts vec
 ```
@@ -444,7 +429,7 @@ puts vec
 A list is created in R with the 'list' function, so in Galaaz we do:
 
 
-```ruby
+``` ruby
 list = R.list(a: 1.0, b: 2, c: 3)
 puts list
 ```
@@ -462,7 +447,7 @@ puts list
 Note that we can use named arguments in our list.  The same code in R would be:
 
 
-```r
+``` r
 lst = list(a = 1, b = 2L, c = 3L)
 print(lst)
 ```
@@ -482,8 +467,8 @@ the expression $y = sin(45^\circ)$, which is $y = 0.850...$.  In this case,
 we will use 'R.sin':
 
 
-```ruby
-exp10 = :y.assign R.sin(45)
+``` ruby
+exp10 = R[:y].assign R.sin(45)
 puts exp10
 ```
 
@@ -501,42 +486,17 @@ Transportation Statistics.
 Let's start by taking a look at this dataset:
 
 
-```ruby
+``` ruby
 R.library('nycflights13')
 # check it's dimension
-puts ~:flights.dim
+puts ~R[:flights].dim
 # and the structure
-~:flights.str
+~R[:flights].str
 ```
 
 ```
-## Message:
-##  Method ~ not found in R environment
-```
-
-```
-## Message:
-##  /home/rbotafogo/desenv/galaaz/lib/R_interface/rsupport.rb:90:in `eval'
-## /home/rbotafogo/desenv/galaaz/lib/R_interface/rsupport.rb:270:in `exec_function_name'
-## /home/rbotafogo/desenv/galaaz/lib/R_interface/robject.rb:166:in `method_missing'
-## /home/rbotafogo/desenv/galaaz/lib/util/exec_ruby.rb:105:in `get_binding'
-## /home/rbotafogo/desenv/galaaz/lib/util/exec_ruby.rb:102:in `eval'
-## /home/rbotafogo/desenv/galaaz/lib/util/exec_ruby.rb:102:in `exec_ruby'
-## /home/rbotafogo/desenv/galaaz/lib/gknit/knitr_engine.rb:650:in `block in initialize'
-## /home/rbotafogo/desenv/galaaz/lib/R_interface/ruby_callback.rb:77:in `call'
-## /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'
-## /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>'
-## unknown.r:1:in `<no source>'
-## <REPL>:4:in `<repl wrapper>'
-## <REPL>:1
+## ~(dim(flights))
+## <environment: 0x5f0b6a5b7790>
 ```
 
 Now, let's use a first verb of _dplyr_: 'filter'. This verb, obviously, will filter the data
@@ -549,34 +509,34 @@ The second and third arguments are expressions that will be used by the filter f
 filter by columns, looking for entries in which the month and day are equal to 1.
 
 
-```ruby
-puts R.filter(:flights, (:month.eq 1), (:day.eq 1))
+``` ruby
+puts R.filter(:flights, (R[:month].eq 1), (R[:day].eq 1))
 ```
 
 ```
-## # A tibble: 842 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
-##  7  2013     1     1      555            600        -5      913
-##  8  2013     1     1      557            600        -3      709
-##  9  2013     1     1      557            600        -3      838
-## 10  2013     1     1      558            600        -2      753
-## # … with 832 more rows, and 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>
+## # A tibble: 842 × 19
+##     year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+##    <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
+##  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
+##  7  2013     1     1      555            600        -5      913            854
+##  8  2013     1     1      557            600        -3      709            723
+##  9  2013     1     1      557            600        -3      838            846
+## 10  2013     1     1      558            600        -2      753            745
+## # ℹ 832 more rows
+## # ℹ 11 more variables: 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>
 ```
 
 
 ## Programming with _dplyr_: problems and how to solve them in Galaaz
 
-In this section we look at the list of problems that Hardley describes in the "Programming with dplyr"
+In this section we look at the list of problems that Hadley describes in the "Programming with dplyr"
 vignette and show how those problems are solved and coded with Galaaz. Readers interested in
 how those problems are treated in _dplyr_ should read the vignette and use it as a comparison with
 this blog.
@@ -590,7 +550,7 @@ functions that have a '.' in them, we need to substitute the '.' with '__'. So,
 'data.frame' in R, is called in Galaaz as 'R.data\_\_frame':
 
 
-```ruby
+``` ruby
 df = R.data__frame(x: (1..3), y: (3..1))
 puts df
 ```
@@ -608,16 +568,16 @@ by using dot notation.
 
 -------FIX---------
 
-We prefer to use dot notation as shown bellow.  The argument to 'filter' should be an 
+We prefer to use dot notation as shown below.  The argument to 'filter' should be an 
 expression. Note that if we gave to filter a Ruby expression such as
 'x == 1', we would get an error, since there is no variable 'x' defined and if 'x' was a variable
 then 'x == 1' would either be 'true' or 'false'. Our goal is to filter our data frame returning
-all rows in which the 'x' value is equal to 1. To express this we want: ':x.eq 1', where :x will
+all rows in which the 'x' value is equal to 1. To express this we want: 'R[:x].eq 1', where :x will
 be interpreted by filter as the 'x' column.
 
 
-```ruby
-puts df.filter(:x.eq 1)
+``` ruby
+puts df.filter(R[:x].eq 1)
 ```
 
 ```
@@ -629,21 +589,21 @@ In R, and when coding with 'tidyverse', arguments to a function are usually not
 object that you’ve defined elsewhere. In other words, this code
 
 
-```r
+``` r
 my_var <- x
 filter(df, my_var == 1)
 ```
 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 the error "object 'x' not found" 
+code below.  Note initially that 'my_var = R[:x]' will not give the error "object 'x' not found" 
 since ':x' is treated as an expression and assigned to my\_var. Then when doing (my\_var.eq 1), 
-my\_var is a variable that resolves to ':x' and it becomes equivalent to (:x.eq 1) which is
+my\_var is a variable that resolves to ':x' and it becomes equivalent to (R[:x].eq 1) which is
 what we want.
 
 
-```ruby
-my_var = :x
+``` ruby
+my_var = R[:x]
 puts df.filter(my_var.eq 1)
 ```
 
@@ -651,7 +611,7 @@ puts df.filter(my_var.eq 1)
 ##   x y
 ## 1 1 3
 ```
-As stated by Hardley
+As stated by Hadley
 
 > dplyr code is ambiguous. Depending on what variables are defined where, 
 > filter(df, x == y) could be equivalent to any of:
@@ -663,18 +623,18 @@ df[x == df$y, ]
 df[x == y, ]
 ```
 In galaaz this ambiguity does not exist, filter(df, x.eq y) is not a valid expression as 
-expressions are build with symbols.  In doing filter(df, :x.eq y) we are looking for elements
+expressions are build with symbols.  In doing filter(df, R[:x].eq y) we are looking for elements
 of the 'x' column that are equal to a previously defined y variable.  Finally in 
-filter(df, :x.eq :y) we are looking for elements in which the 'x' column value is equal to
+filter(df, R[:x].eq R[:y]) we are looking for elements in which the 'x' column value is equal to
 the 'y' column value. This can be seen in the following two chunks of code:
 
 
-```ruby
+``` ruby
 y = 1
 x = 2
 
 # looking for values where the 'x' column is equal to the 'y' column
-puts df.filter(:x.eq :y)
+puts df.filter(R[:x].eq R[:y])
 ```
 
 ```
@@ -683,10 +643,10 @@ puts df.filter(:x.eq :y)
 ```
 
 
-```ruby
+``` ruby
 # looking for values where the 'x' column is equal to the 'y' variable
 # in this case, the number 1
-puts df.filter(:x.eq y)
+puts df.filter(R[:x].eq y)
 ```
 
 ```
@@ -718,18 +678,19 @@ Unfortunately, in R, this function can fail silently if one of the variables isn
 in the data frame, but is present in the global environment.  We will not go through here how
 to solve this problem in R.
 
-In Galaaz the method mutate_y bellow will work fine and will never fail silently.
+In Galaaz the method mutate_y below will work fine and will never fail silently.
 
 
-```ruby
+``` ruby
 def mutate_y(df)
-  df.mutate(:y.assign :a + :x)
+  # Mutate column names are Ruby kwargs (y: …). Use .assign only for R `<-` expressions.
+  df.mutate(y: R[:a] + R[:x])
 end
 ```
 Here we create a data frame that has only one column named 'x':
 
 
-```ruby
+``` ruby
 df1 = R.data__frame(x: (1..3))
 puts df1
 ```
@@ -742,33 +703,29 @@ puts df1
 ```
 
 Note that method mutate_y will fail independetly from the fact that variable 'a' is defined and
-in the scope of the method.  Variable 'a' has no relationship with the symbol ':a' used in the
+in the scope of the method.  Variable 'a' has no relationship with the symbol `R[:a]` used in the
 definition of 'mutate\_y' above:
 
 
-```ruby
+``` ruby
 a = 10
 mutate_y(df1)
 ```
 
 ```
-## Message:
-##  Error in mutate_impl(.data, dots) :
-##   Evaluation error: object 'a' not found.
-## In addition: Warning message:
-## In mutate_impl(.data, dots) :
-##   mismatched protect/unprotect (unprotect with empty protect stack) (RError)
-## Translated to internal error
+## Error: ℹ In argument: `y = a + x`.
+## Caused by error:
+## ! object 'a' not found
 ```
 ## Different expressions
 
-Let's move to the next problem as presented by Hardley where trying to write a function in R 
+Let's move to the next problem as presented by Hadley where trying to write a function in R 
 that will receive two argumens, the first a variable and the second an expression is not trivial.
-Bellow we create a data frame and we want to write a function that groups data by a variable and
+Below we create a data frame and we want to write a function that groups data by a variable and
 summarises it by an expression:
 
 
-```r
+``` r
 set.seed(123)
 
 df <- data.frame(
@@ -790,7 +747,7 @@ as.data.frame(df)
 ## 5  2  1 1 4
 ```
 
-```r
+``` r
 d2 <- df %>%
   group_by(g1) %>%
   summarise(a = mean(a))
@@ -804,7 +761,7 @@ as.data.frame(d2)
 ## 2  2 3.333333
 ```
 
-```r
+``` r
 d2 <- df %>%
   group_by(g2) %>%
   summarise(a = mean(a))
@@ -818,10 +775,10 @@ as.data.frame(d2)
 ## 2  2 3
 ```
 
-As shown by Hardley, one might expect this function to do the trick:
+As shown by Hadley, one might expect this function to do the trick:
 
 
-```r
+``` r
 my_summarise <- function(df, group_var) {
   df %>%
     group_by(group_var) %>%
@@ -834,24 +791,25 @@ my_summarise <- function(df, group_var) {
 
 In order to solve this problem, coding with dplyr requires the introduction of many new concepts
 and functions such as 'quo', 'quos', 'enquo', 'enquos', '!!' (bang bang), '!!!' (triple bang). 
-Again, we'll leave to Hardley the explanation on how to use all those functions.
+Again, we'll leave to Hadley the explanation on how to use all those functions.
 
 Now, let's try to implement the same function in galaaz.  The next code block first prints the
-'df' data frame define previously in R (to access an R variable from Galaaz, we use the tilda 
+'df' data frame defined previously in R (to access an R variable from Galaaz, we use the tilde 
 operator '~' applied to the R variable name as symbol, i.e., ':df'.  We then create the 
 'my_summarize' method and call it passing the R data frame and the group by variable ':g1':
 
 
-```ruby
-puts ~:df
-print "\n"
+``` ruby
+puts ~R[:df]
+print "
+"
 
 def my_summarize(df, group_var)
   df.group_by(group_var).
-    summarize(a: :a.mean)
+    summarize(a: R[:a].mean)
 end
 
-puts my_summarize(:df, :g1)
+puts my_summarize(~R[:df], R[:g1])
 ```
 
 ```
@@ -862,7 +820,7 @@ puts my_summarize(:df, :g1)
 ## 4  2  2 4 5
 ## 5  2  1 1 4
 ## 
-## # A tibble: 2 x 2
+## # A tibble: 2 × 2
 ##      g1     a
 ##   <dbl> <dbl>
 ## 1     1  2.5 
@@ -871,12 +829,12 @@ puts my_summarize(:df, :g1)
 It works!!! Well, let's make sure this was not just some coincidence
 
 
-```ruby
-puts my_summarize(:df, :g2)
+``` ruby
+puts my_summarize(~R[:df], R[:g2])
 ```
 
 ```
-## # A tibble: 2 x 2
+## # A tibble: 2 × 2
 ##      g2     a
 ##   <dbl> <dbl>
 ## 1     1     3
@@ -892,7 +850,7 @@ In the previous section we've managed to get rid of all NSE formulation for a si
 does this remain true for more complex examples, or will the Galaaz way prove inpractical for
 more complex code?
 
-In the next example Hardley proposes us to write a function that given an expression such as 'a'
+In the next example Hadley proposes us to write a function that given an expression such as 'a'
 or 'a * b', calculates three summaries.  What we want a function that does the same as these R
 statements:
 
@@ -913,7 +871,7 @@ summarise(df, mean = mean(a * b), sum = sum(a * b), n = n())
 Let's try it in galaaz:
 
 
-```ruby
+``` ruby
 def my_summarise2(df, expr)
   df.summarize(
     mean: E.mean(expr),
@@ -922,8 +880,8 @@ def my_summarise2(df, expr)
   )
 end
 
-puts my_summarise2((~:df), :a)
-puts my_summarise2((~:df), :a * :b)
+puts my_summarise2((~R[:df]), :a)
+puts my_summarise2((~R[:df]), R[:a] * R[:b])
 ```
 
 ```
@@ -938,7 +896,7 @@ careful about is the use of 'E' to build expressions from functions 'mean', 'sum
 
 ## Different input and output variable
 
-Now the next challenge presented by Hardley is to vary the name of the output variables based on 
+Now the next challenge presented by Hadley is to vary the name of the output variables based on 
 the received expression.  So, if the input expression is 'a', we want our data frame columns to
 be named 'mean\_a' and 'sum\_a'.  Now, if the input expression is 'b', columns
 should be named 'mean\_b' and 'sum\_b'.
@@ -964,13 +922,13 @@ mutate(df, mean_b = mean(b), sum_b = sum(b))
 #> 4     2     2     5     4      3    15
 #> # … with 1 more row
 ```
-In order to solve this problem in R, Hardley needs to introduce some more new functions and notations:
+In order to solve this problem in R, Hadley needs to introduce some more new functions and notations:
 'quo_name' and the ':=' operator from package 'rlang'
 
 Here is our Ruby code:
 
 
-```ruby
+``` ruby
 def my_mutate(df, expr)
   mean_name = "mean_#{expr.to_s}"
   sum_name = "sum_#{expr.to_s}"
@@ -979,8 +937,8 @@ def my_mutate(df, expr)
             sum_name => E.sum(expr))
 end
 
-puts my_mutate((~:df), :a)
-puts my_mutate((~:df), :b)
+puts my_mutate((~R[:df]), :a)
+puts my_mutate((~R[:df]), :b)
 ```
 
 ```
@@ -1007,25 +965,25 @@ and variable mean\_name is not followed by ':' but by '=>'.  This is standard Ru
 
 ## Capturing multiple variables
 
-Moving on with new complexities, Hardley proposes us to solve the problem in which the 
+Moving on with new complexities, Hadley proposes us to solve the problem in which the 
 summarise function will receive any number of grouping variables.
 
 This again is quite standard Ruby.  In order to receive an undefined number of paramenters
 the paramenter is preceded by '*':
 
 
-```ruby
+``` ruby
 def my_summarise3(df, *group_vars)
   df.group_by(*group_vars).
     summarise(a: E.mean(:a))
 end
 
-puts my_summarise3((~:df), :g1, :g2)
+puts my_summarise3((~R[:df]), :g1, :g2)
 ```
 
 ```
-## # A tibble: 4 x 3
-## # Groups:   g1 [?]
+## # A tibble: 4 × 3
+## # Groups:   g1 [2]
 ##      g1    g2     a
 ##   <dbl> <dbl> <dbl>
 ## 1     1     1     3
@@ -1049,7 +1007,7 @@ In Ruby, there is no lazy evaluation of parameters and 'a' is always a variable
 Variables assume their value as soon as they are used, so 'x = a' is immediately evaluate and 
 variable 'x' will receive the value of variable 'a' as soon as the Ruby statement is executed. 
 Ruby also provides the notion of a symbol; ':a' is a symbol and does not evaluate to anything.
-Galaaz uses Ruby symbols to build expressions that are not bound to anything: ':a.eq :b' is
+Galaaz uses Ruby symbols to build expressions that are not bound to anything: 'R[:a].eq R[:b]' is
 clearly an expression and has no relationship whatsoever with the statment 'a = b'. By using
 symbols, variables and expressions all the possible ambiguities that are found in R are 
 eliminated in Galaaz.
@@ -1059,7 +1017,7 @@ of input they are expecting, they might be expecting regular variables or they m
 expecting expressions and the R function will know how to deal with an input of the form 
 'a = b', now for the Ruby developer it might not be immediately clear if it 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'.
+call the function passing the expression 'R[:a].eq R[:b]'.
 
 
 # Advanced dplyr features
@@ -1082,28 +1040,28 @@ In the following examples, we show the use of functions 'group\_by\_at', 'summar
 features of characters in the Starwars movies:
 
 
-```ruby
-puts (~:starwars).head
+``` ruby
+puts (~R[:starwars]).head
 ```
 
 ```
-## # 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>,
+## # A tibble: 6 × 14
+##   name      height  mass hair_color skin_color eye_color birth_year sex   gender
+##   <chr>      <int> <dbl> <chr>      <chr>      <chr>          <dbl> <chr> <chr> 
+## 1 Luke Sky…    172    77 blond      fair       blue            19   male  mascu…
+## 2 C-3PO        167    75 <NA>       gold       yellow         112   none  mascu…
+## 3 R2-D2         96    32 <NA>       white, bl… red             33   none  mascu…
+## 4 Darth Va…    202   136 none       white      yellow          41.9 male  mascu…
+## 5 Leia Org…    150    49 brown      light      brown           19   fema… femin…
+## 6 Owen Lars    178   120 brown, gr… light      blue            52   male  mascu…
+## # ℹ 5 more variables: homeworld <chr>, species <chr>, films <list>,
 ## #   vehicles <list>, starships <list>
 ```
-The grouped_mean function bellow will receive a grouping variable and calculate summaries for
+The grouped_mean function below will receive a grouping variable and calculate summaries for
 the value\_variables given:
 
 
-```r
+``` r
 grouped_mean <- function(data, grouping_variables, value_variables) {
   data %>%
     group_by_at(grouping_variables) %>%
@@ -1114,7 +1072,22 @@ grouped_mean <- function(data, grouping_variables, value_variables) {
 
 gm = starwars %>% 
    grouped_mean("eye_color", c("mass", "birth_year"))
+```
 
+```
+## Warning: `funs()` was deprecated in dplyr 0.8.0.
+## ℹ Please use a list of either functions or lambdas:
+## 
+## # Simple named list: list(mean = mean, median = median)
+## 
+## # Auto named with `tibble::lst()`: tibble::lst(mean, median)
+## 
+## # Using lambdas list(~ mean(., trim = .2), ~ median(., na.rm = TRUE))
+## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
+## generated.
+```
+
+``` r
 as.data.frame(gm)   
 ```
 
@@ -1140,20 +1113,20 @@ as.data.frame(gm)
 The same code with Galaaz, becomes:
 
 
-```ruby
+``` ruby
 def grouped_mean(data, grouping_variables, value_variables)
   data.
     group_by_at(grouping_variables).
     mutate(count: E.n).
-    summarise_at(E.c(value_variables, "count"), ~:mean, na__rm: true).
+    summarise_at(E.c(value_variables, "count"), R[:mean], na__rm: true).
     rename_at(value_variables, E.funs(E.paste0("mean_", value_variables)))
 end
 
-puts grouped_mean((~:starwars), "eye_color", E.c("mass", "birth_year"))
+puts grouped_mean((~R[:starwars]), "eye_color", E.c("mass", "birth_year"))
 ```
 
 ```
-## # A tibble: 15 x 4
+## # A tibble: 15 × 4
 ##    eye_color     mean_mass mean_birth_year count
 ##    <chr>             <dbl>           <dbl> <dbl>
 ##  1 black              76.3            33      10
@@ -1175,17 +1148,13 @@ puts grouped_mean((~:starwars), "eye_color", E.c("mass", "birth_year"))
 
 # Further reading
 
-For more information on GraalVM, TruffleRuby, fastR, R and Galaaz check out the following sites/posts:
-
-* [GraalVM Home](https://www.graalvm.org/)
-* [TruffleRuby](https://github.com/oracle/truffleruby)
-* [FastR](https://github.com/oracle/fastr)
-* [Faster R with FastR](https://medium.com/graalvm/faster-r-with-fastr-4b8db0e0dceb)
-* [How to make Beautiful Ruby Plots with Galaaz](https://medium.freecodecamp.org/how-to-make-beautiful-ruby-plots-with-galaaz-320848058857)
-* [Ruby Plotting with Galaaz: An example of tightly coupling Ruby and R in GraalVM](https://towardsdatascience.com/ruby-plotting-with-galaaz-an-example-of-tightly-coupling-ruby-and-r-in-graalvm-520b69e21021)
+* [JRuby](https://www.jruby.org/) — Ruby on the JVM (Galaaz 2.0)
+* [How to make Beautiful Ruby Plots with Galaaz](https://medium.freecodecamp.org/how-to-make-beautiful-ruby-plots-with-galaaz-320848058857) (plots; narrative partly pre-2.0)
+* [Ruby Plotting with Galaaz in GraalVM](https://towardsdatascience.com/ruby-plotting-with-galaaz-an-example-of-tightly-coupling-ruby-and-r-in-graalvm-520b69e21021) (older stack; ideas still useful)
 * [How to do reproducible research in Ruby with gKnit](https://towardsdatascience.com/how-to-do-reproducible-research-in-ruby-with-gknit-c26d2684d64e)
 * [R for Data Science](https://r4ds.had.co.nz/)
 * [Advanced R](https://adv-r.hadley.nz/)
+* Historical context: [GraalVM](https://www.graalvm.org/), [TruffleRuby](https://github.com/oracle/truffleruby), [FastR](https://github.com/oracle/fastr)
 
 # Conclusion