Make some improvements, although it's not complete yet.

Author: josealonso

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

@@ -1,9 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" output="bin/main" path=".meta/src/reference/java">
+	<classpathentry kind="src" output="bin/starterTest" path="src/test/java">
 		<attributes>
-			<attribute name="gradle_scope" value="main"/>
-			<attribute name="gradle_used_by_scope" value="main,test"/>
+			<attribute name="gradle_scope" value="starterTest"/>
+			<attribute name="gradle_used_by_scope" value="starterTest"/>
+			<attribute name="test" value="true"/>
 		</attributes>
 	</classpathentry>
 	<classpathentry kind="src" output="bin/starterSource" path="src/main/java">
@@ -12,20 +13,19 @@
 			<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="src" output="bin/test" path="build/gen/test/java">
 		<attributes>
 			<attribute name="gradle_scope" value="test"/>
 			<attribute name="gradle_used_by_scope" value="test"/>
 			<attribute name="test" value="true"/>
 		</attributes>
 	</classpathentry>
+	<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="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/default"/>

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

@@ -0,0 +1,25 @@
+# ???
+
+The **Optional<T>** type was introduced in Java 8 as a way to indicate that a method _may_ return a value.
+
+Before Java 8, developers had to implement null checks:
+
+```java
+public Employee getEmployee(String name) {
+    // Assume that getEmployeeByName retrieves an Employee from a database
+    Employee employee = getEmployeeByName(name);
+    if (employee != null) {
+        return employee;
+    } else {
+        throw new IllegalArgumentException("Employee not 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.
+
+TBD: Rephrase this last paragraph.
+
+The Optional type is mainly used as returned type. Using it as a parameter type or field type is less common and
+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).

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

@@ -4,7 +4,7 @@
 
 - This method returns an `Optional<Employee>` object, not an `Employee` one.
 
-## 2. Return the name and department of a given employee in a certain format 
+## 2. Return the name and department of a given employee in a certain format
 
 - You can call the method `getEmployeeById(int)` to get the employee.
-- Remember the syntax of the `ifPresentOrElse()` method.
+- Remember the syntax of the `ifPresentOrElse()` method.

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

@@ -8,7 +8,8 @@ You will be writing two methods: `getEmployeeById(int)` and `getEmployeeDetailsB
 
 ## 1. Get an employee by ID
 
-Implement the `getEmployeeById(int)` method so that it returns an Optional<Employee> object. 
+Implement the `getEmployeeById(int)` method so that it returns an Optional<Employee> object.
+
 If the employee does not exist, returns an empty Optional instance.
 
 ## 2. Return the name and department of a given employee in a certain format
@@ -21,4 +22,4 @@ getEmployeeDetailsById(1) => "1 - Tim - Marketing"
 getEmployeeDetailsById(3) => "3 - Steve - Engineering"
 ```
 
-If the employee does not exist or is null, it returns `No employee found for id: [id]`.
+If the employee does not exist or is null, it returns `No employee found for id: [id]`.

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

@@ -2,24 +2,24 @@
 
 ## Optional
 
-## Introduction
+The **Optional<T>** type was introduced in Java 8 as a way to indicate that a method _may_ return a value.
 
-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:
+In other words, there is a chance the method returns "no value" at all.
+
+## Creating an Optional<T> object
+
+Given an object of type Employee, an Optional<Employee> object is created as follows:
 
 ```java
-public Employee getEmployee(String name) {
-    // Assume that getEmployeeByName retrieves an Employee from a database
-    Employee employee = getEmployeeByName(name);
-    if (employee != null) {
-        return employee;
-    } else {
-        throw new IllegalArgumentException("Employee not found");
-    }
-}
+Employee employee = new Employee();
+Optional<Employee> optionalEmployee = Optional.of(employee);
 ```
 
-With the Optional API, the code above can be simplified to:
+`optionalEmployee` is a wrapper of `employee`.
+
+TBD: explain empty, present and get.
+
+## Usage
 
 ```java
 public Optional<Employee> getEmployee(String name) {
@@ -62,8 +62,3 @@ public Optional<Integer> getEmployeeAge(String name) {
                .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 Optional type is mainly used as returned type. Using it as a parameter type or field type is less common and 
-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)

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

@@ -1,17 +1,25 @@
 {
+  "name": "tim-from-marketing-2",
+  "uuid": "a6cfc286-8c62-4f5b-8e59-f6bfc4374092",
+  "concepts": [
+    "optional-type"
+  ],
   "authors": [
     "josealonso"
   ],
+  "contributors": [
+    "kahgoh"
+  ],
   "files": {
     "solution": [
-      "src/main/java/EmployeeService.java"
+      "src/main/java/EmployeeDatabase.java"
     ],
     "test": [
-      "src/test/java/EmployeeServiceTest.java"
+      "src/test/java/EmployeeDatabaseTest.java"
     ],
     "exemplar": [
       ".meta/src/reference/java/EmployeeService.java"
-    ],
+    ]
   },
   "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,9 +3,8 @@
 ## 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`, `orElseThrow`. 
+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.
 
 ## Learning objectives
 
@@ -35,8 +34,9 @@ This Concept Exercise's prerequisites Concepts are:
 ## Analyzer
 
 This exercise could benefit from the following rules in the [analyzer]:
+
 - `essential`: 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. 
+- `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.

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

@@ -1,5 +1,8 @@
 import java.util.Objects;
-import java.util.Optional;
+
+/**
+ * Holds information about an employee. There is no need to change this file.
+*/
 
 class Employee {
     private final int id;

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

@@ -2,12 +2,12 @@
 import java.util.Optional;
 import java.util.Objects;
 
-class EmployeeService {
+class EmployeeDatabase {
 
     // This list is populated in the tests
     private List<Employee> employeesList;
 
-    public EmployeeService(List<Employee> listOfEmployees) {
+    public EmployeeDatabase(List<Employee> listOfEmployees) {
         employeesList = listOfEmployees;
     }
 

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

@@ -0,0 +1,5 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.classpath.outputOverlappingAnotherSource=ignore
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=17
+org.eclipse.jdt.core.compiler.compliance=17
+org.eclipse.jdt.core.compiler.source=17