src/main/scala/concpar22final03/Economics.scala

+package concpar22final03
+
+import scala.concurrent.Future
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+import scala.util.Random
+
+trait Economics:
+
+  /** A trading card from the game Scala: The Programming. We can own a card,
+    * but once don't anymore.
+    */
+  final class Card(val name: String)
+  def isMine(c: Card): Boolean
+
+  /** This function uses the best available database to return the sell value of
+    * a card on the market.
+    */
+  def valueOf(cardName: String): Int = List(1, cardName.length).max
+
+  /** This method represents an exact amount of money that can be hold, spent,
+    * or put in the bank
+    */
+  final class MoneyBag()
+  def moneyIn(m: MoneyBag): Int
+
+  /** If you sell a card, at some point in the future you will get some money
+    * (in a bag).
+    */
+  def sellCard(c: Card): Future[MoneyBag]
+
+  /** You can buy any "Scala: The Programming" card by providing a bag of money
+    * with the appropriate amount and waiting for the transaction to take place.
+    * You will own the returned card.
+    */
+  def buyCard(money: MoneyBag, name: String): Future[Card]
+
+  /** This simple bank account holds money for you. You can bring a money bag to
+    * increase your account's balance, or withdraw a money bag of any size not
+    * greater than your account's balance.
+    */
+  def balance: Int
+  def withdraw(amount: Int): Future[MoneyBag]
+  def deposit(bag: MoneyBag): Future[Unit]
+
+  class NotEnoughMoneyException
+      extends Exception("Not enough money provided to buy those cards")

src/main/scala/concpar22final03/Problem3.scala

+package concpar22final03
+
+import scala.concurrent.Future
+import concurrent.ExecutionContext.Implicits.global
+
+trait Problem3:
+  val economics: Economics
+  import economics.*
+
+  /** The objective is to propose a service of deck building. People come to you
+    * with some money and some cards they want to sell, and you need to return
+    * them a complete deck of the cards they want.
+    */
+  def orderDeck(
+      bag: MoneyBag,
+      cardsToSell: List[Card],
+      wantedDeck: List[String]
+  ): Future[List[Card]] =
+    Future {
+      val totalGivenMoney =
+        cardsToSell.foldLeft(moneyIn(bag))((sum, c) => sum + valueOf(c.name))
+      val totalNeededMoney =
+        wantedDeck.foldLeft(0)((sum, n) => sum + valueOf(n))
+      if totalGivenMoney < totalNeededMoney then
+        throw new NotEnoughMoneyException()
+      val soldCards: Future[Unit] =
+        if moneyIn(bag) != 0 then
+          sellListOfCards(cardsToSell).zip(deposit(bag)).map(_ => ())
+        else sellListOfCards(cardsToSell).map(_ => ())
+      soldCards.flatMap { _ => buyListOfCards(wantedDeck) }
+    }.flatten
+
+  /** This helper function will sell the provided list of cards and put the
+    * money on your personal bank account. It returns a Future of Unit, which
+    * indicates when all sales are completed.
+    */
+  def sellListOfCards(cardsToSell: List[Card]): Future[Unit] =
+    val moneyFromSales: List[Future[Unit]] = cardsToSell.map { c =>
+      sellCard(c).flatMap(m => deposit(m).map { _ => })
+    }
+    Future
+      .sequence(moneyFromSales)
+      .map(_ =>
+        ()
+      ) // Future.sequence transforms a List[Future[A]] into a Future[List[A]]
+
+  /** This helper function, given a list of wanted card names and assuming there
+    * is enough money in the bank account, will buy (in the future) those cards,
+    * and return them.
+    */
+  def buyListOfCards(wantedDeck: List[String]): Future[List[Card]] =
+
+    val boughtCards: List[Future[Card]] = wantedDeck.map { name =>
+      withdraw(valueOf(name)).flatMap(mb => buyCard(mb, name))
+    }
+    Future.sequence(boughtCards)

src/main/scala/concpar22final04/Problem4.scala

+package concpar22final04
+
+import akka.actor.*
+import akka.testkit.*
+import java.util.Date
+import akka.event.LoggingReceive
+import akka.pattern.*
+import akka.util.Timeout
+import concurrent.duration.*
+import scala.concurrent.Future
+import scala.concurrent.ExecutionContext
+
+given timeout: Timeout = Timeout(200.millis)
+
+/** Data associated with a song: a unique `id`, a `title` and an `artist`.
+  */
+case class Song(id: Int, title: String, artist: String)
+
+/** An activity in a user's activity feed, representing that `userRef` is
+  * listening to `songId`.
+  */
+case class Activity(userId: String, userName: String, songId: Int)
+
+/** Companion object of the `User` class.
+  */
+object User:
+  /** Messages that can be sent to User actors.
+    */
+  enum Protocol:
+    /** Asks for a user name and id. Should be answered by a Response.Info.
+      */
+    case GetInfo
+
+    /** Asks home page data. Should be answered by a Response.HomepageData.
+      */
+    case GetHomepageData
+
+    /** Like song with id `songId`.
+      */
+    case Like(songId: Int)
+
+    /** Unlike song with id `songId`.
+      */
+    case Unlike(songId: Int)
+
+    /** Adds `subscriber` to the list of subscribers.
+      */
+    case Subscribe(subscriber: ActorRef)
+
+    /** Remove `subscriber` from the list of subscribers.
+      */
+    case Unsubscribe(subscriber: ActorRef)
+
+    /** Adds the activity `activity` to the activity feed. This message will be
+      * sent by the users this user has subscribed to.
+      */
+    case AddActivity(activity: Activity)
+
+    /** Sent when a user starts playing a song with id `songId`. The recipient
+      * should notify all its subscribers to update their activity feeds by
+      * sending them `AddActivity(Activity(...))` messages. No answer is
+      * expected. This message is sent by external actors.
+      */
+    case Play(songId: Int)
+
+    /** Asks for home page text. Should be answered by a Response.HomepageText.
+      */
+    case GetHomepageText
+
+  /** Responses that can be sent back from User actors.
+    */
+  enum Responses:
+    /** Answer to a Protocol.GetInfo message
+      */
+    case Info(id: String, name: String)
+
+    /** Answer to a Protocol.GetHomepageData message
+      */
+    case HomepageData(songIds: List[Int], activities: List[Activity])
+
+    /** Answer to a Protocol.GetHomepageText message
+      */
+    case HomepageText(result: String)
+
+/** The `User` actor, responsible to handle `User.Protocol` messages.
+  */
+class User(id: String, name: String, songsStore: ActorRef) extends Actor:
+  import User.*
+  import User.Protocol.*
+  import User.Responses.*
+  import SongsStore.Protocol.*
+  import SongsStore.Responses.*
+
+  given ExecutionContext = context.system.dispatcher
+
+  /** Liked songs, by reverse date of liking time (the last liked song must be
+    * the first must be the first element of the list). Elements of this list
+    * must be unique: a song can only be liked once. Liking a song twice should
+    * not change the order.
+    */
+  var likedSongs: List[Int] = List()
+
+  /** Users who have subscribed to this users.
+    */
+  var subscribers: Set[ActorRef] = Set()
+
+  /** Activity feed, by reverse date of activity time (the last added activity
+    * must be the first element of the list). Items in this list should be
+    * unique by `userRef`. If a new activity with a `userRef` already in the
+    * list is added, the former should be removed, so that we always see the
+    * latest activity for each user we have subscribed to.
+    */
+  var activityFeed: List[Activity] = List()
+
+  /** This actor's behavior. */
+
+  override def receive: Receive = LoggingReceive {
+    case GetInfo =>
+      sender() ! Info(id, name)
+    case GetHomepageData =>
+      sender() ! HomepageData(likedSongs, activityFeed)
+    case Like(songId) if !likedSongs.contains(songId) =>
+      likedSongs = songId :: likedSongs
+    case Unlike(songId) =>
+      likedSongs = likedSongs.filter(_ != songId)
+    case Subscribe(ref: ActorRef) =>
+      subscribers = subscribers + ref
+    case Unsubscribe(ref: ActorRef) =>
+      subscribers = subscribers - ref
+    case AddActivity(activity: Activity) =>
+      activityFeed =
+        activity :: activityFeed.filter(_.userId != activity.userId)
+    case Play(songId) =>
+      subscribers.foreach(_ ! AddActivity(Activity(id, name, songId)))
+    case GetHomepageText =>
+      val likedSongsFuture: Future[Songs] =
+        (songsStore ? GetSongs(likedSongs)).mapTo[Songs]
+      val activitySongsFuture: Future[Songs] =
+        (songsStore ? GetSongs(activityFeed.map(_.songId))).mapTo[Songs]
+      val response: Future[HomepageText] =
+        for
+          likedSongs <- likedSongsFuture;
+          activitySongs <- activitySongsFuture
+        yield HomepageText(
+          f"""
+          |Howdy ${name}!
+          |
+          |Liked Songs:
+          |${likedSongs.songs
+              .map(song => f"* ${song.title} by ${song.artist}")
+              .mkString("\n")}
+          |
+          |Activity Feed:
+          |${activityFeed
+              .zip(activitySongs.songs)
+              .map((activity, song) =>
+                f"* ${activity.userName} is listening to ${song.title} by ${song.artist}"
+              )
+              .mkString("\n")}""".stripMargin.trim
+        )
+      response.pipeTo(sender())
+  }
+
+/** Objects containing the messages a songs store should handle.
+  */
+object SongsStore:
+  /** Ask information about a list of songs by their ids.
+    */
+  enum Protocol:
+    case GetSongs(songIds: List[Int])
+
+  /** List of `Song` corresponding to the list of IDs given to `GetSongs`.
+    */
+  enum Responses:
+    case Songs(songs: List[Song])
+
+/** A mock implementation of a songs store.
+  */
+class MockSongsStore extends Actor:
+  import SongsStore.Protocol.*
+  import SongsStore.Responses.*
+  import SongsStore.*
+
+  val songsDB = Map(
+    1 -> Song(1, "High Hopes", "Pink Floyd"),
+    2 -> Song(2, "Sunny", "Boney M."),
+    3 -> Song(3, "J'irai où tu iras", "Céline Dion & Jean-Jacques Goldman"),
+    4 -> Song(4, "Ce monde est cruel", "Vald"),
+    5 -> Song(5, "Strobe", "deadmau5"),
+    6 -> Song(6, "Désenchantée", "Mylène Farmer"),
+    7 -> Song(7, "Straight Edge", "Minor Threat"),
+    8 -> Song(8, "Hold the line", "TOTO"),
+    9 -> Song(9, "Anarchy in the UK", "Sex Pistols"),
+    10 -> Song(10, "Breakfast in America", "Supertramp")
+  )
+
+  override def receive: Receive = LoggingReceive { case GetSongs(songsIds) =>
+    sender() ! Songs(songsIds.map(songsDB))
+  }
+
+/////////////////////////
+//        DEBUG        //
+/////////////////////////
+
+/** Infrastructure to help debugging. In sbt use `run` to execute this code. The
+  * TestKit is an actor that can send messages and check the messages it
+  * receives (or not).
+  */
+@main def debug() = new TestKit(ActorSystem("DebugSystem")) with ImplicitSender:
+  import User.*
+  import User.Protocol.*
+  import User.Responses.*
+  import SongsStore.Protocol.*
+  import SongsStore.Responses.*
+
+  try
+    val songsStore = system.actorOf(Props(MockSongsStore()), "songsStore")
+    val anita = system.actorOf(Props(User("100", "Anita", songsStore)))
+
+    anita ! Like(6)
+    expectNoMessage() // expects no message is received
+
+    anita ! GetHomepageData
+    expectMsg(HomepageData(List(6), List()))
+  finally shutdown(system)

src/main/scala/ed/28596.worksheet.sc

+// This demonstrates how to import functions from a package inside a worksheet.
+
+import midterm22.{task, find}
+
+find(Array(1, 2, 3), 2, 1)

src/main/scala/ed/39368.scala

+package ed
+
+// To demonstrate different ways of pattern matching, let's consider the
+// following example case class and instance:
+case class Person(name: String, age: Int)
+val ada = Person("Ada", 36)
+
+// Run using `sbt "runMain ed.patternMatching"`.
+@main def patternMatching =
+  // There are several ways to pattern match on the `ada` instance:
+  // 1. Pattern matching on the case class constructor using `Person(name, age)`.
+  //    If the pattern matches, the value of `n` is bound `ada.name` field, and
+  //    `a` is bound to the `ada.age` field.
+  ada match
+    case Person(n, a) => println(f"$n is $a years old")
+
+  // 2. We can also check only that `ada` is of type `Person` without binding its
+  //    fields by using a `:` pattern. The `:` pattern is used to check if a value is
+  //    of a certain type.
+  ada match
+    case p: Person => println(f"${p.name} is ${p.age} years old")
+
+  // 3. If we want to both bind the fields and bind a value to the whole instance,
+  //    we can use an `@` pattern.
+  ada match
+    case p @ Person(n, a) => println(f"${p.name} is ${a} years old")

src/main/scala/ed/40056.scala

+package ed
+
+import concurrent.{Await, Future}
+import concurrent.duration.Duration
+import concurrent.ExecutionContext.Implicits.global
+
+// Pro Tip: you can print the code generated by the Scala compiler after the
+// translation of for-comprehensions by running:
+//
+// scala -Xprint:firstTransform src/main/scala/ed/40056.scala
+@main def futuresForTranslation =
+  val f1 = Future { 451 }
+  val f2 = Future { 1984 }
+  val f3 = for v1 <- f1; v2 <- f2 yield v1 + v2
+  println(Await.result(f3, Duration.Inf))
+
+  val f4 = Future { 451 }
+  val f5 = Future { 1984 }
+  val f6 = f4.flatMap(v4 => f5.map(v5 => v4 + v5))
+  println(Await.result(f6, Duration.Inf))

src/main/scala/sumList.worksheet.sc → src/main/scala/ex01/01-sumList.worksheet.sc

+// This is a minimal worksheet example. If you open the folder cs206-demos in
+// VSCode and then display this source, you should see all top-level statements
+// evaluated in comments, as in:
+//
+//    import scala.annotation.tailrec
+// 
+//    val testList = List(1, 2, 3) // List[Int] = List(1, 2, 3)
+// 
+//    testList.head // Int = 1
+//    testList.isEmpty // Boolean = false
+//    testList.tail // List[Int] = List(2, 3)
+//    testList.tail.head // Int = 2
+//    testList ++ List(4, 6) // List[Int] = List(1, 2, 3, 4, 6)
+//
+//    ...
+
 import scala.annotation.tailrec
 
 val testList = List(1, 2, 3)

src/main/scala/ex01/01-minMax.worksheet.sc → src/main/scala/ex01/02-minMax.worksheet.sc

+// This demonstrates different ways of writing a sequential `minMax` function in
+// Scala. It's meant to be a quick recap of `foldLeft` usage and Scala syntax.
+
 val a = Array(2, 3, 1)
 
 a.min
@@ -19,7 +22,8 @@ def myMin2(a: Array[Int]) =
 
 def myMin3(a: Array[Int]) =
   var min = Int.MaxValue
-  for v <- a do if v < min then min = v
+  for v <- a do
+    if v < min then min = v
   min
 
 def myMinMax1(a: Array[Int]) =

src/main/scala/ex02/01-ParSeq.worksheet.sc

+// This demonstrates how to use parallel collections from a Scala worksheet.
+// Note that this works because we added the "scala-parallel-collections"
+// dependency in `build.sbt`. Parallel collections are not part of the Scala
+// standard library anymore since Scala 2.13.
+
 import scala.collection.parallel.immutable.ParVector
 import collection.parallel.CollectionConverters.*
 import collection.parallel.{ParSeq, ParSet}

src/main/scala/ex05/atomicIncrement.worksheet.sc

+import java.util.concurrent.atomic.AtomicInteger
+import collection.parallel.CollectionConverters.*
+
+// This demo should help understanding the `add` method implementation in
+// src/main/scala/midterm22/Part8.scala.
+
+// TL;DR: it demonstrate that `+=` is not atomic.
+
+var id: Int = 0
+
+val l =
+  for _ <- (0 until 10).par yield
+    id += 1
+    id
+
+l
+l.distinct.size
+
+// Try to execute the worksheet several times (by saving again and again). We
+// might get a number of distinct elements not equal to 10. Why?
+//
+// First, note that `id += 1` is equivalent to `val tmp = id; id = tmp + 1`.
+// I.e. the read and write are two separate operations; the `+=` operation is
+// not *atomic*.
+//
+// Then, consider the following execution:
+// - T1: reads 0 from id and store it in its local `tmp` var.
+// - T2: does the same: reads 0 from id and store it in its local `tmp` var.
+// - T1: computes `tmp + 1 == 1`, stores it in `id` and returns `1`
+// - T2: computes `tmp + 1 == 1`, stores it in `id` and returns `1`
+//
+// Now we have two times the ID 1!
+
+// The code we wrote before is equivalent to:
+
+var id2: Int = 0
+val l2 =
+  for _ <- (0 until 10).par yield
+    val tmp = id2
+    id2 = tmp + 1
+    val tmp2 = id2
+    tmp2
+
+l2
+l2.distinct.size // *
+
+// How to make it correct? Use an atomic integer!
+
+val id3 = AtomicInteger()
+
+val l3 =
+  for _ <- (0 until 10).par yield id3.incrementAndGet()
+
+l3
+// Now we are sure that this will always be 10.
+l3.distinct.size // *
+
+assert(l3.distinct.size == 10)
+
+// Or, using only what has been seen before the midterm this year: another
+// solution is to use synchronize:
+
+var id4: Int = 0
+val lock = Object()
+
+val l4 =
+  for _ <- (0 until 10).par yield lock.synchronized {
+    id4 += 1
+    id4
+  }
+
+l4
+// Now we are sure that this will always be 10.
+l4.distinct.size // *
+
+assert(l4.distinct.size == 10)

src/main/scala/instrumentation/Monitor.scala

+package instrumentation
+
+class Dummy
+
+trait Monitor:
+  given dummy: Dummy = new Dummy
+
+  def wait()(implicit i: Dummy = dummy) = waitDefault()
+
+  def synchronized[T](e: => T)(implicit i: Dummy = dummy) = synchronizedDefault(
+    e
+  )
+
+  def notify()(implicit i: Dummy = dummy) = notifyDefault()
+
+  def notifyAll()(implicit i: Dummy = dummy) = notifyAllDefault()
+
+  private val lock = new AnyRef
+
+  // Can be overridden.
+  def waitDefault(): Unit = lock.wait()
+  def synchronizedDefault[T](toExecute: => T): T = lock.synchronized(toExecute)
+  def notifyDefault(): Unit = lock.notify()
+  def notifyAllDefault(): Unit = lock.notifyAll()
+
+trait LockFreeMonitor extends Monitor:
+  override def waitDefault() =
+    throw new Exception("Please use lock-free structures and do not use wait()")
+  override def synchronizedDefault[T](toExecute: => T): T =
+    throw new Exception(
+      "Please use lock-free structures and do not use synchronized()"
+    )
+  override def notifyDefault() =
+    throw new Exception(
+      "Please use lock-free structures and do not use notify()"
+    )
+  override def notifyAllDefault() =
+    throw new Exception(
+      "Please use lock-free structures and do not use notifyAll()"
+    )

src/main/scala/lecture1/02-scalaThreadWrapper.scala

@@ -19,7 +19,7 @@ class ThreadReturning[A](toRun: => A) extends Thread:
     join()
     result
 
-def thread[A](toRun: => A): ThreadReturning[A] =
+def threadStart[A](toRun: => A): ThreadReturning[A] =
   val t = ThreadReturning(toRun)
   t.start()
   t
@@ -37,5 +37,5 @@ def countLots: Long =
 
 // Run from the SBT shell with `runMain lecture1.scalaThreadWrapper`.
 @main def scalaThreadWrapper: Unit =
-  val (x, y) = (thread(countLots), thread(countLots))
+  val (x, y) = (threadStart(countLots), threadStart(countLots))
   println((x.joinMe, y.joinMe))

src/main/scala/lecture1/04-task.scala

@@ -7,5 +7,7 @@ package lecture1
 trait Task[A]:
   def join: A
 
-def task[A](toRun: => A): Task[A] = new Task[A]:
-  override def join: A = thread(toRun).joinMe
+def task[A](toRun: => A): Task[A] =
+  val t = threadStart(toRun)
+  new Task[A]:
+    override def join: A = t.joinMe

src/main/scala/lecture13/AskPattern.scala

+package lecture13
+
+import concurrent.{ExecutionContext, Future, Promise}
+import concurrent.duration.DurationInt
+
+import akka.actor.{Actor, ActorContext, ActorRef, ActorSystem, Props}
+import akka.event.LoggingReceive
+import akka.pattern.pipe
+import akka.testkit.{ImplicitSender, TestKit}
+import akka.util.Timeout
+
+/** This demonstrates a simplified implementation of the ask pattern.
+  *
+  * @param promise
+  *   the promise to be completed when a message is received
+  */
+class AskMiniActor(promise: Promise[Any]) extends Actor:
+  def receive = LoggingReceive {
+    case msg => promise.success(msg)
+  }
+
+extension (receiver: ActorRef)
+  def ?(msg: Any)(using
+      // In this simplified implementation, we don't use the timeout.
+      timeout: Timeout,
+      // This only used for logging purposes (and to get the actor system in the
+      // real implementation), but is not used otherwise in the implementation.
+      sender: ActorRef,
+      // In the real implementation, the actor system is retrieved differently,
+      // but here we pass it as an additional implicit parameter for simplicity.
+      context: ActorContext
+  ): Future[Any] =
+    context.system.log.debug(
+      s"Create mini actor to ask $msg from $sender to $receiver"
+    )
+
+    // Create a `Promise` that will be completed when a message is received.
+    val promise = Promise[Any]()
+
+    // Create a mini actor that will complete the `Promise` when it receives a
+    // message.
+    val miniActor = context.system.actorOf(Props(AskMiniActor(promise)))
+
+    // Send the message to the mini actor, *using the mini actor as the sender*.
+    // This part is important as it is the mini actor that needs to receive the
+    // response.
+    receiver.tell(msg, miniActor)
+
+    // Using the `Promise` from the Scala standard library, the corresponding
+    // `Future` can be retrieved with the method `future`.
+    promise.future
+
+object Person:
+  enum Protocol:
+    case GetName
+    case GetAge
+  enum Response:
+    case Name(name: String)
+    case Age(age: Int)
+    case UnknownMessage
+
+class Person(name: String, age: Int) extends Actor:
+  import Person.Protocol.*
+  import Person.Response.*
+
+  def receive = LoggingReceive {
+    case GetName => sender() ! Name(name)
+    case GetAge  => sender() ! Age(age)
+    case _       => sender() ! UnknownMessage
+  }
+
+object PersonsDatabase:
+  enum Protocol:
+    case CreatePerson(name: String, age: Int)
+    case GetPersonNames(ids: List[Int])
+  enum Response:
+    case PersonCreated(id: Int)
+    case PersonNames(names: List[String])
+
+class PersonsDatabase extends Actor:
+  import Person.Protocol.*
+  import Person.Response.*
+  import PersonsDatabase.Protocol.*
+  import PersonsDatabase.Response.*
+
+  var persons: Map[Int, ActorRef] = Map.empty
+  var maxId = 0
+
+  given ExecutionContext = context.system.dispatcher
+  given Timeout = Timeout(200.millis)
+
+  def receive = LoggingReceive {
+    case CreatePerson(name, age) =>
+      val personRef = context.actorOf(Props(Person(name, age)))
+      persons = persons + (maxId -> personRef)
+      sender() ! PersonCreated(maxId)
+      maxId += 1
+    case GetPersonNames(ids) =>
+      // We ask every person for their name using the ask pattern. This
+      // gives us a list of `Future`s that will each be completed with a
+      // `Name` message.
+      val rawResponsesFutures: List[Future[Any]] =
+        ids.map(id => (persons(id) ? GetName))
+
+      // We first map each `Future[Any]` to a `Future[Name]` using the
+      // `mapTo` method. Then, we map each `Future[Name]` to a
+      // `Future[String]` using the `map` method.
+      val namesFutures: List[Future[String]] =
+        rawResponsesFutures.map(_.mapTo[Name].map(_.name))
+
+      // We use the `Future.sequence` method to convert a
+      // `List[Future[String]]` to a `Future[List[String]]`. The resulting
+      // future will be completed once all the futures in the input list
+      // are completed.
+      val futureOfNames: Future[List[String]] = Future.sequence(namesFutures)
+
+      // Finally, map the `Future[List[String]]` to a `Future[PersonNames]` and
+      // pipe it to the sender of the `GetPersonNames` message.
+      futureOfNames.map(PersonNames.apply).pipeTo(sender())
+  }
+
+@main def askPatternDemo() =
+  new TestKit(ActorSystem("DebugSystem")) with ImplicitSender:
+    import Person.Protocol.*
+    import Person.Response.*
+    import PersonsDatabase.Protocol.*
+    import PersonsDatabase.Response.*
+
+    try
+      val personsDb = system.actorOf(Props(PersonsDatabase()))
+
+      personsDb ! CreatePerson("Anita", 20)
+      expectMsg(PersonCreated(0))
+
+      personsDb ! CreatePerson("Berta", 30)
+      expectMsg(PersonCreated(1))
+
+      personsDb ! CreatePerson("Cecilia", 40)
+      expectMsg(PersonCreated(2))
+
+      personsDb ! GetPersonNames(List(0, 1, 2))
+      expectMsg(PersonNames(List("Anita", "Berta", "Cecilia")))
+    finally shutdown(system)

src/main/scala/lecture13/Become.scala

+package lecture13
+
+import akka.actor.{Actor, ActorContext, ActorRef, ActorSystem, Props}
+import akka.event.LoggingReceive
+import akka.testkit.{ImplicitSender, TestKit}
+
+class CounterRight extends Actor:
+  def counter(n: Int): Receive = {
+    case "increment" => context.become(counter(n + 1), discardOld = false)
+    //                                                 ^^^^^^^^^^^^^^^^^^
+    //                                                 This is needed.
+    case "get"       => sender() ! n
+    case "decrement" => if n != 0 then context.unbecome()
+  }
+  def receive = counter(0)
+
+class CounterWrong extends Actor:
+  def counter(n: Int): Receive = {
+    case "increment" => context.become(counter(n + 1))
+    case "get"       => sender() ! n
+    case "decrement" => if n != 0 then context.unbecome()
+  }
+  def receive = counter(0)
+
+@main def becomeDemo() =
+  new TestKit(ActorSystem("DebugSystem")) with ImplicitSender:
+    try
+      val counter = system.actorOf(Props(CounterRight()), "counter")
+
+      counter ! "increment"
+      counter ! "get"
+      expectMsg(1)
+
+      counter ! "increment"
+      counter ! "get"
+      expectMsg(2)
+
+      counter ! "decrement"
+      counter ! "get"
+      expectMsg(1)
+      // This is wrong if we use CounterWrong because it doesn't set the
+      // discardOld parameter to false. Therefore, it will not remember the
+      // previous state and reset the behavior to the initial one, which is
+      // `counter(0)`.
+
+      counter ! "decrement"
+      counter ! "get"
+      expectMsg(0)
+    finally shutdown(system)

src/main/scala/lecture3/01-intersectionWrong.scala

-//    PDF: https://moodle.epfl.ch/pluginfile.php/3175938/mod_folder/content/0/week03-4-Scala-Parallel-Collections.pdf?forcedownload=1
-//  Video: https://mediaspace.epfl.ch/playlist/dedicated/31866/0_2dyv5wql/0_y9b53u6a
+//    PDF: https://moodle.epfl.ch/pluginfile.php/3175938/mod_folder/content/0/week03-4-Scala-Parallel-Collections.pdf
+//  Video: https://mediaspace.epfl.ch/playlist/dedicated/31866/0_icv10qux/0_h4jt9i7k
 // Slides: 27
 
 package lecture3
@@ -7,6 +7,8 @@ package lecture3
 import scala.collection.parallel.CollectionConverters.IterableIsParallelizable
 import scala.collection.parallel.immutable.ParSet
 
+// Note: we don't use `GenSet` because it is deprecated since Scala 2.13.
+
 def parIntersectionWrong(a: ParSet[Int], b: ParSet[Int]) =
   val result = collection.mutable.Set[Int]()
   for x <- a do
@@ -15,9 +17,9 @@ def parIntersectionWrong(a: ParSet[Int], b: ParSet[Int]) =
   result
 
 @main def intersectionWrong =
-  val a = (0 until 1000).toSet
-  val b = (0 until 1000 by 4).toSet
+  val a = (0 until 10000).toSet
+  val b = (0 until 10000 by 4).toSet
   val seqRes = a.intersect(b)
   val parRes = parIntersectionWrong(a.par.toSet, b.par.toSet)
-  println(s"Sequential result: ${seqRes.size}")
-  println(s"Parallel result: ${parRes.size}")
+  assert(seqRes.size == 2500)
+  assert(parRes.size != 2500)

src/main/scala/lecture3/02-intersectionCorrect.scala

-//    PDF: https://moodle.epfl.ch/pluginfile.php/3175938/mod_folder/content/0/week03-4-Scala-Parallel-Collections.pdf?forcedownload=1
-//  Video: https://mediaspace.epfl.ch/playlist/dedicated/31866/0_2dyv5wql/0_y9b53u6a
+//    PDF: https://moodle.epfl.ch/pluginfile.php/3175938/mod_folder/content/0/week03-4-Scala-Parallel-Collections.pdf
+//  Video: https://mediaspace.epfl.ch/playlist/dedicated/31866/0_icv10qux/0_h4jt9i7k
 // Slides: 28
 
 package lecture3
@@ -8,6 +8,8 @@ import scala.collection.parallel.CollectionConverters.IterableIsParallelizable
 import scala.collection.parallel.immutable.ParSet
 import java.util.concurrent.ConcurrentSkipListSet
 
+// Note: we don't use `GenSet` because it is deprecated since Scala 2.13.
+
 def parIntersectionCorrect(a: ParSet[Int], b: ParSet[Int]) =
   val result = new ConcurrentSkipListSet[Int]()
   for x <- a do
@@ -16,9 +18,9 @@ def parIntersectionCorrect(a: ParSet[Int], b: ParSet[Int]) =
   result
 
 @main def intersectionCorrect =
-  val a = (0 until 1000).toSet
-  val b = (0 until 1000 by 4).toSet
+  val a = (0 until 10000).toSet
+  val b = (0 until 10000 by 4).toSet
   val seqRes = a.intersect(b)
   val parRes = parIntersectionCorrect(a.par.toSet, b.par.toSet)
-  println(s"Sequential result: ${seqRes.size}")
-  println(s"Parallel result: ${parRes.size}")
+  assert(seqRes.size == 2500)
+  assert(parRes.size == 2500)

src/main/scala/lecture3/03-intersectionNoSideEffect.scala

-//    PDF: https://moodle.epfl.ch/pluginfile.php/3175938/mod_folder/content/0/week03-4-Scala-Parallel-Collections.pdf?forcedownload=1
-//  Video: https://mediaspace.epfl.ch/playlist/dedicated/31866/0_2dyv5wql/0_y9b53u6a
+//    PDF: https://moodle.epfl.ch/pluginfile.php/3175938/mod_folder/content/0/week03-4-Scala-Parallel-Collections.pdf
+//  Video: https://mediaspace.epfl.ch/playlist/dedicated/31866/0_icv10qux/0_h4jt9i7k
 // Slides: 29
 
 package lecture3
@@ -8,14 +8,16 @@ import scala.collection.parallel.CollectionConverters.IterableIsParallelizable
 import scala.collection.parallel.immutable.ParSet
 import java.util.concurrent.ConcurrentSkipListSet
 
+// Note: we don't use `GenSet` because it is deprecated since Scala 2.13.
+
 def intersectionParNoSideEffect(a: ParSet[Int], b: ParSet[Int]) =
   if a.size < b.size then a.filter(b(_))
   else b.filter(a(_))
 
 @main def intersectionNoSideEffect =
-  val a = (0 until 1000).toSet
-  val b = (0 until 1000 by 4).toSet
+  val a = (0 until 10000).toSet
+  val b = (0 until 10000 by 4).toSet
   val seqRes = a.intersect(b)
   val parRes = intersectionParNoSideEffect(a.par.toSet, b.par.toSet)
-  println(s"Sequential result: ${seqRes.size}")
-  println(s"Parallel result: ${parRes.size}")
+  assert(seqRes.size == 2500)
+  assert(parRes.size == 2500)

src/main/scala/lecture3/04-parallelGraphContraction.scala

+//    PDF: https://moodle.epfl.ch/pluginfile.php/3175938/mod_folder/content/0/week03-4-Scala-Parallel-Collections.pdf
+//  Video: https://mediaspace.epfl.ch/playlist/dedicated/31866/0_icv10qux/0_h4jt9i7k
+// Slides: 31
+
 package lecture3
 
 import scala.collection.*

src/main/scala/lecture3/05-parallelGraphContractionCorrect.scala

+//    PDF: https://moodle.epfl.ch/pluginfile.php/3175938/mod_folder/content/0/week03-4-Scala-Parallel-Collections.pdf
+//  Video: https://mediaspace.epfl.ch/playlist/dedicated/31866/0_icv10qux/0_h4jt9i7k
+// Slides: 31
+
 package lecture3
 
 import scala.collection.*