Syllabus ordering

[colinleach]

In PR #416 (comment) there was a suggestion that vectors should be moved up before booleans.

Currently non-obvious how we do this? The question should certainly be revisited once more of the syllabus is in place, and we can see how it fits together.

[depial]

From what I gather booleans (i.e. logical) are atomic vectors (along with integer, double, and character).

Ideally we could have an abstract conversation how these and other items that are vectors and how they fit together, but that's probably too heavy for a start, especially since I'm reading about it in Advanced R.

One idea: Maybe the concept of atomic vector could be introduced with booleans as a theoretical aside. I suppose this could also be introduced with numbers or just back reference numbers in the discussion in booleans. This way we don't have to shoehorn in list vectors too early, which could overwhelm students.

In other words, one solution is to mention the vector dependent structure of the language early and then keep an undercurrent of references back to it as novel examples pop up. Plant the seed and let it grow.

[depial]

Another possible addition to the syllabus: Vectorization

Since this is such a fundamental aspect of the language, it might have enough material for its own concept. This could come somewhere after Vectors.

Alternatively, it could be blended with another concept (e.g. vectors or sapply-lapply).

[colinleach]

I think vectorization is really a generalization of the apply functions (there are lots...). Expanding that concept could work well, but it needs to wait until after lists (a very common return type from these operations).

[depial]

I think the aspect I was thinking of is how ubiquitous it appears to be in Base R. It seems like there are many functions that are inherently vectorized.

Again, this is going on my current "feeling" for the language. Initially I felt like R vectorized everything, Python did nothing, and Julia fell somewhere in the happy middle. I accept that is likely hyperbole though ;)

[colinleach]

I felt like R vectorized everything, Python did nothing, and Julia fell somewhere in the happy middle

Almost true, but not quite that simple. R needs the apply functions (kind of like map(), Python does nothing in the core language but we all use NumPy.

[BethanyG]

Again, this is going on my current "feeling" for the language. Initially I felt like R vectorized everything, Python did nothing, and Julia fell somewhere in the happy middle. I accept that is likely hyperbole though ;)

• R was built for statistics and not GP programming. I don't think there are web frameworks for R (I could be wrong tho!)
• Julia was built as a GP programming language with particular focus on scientific computing, high performance, and multiple dispatch. It's got great libs for that - but has gaps for other things.
• Python focused on GP programming ("batteries included"), dynamic typing, and ease of learning. It tried to be 80% of what most programmers wanted on most things .... circa 1991. So it has a bit of everything, but is sorta expert and none (like its sisters Java and Ruby).

So as Colin said: "we all use NumPy". And I would add "we all use add-on libraries to Python when we need deep/expert specialization." 😆

[colinleach]

I don't think there are web frameworks for R

Nothing in the Rails, Django, Flask mode, AFAIK. In line with its data science slant, R was early in the data dashboard world, ahead of the likes of Streamlit. And of course Shiny was popular on R well before they wrote the Python version.

Horses for courses. Just like the Elixir fans sneer at anyone trying to scale a high-performance webserver in anything but Phoenix.

[depial]

Yeah, for the "Python does nothing", I did mean base Python and it's there that I really started to learn how to program (after a false-start with C++ a decade earlier). I was happy when I got into Numpy and found vectorize and such when learning ML stuff.

For R, I think I'm stuck thinking about Base R stuff like paste and ifelse which are inherently vectorized (not to mention math operations natively broadcasting across vectors). This took a bit of rewiring to grasp after coming from Python, but I ended up using it in a lot of my programming exercise solutions (e.g.), so I might have ended up inflating its importance in my mind.