B Learning Objectives

This appendix lists the learning objectives for each chapter, and is intended to help instructors who want to use this curriculum.

B.1 Getting Started

Identify the few standard files that should be present in every research software project.
Explain the typical directory structure used in small and medium-sized data analysis projects.
Download the required data.
Install the required software.

Explain how the shell relates to the keyboard, the screen, the operating system, and users’ programs.
Explain when and why a command-line interface should be used instead of graphical user interfaces.
Explain the steps in the shell’s read-evaluate-print loop.
Identify the command, options, and filenames in a command-line call.
Explain the similarities and differences between files and directories.
Translate an absolute path into a relative path and vice versa.
Construct absolute and relative paths that identify files and directories.
Delete, copy, and move files and directories.

Redirect a command’s output to a file.
Use redirection to process a file instead of keyboard input.
Construct pipelines with two or more stages.
Explain Unix’s “small pieces, loosely joined” philosophy.
Write a loop that applies one or more commands separately to each file in a set of files.
Trace the values taken on by a loop variable during execution of the loop.
Explain the difference between a variable’s name and its value.
Demonstrate how to see recently executed commands.
Re-run recently executed commands without retyping them.

Explain the benefits of writing Python programs that can be executed at the command line.
Create a command-line Python program that respects Unix shell conventions for reading input and writing output.
Use the argparse library to handle command-line arguments in a program.
Explain how to tell if a module is being run directly or being loaded by another program.
Write docstrings for programs and functions.
Explain the difference between optional arguments and positional arguments.
Create a module that contains functions used by multiple programs and import that module.

Explain the advantages and disadvantages of using Git at the command line.
Demonstrate how to configure Git on a new computer.
Create a local Git repository at the command line.
Demonstrate the modify-add-commit cycle for one or more files.
Synchronize a local repository with a remote repository.
Explain what the HEAD of a repository is and demonstrate how to use it in commands.
Identify and use Git commit identifiers.
Demonstrate how to compare revisions to files in a repository.
Restore old versions of files in a repository.
Explain how to use .gitignore to ignore files and identify files that are being ignored.

Explain why branches are useful.
Demonstrate how to create a branch, make changes on that branch, and merge those changes back into the original branch.
Explain what conflicts are and demonstrate how to resolve them.
Explain what is meant by a branch-per-feature workflow.
Define the terms fork, clone, remote, and pull request.
Demonstrate how to fork a repository and submit a pull request to the original repository.

Explain how a project lead can be a good ally.
Explain the purpose of a Code of Conduct and add one to a project.
Explain why every project should include a license and add one to a project.
Describe different kinds of licenses for software and written material.
Explain what an issue tracking system does and what it should be used for.
Describe what a well-written issue should contain.
Explain how to label issues to manage work.
Submit an issue to a project.
Describe common approaches to prioritizing tasks.
Describe some common-sense rules for running meetings.
Explain why every project should include contribution guidelines and add some to a project.
Explain how to handle conflict between project participants.

Explain what a build manager is and how they aid reproducible research.
Name and describe the three parts of a build rule.
Write a Makefile that re-runs a multi-stage data analysis.
Explain and trace how Make chooses an order in which to execute rules.
Explain what phony targets are and define a phony target.
Explain what automatic variables are and identify three commonly used automatic variables.
Write Make rules that use automatic variables.
Explain why and how to write pattern rules in a Makefile.
Write Make rules that use patterns.
Define variables in a Makefile explicitly and by using functions.
Make a self-documenting Makefile.

Explain how to use exceptions to signal and handle errors in programs.
Write try/except blocks to raise and catch exceptions.
Explain what is meant by “throw low, catch high.”
Describe the most common built-in exception types in Python and how they relate to each other.
Explain what makes a useful error message.
Create and use a lookup table for common error messages.
Explain the advantages of using a logging framework rather than print statements.
Describe the five standard logging levels and explain what each should be used for.
Create, configure, and use a simple logger.

Explain what a DOI is and how to get one.
Explain what an ORCID is and get one.
Describe the FAIR Principles and determine whether a dataset conforms to them.
Explain where to archive small, medium, and large datasets.
Describe good practices for archiving analysis code and determine whether a report conforms to them.
Explain the difference between reproducibility and inspectability.