Update learning goals

docs/course-content.md

@@ -17,58 +17,57 @@ The lecture and the accompanying lab assignments are organized in 7 chapters.
 
 ### 1. [Version Control](https://github.com/Simulation-Software-Engineering/Lecture-Material/blob/main/01_version_control/README.md)
 
-- Refresh and organize students' existing knowledge on git (learn how to learn more).
-- Students can explain difference between merge and rebase and when to use what.
-- How to use git workflows to organize research software development in a team.
-- Get to know a few useful GitHub/GitLab standards and a few helpful tools.
+- Refresh and organize students' existing knowledge on Git (learn how to learn more).
+- Explain difference between merge and rebase and when to use what.
+- Use Git workflows to organize research software development in a team.
+- Know about a few useful GitHub/GitLab standards and a few helpful tools.
 
-### 2. [Virtualization and Containerization](https://github.com/Simulation-Software-Engineering/Lecture-Material/blob/main/02_virtualization_and_containers/README.md)
+### 2. [Virtualization and Containers](https://github.com/Simulation-Software-Engineering/Lecture-Material/blob/main/02_virtualization_and_containers/README.md)
 
-- What is the difference between virtualization and containers?
-- When to use virtual machines and when containers.
-- How to work with virtual machines (VirtualBox) and how to manage these with Vagrant.
-- Building containers with Docker and Singularity.
-- Understand pros and cons of different container technologies.
-- Student can set up their own containers tailored to their requirements.
+- Name differences between virtualization and containers and name use cases for each.
+- Create and modify virtual machines with VirtualBox and generate them with Vagrant.
+- Create and manage Docker containers.
+- Name containerization technologies beyond Docker and name their main differences.
 
 ### 3. [Building and Packaging](https://github.com/Simulation-Software-Engineering/Lecture-Material/blob/main/03_building_and_packaging/README.md)
 
-- Comprehending the necessity to package code
-- Using package managers to package code and upload to a remote managing platform
-- What package managers do exist for high-performance computing applications?
-- How to easily add your code to package managers for reproducibility.
-- How to create reproducible builds or environments?
+- Explain why software is packaged.
+- Create Python packages, publish on PyPI, and install with pip.
+- Understand the difference between static and dynamic libraries and common ways of installation on Linux.
+- Build C++ software and handle dependencies with Make and CMake.
+- Package C++ software with CPack and create Debian packages.
+- Create Spack packages, e.g., for high-performance computing systems with restricted access rights.
 
 ### 4. [Documentation](https://github.com/Simulation-Software-Engineering/Lecture-Material/blob/main/04_documentation/README.md)
 
-- Understand what you want to document and that there are different aspects (code, development, API, usage).
-- The students can choose the right tool for the documentation needs.
-- The students know common documentation tools for C++ and Python.
-- The students know fundamentals of technical writing.
-- Students understand the importance of documentation for themselves and others.
+- Be aware that documentation is crucial in RSE.
+- Understand that there is a difference between documentation and good documentation.
+- Know the purpose and basic structure of several standard documentation building blocks (README, commit message, changelog, ...).
+- Read and write common lightweight markup languages and generate PDF files from them.
+- Know about the most important website generators and hosting options for research software documentation.
 
 ### 5. [Testing and Continuous Integration](https://github.com/Simulation-Software-Engineering/Lecture-Material/tree/main/05_testing_and_ci)
 
-- What type of test to use for what use case.
-- Why are tests important?
-- The students learn how to automate tests using GitHub and GitLab.
-- The students have an overview over different testing frameworks.
+- Justify the effort of developing testing infrastructure for simulation software.
+- Discern the concepts of unit testing, integration testing, and regression testing with the perspective of simulation software.
+- Work with the Python testing frameworks pytest and unittest.
+- Write simple tests for C++ toy codes with Boost.Test.
+- Know about general concepts of test frameworks such as fixtures and decorators.
+- Name and explain common workflows to automate in RSE.
+- Write basic automation scripts for GitHub Actions.
+- Read basic automation scripts for GitLab CI/CD and explain the necessary steps to host GitLab Runners yourself.
+- Use CTest to call tests from CMake.
 
-### 6. [Legal, Archiving, Community, and More](https://github.com/Simulation-Software-Engineering/Lecture-Material/tree/main/06_miscellaneous)
+### 6. [Miscellaneous](https://github.com/Simulation-Software-Engineering/Lecture-Material/tree/main/06_miscellaneous)
 
-- Understand why it is important to add a license to one's code.
-- Which license to pick for your code.
-- Importance of long term storage/availability of data and ow to make it available.
-- Data and metadata documentation using DataVerse ([DaRUS](https://darus.uni-stuttgart.de/)).
-- Importance of reproducibility of research.
-- How to build and interact with users to build a community.
+- Know the basics about several other important things concerning research software engineering: FAIRness of research data and research software, FLOSS licenses, versioning schemes, repository layout standards, and more.
 
 ## The challenge
 
 Parallel to the weekly lab work, you work on an individual challenge, where you apply the learned concepts and tools with the ultimate goal to contribute to a large-scale community simulation software package. The challenge is structured in three parts, whereas each part is completed by a short presentation of the intermediate results in class:
 
-1. You get acquainted with the basic functionality of a large-scale simulation software package (such as FEniCS, PETSc, TRILINOS, DuMuX, preCICE, or SU2) by studying tutorials and documentation (first quarter of the course)
-2. You analyze the RSE infrastructure and the development cycle of the software package (second quarter of the course).
+1. You get acquainted with the basic functionality of a large-scale simulation software package (such as FEniCS, PETSc, TRILINOS, DuMuX, preCICE, or SU2) by studying tutorials and documentation (first third of the course)
+2. You analyze the RSE infrastructure and the development cycle of the software package (second third of the course).
 3. You contribute to the software package. The contribution can be small, but should not be trivial. Possible examples: Adding a new tutorial, extending the documentation, working on a "good first issue", adding support of a new package manager. Important is to properly go through all development steps if possible (contact community, open issue, open pull request, test, review, merge).
 
 We got amazing contributions when we did this lecture previously: