Edit README and update test script

.gitignore

 target
 dependency-reduced-pom.xml
 *.sublime-*
+/scratch

README.md

 
     <groupId>org.springframework</groupId>
     <artifactId>gs-rest-service</artifactId>
-    <version>0.0.1-SNAPSHOT</version>
+    <version>1.0</version>
 
     <parent>
         <groupId>org.springframework.bootstrap</groupId>
     "content": "Hello, World!"
 }
 ```
-    
+
 The `id` field is a unique identifier for the greeting, and `content` is the textual representation of the greeting.
 
 To model the greeting representation, we’ll create a representation class:
     private final String content;
 
     public Greeting(long id, String content) {
-    this.id = id;
-    this.content = content;
+        this.id = id;
+        this.content = content;
     }
 
     public long getId() {
-    return id;
+        return id;
     }
 
     public String getContent() {
-    return content;
+        return content;
     }
 }
 ```
 }
 ```
 
-The key difference between a human-facing controller and a REST endpoint controller is in how the response is created. Rather than rely on a view (such as JSP) to render model data in HTML, an endpoint controller simply returns the data to be written directly to the body of the response.
+The key difference between a human-facing controller and a REST endpoint controller is in how the response is created. Rather than rely on a view (such as a [JSP](/understanding/JSP)) to render model data in HTML, an endpoint controller simply returns the data to be written directly to the body of the response.
 
-The magic is in the [`@ResponseBody`](http://static.springsource.org/spring/docs/3.2.x/javadoc-api/org/springframework/web/bind/annotation/ResponseBody.html) annotation. `@ResponseBody` tells Spring MVC to not render a model into a view, but rather to write the returned object into the response body. It does this by using one of Spring's message converters. Because Jackson 2 is in the classpath, this means that [`MappingJackson2HttpMessageConverter`](http://static.springsource.org/spring/docs/3.2.x/javadoc-api/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.html) will handle the conversion of Greeting to JSON if the request's `Accept` header specifies that JSON should be returned.
+The magic is in the [`@ResponseBody`](http://static.springsource.org/spring/docs/3.2.x/javadoc-api/org/springframework/web/bind/annotation/ResponseBody.html) annotation. `@ResponseBody` tells Spring MVC to not render a model into a view, but rather to write the returned object into the response body. It does this by using one of Spring's message converters. Because Jackson 2 is on the classpath, Spring's [`MappingJackson2HttpMessageConverter`](http://static.springsource.org/spring/docs/3.2.x/javadoc-api/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.html) is automatically chosen to convert the Greeting instance to JSON.
 
 
 Creating an executable main class
 
 `pom.xml`
 ```xml
+<properties>
+    <start-class>hello.HelloWorldConfiguration</start-class>
+</properties>
+
 <build>
     <plugins>
         <plugin>
 
 Now you can run it from the jar as well, and distribute that as an executable artifact:
 ```
-$ java -jar target/gs-rest-service-1.0-SNAPSHOT.jar
+$ java -jar target/gs-rest-service-1.0.jar
 
 ... service comes up ...
 ```

test/run.sh

 cd $(dirname $0)
 cd ../complete
 mvn package
-java -jar target/gs-rest-service-complete-1.0-SNAPSHOT.jar &
+java -jar target/gs-rest-service-complete-1.0.jar &
 PID=$!
 sleep 3
 curl -s http://localhost:8080/hello-world > target/actual.json