diff --git a/0__python_refresh.ipynb b/0__python_refresh.ipynb
deleted file mode 100644
index 4ce29c9f4efb1ddb6b1dd2a9ca7121a794a022ef..0000000000000000000000000000000000000000
--- a/0__python_refresh.ipynb
+++ /dev/null
@@ -1,255 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Python Refresher "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This worksheet is not about the actual content of the Research Software Engineering (RSE) course, but meant to make sure that you are ready to use Python for the assignments and\n",
-    "projects ahead. Therefore, it contains instructions on how to install the Anaconda framework for data science (including Python 3) and some programming exercises to revitalize your\n",
-    "Python coding skills. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1.Python Development Environment\n",
-    "\n",
-    "To get started you need a working Python development environment. You can either install Anaconda, or Python directly.\n",
-    "For most tasks of the book, you won't need that many packages, A list will be provided below. This book won't go into detail on how to install python manually, but for those new to Python but experience in other languages you may follow the the instructions on Anaconda. \n",
-    "\n",
-    "### Python Install Instructions\n",
-    "1. On Mac and Windows go to [Python.org](https://python.org) and download Python 3 the latest version manully or follow or use your terminal to install python. Most Linux system come with python pre installed.\n",
-    "2. Install a Text editor VS Code, Jetbrains Pycharm, or Neovim, Helix, Emacs, Sublime, there are no requirements, but having an install of VS Code might make it easier, since VS code can run Jupyter notebooks without you having to install the whole Anaconda ecosystem and starting jupyter notebook server. And run the Notebooks in your Browser, instead you can use VScode including all python linting etc.  \n",
-    "\n",
-    "### Anaconda Install Guide\n",
-    "We will use the Anaconda Data Science platform in the course. Anaconda is a free and open source distribution of Python and some other programming languages used in scientific\n",
-    "applications. It runs on all major operatin systems and provides a number of very useful tools for Python programming, some of which we will use in the course.\n",
-    "Here is what you need to do to get started:\n",
-    "1. Go to https://docs.anaconda.com/anaconda/install/ and follow the installation instructions for your operating system.\n",
-    "2. Go to https://docs.anaconda.com/anaconda/user-guide/getting-started/#open-nav-lin and follow the instructions how to start Spyder.\n",
-    "3. Start coding!\n",
-    "If you have trouble with the installation of Anaconda on your device, please don’t hesitate to ask your questions in the moodle forum."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Revitalize your Python\n",
-    "Here are a couple of exercises to revitalize your basic Python skills. Do these in your favorite IDE (e.g. Spyder, VSCode, ...), using plain .py files, **not Jupyter Notebooks**."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.1 Arithmetics\n",
-    "\n",
-    "Write a Python program that welcomes the user, asks for their name (string), weight in kg (integer) and height in m (float), computes the body mass index (BMI) from the information\n",
-    "(weight/height2) and finally displays a message to the user, saying something like: \n",
-    "\n",
-    "```Bash\n",
-    "Hello Jim, your BMI is 23.4.\n",
-    "```\n",
-    "\n",
-    "\n",
-    "You can assume that the user enters correct values."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code for testing"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.2 Conditional Branching\n",
-    "\n",
-    "Extend the BMI calculation program from the previous exercise so that after informing the user about the calculated BMI, it also prints out if the BMI is within the range that is generally\n",
-    "considered normal (between 18.5 and 25) or higher (above 25) or lower (below 18.5) than that. The output of the modified program should then be something like:\n",
-    "\n",
-    "```\n",
-    "Welcome to the BMI calculator.\n",
-    "What is your name? John Doe\n",
-    "What is your weight (in kg)? 78\n",
-    "What is your height (in m)? 1.82\n",
-    "Hello John Doe, your BMI is 23.5\n",
-    "Your BMI is normal.\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code for testing"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.3 While-Loops\n",
-    "\n",
-    "Write a simple number-guessing game in Python. It generates a random number between 1 and 100 and asks the user to guess it. If the number guessed is too small or too big, a hint is given and the user can try again, until they guess the correct number. The output of the program should be something like:\n",
-    "\n",
-    "```\n",
-    "Can you guess the number? 12\n",
-    "You guessed too small!\n",
-    "Try again: 23\n",
-    "You guessed too big!\n",
-    "Try again: 16\n",
-    "Yes!\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code for testing"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.4 For-Loops, Text Processing\n",
-    "\n",
-    "Write a simple text analysis program that finds the (first) longest word in a text. It should work on any text, but you can use the \"lorem ipsum\" as an example:\n",
-    "\n",
-    "\n",
-    ">text = \"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do \\\n",
-    ">eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad \\\n",
-    ">minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex \\\n",
-    ">ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate \\\n",
-    ">velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat \\\n",
-    ">cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id \\\n",
-    ">est laborum.\"\n",
-    "\n",
-    "To check if a character `c` is an alphabetic character, you can call the `.isalpha()` function on it: `c.isalpha()`. It will return `True` or `False`.\n",
-    "The output of your program should report the longest word and its length, like this:\n",
-    "\n",
-    "```The longest word in the text is \"reprehenderit\" (13 characters)```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code for testing"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.5 Functions\n",
-    "\n",
-    "In our lieftimes (unless we happen to get veeery old) a leap year occurs every four years. But actually, the rule is a bit more involved: A year is a leap year if it is a multiple of 4, but not a multiple of 100, unless it is also a multiple of 400. For example, 1984 and 2000 were leap years, but 1900 and 1985 were not.\n",
-    "\n",
-    "Write a function `is_leap_year(year)` that tests if the year is a leap year. If so, the function should return `True`, and `False` otherwise. Implement the function using only one Boolean expression. You can use the code below to test your function:\n",
-    "\n",
-    "```Python\n",
-    "tests = [1900, 1984, 1985, 2000, 2018]\n",
-    "for test in tests:\n",
-    "    if is_leap_year(test):\n",
-    "        print(f”{test} is a leap year\")\n",
-    "    else:\n",
-    "        print(f”{test} is not a leap year\")\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code for testing"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.6 Dataframes, Pandas\n",
-    "\n",
-    "Use the file [`mcdonalds_menu.csv`](https://gitlab.rrz.uni-hamburg.de/BAT2642/rse24-exercises/-/raw/main/data/mcdonalds_menu.csv). Write a program that reads the content of the file into a dataframe, and displays simple descriptive statistics about the\n",
-    "numerical values in the data frame. Then add some code to create a barplot that displays the number of items per category.\n",
-    "The output should look something like:\n",
-    "\n",
-    "![table1](https://gitlab.rrz.uni-hamburg.de/BAT2642/rse24-exercises/-/raw/main/img/table1.png)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code for testing"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2.7 Classes, Inheritance\n",
-    "\n",
-    "Define two classes `Person` and `Student` with the following characteristics: The base class `Person` provides a field `name` and a function `printInfo` to print information about\n",
-    "the person (i.e., the name). The class `Student` is derived from `Person`. A Student is a Person that in addition has a university, a study program and a number of `creditpoints`. The class `Student` also has a `printInfo` function, which displays information about the university and program in addition to the student’s name. With the functions `setCreditPoints` and `getCreditPoints` the credit points of the student can be set and retrieved"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Your code for testing "
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/1__bash.ipynb b/1__bash.ipynb
deleted file mode 100644
index ce6bfb91d2fb8f53741e517b837bb6164107f3c3..0000000000000000000000000000000000000000
--- a/1__bash.ipynb
+++ /dev/null
@@ -1,1034 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Bash Exercises\n",
-    "\n",
-    "These exercise should help you either reviewing or learning new shell commands. The exercises can be done localy on Linux, Mac, Windows 11 bash console, or in a Terminal in [`code.min.uni-hamburg.de`](https://code.min.uni-hamburg.de).\n",
-    "You can also open this Jupyter Notebook directly in [`code.min.uni-hamburg.de`](https://code.min.uni-hamburg.de) or google colab and do the exercises. In this case be aware that the system runs on linux, which is important when using paths.  \n",
-    "\n",
-    "Linux and mac use `/` instead of `\\` as an example. \n",
-    "\n",
-    "But First we go through a quick explanation on how to use **BASH** in a jupyter notebook on a linux or mac system."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using Bash in Jupyter Notebook"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Depending on what system you use it is important to first figure out the current path on the file system, for that run the next cell. \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%bash\n",
-    "pwd"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To run a single command you may add an exclamation mark to the front of the command. As seen as in the example below **!** is added to the command *echo*. \n",
-    "After that just run the cell and it should give the output, in this case \"hello world\".  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!echo \"hello world!\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "However, that won't work if for example you want to run multiple commands that talk to each other, since each command is executed in a separate process:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!export RAND=42\n",
-    "!echo $RAND "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Nothing is printed, since RAND was defined in a separate process which has already exited"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "But, if your notebook code cell starts with **%%bash**, it's all executed as one script!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%bash\n",
-    "\n",
-    "export RAND=42\n",
-    "echo $RAND"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can also pass python variables into your shell commands, and vise versa! "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# You can also pass python variables into your shell commands, and vise versa!\n",
-    "python_var = []\n",
-    "\n",
-    "\n",
-    "output_of_ls_as_python_var = !ls -a\n",
-    "print(output_of_ls_as_python_var)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Basic Exercises"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Prerequisite\n",
-    "The exercises below involve creating and moving new files, as well as considering hypothetical files.\n",
-    "We will use the Zipf's Law project from the lecture. For this download the current state of the project [here](https://gitlab.rrz.uni-hamburg.de/BAT2642/rse24-exercises/-/raw/main/data/zipf1.tar.gz) and unzip the file with `tar -xzvf zipf1.tar.gz`. \n",
-    "Alternatively, you can conveniently execute the cell below, which downloads and extracts the project for you.  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!wget -qO- https://gitlab.rrz.uni-hamburg.de/BAT2642/rse24-exercises/-/raw/main/data/zipf1.tar.gz | tar -xzvf -"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 1 Exploring more `ls` flags\n",
-    "\n",
-    "What does the command `ls` do when used with the `-l` option?\n",
-    "\n",
-    "What happens if you use two options at the same time, such as `ls -l -h`?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2 Listing recursively and by time \n",
-    "The command `ls -R` lists the contents of directories recursively, which means the subdirectories, sub-subdirectories, and so on at each level are listed.\n",
-    "The command `ls -t` lists things by time of last change, with most recently changed files or directories first.\n",
-    "\n",
-    "In what order does `ls -R -t` display things? Hint: `ls -l` uses a long listing format to view timestamps."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 3 Absolute and relative paths\n",
-    "\n",
-    "Starting from your current directory, which of the following commands could you use to navigate to your home directory,\n",
-    "which is `/Users/*YOUR-USERNAME` or on Linux and Mac `/home/*YOUR-USERNAME*` ?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. `cd .`\n",
-    "2. `cd /`\n",
-    "3. `cd /home/amira`\n",
-    "4. `cd ../..`\n",
-    "5. `cd ~`\n",
-    "6. `cd home`\n",
-    "7. `cd ~/data/..`\n",
-    "8. `cd`\n",
-    "9. `cd ..`\n",
-    "10. `cd ../.`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 4 Relative path resolution\n",
-    "\n",
-    "Using the filesystem shown below,\n",
-    "if `pwd` displays `/Users/sami`, what will `ls -F ../backup` display?\n",
-    "\n",
-    "1.  `../backup: No such file or directory`\n",
-    "2.  `final original revised`\n",
-    "3.  `final/ original/ revised/`\n",
-    "4.  `data/ analysis/ doc/`\n",
-    "    \n",
-    "<img src=\"https://gitlab.rrz.uni-hamburg.de/BAT2642/rse24-exercises/-/raw/main/img/exercise-filesystem.png\" width=\"600\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 5 `ls` reading comprehension \n",
-    "\n",
-    "Using the filesystem shown above, if `pwd` displays `/Users/backup`, and `-r` tells `ls` to display things in reverse order, what command(s) will result in the following output:\n",
-    "\n",
-    "```bash\n",
-    "doc/ data/ analysis/\n",
-    "```\n",
-    "\n",
-    "1.  `ls pwd`\n",
-    "2.  `ls -r -F`\n",
-    "3.  `ls -r -F /Users/backup`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 6 Creating files a different way \n",
-    "\n",
-    "What happens when you execute `touch my_file.txt`?  (Hint: use `ls -l` to find information about the file)\n",
-    "\n",
-    "When might you want to create a file this way?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 7 Using `rm` safely \n",
-    "\n",
-    " What would happen if you executed `rm -i my_file.txt` on the file created in the previous exercise?\n",
-    "\n",
-    " Why would we want this protection when using `rm`?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "### 8 Moving to the current folder \n",
-    "\n",
-    "After running the following commands,\n",
-    "Amira realizes that she put the (hypothetical) files `chapter1.txt` and `chapter2.txt` into the wrong folder:\n",
-    "\n",
-    "```bash\n",
-    "$ ls -F\n",
-    "```\n",
-    "```text\n",
-    "  data/  docs/\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "$ ls -F data\n",
-    "```\n",
-    "```text\n",
-    "README.md\t\t\tfrankenstein.txt\t\tsherlock_holmes.txt\n",
-    "chapter1.txt\t\tjane_eyre.txt\t\t\ttime_machine.txt\n",
-    "chapter2.txt\t\tmoby_dick.txt\n",
-    "dracula.txt\t\t\tsense_and_sensibility.txt\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "$ cd docs\n",
-    "```\n",
-    "\n",
-    "Fill in the blanks to move these files to the current folder (i.e., the one she is currently in):\n",
-    "\n",
-    "```bash\n",
-    "$ mv ___/chapter1.txt  ___/chapter2.txt ___\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 9 Renaming files \n",
-    "\n",
-    "Suppose that you created a plain-text file in your current directory to contain a list of the statistical tests you will need to do to analyze your data, and named it: `statstics.txt`\n",
-    "\n",
-    "After creating and saving this file you realize you misspelled the filename! You want to correct the mistake, which of the following commands could you use to do so?\n",
-    "\n",
-    "1. `cp statstics.txt statistics.txt`\n",
-    "2. `mv statstics.txt statistics.txt`\n",
-    "3. `mv statstics.txt .`\n",
-    "4. `cp statstics.txt .`\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 10 Moving and copying \n",
-    "\n",
-    "Assuming the following hypothetical files, what is the output of the closing `ls` command in the sequence shown below?\n",
-    "\n",
-    "```bash\n",
-    "$ pwd\n",
-    "```\n",
-    "\n",
-    "```text\n",
-    "/Users/amira/data\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "$ ls\n",
-    "```\n",
-    "\n",
-    "```text\n",
-    "books.dat\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "$ mkdir doc\n",
-    "$ mv books.dat doc/\n",
-    "$ cp doc/books.dat ../books-saved.dat\n",
-    "$ ls\n",
-    "```\n",
-    "\n",
-    "1.   `books-saved.dat doc`\n",
-    "2.   `doc`\n",
-    "3.   `books.dat doc`\n",
-    "4.   `books-saved.dat`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 11 Copy with multiple filenames \n",
-    "\n",
-    "This exercise explores how `cp` responds when attempting to copy multiple things.\n",
-    "\n",
-    "What does `cp` do when given several filenames followed by a directory name?\n",
-    "\n",
-    "```bash\n",
-    "$ mkdir backup\n",
-    "$ cp dracula.txt frankenstein.txt backup/\n",
-    "```\n",
-    "\n",
-    "What does `cp` do when given three or more filenames?\n",
-    "\n",
-    "```bash\n",
-    "$ cp dracula.txt frankenstein.txt jane_eyre.txt\n",
-    "```\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 12 List filenames matching a pattern\n",
-    "\n",
-    "When run in the `data` directory of your project directory, which `ls` command(s) will produce this output?\n",
-    "\n",
-    "`jane_eyre.txt   sense_and_sensibility.txt`\n",
-    "\n",
-    "1. `ls ??n*.txt`\n",
-    "2. `ls *e_*.txt`\n",
-    "3. `ls *n*.txt`\n",
-    "4. `ls *n?e*.txt`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 13 Organizing directories and files \n",
-    "\n",
-    "Amira is working on a project and she sees that her files aren't very well organized:\n",
-    "\n",
-    "```bash\n",
-    "$ ls -F\n",
-    "```\n",
-    "\n",
-    "```text\n",
-    "books.txt    data/    results/   titles.txt\n",
-    "```\n",
-    "\n",
-    "The `books.txt` and `titles.txt` files contain output from her data analysis. \n",
-    "\n",
-    "What command(s) does she need to run to produce the output shown?\n",
-    "\n",
-    "```bash\n",
-    "$ ls -F\n",
-    "```\n",
-    "\n",
-    "```text\n",
-    "data/   results/\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "$ ls results\n",
-    "```\n",
-    "\n",
-    "```text\n",
-    "books.txt    titles.txt\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 14 Reproduce a directory structure \n",
-    "\n",
-    "You're starting a new analysis, and would like to duplicate the directory structure from your previous experiment so you can add new data.\n",
-    "\n",
-    "Assume that the previous experiment is in a folder called `2023-05-18`, which contains a `data` folder that in turn contains folders named `raw` and `processed` that contain data files.  The goal is to copy the folder structure of `2023-05-18/data` into a folder called `2023-05-20` so that your final directory structure looks like this:\n",
-    "\n",
-    "```bash\n",
-    "\t2024-05-20/\n",
-    "\t└── data\n",
-    "\t    ├── processed\n",
-    "\t    └── raw\n",
-    "```\n",
-    "Which of the following commands would achieve this objective?\n",
-    "\n",
-    "What would the other commands do?\n",
-    "\n",
-    "```bash\n",
-    "# Set 1\n",
-    "$ mkdir 2023-05-20\n",
-    "$ mkdir 2023-05-20/data\n",
-    "$ mkdir 2023-05-20/data/processed\n",
-    "$ mkdir 2023-05-20/data/raw\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "# Set 2\n",
-    "$ mkdir 2023-05-20\n",
-    "$ cd 2023-05-20\n",
-    "$ mkdir data\n",
-    "$ cd data\n",
-    "$ mkdir raw processed\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "# Set 3\n",
-    "$ mkdir 2023-05-20/data/raw\n",
-    "$ mkdir 2023-05-20/data/processed\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "# Set 4\n",
-    "$ mkdir 2023-05-20\n",
-    "$ cd 2023-05-20\n",
-    "$ mkdir data\n",
-    "$ mkdir raw processed\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 15 Wildcard expressions \n",
-    "\n",
-    "Wildcard expressions can be very complex, but you can sometimes write them in ways that only use simple syntax, at the expense of being a bit more verbose.\n",
-    "In your `data/` directory, the wildcard expression `[st]*.txt` matches all files beginning with `s` or `t` and ending with `.txt`. \n",
-    "\n",
-    "Imagine you forgot about this.\n",
-    "\n",
-    "1.  Can you match the same set of files with basic wildcard expressions\n",
-    "    that do not use the `[]` syntax? *Hint*: You may need more than one\n",
-    "    expression.\n",
-    "\n",
-    "2.  Under what circumstances would your new expression produce an error message\n",
-    "    where the original one would not?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 16 Removing unneeded files\n",
-    "\n",
-    "Suppose you want to delete your processed data files, and only keep your raw files and processing script to save storage.\n",
-    "The raw files end in `.txt` and the processed files end in `.csv`. \n",
-    "\n",
-    "Which of the following would remove all the processed data files, and *only* the processed data files?\n",
-    "\n",
-    "1. `rm ?.csv`\n",
-    "2. `rm *.csv`\n",
-    "3. `rm * .csv`\n",
-    "4. `rm *.*`\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 17 Other wildcards \n",
-    "\n",
-    "The shell provides several wildcards beyond the widely used `*`.\n",
-    "\n",
-    "To explore them, explain in plain language what (hypothetical) files the expression `novel-????-[ab]*.{txt,pdf}` matches and why."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## BASH Tool Exercises"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 1 What does `>>` mean?\n",
-    "\n",
-    "We have seen the use of `>`, but there is a similar operator `>>` which works slightly differently.\n",
-    "We'll learn about the differences between these two operators by printing some strings.\n",
-    "We can use the `echo` command to print strings as shown below:\n",
-    "\n",
-    "\n",
-    "```bash\n",
-    "$ echo The echo command prints text\n",
-    "```\n",
-    "\n",
-    "```text\n",
-    "The echo command prints text\n",
-    "```\n",
-    "\n",
-    "Now test the commands below to reveal the difference between the two operators:\n",
-    "\n",
-    "```bash\n",
-    "$ echo hello > testfile01.txt\n",
-    "```\n",
-    "\n",
-    "and:\n",
-    "\n",
-    "```bash\n",
-    "$ echo hello >> testfile02.txt\n",
-    "```\n",
-    "\n",
-    "Hint: Try executing each command twice in a row and then examining the output files."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2 Appending data \n",
-    "\n",
-    "Given the following commands, what will be included in the file `extracted.txt`:\n",
-    "\n",
-    "```bash\n",
-    "$ head -n 3 dracula.txt > extracted.txt\n",
-    "$ tail -n 2 dracula.txt >> extracted.txt\n",
-    "```\n",
-    "\n",
-    "1. The first three lines of `dracula.txt`\n",
-    "2. The last two lines of `dracula.txt`\n",
-    "3. The first three lines and the last two lines of `dracula.txt`\n",
-    "4. The second and third lines of `dracula.txt`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 3 Piping commands \n",
-    "\n",
-    "In our current directory, we want to find the 3 files which have the least number of lines. \n",
-    "\n",
-    "Which command listed below would work?\n",
-    "\n",
-    "1. `wc -l * > sort -n > head -n 3`\n",
-    "2. `wc -l * | sort -n | head -n 1-3`\n",
-    "3. `wc -l * | head -n 3 | sort -n`\n",
-    "4. `wc -l * | sort -n | head -n 3`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 4 Why does `uniq` only remove adjacent duplicates? \n",
-    "\n",
-    "The command `uniq` removes adjacent duplicated lines from its input. Consider a hypothetical file `genres.txt` containing the following data:\n",
-    "\n",
-    "```text\n",
-    "science fiction\n",
-    "fantasy\n",
-    "science fiction\n",
-    "fantasy\n",
-    "science fiction\n",
-    "science fiction\n",
-    "```\n",
-    "\n",
-    "Running the command `uniq genres.txt` produces:\n",
-    "\n",
-    "```text\n",
-    "science fiction\n",
-    "fantasy\n",
-    "science fiction\n",
-    "fantasy\n",
-    "science fiction\n",
-    "```\n",
-    "\n",
-    "Why do you think `uniq` only removes *adjacent* duplicated lines? (Hint: think about very large datasets.) \n",
-    "\n",
-    "What other command could you combine with it in a pipe to remove all duplicated lines?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 5 Pipe reading comprehension \n",
-    "\n",
-    "A file called `titles.txt` contains a list of book titles and publication years:\n",
-    "\n",
-    "```text\n",
-    "Dracula,1897\n",
-    "Frankenstein,1818\n",
-    "Jane Eyre,1847\n",
-    "Moby Dick,1851\n",
-    "Sense and Sensibility,1811\n",
-    "The Adventures of Sherlock Holmes,1892\n",
-    "The Invisible Man,1897\n",
-    "The Time Machine,1895\n",
-    "Wuthering Heights,1847\n",
-    "```\n",
-    "\n",
-    "What text passes through each of the pipes and the final redirect in the pipeline below?\n",
-    "\n",
-    "```bash\n",
-    "$ cat titles.txt | head -n 5 | tail -n 3 | sort -r > final.txt\n",
-    "```\n",
-    "\n",
-    "Hint: build the pipeline up one command at a time to test your understanding\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 6 Pipe construction \n",
-    "\n",
-    "For the file `titles.txt` from the previous exercise, consider the following command:\n",
-    "\n",
-    "```bash\n",
-    "$ cut -d , -f 2 titles.txt\n",
-    "```\n",
-    "\n",
-    "What does the `cut` command (and its options) accomplish?\n",
-    "\n",
-    "### 7 Which pipe? \n",
-    "\n",
-    "Consider the same `titles.txt` from the previous exercises.\n",
-    "\n",
-    "The `uniq` command has a `-c` option which gives a count of the number of times a line occurs in its input.\n",
-    "\n",
-    " If `titles.txt` was in your working directory, what command would you use to produce a table that shows the total count of each publication year in the file?\n",
-    "\n",
-    "1.  `sort titles.txt | uniq -c`\n",
-    "2.  `sort -t, -k2,2 titles.txt | uniq -c`\n",
-    "3.  `cut -d, -f 2 titles.txt | uniq -c`\n",
-    "4.  `cut -d, -f 2 titles.txt | sort | uniq -c`\n",
-    "5.  `cut -d, -f 2 titles.txt | sort | uniq -c | wc -l`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 8 Doing a dry run \n",
-    "\n",
-    "A loop is a way to do many things at once---or to make many mistakes at once if it does the wrong thing. One way to check what a loop *would* do is to `echo` the commands it would run instead of actually running them.\n",
-    "\n",
-    "Suppose we want to preview the commands the following loop will execute without actually running those commands (`analyze` is a hypothetical command):\n",
-    "\n",
-    "```bash\n",
-    "$ for file in *.txt\n",
-    "> do\n",
-    ">   analyze $file > analyzed-$file\n",
-    "> done\n",
-    "```\n",
-    "\n",
-    "What is the difference between the two loops below, and which one would we want to run?\n",
-    "\n",
-    "```bash\n",
-    "$ for file in *.txt\n",
-    "> do\n",
-    ">   echo analyze $file > analyzed-$file\n",
-    "> done\n",
-    "```\n",
-    "\n",
-    "or:\n",
-    "\n",
-    "```bash\n",
-    "$ for file in *.txt\n",
-    "> do\n",
-    ">   echo \"analyze $file > analyzed-$file\"\n",
-    "> done\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 9 Variables in loops\n",
-    "\n",
-    "Given the files in `data/`, what is the output of the following code?\n",
-    "\n",
-    "```bash\n",
-    "$ for datafile in *.txt\n",
-    "> do\n",
-    ">    ls *.txt\n",
-    "> done\n",
-    "```\n",
-    "\n",
-    "Now, what is the output of the following code?\n",
-    "\n",
-    "```bash\n",
-    "$ for datafile in *.txt\n",
-    "> do\n",
-    ">\tls $datafile\n",
-    "> done\n",
-    "```\n",
-    "\n",
-    "Why do these two loops give different outputs?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 10 Limiting sets of files\n",
-    "\n",
-    "What would be the output of running the following loop in your `data/` directory?\n",
-    "\n",
-    "```bash\n",
-    "$ for filename in d*\n",
-    "> do\n",
-    ">    ls $filename\n",
-    "> done\n",
-    "```\n",
-    "\n",
-    "How would the output differ from using this command instead?\n",
-    "\n",
-    "```bash\n",
-    "$ for filename in *d*\n",
-    "> do\n",
-    ">    ls $filename\n",
-    "> done\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 11 Saving to a file in a loop \n",
-    "\n",
-    "Consider running the following loop in the  `data/` directory:\n",
-    "\n",
-    "```bash\n",
-    "for book in *.txt\n",
-    "> do\n",
-    ">     echo $book\n",
-    ">     head -n 16 $book > headers.txt\n",
-    "> done\n",
-    "```\n",
-    "\n",
-    "Why would the following loop be preferable?\n",
-    "\n",
-    "```bash\n",
-    "for book in *.txt\n",
-    "> do\n",
-    ">     head -n 16 $book >> headers.txt\n",
-    "> done\n",
-    "```\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 12 Why does `history` record commands before running them?\n",
-    "\n",
-    "If you run the command:\n",
-    "\n",
-    "```bash\n",
-    "$ history | tail -n 5 > recent.sh\n",
-    "```\n",
-    "\n",
-    "The last command in the file is the `history` command itself, i.e., the shell has added `history` to the command log before actually running it. \n",
-    "In fact, the shell *always* adds commands to the log\n",
-    "before running them. Why do you think it does this?"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## BASH Advanced"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 1 Cleaning up\n",
-    "\n",
-    "As we have gone through this chapter, we have created several files that we won't need again.\n",
-    "We can clean them up with the following commands; briefly explain what each line does.\n",
-    "\n",
-    "```bash\n",
-    "$ cd ~/zipf\n",
-    "$ for file in $(find . -name \"*.bak\")\n",
-    "> do\n",
-    ">   rm $file\n",
-    "> done\n",
-    "$ rm bin/summarize_all_books.sh\n",
-    "$ rm -r results\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 2 Variables in shell scripts \n",
-    "\n",
-    "Imagine you have a shell script called `script.sh` that contains:\n",
-    "\n",
-    "```bash\n",
-    "head -n $2 $1\n",
-    "tail -n $3 $1\n",
-    "```\n",
-    "\n",
-    "With this script in your `data` directory, you type the following command:\n",
-    "\n",
-    "```bash\n",
-    "$ bash script.sh '*.txt' 1 1\n",
-    "```\n",
-    "\n",
-    "Which of the following outputs would you expect to see?\n",
-    "\n",
-    "1. All of the lines between the first and the last lines of each file ending in `.txt`\n",
-    "    in the `data` directory\n",
-    "2. The first and the last line of each file ending in `.txt` in the `data` directory\n",
-    "3. The first and the last line of each file in the `data` directory\n",
-    "4. An error because of the quotes around `*.txt`\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 3 Find the longest file with a given extension \n",
-    "\n",
-    "Write a shell script called `longest.sh` that takes the name of a directory and a filename extension as its arguments, and prints out the name of the file with the most lines in that directory with that extension. For example:\n",
-    "\n",
-    "```bash\n",
-    "$ bash longest.sh data/ txt\n",
-    "```\n",
-    "\n",
-    "would print the name of the `.txt` file in `data` that has the most lines."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 4 Script reading comprehension \n",
-    "\n",
-    "For this question, consider your `data` directory once again.\n",
-    "Explain what each of the following three scripts would do when run as `bash script1.sh *.txt`, `bash script2.sh *.txt`, and `bash script3.sh *.txt` respectively.\n",
-    "\n",
-    "```bash\n",
-    "# script1.sh\n",
-    "echo *.*\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "# script2.sh\n",
-    "for filename in $1 $2 $3\n",
-    "  do\n",
-    "    cat $filename\n",
-    "  done\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "# script3.sh\n",
-    "echo $@.txt\n",
-    "```\n",
-    "\n",
-    "(You may need to search online to find the meaning of `$@`.)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 5 Using `grep`\n",
-    "\n",
-    "Assume the following text from *The Adventures of Sherlock Holmes* is contained in a file called `excerpt.txt`:\n",
-    "\n",
-    "```text\n",
-    "To Sherlock Holmes she is always THE woman. I have seldom heard\n",
-    "him mention her under any other name. In his eyes she eclipses\n",
-    "and predominates the whole of her sex. It was not that he felt\n",
-    "any emotion akin to love for Irene Adler.\n",
-    "```\n",
-    "\n",
-    "Which of the following commands would provide the following output:\n",
-    "\n",
-    "```text\n",
-    "and predominates the whole of her sex. It was not that he felt\n",
-    "```\n",
-    "\n",
-    "1. `grep \"he\" excerpt.txt`\n",
-    "2. `grep -E \"he\" excerpt.txt`\n",
-    "3. `grep -w \"he\" excerpt.txt`\n",
-    "4. `grep -i \"he\" excerpt.txt`\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 6 Tracking publication years\n",
-    "\n",
-    "In Exercise [bash - pipe commands](https://software-engineering-group-up.github.io/RSE-UP/exercises/bash.html#3-piping-commands) you examined code that extracted the publication year from a list of book titles.\n",
-    "\n",
-    "Write a shell script called `year.sh` that takes any number of filenames as command-line arguments, and uses a variation of the code you used earlier to print a list of the unique publication years appearing in each of those files separately.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 7 Counting names \n",
-    "\n",
-    "You and your friend have just finished reading *Sense and Sensibility* and are now having an argument.\n",
-    "Your friend thinks that the elder of the two Dashwood sisters, Elinor, was mentioned more frequently in the book, but you are certain it was the younger sister, Marianne.\n",
-    "Luckily, `sense_and_sensibility.txt` contains the full text of the novel. \n",
-    "\n",
-    "Using a `for` loop, how would you tabulate the number of times each of the sisters is mentioned?\n",
-    "\n",
-    "Hint: one solution might employ the commands `grep` and `wc` and a `|`, while another might utilize `grep` options.\n",
-    "There is often more than one way to solve a problem with the shell; people choose solutions based on readability, speed, and what commands they are most familiar with."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 8 Matching and subtracting\n",
-    "\n",
-    "Assume you are in the root directory of the `zipf` project.\n",
-    "\n",
-    "Which of the following commands will find all files in `data` whose names end in `e.txt`, but do *not* contain the word `machine`?\n",
-    "\n",
-    "1.  `find data -name '*e.txt' | grep -v machine`\n",
-    "2.  `find data -name *e.txt | grep -v machine`\n",
-    "3.  `grep -v \"machine\" $(find data -name '*e.txt')`\n",
-    "4.  None of the above."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 9 `find` pipeline reading comprehension \n",
-    "\n",
-    "Write a short explanatory comment for the following shell script:\n",
-    "\n",
-    "```bash\n",
-    "wc -l $(find . -name '*.dat') | sort -n\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 10 Finding files with different properties \n",
-    "\n",
-    "The `find` command can be given criteria called \"tests\" to locate files with specific attributes, such as creation time, size, or ownership.\n",
-    "\n",
-    "Use `man find` to explore these, then write a single command using `-type`, `-mtime`, and `-user` to find all files in or below your Desktop directory that are owned by you and were modified in the last 24 hours.\n",
-    "\n",
-    "Explain why the value for `-mtime` needs to be negative."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}