anchor.diff:      }
   }
   ```
  -== Finally, the Data access object
  +== 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).
  
positive.code:    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))
          );
          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!
  
negative.code: 
  There are several CP libs out there (the most used seem to be C3PO and Apache Commons DBCP), but I chose to be adventurous and use https://github.com/brettwooldridge/HikariCP[HikariCP]: after all they claim to be more robust and optimized than C3PO so I have the chance to learn to use this lib.
  
  == Adding the dependencies
  This should appear in the `pom.xml`:
  
  ```
  