anchor.diff:  
   public interface Persistence {
   	public <T> T read(Class<T> clazz, Object id);
  -	public <T> List<T> read(Class<T> clazz, Predicate<T> predicate, int maxResults);
  +	public <T> List<T> read(Class<T> clazz, Criteria criteria, int maxResults);
   	public <T> Object insert(T object);
   	public <T> T update(T object);
   	public <T> void delete(Class<T> clazz, Object id);
  
positive.code: ==== Read by Criteria
  This is the best way to read objects depending on thier fields. The most common use of this is probably when you want
  to implement a filter for a table. The user may see one or more FormElement to enter values the object he is looking
  for should match.
  
  [source,java]
  ----
  	@Override
  	protected List<AccountPosition> load() {
  		return Backend.persistence().read(AccountPosition.class, By.field(AccountPosition.$.account, account).and(By.filter(filter)), 1000);
  	}
  ----
  	
  ==== Read by query
  As nice as the predicates are they have their limits. The query language of a relation database is far mighter than some
  simple 'and' and 'or'. Now maybe SQL queries could to translated in their glories to a java expressions. There are projects that do this
  (or at least try). I have great respect for them. If you are interested have a look at http://www.jooq.org/ or http://www.querydsl.com/ .
  The great appeal of this approach is that you would have static name checks and even some type safety! Why does Minimal-J not go
  
negative.code: 
  1. Read an object by its class and its Id
  
  2. Read one or many objects by more or less complex criteria based on its fields
  
  3. Read objects by a database specific query
  
  