README.md

-This repository will be used as the website for Parallelism and Concurrency CS-206. It will be updated weekly throughout the semester. This README contains general information about the class.
-
-- [previous-exams](previous-exams) contains PDFs for the previous exams.
-- [exercises](exercises) contains markdown documents for exercises and solutions.
-- [slides](slides) contains the slides presented in class.
-- [labs](labs) contains markdown documents for the labs.
-
-We will use GitLab's issue tracker as a discussion forum. Feel free to [open an issue](https://gitlab.epfl.ch/lamp/cs206/issues) if you have any comments or questions.
-
-# First-week tasks
-
-1. Join [the Discord](https://discord.gg/hJsreTeZjc)
-1. Log into gitlab: https://gitlab.epfl.ch/users/sign_in
-1. Please fill in [this table](https://docs.google.com/spreadsheets/d/1rcq_UMgR6bAH-iK1L2I6WoClZtCqUoIOLqQO3NJKdgg) with your GASPAR and SCIPER number
-   * Choose the group for the exercises
-   * This will initialize your GitLab repository for the course
-1. Follow the [Tools Setup](labs/tools-setup.md) page.
-1. Do the [example lab](labs/example-lab.md).
-1. Watch all videos under *Parallelism 1: Introduction to Parallel Programming* below
-1. Do the [first graded lab](labs/lab1-parallel-box-blur-filter/).
-
-# Grading
-
-The grading of the course is divided between exercies (5%), labs (25%), midterm exam (30%) and final exam (40%).
-
-# Staff
-
-| Role        | People |
-| :---        | :--- |
-| Professors  | [Martin Odersky](https://people.epfl.ch/martin.odersky), [Viktor Kunčak](https://people.epfl.ch/viktor.kuncak) |
-| TAs         | [Aleksander Boruch-Gruszecki](https://people.epfl.ch/aleksander.boruch-gruszecki), [Dragana Milovancevic](https://people.epfl.ch/dragana.milovancevic), [Guillaume Martres](https://people.epfl.ch/guillaume.martres), [Nicolas Stucki](https://people.epfl.ch/nicolas.stucki), [Olivier Blanvillain](https://people.epfl.ch/olivier.blanvillain) |
-| Student TAs | [Antoine Masanet](https://people.epfl.ch/antoine.masanet), [Lucas Giordano](https://people.epfl.ch/lucas.giordano), [Kajetan Pyszkowski](https://people.epfl.ch/kajetan.pyszkowski), [Marco Vögeli](https://people.epfl.ch/marco.vogeli), [Quentin Guignard](https://people.epfl.ch/quentin.guignard), [Sara Djambazovska](https://people.epfl.ch/sara.djambazovska) |
-
-# Course Schedule
-
-Lectures are partially live (on Zoom) and partially prerecorded (on YouTube).
-Live sessions will be held on Wednesdays from 14:15 to 16:00.
-Weekly Discord sessions will be held on Wednesdays from 14:15 to 16:00 for exercises (if it is a week with exercises) and 16:15 to 18:00 for labs.
-You should watch the prerecorded lectures before doing the exercies.
-In the first week of the semester, there will be a live Zoom session on Wednesday at 14:15 to welcome you to the class and answer questions you might have, followed by a Discord session.
-
-<!-- seq 0 7 100 | xargs -i date -d "02/24/2021 {} days" +"%d.%m.%Y"  -->
-
-| Week | Date     | Topic            | Lectures (14:15-16:00) | Exercises (14:15-16:00) | Labs (16:15-18:00) |
-| :--  | :--      | :--              | :--                    | :--                     | :--                |
-| 1    | 24.02.21 | Parallelism 1    | Prerecorded            | Welcome Zoom session    | Lab 1              |
-| 2    | 03.03.21 | Parallelism 2    | Prerecorded            | Exercise 1              | Lab 1 & 2          |
-| 3    | 10.03.21 | Parallelism 3    | Prerecorded            | Exercise 2              | Lab 2 & 3          |
-| 4    | 17.03.21 | Parallelism 4    | Prerecorded            | Exercise 3              | Lab 3 & 4          |
-| 5    | 24.03.21 | Concurrency 1    | Live                   |                         | Lab 4 & 5          |
-| 6    | 31.03.21 | Concurrency 2    | Live                   |                         | Lab 5 & 6          |
-| 7    | 07.04.21 | _Easter_         |                        |                         |                    |
-| 8    | 14.04.21 | **Midterm Exam** |                        |                         |                    |
-| 9    | 21.04.21 | Concurrency 3    | Live                   |                         | Lab 6              |
-| 10   | 28.04.21 | Actors 1         | Prerecorded            | Exercise 4              | Lab 7              |
-| 11   | 05.05.21 | Actors 2         | Prerecorded            | Exercise 5              | Lab 7              |
-| 12   | 12.05.21 | Spark 1          | Prerecorded            | Exercise 6              | Lab 8              |
-| 13   | 19.05.21 | Spark 2          | Prerecorded            | Exercise 7              | Lab 8 & 9          |
-| 14   | 26.05.21 | Spark 3          | Prerecorded            | Exercise 8              | Lab 9              |
-| 15   | 02.06.21 | **Final Exam**   |                        |                         |                    |
-
-Solutions to the exercises are released after each deadline. We do not provide solutions for the labs.
-
-Before each Discord session, students should watch videos corresponding to that week's topic:
-
-### Parallelism 1: Introduction to Parallel Programming
-
-- [Introduction to Parallel Computing](https://www.youtube.com/watch?v=94O72nyNFY0)
-- [Parallelism on the JVM I](https://www.youtube.com/watch?v=I8w-q1TPtjA)
-- [Parallelism on the JVM II](https://www.youtube.com/watch?v=BbVWGWTNAXw)
-- [Running Computations in Parallel](https://www.youtube.com/watch?v=KkMZGJ3M2-o)
-- [Monte Carlo Method to Estimate Pi](https://www.youtube.com/watch?v=VBCf-aTgpPU)
-- [First-Class Tasks](https://www.youtube.com/watch?v=mrVVaXCuhBc)
-- [How Fast are Parallel Programs?](https://www.youtube.com/watch?v=Lpnexp_Qxgo)
-- [Benchmarking Parallel Programs](https://www.youtube.com/watch?v=LvS_kjCssfg)
-
-### Parallelism 2: Basic Task Parallel Algorithms
-
-- [Parallel Sorting](https://www.youtube.com/watch?v=AcuvVgQbphg)
-- [Data Operations and Parallel Mapping](https://www.youtube.com/watch?v=ghYtMLrphZw)
-- [Parallel Fold (Reduce) Operation](https://www.youtube.com/watch?v=hEBgyhIoWww)
-- [Associativity I](https://www.youtube.com/watch?v=q-Cl3whISCY)
-- [Associativity II](https://www.youtube.com/watch?v=XBjqYavDUB8)
-- [Parallel Scan (Prefix Sum) Operation](https://www.youtube.com/watch?v=CYr3YaQiMwo)
-
-### Parallelism 3: Data-Parallelism
-
-- [Data-Parallel Programming](https://www.youtube.com/watch?v=WW7TabCiOV8)
-- [Data-Parallel Operations I](https://www.youtube.com/watch?v=Vd35YQ8DEO4)
-- [Data-Parallel Operations II](https://www.youtube.com/watch?v=dcMgKtuAh3s)
-- [Scala Parallel Operations](https://www.youtube.com/watch?v=NjkxjAT7ohE)
-- [Splitters and Combiners](https://www.youtube.com/watch?v=Redz85Nlle4)
-
-### Parallelism 4: Data-Structures for Parallel Computing
-
-- [Implementing Combiners](https://www.youtube.com/watch?v=dTP0ntniB2I)
-- [Parallel Two-phase Construction](https://www.youtube.com/watch?v=XcMtq3OdjQ0)
-- [Conc-Tree Data Structure](https://www.youtube.com/watch?v=cUXHXKL8Xvs)
-- [Amortized, Constant-Time Append Operation](https://www.youtube.com/watch?v=Ic5DUZLITVI)
-- [Conc-Tree Combiners](https://www.youtube.com/watch?v=aLfFlCC1vjc)
-
-### Concurrency 1, 2 & 3
-
-- Live lectures
-
-### Actors 1
-
-- [Introduction: why actors?](https://www.youtube.com/watch?v=ZQAe9AItH8o)
-- [The Actor Model](https://www.youtube.com/watch?v=c49tDZuFtPA)
-
-### Actors 2
-
-- [Message Processing Semantics](https://www.youtube.com/watch?v=Uxn1eg6R0Fc)
-- [Designing Actor Systems](https://www.youtube.com/watch?v=uxeMJLo3h9k)
-- [Testing Actor Systems](https://www.youtube.com/watch?v=T_2nwLr-H2s)
-
-### Spark 1: Spark Basics
-
-- [From Parallel to Distributed](https://www.youtube.com/watch?v=bfMbJ8NzTZI)
-- [Latency](https://www.youtube.com/watch?v=igNIz2Ent5E)
-- [RDDs, Spark's Distributed Collection](https://www.youtube.com/watch?v=EuVmW62aIXI)
-- [RDDs: Transformations and Actions](https://www.youtube.com/watch?v=qJlfATheS38)
-- [Evaluation in Spark: Unlike Scala Collections!](https://www.youtube.com/watch?v=0pVYuuUrN74)
-- [Cluster Topology Matters](https://www.youtube.com/watch?v=lS4vRzwrmtU)
-
-### Spark 2: Reduction Operations & Distributed Key-Value Pairs
-
-- [Reduction Operations](https://www.youtube.com/watch?v=JhF0_Ka_iqU)
-- [Pair RDDs](https://www.youtube.com/watch?v=kIUzgweDMUs)
-- [Transformations and Actions on Pair RDDs](https://www.youtube.com/watch?v=ovf0GFbnp5g)
-- [Joins](https://www.youtube.com/watch?v=kYpaZpj4qTM)
-
-### Spark 3: Partitioning and Shuffling
-
-- [Shuffling: What it is and Why it's important](https://www.youtube.com/watch?v=LrgA4PrKrks)
-- [Partitioning](https://www.youtube.com/watch?v=sTcki6mxjcA)
-- [Optimizing with Partitioners](https://www.youtube.com/watch?v=4Vfp5kp2jnE)
-- [Wide vs Narrow Dependencies](https://www.youtube.com/watch?v=L9BnaYp10c8)
-
-
-# Labs
-
-Labs are individual assignments where you get to write Scala programs using the concepts learned during lectures.
-Labs are submitted by pushing your code on GitLab, see details in the [grading and submission](labs/grading-and-submission.md) page.
-
-| Labs  | Name                       | Start date | Due date (23:59 [AoE](https://en.wikipedia.org/wiki/Anywhere_on_Earth)) |
-| :--   | :--                        | :--        | :--        |
-| Lab 1 | Parallel Box Blur Filter   | 22.02.21   | 07.03.2021 |
-| Lab 2 | Reductions and Prefix Sums | 01.03.21   | 14.03.2021 |
-| Lab 3 | K-Means                    | 08.03.21   | 21.03.2021 |
-| Lab 4 | Barnes-Hut Simulation      | 15.03.21   | 28.03.2021 |
-| Lab 5 | Bounded Buffer             | 22.03.21   | 04.04.2021 |
-| Lab 6 | Lock-free Sorted List      | 29.03.21   | 25.04.2021 |
-| Lab 7 | Actors Binary Tree         | 26.04.21   | 09.05.2021 |
-| Lab 8 | Wikipedia                  | 10.05.21   | 23.05.2021 |
-| Lab 9 | StackOverflow              | 17.05.21   | 30.05.2021 |
-
-# Exercises
-
-Exercises are pen and paper style questions that will help you consolidate the knowledge learned during lectures.
-Exercises should be done in groups and submitted on GitLab.
-You should form groups of up to five students for each exercise, solve the exercise remotely with your group (using Discord, Hangouts, Zoom, ...), and write your solutions in a text file.
-The first line of your solution file should list all the group members' SCIPER numbers.
-After you solve the exercise with your group, each member should submit a copy of this file to their GitLab repository following the instructions given in the problem statement.
-Exercises will be given a participation grade at the end of the semester, which accounts for 5% of the overall course grade.
-
-| Exercises  | Start date | Due date (23:59 [AoE](https://en.wikipedia.org/wiki/Anywhere_on_Earth)) |
-| :--        | :--        | :--        |
-| Exercise 1 | 01.03.2021 | 07.03.2021 |
-| Exercise 2 | 08.03.2021 | 14.03.2021 |
-| Exercise 3 | 15.03.2021 | 21.03.2021 |
-| Exercise 4 | 26.04.2021 | 02.05.2021 |
-| Exercise 5 | 03.05.2021 | 09.05.2021 |
-| Exercise 6 | 10.05.2021 | 16.05.2021 |
-| Exercise 7 | 17.05.2021 | 23.05.2021 |
-| Exercise 8 | 24.05.2021 | 30.05.2021 |
-
-# Exams
-
-The midterm exam will take place on 14.04.21. The midterm exam will cover all the material seen in the class up to week 6 (included).
-
-The final exam will take place on 02.06.21. The final exam will cover all material seen during the semester.
-
-Information about exams organization will be communicated by email.
+Moved to [Moodle](https://moodle.epfl.ch/course/view.php?id=14388).

exercises/exercise-1.md

-# Exercise 1
-
-Use the following commands to make a fresh clone of your repository:
-
-```
-git clone -b exercise-1 git@gitlab.epfl.ch:lamp/student-repositories-s21/cs206-GASPAR.git exercise-1
-```
-
-Update the README.md file with your solutions. Don't forget to list the group members' SCIPER numbers.
-
-# Problem 1: Introduction to Concurrency
-
-Freshly graduated from EPFL, you all have been hired as contractors for a successful and rapidly growing bank. The bank has recently been experiencing problems with their money management system, coded in Scala, and so they hired the best and brightest young engineers they could find: you! The system has been working perfectly fine so far, they tell you. In the past days, due to an increased number of customers, they had to switch from a single threaded sequential execution environment to a multithreaded concurrent environment, in which multiple threads may perform transactions concurrently. That's when problems started, your manager says…
-
-Below is the code responsible to withdraw money from the account from and transfer it to the account to, within the same bank.
-
-```scala
-def transfer(from: Account, to: Account, amount: BigInt) {
-  require(amount >= 0)
-
-  val balanceFrom = from.balance
-  if (balanceFrom >= amount) {
-    from.balance = balanceFrom - amount
-    val balanceTo = to.balance
-    to.balance = balanceTo + amount
-  }
-}
-```
-
-For the bank, it is very important that the following two properties hold after any sequence of completed transfer transactions:
-
-1. The balance of an account never goes below 0.
-2. The total sum of money held by the bank is constant.
-
-## Question 1
-
-Does the above transfer method respect the two properties in a *sequential* execution environment, that is, when there is only one thread in the program?
-
-## Question 2
-
-What can go wrong in a setting where multiple threads can execute the `transfer` method concurrently? For each of the two desired properties of the system, check if its holds in this concurrent environment. If not, come up with an example execution which exhibits a violation of the property.
-
-# Question 3
-
-For each of the proposed implementations of `transfer` below, check which of the properties hold. Additionally, check if the system is vulnerable to *deadlocks*.
-
-Variant 1
-
-```scala
-def transfer(from: Account, to: Account, amount: Long): Unit = {
-  require(amount >= 0)
-
-  val balanceFrom = from.balance
-  if (balanceFrom >= amount) {
-    from.synchronized {
-      from.balance = balanceFrom - amount
-    }
-    to.synchronized {
-      val balanceTo = to.balance
-      to.balance = balanceTo + amount
-    }
-  }
-}
-```
-
-Variant 2
-
-```scala
-def transfer(from: Account, to: Account, amount: Long): Unit = {
-  require(amount >= 0)
-
-  from.synchronized {
-    val balanceFrom = from.balance
-    if (balanceFrom >= amount) {
-      from.balance = balanceFrom - amount
-      to.synchronized {
-        val balanceTo = to.balance
-        to.balance = balanceTo + amount
-      }
-    }
-  }
-}
-```
-
-Variant 3
-
-```scala
-object lock // Global object
-def transfer(from: Account, to: Account, amount: Long): Unit = {
-  require(amount >= 0)
-
-  lock.synchronized {
-    val balanceFrom = from.balance
-    if (balanceFrom >= amount) {
-      from.balance = balanceFrom - amount
-      val balanceTo = to.balance
-      to.balance = balanceTo + amount
-    }
-  }
-}
-```
-
-# Problem 2: Parallel Reductions
-
-## Question 1
-
-As a group, write a function called `minMax`, which should take a non-empty array as input and return a pair containing the smallest and the largest element of the array.
-
-```scala
-def minMax(a: Array[Int]): (Int, Int) = ???
-```
-
-Now write a parallel version of the function. You may use the constructs `task` and/or `parallel`, as seen in the lectures.
-
-## Question 2
-
-Imagine that the data structure you are given, instead of an `Array[A]`, is one called `ParSeq[A]`. This class offers the two following methods, which work in parallel:
-
-```scala
-def map[B](f: A => B): ParSeq[B]
-def reduce(f: (A, A) => A): A
-```
-
-Can you write the following `minMax` function in terms of `map` and/or `reduce` operations ?
-
-```scala
-def minMax(data: ParSeq[Int]): (Int, Int) = ???
-```
-
-## Question 3
-
-What property does the function `f` passed to reduce need to satisfy in order to have the same result regardless on how reduce groups the applications of the operation f to the elements of the data structure? Prove that your function `f` indeed satisfies that property.

grading-gitlab-ci.yml

+# This CI config file is not used in this repository but instead referenced
+# from each student project (https://gitlab.epfl.ch/help/ci/pipelines/settings#custom-ci-configuration-path)
+# and used to grade them.
+
+workflow:
+  rules:
+    # Don't run the CI on commit messages contain "[no-ci]", used to deploy
+    # assignments without overloading the CI.
+    - if: $CI_COMMIT_MESSAGE !~ /\[no-ci\]/
+
+stages:
+  - build
+  - grade
+
+compile:
+  stage: build
+  timeout: 10m
+  image: ${DOCKER_REPO}/compile
+  tags:
+    - cs210
+  except:
+    - tags
+    - main
+  script:
+    - sbt packageSubmission
+  # Output of this job that needs to be stored to be reused in the grade job below
+  artifacts:
+    expire_in: 24h
+    paths:
+      - submission.jar
+
+grade:
+  stage: grade
+  timeout: 10m
+  except:
+    - tags
+    - main
+  tags:
+    - cs210
+  variables:
+    JAR_PATH: "${CI_PROJECT_DIR}/submission.jar"
+  image: ${DOCKER_REPO}/grader-${CI_COMMIT_BRANCH}
+  allow_failure: true
+  script: "😎"

labs/example-lab.md

-# Example Lab
-
-The goal of this assignment is to familiarize yourself with the infrastructure and tools used in this class. Even though the grade in this assignment won't influence your grade for the course, it is important that you work through this assignment carefully.
-
-## Part 1: Obtaining the Project Files
-
-First, make sure you've followed the [Tools Setup](tools-setup.md) page.
-
-**At this point, we strongly encourage you to take the time to read at least the first three chapters of the [Git Book](https://git-scm.com/book/en/v2). If you just copy-paste the commands we give you without understanding them, it's likely that you'll make a mistake somewhere and waste time. Git can be a huge productivity enhancer when used correctly, so it's definitely worth the investment!**
-
-We'll starting by cloning the repository containing all our assignment (make
-sure to replace `GASPAR` with your EPFL username (the one with letters, not the
-one with number) in the following command).
-
-```shell
-git clone -b example git@gitlab.epfl.ch:lamp/student-repositories-s21/cs206-GASPAR.git cs206-example
-```
-
-```shell
-cd cs206-example
-```
-
-Now that we've obtained the project, let's take a look at its structure:
-
-```shell
-.
-├── build.sbt
-├── project
-│   ├── ...
-└── src
-    ├── main
-    │   └── scala
-    │       └── example
-    │           └── Lists.scala
-    └── test
-        └── scala
-            └── example
-                └── ListsSuite.scala
-```
-
-- All the files ending with `.sbt` or in the `project/` directory are build tool configuration files: you don't need to modify them or look at them for any of the assignments
-- The project sources are in `src/main/scala/`
-- The sources of the unit tests are in `src/test/scala/`. You will need to make all the tests pass to complete the assignments, and you should write additional tests to check for cases that our tests do not cover.
-
-## Part 2: Using sbt
-
-Start sbt by running:
-```shell
-sbt
-```
-
-Once it's finished starting (this may take a while), you'll be able to enter sbt
-commands. You can compile your project using `compile` and run the tests with
-`test` (this automatically compiles your code if needed to). Note that if
-compilation fails, no tests will be run. The first time you'll run `test` in an
-assignment you should see many errors: that's normal, your job is to make the
-tests pass! To do this, it's useful to understand in details what the test
-output means, here's an example:
-
-![](images/sbt-test-error.png)
-
-This tells us several things:
-
-- There's a test named `max of a few numbers (10pts)` in the class `ListsSuite` in the package `example`
-- The test failed with an exception: `scala.NotImplementedError: an implementation is missing`. This is followed by a stack trace showing where the exception happened.
-- This exception was thrown from the method `scala.Predef$.???` in the file `Predef.scala` at line 284.
-- This method was called from `example.Lists$.max` in the file `Lists.scala` at line 40.
-- ... which was itself called from the method `example.ListsSuite.max of a few
-  numbers` in the file `ListsSuite.scala` at line 83.
-
-It's now time to look at some code: the next section will show you how to start and navigate using the IDE.
-
-## Part 3: Using the IDE
-
-### Startup
-
-This course is run with an experimental version of Scala called Dotty that will become Scala 3 in the future. Because it's so new, most IDEs like IntelliJ and Eclipse are unlikely to work correctly with it. Thankfully we've developed our own IDE support. It's designed to work with any text editor but we currently only support VSCode. If you've followed the [Tools Setup](https://lampepfl-courses.github.io/moocs/tools-setup/Tools%20Setup.html) page you should have VSCode installed by now, but don't start it just yet, instead run the following command from `sbt`:
-```shell
-launchIDE
-```
-
-This will download the Dotty extension for VSCode and set everything up. You will need to do this for every assignment, and we recommend always using this command to start the IDE.
-
-The first time the IDE starts, it will take some time to download more components, as displayed in the bottom left:
-
-![](images/downloading-dls.png)
-
-#### Data collection
-
-Fixing bugs in the compiler and the IDE is much easier when we have all the information needed to reproduce them. To help us achieve that, we've added an optional data collection mechanism in the IDE extension, when you start an assignment, you'll see the following pop-up:
-![](images/telemetry-allow.png)
-
-You are free to either allow or deny the data collection, but we would appreciate it if you clicked "Allow". If you do, you'll contribute to making Scala better! If you change your mind, you can turn on or off the data collection at any time by clicking on the "Scala telemetry" button on the bottom-left of the IDE window:
-
-![](images/telemetry-status.png)
-
-
-### Usage
-
-It's now time to dig in! Earlier we talked about a failing test, the stack trace told us that it was failing on line 83 of the file ListsSuite.scala, so let's open that file:
-
-![](images/open-test.png)
-
-Here's the source code of the test method:
-
-![](images/test-source.png)
-
-This looks like a regular method except for a few things:
-
-- It starts with `@Test`, this is an annotation that lets JUnit (the testing framework we use) know that this is a test method.
-- The name of the method starts and ends with backticks (\`): this is what allows us to put spaces in the method name. Normally, names defined in Scala cannot contain special characters such as spaces or dashes, but any character is allowed as long as backticks are put around the name (even emojis 🔥!). We've taken advantage of this in the tests we define to give them nicer names: `max of a few numbers failed` is easier to read than `maxOfAFewNumbers failed`, but this is just a convention: if you define your own tests you're free to name them however you want.
-
-Recall that the second line of the stack trace was:
-```scala
-at example.Lists$.max(Lists.scala:40)
-```
-
-This tells us that the crash happened when calling `max`, we can hover with our mouse over the call to `max` in the test method to get more information on it:
-
-![](images/hover.png)
-
-
-The hover is split into two parts: the first part is:
-```scala
-(xs: List[Int]): Int
-```
-This means that `max` is a method that takes a `List` of `Int` as argument and
-returns an `Int`. The second part is the documentation of `max`. We can jump to
-the definition of max by `Ctrl+click` (`Cmd+click` on Mac) or by `right click ->
-Go to Definition` (*note: this is currently broken under Windows, you'll have to
-manually open `src/main/scala/example/Lists.scala`*). Once there we see:
-
-![](images/max-def.png)
-
-Now we know why the test failed: `max` calls `???`, which is a method defined in the Scala standard library that simply crashes your program: whenever you see it in an assignment it means that this is something you need to replace by your own implementation.
-
-You now know enough to be able to work with the IDE, here are some additional tips:
-
-- When you press `Enter` to make a new line, the IDE will automatically indent the
-  line if needed (for example, if the last word on the previous line was
-  `then`), however it will never unindent code for you (for example, when
-  writing `else`). You can always indent code manually by pressing `Tab` and
-  unindent it by pressing `Shift + Tab`.
-- When working on an assignment,  you are free to create as many methods, classes and objects as you want. **But you shouldn't change the name of existing methods, classes and objects, because that may break the automated grading system, this is important!**.
-- You can see a list of all warnings and errors reported by the compiler by clicking on ![](images/warnings-errors.png) at the bottom left of VSCode.
-- The IDE can show you on hover the documentation of classes, defs and vals defined in the current project but support for external project is currently missing. To compensate for this, you can consult the documentation online:
-  - The documentation for the Scala standard library is at [https://www.scala-lang.org/files/archive/api/2.13.1/](https://www.scala-lang.org/files/archive/api/2.13.1/)
-  - The documentation for the Java standard library is at [https://docs.oracle.com/en/java/javase/11/docs/api/index.html](https://docs.oracle.com/en/java/javase/11/docs/api/index.html)
-- You can customize Visual Studio Code as much as you want, including installing additional extensions, but please avoid installing other Scala-related extensions: they may conflict with the one we use for this course.
-- While working on your assignment, you will regularly want to go back to the sbt console to run the tests. You could simply run the command `test` every time, but you can take advantage of the watch mode instead: if a command is prefixed by `~`, sbt will watch the source directory for changes and re-run the command every time a file is saved. So a possible workflow is:
-
-    1. Start sbt
-    2. Run `launchIDE`
-    3. Once the IDE has started, go back to sbt and run `~test` (or run `~compile` if you don't want to look at the tests)
-    4. Work in the IDE, and check the output of the sbt console from time to time
-
-- We're actively working on improving the IDE support using Visual Studio Code
-  and interested in hearing your ideas and suggestions. Feel free to share your
-  feedback (both good and bad) with us using Gitlab issues!
-
-## Part 4: Running your code
-
-Writing code and running tests is nice, but sometimes more direct feedback is useful, like when you want to experiment with Scala, or try out some methods that you implemented. You can do this using the Scala REPL (Read/Eval/Print Loop) or with a worksheet.
-
-### The REPL
-After having started sbt, you can start the REPL by typing `console`, you will see the following prompt:
-```scala
-scala>
-```
-At this point you can write any Scala expression you want, for example:
-```scala
-scala> val l = List(3,7,2)
-val l: List[Int] = List(3, 7, 2)
-```
-
-(If you write an expression without wrapping it in a `val` or a `def`, the REPL will give it a name for you, starting with `res`)
-
-```scala
-scala> l.isEmpty
-val res0: Boolean = false
-
-scala> println(res0)
-false
-
-scala> l.tail.head
-res1: Int = 7
-
-scala> List().isEmpty
-res2: Boolean = true
-```
-
-The classes of the assignment are available inside the REPL, so you can for instance import all the methods from `object Lists` and start using `max`:
-
-```scala
-scala> import example.Lists._
-import example.Lists._
-
-scala> max(List(1,3,2))
-res1: Int = 3
-```
-
-You can enter a multiline expression in the REPL by using `Alt+Enter`
-(`Option+Enter` on macOS) instead of `Enter`:
-
-```scala
-scala> if 1 == 1 then
-     |   "a"
-     | else
-     |   "b"
-val res0: String = a
-```
-
-In order to exit the Scala REPL and go back to sbt, type `Ctrl+D`.
-
-### The worksheet mode
-A *worksheet* is a file where every line of code written in the IDE is executed and its output displayed as a comment.
-
-#### Creating a worksheet
-Any file that ends in `.sc` is considered to be a worksheet by the IDE. Once VSCode is launched in a project, all you have to do is create a new file and save it (`Ctrl+N, Ctrl+S`) using any name as long as it ends in `.sc`.
-
-#### Using the worksheet mode
-
-Inside this file, you can type any line of code you would type in the REPL. To run the worksheet, either press the "Run this worksheet" button at the top of the file, or save the file. Each line of code will be executed one by one and its output is shown in green on the right. If your code contains an infinite loop, the worksheet will never finish running by itself, but you can cancel it by clicking the same button used to run the worksheet at the top of the file.
-
-**IMPORTANT**: When you run a worksheet, you should have sbt open and either `~test` or `~compile` running as recommended in Part 3, otherwise changes to other files won't be reflected in the output of your worksheet.
-
-## Part 5: Submitting your Solution
-
-[Click here to learn how to submit your assignment.](grading-and-submission.md)

labs/grading-and-submission.md

-# Grading and submission
-
-## Local tests and grading
-
-Each lab is shipped with two sets of tests:
-  * The tests defined under `src/test/scala`, these are usually incomplete: we
-    strongly encourage you to write additional tests to exercise every aspect of
-    your code. You can run these tests from `sbt` using the following command:
-    ```shell
-    test
-    ```
-  * The **grading tests**, that we use to grade your labs, these are
-    provided as a "black box": you can run them but are not allowed to see their
-    content, to encourage you to write your own tests. You can run them from
-    `sbt` using the following command:
-    ```shell
-    grading:test
-    ```
-
-    Your grade is determined by the number of these tests that pass, see the
-    next section to see how to actually get a grade.
-
-(remember that you can always put `~` before an sbt command to automatically
-re-run it when you save a file)
-
-## Committing and pushing your code
-
-**You need to push your code to gitlab before the deadline for the lab to
-receive a grade. If you forget, your grade will be zero.**
-
-If you've read the first few chapters of [Git
-book](https://git-scm.com/book/en/v2) as recommended, you must already be
-familiar with committing and pushing, but let's go over the basics once again:
-
-At any point while working on an lab, you can see what changes you
-haven't committed by writing:
-```shell
-git status
-```
-
-(If you get the error `Not a valid command: git`, it means you're inside sbt,
-you can't run git from sbt itself, you need to open another terminal in the same
-directory)
-
-This will display the list of files you have modified since the last commit, to
-see the exact changes you made, run:
-```shell
-git diff
-```
-
-To save these changes in a commit, run: (replace `"My message"` by a message
-describing the changes since the last commit, see [How to Write a Git Commit
-Message](https://chris.beams.io/posts/git-commit/) for some tips on writing
-good commit messages)
-```shell
-git commit -am "My message"
-```
-
-(It's good practice to commit your code regularly to document your changes)
-
-You can then synchronize your local git repository with the gitlab server by
-first running:
-```shell
- git pull --no-rebase
-```
-
-This will merge in your local repository any change we made to the lab
-(we only change labs to fix critical bugs found after it's been released,
-so most of the time this will not do anything).
-
-Finally, you can push your changes to gitlab:
-```shell
-git push
-```
-
-Note that there are also graphical user interfaces to interact with git, for
-example [VSCode has built-in git
-support](https://code.visualstudio.com/docs/editor/versioncontrol#_git-support).
-
-Once you've pushed your code, you can see the result online by going to
-`gitlab.epfl.ch/lamp/students-repositories-s21/cs206-GASPAR/pipelines` where
-`GASPAR` is your username (you can also access this page from the main page of
-your repository by clicking on the rocket icon on the left side of the gitlab
-interface, then clicking on "Pipelines").
-
-![](images/pipeline-tab.png)
-
-The grading pipeline contains two steps:
-  * *compile*: your code does not compile for grading if the job fail.
-  * *grade*: the job results in a warning if you do not get the maximum grade
-    (10.00/10.00)
-
-If a job is marked "pending", it means there are other students running jobs at
-the same time and you'll have to wait a bit for your job to run.
-
-You can click on the `grade` job to see its output:
-
-![](images/pipeline-details.png)
-
-![](images/pipeline-logs.png)
-
-Your grade is given on the line that starts with `Your overall score for this
-lab is`
-
-**If you push to gitlab multiple times, your final grade will be based on the
-last commit you pushed before the deadline.**