diff --git a/src/3_Data_Types_Multiple_Dispatch.ipynb b/src/3_Data_Types_Multiple_Dispatch.ipynb
index 0e30e4bf51c9477e1c3eb8c801bac5ef9ba362c8..65a408d3b05920482d1a2ec9cb084a515d56c866 100644
--- a/src/3_Data_Types_Multiple_Dispatch.ipynb
+++ b/src/3_Data_Types_Multiple_Dispatch.ipynb
@@ -1432,20 +1432,46 @@
   },
   {
    "cell_type": "markdown",
-   "id": "3e8c5b51-3ef6-4d40-9803-dcc2ab6eda3f",
+   "id": "bd273bc8-96ea-4260-93db-4934b7291965",
    "metadata": {},
    "source": [
-    "## Exercises"
+    "## Exercise\n",
+    "\n",
+    "This exercise is about writing a custom data type for polynomials, a set of constructors for them, and functions to perform operations on them. **Note:** writing custom polynomials in this way is neither efficient nor convenient, but it is a great example of the topics seen so far.\n",
+    "\n",
+    "  - Implement a new abstract type `AbstractPolynomial`. Then, implement a few concrete subtypes, `PolynomialDegree0`, `PolynomialDegree1`, `PolynomialDegree2` and `PolynomialArbitraryDegree`. **Tip:** use a dictionary to store the coefficients and do it in a consistent way between the various subtypes: you can use the power of `x` as the key for the coefficient value.\n",
+    "\n",
+    "  - Write a constructor for each of them which takes as input the coefficients. **Tip:** use `args::Real...` to gather an arbitrary number of arguments, specifying the type is important for avoiding ambiguity when calling with one argument (try not specyifing `Real` to see the problem).\n",
+    "\n",
+    "  - Write a function `Polynomial` with multiple methods: depending on the number of arguments, it should call the correct constructor. **Tips:** you can use the shorthand `Polynomial(c0) = PolynomialDegree0(c0)` to write more concise code, and you should again use `args...` to support an arbitrary amount of arguments.\n",
+    "\n",
+    "  - Implement a method of the `+` function which sums together two `AbstractPolynomial`. It should work with any combination of the concrete types. It should also use a loop over the coefficients. **Note:** implementing a method for a function of the core library requires first to import it `import Base.:+`.\n",
+    "\n",
+    "  - Implement some more methods of the `+` library which sum together polynomials of low degree, they should not use a for loop.\n",
+    "\n",
+    "  - Last, benchmark the `+` function for two `PolynomialDegree1` polynomials and for two `PolynomialArbitraryDegree` of degree 1. **Tips:** generate random coefficients using `rand()`, repeat the process a few thousands times to get a measurable run time, use the macro `@time` to get the time."
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "bd273bc8-96ea-4260-93db-4934b7291965",
+   "id": "3e8c5b51-3ef6-4d40-9803-dcc2ab6eda3f",
    "metadata": {},
    "source": [
-    "Implement a new abstract type `Polynomial` which is a subtype of `Number`.\n",
+    "## Übung\n",
+    "\n",
+    "Diese Übung befasst sich mit dem Schreiben eines benutzerdefinierten Datentyps für Polynome, einer Reihe von Konstruktoren dafür und Funktionen zum Durchführen von Operationen an ihnen. **Hinweis:** Das Schreiben benutzerdefinierter Polynome auf diese Weise ist weder effizient noch bequem, aber es ist ein gutes Beispiel für die bisher behandelten Themen.\n",
+    "\n",
+    "- Implementieren Sie einen neuen abstrakten Datentyp `AbstractPolynomial`. Dann implementieren Sie einige konkrete Untertypen, `PolynomialDegree0`, `PolynomialDegree1`, `PolynomialDegree2` und `PolynomialArbitraryDegree`. **Tipp:** Verwenden Sie ein Wörterbuch, um die Koeffizienten auf konsistente Weise zwischen den verschiedenen Untertypen zu speichern: Sie können die Potenz von `x` als Schlüssel für den Koeffizientenwert verwenden.\n",
+    "\n",
+    "- Schreiben Sie einen Konstruktor für jeden von ihnen, der die Koeffizienten als Eingabe erhält. **Tipp:** Verwenden Sie `args::Real...`, um eine beliebige Anzahl von Argumenten zu sammeln. Die Angabe des Typs ist wichtig, um Unklarheiten beim Aufruf mit einem Argument zu vermeiden (versuchen Sie, `Real` nicht anzugeben, um das Problem zu sehen).\n",
+    "\n",
+    "- Schreiben Sie eine Funktion `Polynomial` mit mehreren Methoden: Abhängig von der Anzahl der Argumente sollte sie den richtigen Konstruktor aufrufen. **Tipps:** Sie können die Kurzform `Polynomial(c0) = PolynomialDegree0(c0)` verwenden, um den Code kürzer zu schreiben, und Sie sollten erneut `args...` verwenden, um eine beliebige Anzahl von Argumenten zu unterstützen.\n",
     "\n",
-    "TO BE FINISHED"
+    "- Implementieren Sie eine Methode der `+` Funktion, die zwei `AbstractPolynomial` zusammenzählt. Es sollte mit jeder Kombination der konkreten Typen funktionieren. Es sollte auch eine Schleife über die Koeffizienten verwenden. **Hinweis:** Das Implementieren einer Methode für eine Funktion der Kernbibliothek erfordert zunächst das Importieren von `import Base.:+`.\n",
+    "\n",
+    "- Implementieren Sie einige weitere Methoden der `+`-Bibliothek, die Polynome niedriger Ordnung zusammenzählen. Diese sollten keine Schleife verwenden.\n",
+    "\n",
+    "- Zuletzt führen Sie eine Leistungsbewertung der `+` Funktion für zwei `PolynomialDegree1`-Polynome und für zwei `PolynomialArbitraryDegree`-Polynome vom Grad 1 durch. **Tipps:** Generieren Sie zufällige Koeffizienten mit `rand()`, wiederholen Sie den Vorgang einige Tausend Mal, um eine messbare Laufzeit zu erhalten, verwenden Sie die Makro `@time`, um die Zeit zu messen.\n"
    ]
   },
   {
@@ -1454,7 +1480,9 @@
    "id": "be3f23e1-b0f8-498f-afd2-9618cb64febb",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# TODO: implement your code here.\n"
+   ]
   }
  ],
  "metadata": {