diff --git a/slides.md b/slides.md
index 749d00f..bdee195 100644
--- a/slides.md
+++ b/slides.md
@@ -28,7 +28,7 @@
 
 ---
 
-# Antes de empezar?
+# Encuesta
 
 * Java 21? :thumbsup:
 * Java 17? :ok:
@@ -40,10 +40,16 @@
 
 ---
 
-# Java 8
+# Jetbrains ecosystem survey
 
-* Lanzado en 2014 :rocket:.
-* [2023 Jetbrains ecosystem survey](https://www.jetbrains.com/lp/devecosystem-2023/java/#java_versions)
+* [¿Qué versión de Java usáis regularmente?](https://www.jetbrains.com/lp/devecosystem-2023/java/#java_versions)
+
+
+---
+
+# Jetbrains ecosystem survey
+
+* [¿Qué versión de Java usáis regularmente?](https://www.jetbrains.com/lp/devecosystem-2023/java/#java_versions)
 
 
 | Version | Percentage|
@@ -53,6 +59,12 @@
 | Java11  | 38%       |
 | Java20  | 11%       |
 
+---
+
+# Java 8
+
+* Lanzado en 2014 :rocket:
+
 <!--
     No existía ni tiktok ni openai
     Ese mismo año se lanzó spring-boot v1.0.0
@@ -358,4 +370,57 @@
 
 # Links
 
-- [Data Oriented Programmig](https://www.infoq.com/articles/data-oriented-programming-java/) Brian Goetz
\ No newline at end of file
+- [Data Oriented Programmig](https://www.infoq.com/articles/data-oriented-programming-java/) Brian Goetz
+
+<!-- TODO:
+
+  why use pattern matching?
+    - reduce cognitive load.
+    - pattern exhaustiveness.
+
+  features:
+   - enum
+   - null checks
+   - partial / nested patterns
+
+   other languages:
+   - scala
+   - kotlin
+   - haskell
+   - rust
+   - C#
+
+   algebraic data types:
+   - algegraic: because it has properties like an algebra
+   - product type
+    tuples, records, pairs, struts
+    in java record
+    cartesian product a * b
+    cardinality
+   - sum type
+    enum
+    sealed classes and interfaces
+    a + b
+   - exponential types are functions
+   - tree of products and sums
+   - distributibity 
+    (a * b) + (a * c) <=> a * (b + c)
+   - commutatibity 
+    a * b <=> b * a
+    a + b <=> b + a
+   - identity:
+    - Unit Type just one value
+   - associatibity:
+    a + b + c <=> a + (b + c)
+    a * b * c <=> a * (b * c)
+   - currying:
+    (a, b) -> c <=> a -> b 
+
+   meta:
+   - target audience
+   - manage expectations
+   - content
+   - confirm expectations
+   - links to follow
+    -->
+-->
\ No newline at end of file
diff --git a/snippets/Expr.java b/snippets/Expr.java
index 9b9067a..55e6529 100644
--- a/snippets/Expr.java
+++ b/snippets/Expr.java
@@ -15,6 +15,15 @@
             case Times(var left, var right) -> left.evaluate() * right.evaluate();
         };
     }
+      
+    default String print() {
+        return switch (this) {
+            case Lit(var value) -> String.valueOf(value);
+            case Sum(var left, var right) -> "(" + left.print() + "+" + right.print() + ")";
+            case Diff(var left, var right) -> "(" + left.print() + "-" + right.print() + ")";
+            case Times(var left, var right) -> "(" + left.print() + "*" + right.print() + ")";
+        };
+    }
 
     static Expr lit(int value) {
         return new Lit(value);
diff --git a/snippets/List.java b/snippets/List.java
index 227b964..9adf420 100644
--- a/snippets/List.java
+++ b/snippets/List.java
@@ -1,6 +1,29 @@
 package snippets;
 
+import java.util.function.Function;
+import java.util.function.Predicate;
+
 sealed interface List<T> {
     record NonEmpty<T>(T head, List<T> tail) implements List<T> {}
     record Empty<T>() implements List<T> {}
+
+    default <R> List<R> map(Function<T, R> mapper) {
+        return switch (this) {
+            case NonEmpty<T>(var head, var tail) 
+                -> new NonEmpty<>(mapper.apply(head), tail.map(mapper));
+            case Empty<T>() 
+                -> new Empty<>();
+        };
+    }
+
+    default List<T> filter(Predicate<T> filter) {
+        return switch (this) {
+            case NonEmpty<T>(var head, var tail) when filter.test(head) 
+                -> new NonEmpty<>(head, tail.filter(filter));
+            case NonEmpty<T>(var head, var tail) 
+                -> tail.filter(filter);
+            case Empty<T>() 
+                -> new Empty<>();
+        };
+    }
 }
diff --git a/snippets/Optional.java b/snippets/Optional.java
index 5537351..4cf3d4a 100644
--- a/snippets/Optional.java
+++ b/snippets/Optional.java
@@ -5,34 +5,36 @@
 import java.util.function.Supplier;
 
 sealed interface Optional<T> {
+
     record Empty<T>() implements Optional<T> { }
     record Present<T>(T value) implements Optional<T> {}
 
     default <R> Optional<R> map(Function<T, R> mapper) {
         return switch (this) {
-            case Present(T value) -> new Present<>(mapper.apply(value));
-            case Empty() -> new Empty<>();
+            case Present<T>(var value) -> new Present<>(mapper.apply(value));
+            case Empty<T> _ -> new Empty<>();
         };
     }
 
     default <R> Optional<R> flatMap(Function<T, Optional<R>> mapper) {
         return switch (this) {
-            case Present(T value) -> mapper.apply(value);
-            case Empty() -> new Empty<>();
+            case Present<T>(var value) -> mapper.apply(value);
+            case Empty<T> _ -> new Empty<>();
         };
     }
 
     default <R> R fold(Supplier<R> onEmpty, Function<T, R> onPresent) {
         return switch (this) {
-            case Present(T value) -> onPresent.apply(value);
-            case Empty() -> onEmpty.get();
+            case Present<T>(var value) -> onPresent.apply(value);
+            case Empty<T> _ -> onEmpty.get();
         };
     }
 
     default Optional<T> filter(Predicate<T> filter) {
         return switch (this) {
-            case Present(T value) when filter.test(value) -> this;
-            default -> new Empty<>();
+            case Present<T>(var value) when filter.test(value) -> this;
+            case Present<T> _ -> new Empty<>();
+            case Empty<T> _ -> new Empty<>();
         };
     }
-}
+}
\ No newline at end of file