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: </dependencies>
  ```
  
  You actually only need the Postgresql (which is actually the Postgres JDBC driver for Java) and HikariCP dependencies. However the code that I will show you now is also managing the old H2 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 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();
  
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`:
  
  ```
  