Core Learning Objectives

Tiered Scoring

Each objective is scored on a 4 / 5 / 6 point scale based on the quality and independence of your demonstration of the skill.

Points	Label	Description
No grade	No demonstration	You have not yet demonstrated this skill.
4	Meets Expectations	You demonstrate the skill correctly in structured or familiar contexts (for example, following a guided assignment or closely modeled example).
5	Exceeds Expectations	You apply the skill correctly and independently in a novel context, with clear, well-chosen code that would generalize to new datasets or problems.
6	Outstanding	You use the skill in an especially expansive way: combining it with other skills, applying it to a complex or less-structured task, or going beyond the scope of in-class examples.

All three levels (4, 5, 6) are successful demonstrations. If you do not demonstrate a skill at least at the 4-point level, you will not earn credit for that standard.

Earning an average of 5 points per standard will earn you all 60 points. An average lower than 5 points can still result in an ‘A’ grade for the class if you complete enrichment activities.

Each assignment will receive a score for each standard it addresses based on this rubric. Individual assignments may not be resubmitted for a higher score, but you may improve your score for a standard by submitting new assignments that demonstrate that standard at a higher level.

Higher scores always replace lower scores for core standards, so after earning a high score with an impressive assignment, subsequent assignments that use the skill at a more basic level won’t lower your score.

General Grading Guidelines

• It is possible to earn a score without checking off each specific requirement if the overall work clearly demonstrates foundational (4), strong (5), or outstanding (6) skills. These guidelines are intended to give you confidence in your work before submission. They should not be interpreted as perfectly rigid requirements to work against you. If you have met all the expectations listed for a score, you will not earn lower than that score.
• Code failing to execute correctly does not necessarily preclude earning points for an objective. R scripts, code chunks, and knitted documents that do not execute or render as intended may still receive credit if the problems are minor and there is evidence of the objective in other parts of the submission.
• All three levels represent successful demonstrations. No credit is given if the skill is not demonstrated at minimum 4-point level.
• Higher scores always replace lower scores, so students can improve by submitting new work.
• Individual assignments cannot be resubmitted for regrading, but students may submit new assignments demonstrating the same standard at a higher level. In rare cases, students may be invited to correct trivial errors or reattempt assignments following significant misunderstanding.
• The less structured the project, the higher the potential score. Structured projects with extensive scaffolding typically cap at 4-5 points, while unstructured projects can more easily reach 6.

Quarter 1 Core Learning Objectives

The 12 Quarter‑1 core learning objectives are all technical and observable. For each one ask: Is there clear, identifiable code or output that shows this skill?

The objectives are listed (more or less) in the order they are covered in class, but you can demonstrate them in any order.

Quarter 1 | Core Learning Objectives

Objective 1: RStudio + Quarto workflow

Core standard: Create an RStudio project for coursework, use relative paths, and knit simple Quarto documents that combine code and narrative.

Grading Criteria:

Basic Class Expectation, No Points

To fully participate in the class, you need to have simple proficiency with RStudio and Quarto. You are expected to be able to execute the following workflow, separately from the core standard:

• Create an RStudio project (typically by cloning a GitHub Classroom assignment repo)
• Use relative paths to read and write files within your project
• Write a Quarto document that combines code chunks and narrative text
• Knit the .qmd file to an output format (.html, .pdf, or .docx) without errors

4 Points:

• RStudio project created (typically by cloning repo)
• At least 2 chunks have labels and a chunk option (e.g., echo=FALSE)
• Multiple markdown elements used (headings, lists, text styling)
• .qmd knits without errors to .html, .docx, or .pdf
• At least one line of code reads from relative path and one writes to relative path

5 Points:

• All 4-point expectations met
• Reasonable directory structure with at least 2 subdirectories
• All code chunks have labels and at least one chunk option
• At least 2 unique chunk options used purposefully across document
• Markdown formatting, including at least 3 common elements heading levels, lists, text styling, blockquotes, hyperlinks, tables)
• At least 1 YAML header option beyond defaults (e.g., toc, number-sections, theme)
• Produces clean, professional knitted output

6 Points:

• All 5-point expectations met
• Goes beyond in meaningful ways such as:
  • Sophisticated project organization
  • Custom YAML configurations
  • Advanced chunk options
  • Multiple output formats
  • Advanced Quarto features (tabsets, cross-references, custom layouts)
  • Comprehensive documentation, or additional evidence of workflow mastery

Objective 2: GitHub repositories and version control

Core standard: Create and maintain a GitHub repo with README, .gitignore, and a commit history that reflects real work over time.

View the Git & GitHub Submissions Guidelines for detailed instructions on how to complete and submit assignments using GitHub Classroom and private GitHub repositories.

Grading Criteria:

Basic Class Expectation (No points):

To fully participate in the class, you need to have simple proficiency with GitHub Classrooms. You are expected to be able to execute the following Classrooms workflow, separately from the core standard:

• Clone the GitHub Classroom assignment repo to your local machine as an RStudio project
• Complete work in RStudio
• Commit and push changes to the GitHub Classroom assignment repo for submission
• Subscribe to the auto-generated pull request to review grades and communicate with your grader

4 Points:

• GitHub Classroom workflow completed
• README.md added or significantly edited describing assignment and repo structure
• .gitignore added or significantly edited with at least one custom rule that actually ignores something
• At least 3 meaningful commits with descriptive messages reflecting work over time

5 Points:

• All 4-point expectations met
• Dedicated GitHub repository created from scratch (not just cloning Classroom repo)
• Reasonable structure with at least 2 subdirectories with files in each
• Instructor/TA invited as collaborators (if not created in the D2M-R repo)
• Repo set to private
• Feedback branch created with pull request initiated

6 Points:

• All 5-point expectations met
• Goes beyond in meaningful ways such as:
  • Includes many small, meaningful commits across time
  • Uses a complex directory structure appropriately
  • Provides extensive README documentation
  • Uses advanced Git/GitHub features (branching, merging, issues)
  • Uses GitHub for collaborative work on shared repo

Objective 3: Base R syntax and data structures

Core standard: Create, index, and manipulate vectors, lists, and data frames, including handling missing data.

Grading Criteria:

4 Points:

• Creates at least 2 unique types of structures such as variables, vectors, lists, and/or data frames using standard syntax
• Uses at least 1 indexing method to access elements (e.g., vec[1], df$column, list[[1]])
• Performs basic manipulations (e.g., adding elements, subsetting, object assignment and reassignment, etc.)
• If dataset includes missing data, it is handled appropriately

5 Points:

• All 4-point expectations met
• Applies skills to novel dataset or problem not directly modeled in class
• Uses at least 2 indexing methods appropriately (positional, by name, [], $, etc.)
• Handles missing data appropriately, minimally with at least 1 instance of [is.na](http://is.na)() or na.omit() (or more advanced method)
• Code demonstrates clear understanding that would transfer to new situations
• Clean, well-commented code

6 Points:

• All 5-point expectations met
• Combines data structure skills with other techniques in sophisticated ways, e.g.:
  • Works with nested or complex data structures
  • Demonstrates advanced indexing or manipulation techniques
  • Applies skills to particularly complex or unstructured task
  • Works with data structures outside base R and the tidyverse

Objective 4: Control flow (if/else, loops)

Core standard: Use if/else and loops to branch logic and automate repetitive tasks in multiple contexts.

Grading Criteria:

4 Points:

• Uses at least 1 if/else statement or function to create conditional logic
• Uses at least 1 for or while loop for automation (may be very simplistic; may be only one type)
• Uses control flow structures in at least 2 distinct contexts
• Code executes correctly in structured assignments

5 Points:

• All 4-point expectations met
• Applies control flow to novel problems independently
• Uses control flow structures in at least 3 distinct contexts
• Combines if/else and loops effectively (e.g., conditional logic within loops)
• Code is generalizable, well-structured, and clearly commented

6 Points:

• All 5-point expectations met
• Demonstrates advanced applications beyond class examples, e.g.:
  • Implements complex control flow logic
  • Uses function alternatives to standard conditional and loops, like the apply family of functions or the data.table package
  • Nests control structures appropriately for sophisticated tasks
  • Uses vectorized alternatives where appropriate, showing understanding of when loops are/aren’t needed

Objective 5: Defining functions in Base R

Core standard: Define and use functions with arguments and return values with reusable code logic in multiple contexts.

Grading Criteria:

4 Points:

• Follows all guided assignment instructions
• Defines functions using function() syntax, either:
  • At least 2 functions with 1 argument or
  • At least 1 function with 2 or more arguments
• Function includes return value (explicit or implicit)
• Function demonstrates clear reusable logic
• Uses function in at least 2 contexts returning different output

5 Points:

• All 4-point expectations met
• Defines functions independently for novel problems, both:
  • At least 2 functions with 2 or more required arguments and
  • At least 1 function with both required and optional arguments
• Uses multiple arguments effectively
• Function definition follows best practices for naming and clear, informative commenting
• Functions are appropriately scoped within their local environment for use in the global environment

6 Points:

• All 5-point expectations met
• Demonstrates advanced understanding beyond class scope, e.g.:
  • Defines multiple related functions or nested function calls
  • Implements sophisticated function logic
  • Accepts multiple data types within a single argument
  • Include error handling or input validation

Objective 6: Importing data with tidyverse tools

Core standard: Import datasets with readr and related packages, handling paths and basic options.

Note: For this requirement, you may interpret “readr functions” as including functions from related packages, like googlesheets4 or readxl.

• IMPORTANT: Read and write functions that are provided in assignment documents cannot count toward this objective.

Grading Criteria:

4 Points:

• IMPORTANT: To receive 4 points for this standard, read-in functions must run without error for the grader after cloning your assignment repository to a local machine. Ensure that:
  • All files use correct relative paths (remember that relative paths are handled differently in .R scripts and .qmd code chunks)
  • Read and write functions do not reference files or directories ignored by Git processes
• Uses readr functions to both:
  • Read in a data file and assign to an R object
  • Write out an R object to a data file
• Data successfully imported for use in analysis
• May specify basic options (e.g., column types, skip rows)

5 Points:

• All 4-point expectations met
• After meeting requirements for 4 points with error-free read-in and write-out, additional requirements for 5 or 6 points may be met with functions that read from or write to ignored files and directories under the following conditions:
  • Access to the ignored data is not required to execute any code you intend to count toward other objectives (i.e., your grader must be able to evaluate other objectives fully independently from your ignored files)
  • You clearly document in both your submission markdown file and in the comments of your import script where and how you have used the advanced read/write skills
• Uses multiple read or multiple write functions
• Uses at least 2 unique optional arguments in read/write function(s) (e.g., col_types, na values, skip)
  • Arguments do not need to be in the same function, but must be unique.
• Clear comments documenting import decisions

6 Points:

• All 5-point expectations met
• Shows advanced application of reading and writing data, e.g.:
  • Handles complex import scenarios (messy formats, multiple files, unusual delimiters)
  • Uses advanced readr features or other tidyverse import tools
  • Uses import and export functions from additional packages
  • Imports or exports non-tabular data
  • Integrates import process smoothly into larger workflow
  • Defines a data manipulation function with embedded data import
  • Demonstrates troubleshooting of import problems

Objective 7: Data manipulation with dplyr and pipelines

Core standard: Use multiple dplyr verbs (filter, select, mutate, summarize, arrange, group_by) in chained pipelines.

Grading Criteria:

4 Points:

• Uses pipe operator (%>% or |>) to chain operations
• Uses at least 2 dplyr functions in at least 2 pipelines
• Uses at least 1 dplyr function acting on the shape of a tibble, e.g.: filter(), select(), arrange()
• Uses at least 1 dplyr function dependent on values of a tibble, e.g.: mutate(), summarize(), group_by()
• Code executes correctly in structured context
• Achieves stated data manipulation goals

5 Points:

• All 4-point expectations met
• Creates pipelines independently for novel data problems
• Uses at least 4 unique dplyr functions across work
• Creates a single pipeline with at least 4 pipe operators
• Uses at least 1 of the following:
  • Joins (left_join(), inner_join(), etc.)
  • mutate() with dplyr conditional logic functions
  • group_by() piped to summarize()
  • tidyselect helper(s)
• Demonstrates understanding of when to use each verb
• Clean, readable, and commented pipeline code with appropriate line breaks

6 Points:

• All 5-point expectations met
• Shows advanced application of dplyr and pipelines, e.g.:
  • Creates complex multi-step pipelines beyond expectations for a 5
  • Non-trivially combines techniques for sophisticated data transformations
  • Uses multiple tidyselect helpers in unique contexts
  • Demonstrates efficiency and creativity in pipeline design
  • Uses placeholders (. or _, depending on pipe) to include non-tidyverse functions in a pipeline

Objective 8: Tidy data structure

Core standard: Diagnose untidy data and reshape to a tidy format, with explanation.

Note: This objective is about conceptual understanding, which may not be straightforward to demonstrate in code alone. Use of dplyr and/or tidyr functions to meet objectives 7 & 9 is not sufficient to meet objective 8, though a project that successfully demonstrates 7 or 9 is likely a good opportunity to demonstrate 8 as well.

Use comments to explain decisions about managing tidy data in your code. Use the self-evaluation section of your submission doc to elaborate on how your understanding of tidy data structure factored into the project.

Grading Criteria:

4 Points:

• Identifies what makes a dataset untidy
• Reshapes data to tidy format (one variable per column, one observation per row)
• Includes brief explanation of tidy data principles
• Uses functions from tidyverse packages to achieve tidy structure

5 Points:

• All 4-point expectations met
• Diagnoses untidy data independently in novel context, outside of clear assignment guidance
• Provides clear, detailed explanation of why data is/was untidy
• Articulates tidy data principles clearly
• Transforms data appropriately for intended analysis or additional wrangling
• May discuss trade-offs of tidy vs. wide formats for specific uses

6 Points:

• All 5-point expectations met
• Demonstrates sophisticated understanding of tidy data principles, e.g.:
  • Transforms particularly messy or complex data structures into tidy format
  • Effectively uses both tidy and non-tidy versions of a dataset within a single project
  • Describes how tidy format enables subsequent analysis steps
  • Creates comprehensive documentation of transformation process

Objective 9: Reshaping data with tidyr

Core standard: Use multiple tidyr functions (pivot_longer/pivot_wider/separate/unite) to reshape data.

Grading Criteria:

4 Points:

• Uses at least 2 unique tidyr functions for reshaping data (e.g., pivot_longer(), pivot_wider(), separate(), unite())
• Successfully reshapes data as needed for analysis or further data manipulation with dplyr and other tidyverse tools
• Code executes correctly in structured context
• Follows guided assignment instructions

5 Points:

• All 4-point expectations met
• Applies reshaping skills independently to novel data outside a structured assignment
• Uses at least 3 unique tidyr functions or multiple applications of at least 2 unique functions
• Uses at least 1 tidyr function to manage missing values (e.g., complete(), expand(), drop_na(), replace_na())
• Chooses appropriate functions for specific reshaping needs and explains choices in comments
• Reshaping serves clear purpose in analysis workflow
• Demonstrates clear understanding of function arguments (typically necessitates using optional arguments in some functions)

6 Points:

• All 5-point expectations met
• Shows advanced application of tidyr, e.g.:
  • Handles complex reshaping scenarios
  • Chains multiple tidyr operations effectively
  • Combines tidyr with dplyr functions in sophisticated pipelines
  • Uses tidyr with nested data
• Works with particularly messy or unusual data structures

Objective 10: Character strings with stringr

Core standard: Use stringr functions (e.g., str_detect, str_replace, str_extract) to solve text cleaning or extraction tasks.

Grading Criteria:

4 Points:

• Uses at least 2 unique stringr functions effectively
  • Common functions: str_detect(), str_replace(), str_extract(), str_to_lower(), str_trim(), str_sub(), etc.
  • At least 1 function uses pattern matching (tidyverse simplified or regex)
• Solves text cleaning or extraction tasks correctly
• Code executes in structured context

5 Points:

• All 4-point expectations met
• Applies string manipulation independently to novel problems
• Uses a unique stringr function for each (all) of the following:
  • Combining strings (e.g., str_c(), str_flatten())
  • Changing case (e.g., string_to_upper(), str_to_snake())
  • Detecting, modifying, or removing matched patterns (e.g., str_detect(), str_extract(), str_remove_all() , str_like())
  • Computing, detecting, or modifying length and/or whitespace (e.g., str_trim(), str_trunc(), str_length())
• Uses at least 1 of the following:
  • Regular expressions
  • Escaped characters
  • Locale sensitive function with a meaningful locale argument
  • SQL style matching (e.g., using str_ilike())
• Clear commented documentation of string manipulation logic
• String work integrated into larger data manipulation or analysis workflow

6 Points:

• All 5-point expectations met
• Shows advanced application of stringr or regular expressions, e.g.:
  • Handles complex text manipulation tasks
  • Creates sophisticated patterns for extraction or replacement
  • Combines stringr functions with string/character manipulation functions from other packages

Objective 11: Factors with forcats

Core standard: Recode, reorder, and/or lump factor levels to prepare categorical variables for analysis or plotting.

Grading Criteria:

4 Points:

• Use base R factor() in at least one context
• Uses base R levels() function or levels argument
• Uses at least 1 forcats function (e.g., fct_recode(), fct_reorder(), fct_lump(), fct_relevel(), as_factor(), fct_infreq(), etc.)
• Prepares categorical variables appropriately
• Code executes correctly in structured context

5 Points:

• All 4-point expectations met
• Uses factor() with optional variables
• Uses at least 2 forcats functions or demonstrates sophisticated factor manipulation with base factor()
• Applies factor skills independently to novel data
• Prepares factors thoughtfully for specific analysis or visualization needs
• Clean, documented factor manipulation code
• Factor work clearly serves analysis or data manipulation goals

6 Points:

• All 5-point expectations met
• Shows advanced management of factor variables, e.g.:
  • Handles complex factor manipulation scenarios
  • Creates custom factor level schemes with clear purpose
  • Demonstrates advanced forcats techniques
  • Factor manipulation integrated into sophisticated analysis/visualization workflow
  • Makes informed and well-explained choices about whether to treat variables as factors when not clearly required (e.g., deciding whether a Likert scale should be handled as categorical or continuous)

Objective 12: Basic reporting: plots and descriptives in Quarto

Core standard: Create simple ggplot2 plots and compute/report basic descriptive statistics (means, medians, counts, proportions) in a Quarto document with clear captions and narrative.

Grading Criteria:

4 Points:

• IMPORTANT: To receive 4 points for this standard, the Quarto document(s) must run without error for the grader after cloning your assignment repository to a local machine.
• All plots and analyses are integrated into the Quarto document with code chunks and render into the knitted document
• Uses ggplot2 to create at least 2 simple plots
  • At least 1 plot must have 2 or more variables
  • All plots must include at least 1 geom layer and at least 1 specified aesthetic (aes())
• Includes titles or captions for plots, either using ggplot arguments or Quarto markdown syntax
• Computes and reports results of at least 1 descriptive analysis (means, medians, counts, proportions, etc.)
  • May be directly reported from the code chunk’s R output rather than integrated into Quarto markdown or presented in a styled table
• Includes narrative text explaining results

5 Points:

• All 4-point expectations met
• Applies skills independently to novel data beyond structured assignment
• Creates at least 2 plots, where combined contents of all plots include:
  • At least 1 categorical variable
  • At least 1 continuous variable
  • At least 1 layer other than the required geom (may be a second geom on the same plot)
• Computes and reports results of at least 2 unique descriptive analyses (means, medians, counts, proportions, etc.)
• Include at least 1 inline value reference or code execution (e.g., r my_table[4,5] , r result1 + result2)
• Uses code chunk options to display output only for figures and results
• Clear, informative captions and narrative

6 Points:

• All 5-point expectations met
• Shows intermediate or advanced plotting or analysis, beyond what is covered in Quarter 1:
  • Creates comprehensive reporting document
  • Uses intermediate/advanced ggplot2 features (themes, facets, scales, etc.)
  • Computes and reports results of complex descriptive statistics or hypothesis testing
  • Highly polished, publication-ready output
  • Sophisticated integration of code, output, and narrative
  • Reports results using kable, gt, stargazer, or similar

Submission & Grading

All core objectives projects should be submitted via GitHub pull requests and finalized for grading with the online Submission Form.

The final deadline to submit core objectives project is Friday, March 6th. Requests for extensions should be made by contacting the TA and are granted/denied entirely at the TA’s discretion.