anchor.diff:  
   A property is an externally visible feature of a class. Rather than just using a public field to represent
   such features (which provides a more limited abstraction and would restrict refactoring possibilities),
  -the typical convention in Java is to follow JavaBean conventions, i.e. represent the property using a
  +the typical approach in Java is to follow the conventions outlined in the
  +{javabeans}[JavaBeans Specification], i.e. represent the property using a
   combination of a private backing field and getters/setters. Groovy follows these same conventions
  -but provides a simpler approach to defining the property. You can define a property with:
  +but provides a simpler way to define the property. You can define a property with:
   
   * an *absent* access modifier (no `public`, `protected` or `private`)
   * one or more optional _modifiers_ (`static`, `final`, `synchronized`)
  
positive.code: <3> writing `p.groovy` is allowed because there is a pseudo-writeonly property `groovy`
  
  This syntactic sugar is at the core of many DSLs written in Groovy.
  
  === Annotation
  
  
negative.code: <1> the field `mapping` doesn't declare a type
  <2> the field `mapping` has a strong type
  
  The difference between the two is important if you want to use optional type checking later.
  It is also important as a way to document the class design.
  However, in some cases like scripting or if you want to rely on duck typing it may be useful
  to omit the type.
  
  [[properties]]
  