Ross Ihaka

Have you looked at a field recently? Spot the flowers: https://wallpapercave.com/field-of-flowers-wallpaper - I'm not sure what you call colourful; but I call those colourful. The flowers are still hard to miss. The colour makes them more obvious. If you want a more academic source; try https://www.stat.auckland.ac.nz/~ihaka/courses/120/Lectures/lecture12.… slides 13 & 14. Colour isn't some random distraction, the human vision system uses it to help decide what to focus on. Then you get things like peacocks where they go all in on using colourful visualisations to attract attention.

Is it clear people wanted to get away from Lisp rather than use a more-or-less clone of S? (One of R's originators did propose moving back to a Lisp base [1], though part of the justification was HPC, which is now at least partially covered [2].) However, much as I like Lisp, I do want a mixfix syntax for interactive use like R, but something CGOL-ish is easy enough; I don't remember xlisp-stat having something like that. 1. https://www.stat.auckland.ac.nz/~ihaka/downloads/Compstat-2008.pdf 2. https://pbdr.org

Accessing the code part and modifying during execution is actually rather easy in R. Functions such as substitute or quote are commonly used and a language expression in R is a list that you can edit and evaluate back. The internals itself in R actually sound quite lispy: both values and codes are SEXP (S-expressions). R is inspired by Scheme and Common Lisp; it has first-class functions, multiple dispatch. https://www.stat.auckland.ac.nz/~ihaka/downloads/Interface98.pdf "This decision, more than anything else, has driven the direction that R development has taken. As noted above, there are quite strong similarities between Scheme and S, and the adoption of the S syntax for our interpreter produced something which “felt” remarkably close to S."

R language has many quirks. Here was an effort to list them: https://www.burns-stat.com/pages/Tutor/R_inferno.pdf Also, the author of R language said the performance of R is sub-optimal. In his own words: https://www.stat.auckland.ac.nz/~ihaka/downloads/JSM-2010.pdf Currently I am using PyCharm with R plugin that JetBrains released very recently. R Studio is very slow and buggy.

Note: this paper is from 2010 and he has been making similar statements since 2008 (https://www.stat.auckland.ac.nz/~ihaka/?Papers_and_Talks) Giving the timing, I'm interested in what he might think of Julia, which seems to have reaches a similar conclusion - statisticians need a new tool.

According to an article published in 1996 by Ihaka and Gentleman: “The work has been heavily influenced by two existing languages-Becker, Chambers, and Wilks' S (1985) and Steel and Sussman's Scheme (1975). We felt that there were strong points in each of these languages and that it would be interesting to see if the strengths could be combined. The resulting language is very similar in appearance to S, but the underlying implementation and semantics are derived from Scheme. In fact, we implemented the language by first writing an interpreter for a Scheme subset and then progressively mutating it to resemble S.” (https://www.stat.auckland.ac.nz/~ihaka/downloads/R-paper.pdf) Unfortunately R’s gain was LispStat’s loss: https://www.jstatsoft.org/issue/view/v013

See also: Back to the Future: Lisp as a Base for a Statistical Computing System https://www.stat.auckland.ac.nz/~ihaka/downloads/Compstat-2008.pdf

Ros Ihaka actually suggested rewriting R in Common Lisp. https://www.stat.auckland.ac.nz/~ihaka/downloads/Compstat-2008.pdf

For contex, Ross Ihaka is one of the original authors of R. This date back to 2008. Also see Ross Ihaka's 2010 paper: https://www.stat.auckland.ac.nz/~ihaka/downloads/JSM-2010.pdf

> > Indeed, it is a variant of S with lexical scoping to make large code bases cleaner > I have no clue where he's getting this. The original S language from the Bell Labs (and the commercial version S-PLUS) used dynamic scoping (like Emacs lisp). https://www.stat.auckland.ac.nz/~ihaka/downloads/lexical.pdf

It is mentioned on page 2: "However, the case of the R programming language is particularly interesting, because initially it was just a harmless implementation of Scheme; but then as a result of the irresponsible experiments of mad scientists it mutated into a monster [3].", where [3] is the link to https://www.stat.auckland.ac.nz/~ihaka/downloads/JSM-2010.pdf

I've always found it a bit depressing that Lisp-Stat died, and Incanter became stagnant. Ross Ihaka, one of R's creators recognised a Lisp-based solution is the way to go. Interestingly, even R is borrowing some ideas from Scheme. https://www.stat.auckland.ac.nz/~ihaka/downloads/Compstat-2008.pdf

I don't really see the point of this article. You don't need Fortran or C to implement the calculations of the Fibonacci as described in the article. On top of that the article is missing the point that some elements functional programming (map, lambda) are actually making a numerical implementation neater. It is not an accident that the original authors of R were themselves lispers and admitted having been inspired by lisp when creating R. I think among others, those links will illustrate the previous point: http://cran.r-project.org/doc/html/interface98-paper/paper.html http://www.stat.auckland.ac.nz/~ihaka/downloads/Compstat-2008.pdf

Author here. Lisp-Stat is no April's fool's joke. The project is real and only a coincidence that it was mentioned here shortly before 1st of April. The Overview [1] and About [2] pages provide the best background to the project. Also see Tierney's paper, Back to the Future: Lisp as a Base for a Statistical Computing System [3] Although inspired by Tierney's XLisp-Stat, this is a reboot in Common Lisp. XLisp-Stat code is unlikely to run except in trivial cases, but existing XLisp-Stat libraries can be ported with the assistance of the XLS-Compat [4] system. One of the goals was to make porting easier so as to have a ready-made eco-system of sorts. To that end I've also collected all the XLS code that is still readily available and put that on github. A summary of what's there is available on the website [5]. In developing the system, I wanted to avoid the 'lisp curse' [6] and picked existing libraries where possible, developed what didn't exist, and documented them all in an attempt to make the learning curve somewhat less steep. It's now to the point where I can use it in my own work and thought the broader CL community might find it useful. [1] https://lisp-stat.dev/docs/overview/ [2] https://lisp-stat.dev/about [3] https://www.stat.auckland.ac.nz/~ihaka/downloads/Compstat-2008.pdf [4] https://github.com/Lisp-Stat/XLS-compat [5] https://lisp-stat.dev/docs/contributing/xlisp/ [6] http://www.winestockwebdesign.com/Essays/Lisp_Curse.html

If you're going to try to do practical things in Common Lisp, make sure you get well acquainted with quicklisp, for easy library installation, and http://www.cliki.net/ for finding out about half of those libraries. I say you have/will want to do a lot yourself, but you don't have to do it all. Be aware that SICP is written for Scheme. They're both lisp dialects, but they are different. I've done bits of it here and there in Common Lisp, but the two variable namespaces, no first class continuations, different function names, less emphasis on recursion (due to specific iteration forms/macros in Common lisp) and native efficient data structures offered by common lisp might make some things non-applicable or difficult even if you're already familiar with the language. Tail call optimization is, i believe, not required in the Common Lisp standard, but I believe SBCL performs it, at least above certain low optimization declarations. I've only just started looking at multi-threading in Common Lisp myself. I imagine the proper answer about "mature" parellelization is no, relative to some other languages (i have no real basis for this, just side-knowledge that other languages focus on such issues more. Hell, its probably better than R.). Multi-threading is not established in the language specification, but in practice, implementations have their own version of it, including SBCL, which is the version I'm sticking to for numerical work. If you're looking into it, I believe…