anchor.diff:  Boot specifics, see the
   http://docs.spring.io/spring-boot/docs/current/reference/html/[Spring Boot reference documentation].
   
  -We also need to create an `application.properties` file in `src/main/resources`. We need
  -to configure two properties in `application.properties`: We need to set the application
  -name (which is translated to the task name), and we need to set the logging for Spring
  -Cloud Task to `DEBUG` so that we can see what's going on. The following example shows how
  -to do both:
  +Now we can open the `application.properties` file in `src/main/resources`.
  +We need to configure two properties in `application.properties`:
  +
  +* `application.name`: To set the application name (which is translated to the task name)
  +* `logging.level`: To set the logging for Spring Cloud Task to `DEBUG` in order to
  +get a view of what is going on.
  +
  +The following example shows how to do both:
  +
   
   [source]
   ----
  
positive.code: automatically generates a new project structure so that you can start coding right away.
  We recommend experimenting with the Spring Initializr to become familiar with it.
  
  Before we begin, open a terminal to check that you have valid versions of Java and Maven
  installed, as shown in the following two listings:
  
  [source]
  $ java -version
  java version "1.8.0_31"
  Java(TM) SE Runtime Environment (build 1.8.0_31-b13)
  Java HotSpot(TM) 64-Bit Server VM (build 25.31-b07, mixed mode)
  
  [source]
  $ mvn -v
  Apache Maven 3.2.3 (33f8c3e1027c3ddde99d3cdebad2656a31e8fdf4; 2014-08-11T15:58:10-05:00)
  Maven home: /usr/local/Cellar/maven/3.2.3/libexec
  Java version: 1.8.0_31, vendor: Oracle Corporation
  
  NOTE: This sample needs to be created in its own folder. Subsequent instructions assume
  you have created a suitable folder and that it is your "`current directory.`"
  
  [[getting-started-creating-the-pom]]
  === Creating the POM
  
  We need to start by creating a Maven `pom.xml` file. The `pom.xml` file contains the
  recipe that Maven uses to build your project. To create the pom.xml file, open your
  favorite text editor and add the following:
  
  [code,xml]
  ----
  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
  		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  
  	<modelVersion>4.0.0</modelVersion>
  
  	<groupId>com.example</groupId>
  	<artifactId>myproject</artifactId>
  	<packaging>jar</packaging>
  	<version>0.0.1-SNAPSHOT</version>
  
  	<parent>
  		<groupId>org.springframework.boot</groupId>
  		<artifactId>spring-boot-starter-parent</artifactId>
  		<version>1.5.2.RELEASE</version>
  	</parent>
  
  	<properties>
  		<start-class>com.example.SampleTask</start-class>
  	</properties>
  
  	<dependencies>
  		<dependency>
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-starter</artifactId>
  		</dependency>
  	</dependencies>
  
  	<build>
  		<plugins>
  			<plugin>
  				<groupId>org.springframework.boot</groupId>
  				<artifactId>spring-boot-maven-plugin</artifactId>
  			</plugin>
  		</plugins>
  	</build>
  </project>
  ----
  
  Creating a `pom.xml` file with the preceding content should give you a working build. You
  can test it by running `mvn package` (for now, you can ignore the "jar will be empty - no
  content was marked for inclusion!" warning ).
  
  NOTE: At this point, you could import the project into an IDE (most modern Java IDE's
  include built-in support for Maven). For simplicity, we continue to use a plain text
  editor for this example.
  
  [[getting-started-adding-classpath-dependencies]]
  === Adding classpath dependencies
  
  A Spring Cloud Task is made up of a Spring Boot application that is expected to end. In
  the `pom.xml` file we showed earlier, we created the shell of a Spring Boot application by
  setting our parent to use the `spring-boot-starter-parent`.
  
  Spring Boot provides a number of additional "`Starter POMs`". Some of them are appropriate
  for use within tasks (`spring-boot-starter-batch`, `spring-boot-starter-jdbc`, and
  others), and some may not be ('spring-boot-starter-web` is probably not going to be used
  in a task). The best indicator of which starter makes sense is whether the resulting
  application should end. Batch-based applications typically end. Conversely, the
  `spring-boot-starter-web` dependency bootstraps a servlet container, which better suits
  applications that continue.
  
  For this example, we need only to add a single additional dependency -- the one for
  Spring Cloud Task itself:
  
  [source,xml]
  		<dependency>
  			<groupId>org.springframework.cloud</groupId>
  			<artifactId>spring-cloud-starter-task</artifactId>
  			<version>1.2.3.RELEASE</version>
  		</dependency>
  
  [[getting-started-writing-the-code]]
  === Writing the Code
  
  To finish our application, we need to create a single Java file. By default, Maven
  compiles the sources from `src/main/java`, so you need to create that folder structure.
  Then you need to add a file named `src/main/java/com/example/SampleTask.java`, as shown
  in the following example:
  
  [source,java]
  ----
  package com.example;
  
  import org.springframework.boot.*;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.cloud.task.configuration.EnableTask;
  import org.springframework.context.annotation.Bean;
  
  @SpringBootApplication
  @EnableTask
  public class SampleTask {
  
  	@Bean
  	public CommandLineRunner commandLineRunner() {
  
negative.code: 	}
  
  	public static void main(String[] args) {
  		SpringApplication.run(HelloworldApplication.class, args);
  	}
  
  	public static class HelloWorldCommandLineRunner implements CommandLineRunner {
  