anchor.diff:     public static void main(String...args) throws SQLException {
           Dao dao = new Dao(DataSourceFactory.getPostgresHikariCPDataSource());
           dao.prepareDb();
  -        
  -        IntStream.range(0, 100).forEach(
  -            x -> dao.insertItem(new Item(x+1, "test" +x))
  -        );
  +        IntStream.range(0, 100).forEach( x -> dao.insertItem(new Item(x+1, "test" +x)));
           List<Item> list = dao.fetchAllItems();
           list.forEach(item -> LOG.info("Found item with index {}", item.getIndex()));
       }
       ...
   ```
  -Clearly it is not worth the pain of managing a DB server if you only manage a single kind of entity (Person.class). The focus of this tutorial is not really the complexity of the data to manage, but how to build the persistence layer of your application is a structured manner and to be ready to switch database under the hood -- and also some advanced information about connection pooling :) Hope you liked it!
  +Clearly it is not worth the pain of managing a DB server if you only manage a single kind of entity (`Person.class`). The focus of this tutorial is not really the complexity of the data to manage, but how to build the persistence layer of your application is a structured manner and to be ready to switch database under the hood -- and also some advanced information about connection pooling :) Hope you liked it!
  
positive.code:     }
  }
  ```
  == Finally, the Data access object
  What I usually do at this point, is having a a Dao class that masks, or abstracts, the database interactions.
  In the future, I want this object Dao to be *injected*, so it will have a constructor that gets a DataSource implementation, coming from the static Factory that we wrote before.
  As mentioned, I'm using Sql2o library which is a nice wrapper of SQL statements in object oriented form (it is NOT an ORM like Hibernate, it is just a SQL formatter).
  
negative.code: </dependencies>
  ```
  
  You actually only need the Postgresql (which is actually the Postgres JDBC driver for Java) and HikariCP dependencies. The reason why the other dependencies are shown is that the code that I will show you now is also managing the old H2 db instance I had before this change (which I'm retaining for testing), and uses the library SQL2o for submitting queries -- more on this in the examples.
  
  == Using Hikari
  Using Hikari is very straightforward. Instead of instantiating a connector to the Postgres JDBC driver directly, we have to instantiate the `javax.sql.DataSource` implementation of HikariCP: A configuration file in `src/main/resources` will worry telling Hikari how to connect to Pg and which Driver class to use:
  ```
  System.setProperty("hikaricp.configurationFile", "src/main/resources/conf.properties");
  DataSource ds = new HikariDataSource();
  