Explain the flatmap operation. The hints.md and introduction.md files are not over yet.

Author: josealonso

exercises/concept/tim-from-marketing-2/.docs/hints.md

@@ -0,0 +1,11 @@
+# Hints
+
+## 1.- Print the name of all the employees
+
+WIP
+
+
+## 2.- Print the name and department of a given employee
+
+WIP
+

exercises/concept/tim-from-marketing-2/.docs/instructions.md

@@ -3,22 +3,13 @@
 In this exercise you will be writing code to print all the names of the factory employees.
 
 Employees have an ID, a name and a department name, like in [tim-from-marketing](/exercises/concept/tim-from-marketing). 
-Assume that the ID of the first employee is 1, the ID of the second employee is 2, and so on. If an employee has an ID, the other two fields, name and department name, have valid values.
+Assume that the ID of the first employee is 1, the ID of the second employee is 2, and so on. The three fields of an employee may be empty, That's why they are declared as Optional<T> types.
 
 Two methods are already implemented:
 
 - `getAllTheEmployeesById()` returns an Optional<List<Employee>> object. Notice this method does NOT receive any parameter.
 - `getEmployeeById(id)` returns an Optional<Employee> object for the given ID, being Employee the following class:
 
-```java
-class Employee {
-    private int id;
-    private String name;
-    private String departmentName;
-    // Getters and setters
-}
-```
-
 ## 1.- Print the names of all the employees
 
 Implement the `printAllEmployeesNamesById()` method to print the names of all the employees, together with their id. If the employee does not exist, print "[id] - This employee does not exist".
@@ -42,4 +33,3 @@ printEmployeeNameAndDepartmentById(3) => "3 - Steve - Engineering"
 printEmployeeNameAndDepartmentById(4) => "4 - This employee does not exist"
 printEmployeeNameAndDepartmentById(5) => "5 - Charlotte - Owner"
 ```
-

exercises/concept/tim-from-marketing-2/.docs/introduction.md

@@ -4,13 +4,13 @@
 
 ## Introduction
 
-The Optional<T> type was introduced in Java 8 as a way to indicate that a method will return an object of type T or a null value. It is present in type signatures of many core Java methods. 
+The **Optional<T>** type was introduced in Java 8 as a way to indicate that a method will return an object of type T or an empty value. It is present in type signatures of many core Java methods. 
 
 Before Java 8, developers had to implement null checks:
 
 ```java
 public Employee getEmployee(String name) {
-    // Assume that getEmployeeByName retrieves an Employee from a data base
+    // Assume that getEmployeeByName retrieves an Employee from a database
     Employee employee = getEmployeeByName(name);
     if (employee != null) {
         return employee;
@@ -46,10 +46,32 @@ Provided all the invoked methods return Optional objects, many methods can be ch
 public Optional<Integer> getEmployeeAge(String name) {
     Optional<Employee> optionalEmployee = getEmployeeByName(name);
     return getEmployeeByName(name)
-               .map(Employee::getAge)
+               .map(employee -> employee.getAge())
                .orElse(0);
 }
 ```
 
-It is important to understand that the Optional API does not eliminate the null values. It defers the null checking until the end of a series of methods, as long as all those methods return an optional object. 
+It is important to understand that the Optional API does not eliminate the null checking, but it defers it until the end of a series of methods, as long as all those methods return an optional object. 
 
+## Flatmap operation
+
+The **flatMap** method flattens a List of Optional objects into a List of those objects. In other words, extracts the value of each list element, discarding empty Optionals. For example:
+
+```java
+List<Optional<String>> listOfOptionals = Arrays.asList(
+    Optional.of("Java"),
+    Optional.empty(),
+    Optional.of("Kotlin")
+);
+```
+
+```java
+// Using flatMap to extract present values
+        List<String> result = listOfOptionals.stream()
+            .flatMap(Optional::stream)
+            .collect(Collectors.toList());
+
+        System.out.println(result); // Output: [Java, Kotlin]
+    }
+}
+```

exercises/concept/tim-from-marketing-2/.docs/introduction.md.tpl

@@ -1,5 +1,5 @@
 # Introduction
 
-## Optional
+%{concept:optional-types}
 
-%{concept:optional}
+%{concept:flatMap-operation}

exercises/concept/tim-from-marketing-2/.meta/config.json

@@ -1,13 +1,18 @@
 {
-  "authors": ["josealonso"],
+  "authors": [
+    "josealonso"
+  ],
   "files": {
     "solution": [
-      "src/main/java/TimFromMarketing2.java"
+      "src/main/java/EmployeeService.java"
     ],
     "test": [
-      "src/test/java/TimFromMarketing2Test.java"
+      "src/test/java/EmployeeServiceTest.java"
+    ],
+    "exemplar": [
+      ".meta/src/reference/java/EmployeeService.java"
     ],
-    "exemplar": []
   },
-  "blurb": ""
+  "icon": "language-list",
+  "blurb": "Learn to use the Optional class by helping Tim print details of his company employees."
 }

exercises/concept/tim-from-marketing-2/.meta/design.md

@@ -0,0 +1,51 @@
+# Design
+
+## Goal
+
+The goal of this exercise is to teach the student how to use the Optional API.
+We will use the most common methods: `ifPresent`, `orElse`, `ifPresentOrElse`, `orElseThrown`. 
+The `isPresent` and `get` methods are not presented, since they do not provide any value over an ordinary null check.
+
+Some methods of the Stream API are needed. This is a bit problematic, since they have not been explained in the current Java track.
+
+## Learning objectives
+
+- Know what optional types are.
+- Know how to use Optional<T> fields.
+- Know how to use methods that return an Optional<T> type.
+- See the utility of some Stream methods, `flatMap` specifically.
+
+## Out of scope
+
+- Streams API.
+
+## Concepts
+
+This Concepts Exercise's Concepts are:
+
+- `Optional<T>` class and some methods that mimic a null check.
+
+## Prerequisites
+
+This Concept Exercise's prerequisites Concepts are:
+
+- `custom classes`.
+- `generic-types`.
+- `streams`.
+
+## Analyzer
+
+wip
+
+This exercise could benefit from the following rules in the [analyzer]:
+
+- `actionable`: If the solution did not use `contains` in the method `containsLanguage`, instruct the student to do so.
+- `actionable`: If the solution did not use `isEmpty` in the method `isEmpty`, instruct the student to do so.
+- `informative`: If the student did not reuse the implementation of the `containsLanguage` method in the `isExciting` method, instruct them to do so.
+  Explain that reusing existing code instead of copy-pasting can help make code easier to maintain.
+- `informative`: If the solution uses an `if statement` in the `containsLanguage` method, instruct the student to return directly the `contains` method.
+
+If the solution does not receive any of the above feedback, it must be exemplar.
+Leave a `celebratory` comment to celebrate the success!
+
+[analyzer]: https://github.com/exercism/java-analyzer