One method definition is now given to the student and more explanations have been added. The tests have been corrected and integrated in an IDE. What remains are the hints.md and the icon files, and the gradle files for this exercise.

Author: josealonso

exercises/concept/tim-from-marketing-2/.classpath

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="bin/main" path=".meta/src/reference/java">
+		<attributes>
+			<attribute name="gradle_scope" value="main"/>
+			<attribute name="gradle_used_by_scope" value="main,test"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="bin/starterSource" path="src/main/java">
+		<attributes>
+			<attribute name="gradle_scope" value="starterSource"/>
+			<attribute name="gradle_used_by_scope" value="starterSource"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="bin/starterTest" path="src/test/java">
+		<attributes>
+			<attribute name="gradle_scope" value="starterTest"/>
+			<attribute name="gradle_used_by_scope" value="starterTest"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-17/"/>
+	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

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

@@ -2,34 +2,30 @@
 
 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. 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:
+Employees have an ID, a name and a department name, like in the [tim-from-marketing](/exercises/concept/tim-from-marketing) exercise. 
+Assume that the ID of the first employee is 0, the ID of the second employee is 1, and so on. The three fields of an employee may be empty, that's why they are declared as Optional<T> types.
+The class constructor receives a parameter of type List<Optional<Employee>>, which is populated in the tests.
 
 ## 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".
+Implement the `printAllEmployeesNames()` method to print the names of all the employees, together with their id. If the employee does not exist, print "[id] - No employee found".
 
 ```java
-"1 - Tim"
-"2 - Bill"
-"3 - Steve"
-"4 - This employee does not exist"
-"5 - Charlotte"
+"
+1 - Tim
+2 - Bill
+3 - Steve
+4 - No employee found
+5 - Charlotte
+"
 ```
 
 ## 2.- Print the name and department of a given employee
 
-Implement the `printEmployeeNameAndDepartmentById(id)` method to print the name and department of a given employee, together with their id. If the employee does not exist, print "[id] - This employee does not exist":
+Implement the `printEmployeeNameAndDepartmentById(id)` method to print the name and department of a given employee, together with their id. If the employee does not exist, print "[id] - No employee found". You will have to call the method `getEmployeeById(int employeeId)`, which returns an Optional<Employee> and it's already defined.
 
 ```java
 printEmployeeNameAndDepartmentById(1) => "1 - Tim - Marketing"
-printEmployeeNameAndDepartmentById(2) => "2 - Bill - Sales"
 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

@@ -40,19 +40,34 @@ public Optional<Employee> getEmployee(String name) {
 }
 ```
 
+Other commonly used method is `ifPresentOrElse`, which is used to handle the case where the value is present and the case where the value is empty.
+
+```java
+public Optional<Employee> getEmployee(String name) {
+    // Assume that getEmployeeByName returns an Optional<Employee>
+    return getEmployeeByName(name)
+           .ifPresentOrElse(
+                   employee -> System.out.println(employee.getName()),
+                   () -> System.out.println("Employee not found")
+           );
+}
+```
+
 Provided all the invoked methods return Optional objects, many methods can be chained without having to worry about null checking:
 
 ```java
 public Optional<Integer> getEmployeeAge(String name) {
     Optional<Employee> optionalEmployee = getEmployeeByName(name);
     return getEmployeeByName(name)
                .map(employee -> employee.getAge())
-               .orElse(0);
+               .orElse("No employee found");
 }
 ```
 
 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. 
 
+The fields of the Employee class have an Optional type. Notice that this is not recommended, as explained by one well-known Java language architect in [this SO answer](https://stackoverflow.com/questions/26327957/should-java-8-getters-return-optional-type)
+
 ## 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:
@@ -68,7 +83,7 @@ List<Optional<String>> listOfOptionals = Arrays.asList(
 ```java
 // Using flatMap to extract present values
         List<String> result = listOfOptionals.stream()
-            .flatMap(Optional::stream)
+            .flatMap(language -> language.stream())
             .collect(Collectors.toList());
 
         System.out.println(result); // Output: [Java, Kotlin]

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

@@ -13,6 +13,6 @@
       ".meta/src/reference/java/EmployeeService.java"
     ],
   },
-  "icon": "language-list",
+  "icon": "nullability",
   "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

@@ -3,7 +3,7 @@
 ## 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`. 
+We will use the most common methods: `ifPresent`, `orElse`, `ifPresentOrElse`, `orElseThrow`. 
 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.
@@ -35,15 +35,11 @@ This Concept Exercise's prerequisites Concepts are:
 
 ## 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.
+- `actionable`: If the solution uses `null` in any method, encourage the student to use `Optional<T>` instead.
+- `actionable`: If the solution uses the `get` or `isPresent` methods of the Optional<T> API, encourage the student to use `orElse`, `orElseThrow` or `ifPresentOrElse` instead. 
+- `informative`: TODO.
 
 If the solution does not receive any of the above feedback, it must be exemplar.
 Leave a `celebratory` comment to celebrate the success!

exercises/concept/tim-from-marketing-2/.meta/src/reference/java/EmployeeService.java

@@ -1,66 +1,60 @@
 import java.util.List;
 import java.util.ArrayList;
 import java.util.Optional;
-import java.util.stream.*;
-
 
 class EmployeeService {
-  
-    public List<Optional<Employee>> getAllTheEmployeesById() {
-        return getAllTheEmployeesById()
-        .stream()
-        .map(employee -> Optional.ofNullable(employee))
-        .collect(Collectors.toList());
+
+    //  This list is populated in the tests
+    private List<Optional<Employee>> nullableEmployeesList = new ArrayList<>();
+
+    public EmployeeService(List<Optional<Employee>> listOfEmployees) {
+        nullableEmployeesList = listOfEmployees;
     }
 
     public Optional<Employee> getEmployeeById(int employeeId) {
-       /* Solution using Streams
-        
-        return getAllTheEmployeesById(employeesList).stream()
-                                     .filter(employee -> employee.getId() == id)
-                                     .orElse("Employee not found");
-        */
-
-        return Optional.ofNullable(getEmployeeById(employeeId));
+        return nullableEmployeesList
+                .stream()
+                .flatMap(employee -> employee.stream())
+                .filter(employee -> employee.getNullableId()
+                        .map(id -> id == employeeId)
+                        .orElse(false))
+                .findFirst();
     }
 
-    public String printAllEmployeesNamesById() {
-        List<Optional<Employee>> nullableEmployeesList = getAllTheEmployeesById();
+    /* I could use IntStream.range(0, nullableEmployeesList.size()) instead of a for loop, but
+       understanding the Optional API is difficult enough.
+       I do not use method references for the same reason. */
+    public String printAllEmployeesNames() {
         StringBuilder stringBuilder = new StringBuilder();
         for (int i = 0; i < nullableEmployeesList.size(); i++) {
             stringBuilder.append(i).append(" - ");
 
             nullableEmployeesList.get(i)
-                .flatMap(employee -> employee.getName())
-                .ifPresentOrElse(
-                    name -> stringBuilder.append(name).append("\n"),
-                    () -> stringBuilder.append("No employee found\n")
-                );
+                    .flatMap(employee -> employee.getNullableName())
+                    .ifPresentOrElse(
+                            name -> stringBuilder.append(name).append("\n"),
+                            () -> stringBuilder.append("No employee found\n")
+                    );
         }
         return stringBuilder.toString();
     }
 
     public String printEmployeeNameAndDepartmentById(int employeeId) {
-
-        var employee = getEmployeeById(employeeId);
+        Optional<Employee> employee = getEmployeeById(employeeId);
         StringBuilder stringBuilder = new StringBuilder();
         stringBuilder.append(employeeId).append(" - ");
+        // Handle Optional values
         employee.ifPresentOrElse(
-            e -> {
-                // Handle Optional values
-                e.getName().ifPresentOrElse(
-                    name -> stringBuilder.append(name).append(" - "),
-                    () -> {}
-                );
-                e.getDepartment().ifPresentOrElse(
-                    department -> stringBuilder.append(department),
-                    () -> {}
-                );
-            },
-            () -> stringBuilder.append("No employee found")
+                e -> {
+                    e.getNullableName().ifPresent(name ->
+                            e.getNullableDepartment().ifPresent(department ->
+                                    stringBuilder.append(name).append(" - ").append(department)
+                            )
+                    );
+                },
+                () -> stringBuilder.append("No employee found")
         );
         return stringBuilder.toString();
-    }       
+    }
 
 }
-

exercises/concept/tim-from-marketing-2/.project

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>tim-from-marketing-2</name>
+	<comment>Project tim-from-marketing-2 created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1739322795991</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>

exercises/concept/tim-from-marketing-2/.settings/org.eclipse.buildship.core.prefs

@@ -0,0 +1,2 @@
+connection.project.dir=../tim-from-marketing
+eclipse.preferences.version=1

exercises/concept/tim-from-marketing-2/build.gradle

@@ -0,0 +1,23 @@
+plugins {
+    id "java"
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation platform("org.junit:junit-bom:5.10.0")
+    testImplementation "org.junit.jupiter:junit-jupiter"
+    testImplementation "org.assertj:assertj-core:3.25.1"
+}
+
+test {
+    useJUnitPlatform()
+
+    testLogging {
+        exceptionFormat = "full"
+        showStandardStreams = true
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/concept/tim-from-marketing-2/src/main/java/Employee.java

@@ -1,3 +1,6 @@
+import java.util.Objects;
+import java.util.Optional;
+
 class Employee {
     private final int id;  
     private final String name;
@@ -9,15 +12,29 @@ public Employee(int id, String name, String department) {
         this.department = department;
     }
 
-    public Optional<Integer> getId() {
-        return Optional.ofNullable(id); 
+    public Optional<Integer> getNullableId() {
+        return Optional.ofNullable(id);
     }
 
-    public Optional<String> getName() {
+    public Optional<String> getNullableName() {
         return Optional.ofNullable(name);
     }
 
-    public Optional<String> getDepartment() {
+    public Optional<String> getNullableDepartment() {
         return Optional.ofNullable(department);
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Employee employee = (Employee) o;
+        return id == employee.id &&
+                Objects.equals(name, employee.name) && Objects.equals(department, employee.department);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name, department);
+    }
 }