R Syllabus: Late May Update

[colinleach]

Continues #492.

I am trying to get this moving again, after a planned pause for visitors and an unplanned 2-week brain outage (the latter hopefully coming to an end?). It's an arbitrary deadline, but I would really like to get something (even if clearly incomplete) out to students by the end of June.

There are quite a few things in progress: draft concepts with no exercise, plus some incomplete drafts I need to finish and PR. That was deliberate (honestly!): I've been learning a lot along the way, and my thinking has changed as I write the concept drafts.

	Concept	Exercise
basics	✔️	✔️
booleans	✔️	✔️
conditionals	✔️	✔️
vectors	✔️	✔️
vector-filtering	✔️	✔️
vector-functions	✔️	✔️
strings	✔️	✔️
nothingness	✔️	✔️
errors	✔️	✔️
names-attribute	✔️	✔️
lists	✔️	✔️
switch	✔️	✔️
loops	✔️	✔️
set-operations	✔️	✔️
randomness	✔️	✔️
complex-numbers	#390	non-urgent
functions	#493	exercise ideas needed!
functional-programming	#501	maybe cheese-club?
dates-times	✔️	✔️
matrices-arrays	✔️	concept-only
dataframes	#506	exercise ideas needed!
factors	wip	??
classes	wip	concept-only
regular-expressions	✔️	✔️

We'll also need regular-expressions with regular-chatbot at some point (boring, but shouldn't be too difficult).

I'm starting to think about one or more concepts lumped under data-operations. That's open-ended: it could turn into a complete R translation of Pandas Workout and Pandas in Action, given that tibbles have pretty much the same range of functionality!

More realistically, I'm looking to start with:

• Basic readr stuff, probably limited to not much more than read_csv().
• Basic tidyr stuff, such as pivot_longer() and pivot_wider().
• group_by operations.
• Simple relational joins between tables.

All that can be done within the test runner, as currently configured.

Put together, it might look roughly like this flowchart

Thinking about the critical path:

• To me, Dataframes are absolutely central to modern R: much more now than 20 years ago. It's as if Python was just a scripting language for Pandas!
• That means we need a sequence of three concepts, with exercises, before launch:
  1. Functions
  2. Functional Programming
  3. Dataframes

The rest can be added later, if necessary.

Thoughts?

[depial]

I'm still dealing with a brain-outage of my own, but it's entering its second week, so hopefully it'll be over soon?

Your ideas look good to me. The only thing I can immediately comment on is that I'm not a fan of exercism-matrix since it's hovering around 75% completion on the Julia track. That said, I think I would prefer to have something, so that the concept is visible on the syllabus, but that is not a strong preference.

I'll try to do some type of re-onboarding this week to get back up to speed on what we need to do here (and the Julia track), so I can comment more intelligently. If food helps brain, I'll try to take a look at the Matrices and Arrays concept after lunch. No promises though...

[colinleach]

Good luck! I hope you will make rapid progress in reconnecting the synapses.

For #503, my own view changed since the original PR. I now prefer Concept-only, with no exercise: exercism-matrix is too far from what modern R is about (data! function pipelines!). The main value of the concept is being able to link to it, when discussing (outdated) ways to index into dataframes.

Speaking of which, I'm making progress with the Dataframes concept and hope to PR a draft today or tomorrow. It's really important.

[ai-hustle-bro]

Since the critical path in the issue is Functions -> Functional Programming -> Dataframes, I would be tempted to make those three exercises feel like one small learning arc rather than three unrelated kata.

One possible set of raw exercise ideas:

1. Functions: event-schedule

   • Input: a small vector of event names, start times, and durations.
   • Tasks: write small helpers like finish_time(start, duration), is_long_session(duration), and session_label(name, start, duration).
   • Concept focus: function arguments, return values, defaults, small pure functions, maybe simple vectorisation if the track wants that this early.
   • Why it helps the later path: it creates reusable helpers that can be mapped over records in the next concept.

2. Functional Programming: schedule-cleanup

   • Input: a list of session records, each with name, room, duration, and tags.
   • Tasks: use lapply() / vapply() / anonymous functions to normalise labels, compute finish times, extract tags, and filter sessions.
   • Concept focus: applying functions over lists, avoiding copy-paste loops, choosing a return shape deliberately.
   • Stretch idea: compare a loose lapply() result with a stricter vapply() result so learners see why output shape matters.

3. Dataframes: conference-checkin

   • Input: two tiny data frames: attendees and checkins.
   • Tasks: find missing check-ins, count attendance by session, join attendee names to check-in rows, and produce a simple summary table.
   • Concept focus: selecting columns, filtering rows, joining by an id, grouped summaries.
   • This could be base-R first (merge(), aggregate(), indexing) with a later tidyverse/tibble version if the track wants a separate data-operations concept.

The thing I like about this arc is that it avoids making "functions" feel abstract. The learner first writes small helpers, then applies those helpers over a list, then sees why a rectangular data frame is more convenient once the records become tabular.

If the track wants more R-flavoured context, the same shape could be changed from a conference schedule to lab samples, survey responses, reading logs, or package download records. I would keep the first version mundane; the teaching value is in the data shape, not the story.