anchor.diff:  * Assume that you modify `helloBye` so that it creates the paths it needs using `Path.of` (and using strings, converting the path given as argument to a string by using `toString()`) instead of by creating the paths it needs from the path instance given as argument. What would continue to work, among what we did so far, and what would fail? Explain, using the explanations given in the section here above, why it is impossible to make this whole exercice work if creating path instances using `Path.of`.
   
   == Make sure your methods that write data can write anywhere
  -A method that writes data (for example, converts some object to an XML representation) should be able to write not only on a file sitting on a hard disk, but also in memory or generally on any output stream: this makes it more general, at no cost. 
  +A method that writes data (for example, converts some object to an XML representation) should be able to write not only on a file sitting on a hard disk, but also in memory or generally on any instance of `Path`: this makes it more general, at no cost. 
   
  -For example, instead of `asXml(String fileName)`, design your class with a method `asXml(Path outputPath)` and `asXml(OutputStream stream)` (just the first one is a better choice if your data size is small; the second one should accept a `Writer` instead of an `OutputStream` for character based flows).
  +For example, instead of `asXml(String fileName)`, design your class with a method `asXml(): String` (if the expected data size is small) and `asXml(Path outputPath)`.
   
   In particular, it often happens that some unit test needs to call a method that writes data, then needs to re-read the data just written, to check for correctness. In that case, writing to a physical file is inelegant: creating a physical file just to read it and deleting it afterwards is a waste of time and resources, and practically speaking, it requires to find some place on the hard disk where your code has write access, then make sure that somehow the file gets deleted afterwards. It is much better to write in memory. 
   
  
positive.code: == Constructing paths from other paths
  There are two important ways of obtaining a `Path` instance. One is to build it from `String` instances, as illustrated here above. Another is to obtain a path _from another path_. The crucial difference is that when you obtain your instance from another path, _your instance is bound to the same provider as the other path provider_. Thus, if you receive a `Path` instance that is bound to an in-memory file system, and obtain, say, a child of that path (by calling `resolve(String)` on that path), you obtain another `Path` instance bound to this same in-memory file system. This is very handy: in this way, you can create general code that deals with any file system given by your user, even if you know nothing about the specifics of those other file systems.
  
  == Exercice: Write two files
  In this exercice we will write code that writes two files, `hello.txt` and `subfolder/bye.txt`.
  
  * Define a method `helloBye(Path)` that accepts a `Path` (considered to represent a folder). Define another path instance from that path, representing the file `hello.txt` sitting in the folder represented by that path (thus, for example, if given a path representing `/home/user/afolder/`, your new path instance should represent `/home/user/afolder/hello.txt`). Write the string `Hello, world` in that file. Check that it works.
  * Extend your method so that it creates a path representing the folder `subfolder` as a child folder of the path received as argument, create that folder, and in that folder, create a file `bye.txt` containing `Bye bye!`. Check that this works.
  * Create somewhere (manually, with your file browser) some folders `test1/` and `test2/asubfolder/`. Define a `main` method that calls `helloBye()` twice, giving it paths representing `test1/` and then `test2/asubfolder/`. Check that your code has created the four expected files.
  
  == Exercice: abstract path concept
  Here we will reuse our previous code to write at different places in our default file system and to a zip file.
  
  
negative.code: 
  * Create a unit test that creates a `String` equal to `firstname\nlastname`. The test gives the string to your `readPersons` method created in the previous exercice. To do this, use a https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/StringReader.html[`StringReader`]. The test asserts that the created person has the right first and last names.
  
  == Exercice: Write two files
  In this exercice we will write code that writes two files, `hello.txt` and `subfolder/bye.txt`.
  
  * Define a method `helloBye(Path)` that accepts a `Path` (considered to represent a folder). Define another path instance from that path, representing the file `hello.txt` sitting in the folder represented by that path (thus, for example, if given a path representing `/home/user/afolder/`, your new path instance should represent `/home/user/afolder/hello.txt`). Write the string `Hello, world` in that file. Check that it works.
  * Extend your method so that it creates a path representing the folder `subfolder` as a child folder of the path received as argument, create that folder, and in that folder, create a file `bye.txt` containing `Bye bye!`. Check that this works.
  * Create somewhere (manually, with your file browser) some folders `test1/` and `test2/asubfolder/`. Define a `main` method that calls `helloBye()` twice, giving it paths representing `test1/` and then `test2/asubfolder/`. Check that your code has created the four expected files.
  
  == Path operations
  A `Path` represents a path in a tree, and that tree represents a “file” system. From a given `Path` instance (representing, thus, a path in a file system), you can obtain other `Path` instances, representing relative or absolute paths that relate to that first path. See https://docs.oracle.com/javase/tutorial/essential/io/pathOps.html[here] for the essentials about this. 
  
  