anchor.diff:           <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
  -             <version>3.3</version>
  +             <version>3.6.0</version>
                <executions>
                    <execution>
                        <id>default-compile</id>
  
positive.code: 
  
  == About
  GhostWriter is the tracking/monitoring solution that you've been looking for! You just don't know it yet!
  With only a recompilation, your application will be instrumented with capabilities that provide a way to react to various events,
  such as method invocations, state changes or even unhandled exceptions.
  How these events are handled is up to the runtime component, which opens the door for possibilities.
  During development, you might want a full trace of what and how data passes through your application.
  In production, you can opt for just capturing the application state that led to an unhandled error.
  Or you can provide your own implementation, which is customized to meet your needs.
  All this is provided in a noninvasive way! You don't need to modify your code, you won't get proxy classes or mangled stack traces.
  Trying it out is simply a matter of adding a dependency and a flag to your application.
  
  == Getting started
  
  GhostWriter is divided into two major components. The compile-time module, which is responsible for instrumenting your application
  with the necessary API calls and the runtime modules, which handles the API calls.
  
  === Compile time module ===
  
  The compile time module is specific to a compiler version. So you have to specify the correct dependency, otherwise your build will fail.
  This means that for JDKv7 you will have to use the _ghostwriter-openjdk-v7_ module and for JDKv8 _ghostwriter-openjdk-v8_.
  There are corresponding sections both for Maven and Gradle to get you started, just check those.
  By default, GhostWriter uses a "no operation" runtime implementation. To add a more concrete functionality, you need to specify a runtime module.
  Check the corresponding section (_Runtime module_) for details.
  
  ==== Maven ====
  
  Add another _dependency_ entry to the _dependencies_ section.
  This means that for JDKv7, you will have the following entry in you _pom.xml_ file.
  
  ----
  <dependency>
      <groupId>io.ghostwriter</groupId>
      <artifactId>ghostwriter-openjdk-v7</artifactId>
      <version>0.1.0</version>
      <scope>compile</scope>
  </dependency>
  ----
  
  In order to instrument your application, you have to set the compile time annotation processor.
  In Maven this is done by adding the following lines to your _pom.xml_.
  
  ----
  <build>
  
negative.code: The important part is the specification of the annotation processor using the _annotationProcessor_ tag.
  The rest is more or less Maven foreplay.
  
  === Gradle ===
  
  The provided snippets work with Gradle 2+.
  The dependencies of GhostWriter are fetched from Maven Central. So you have to add it to your list of repositories if its not there yet.
  For a project that uses JDK8, you'll will have to add the following lines to your _build.gradle_ file.
  
  ----
  repositories {
  