anchor.diff:  
   == Null-safety of Spring API
   
  -One of Kotlin's key features is https://kotlinlang.org/docs/reference/null-safety.html[null-safety] which allows to deal with
  -`null` values at compile time rather than bumping into the famous `NullPointerException` at runtime. This makes your applications
  -safer through clean nullability declarations, expressing "value or no value" semantics without paying the cost of wrapper like `Optional`.
  +One of Kotlin's key features is https://kotlinlang.org/docs/reference/null-safety.html[null-safety]
  +which allows to deal with `null` values at compile time rather than bumping into the famous
  +`NullPointerException` at runtime. This makes your applications safer through clean nullability
  +declarations, expressing "value or no value" semantics without paying the cost of wrapper like `Optional`.
   (Kotlin allows using functional constructs with nullable values; check out this
   http://www.baeldung.com/kotlin-null-safety[comprehensive guide to Kotlin null-safety].)
   
   Although Java does not allow to express null-safety in its type-system, Spring Framework 5 introduces
  -https://jira.spring.io/browse/SPR-15540[null-safety of the whole Spring Framework APIs] via tooling-friendly annotations:
  +https://jira.spring.io/browse/SPR-15540[null-safety of the whole Spring Framework APIs]
  +via tooling-friendly annotations:
   
    * `@NonNullApi` annotations at package level declare that non-null is the default behavior
    * `@Nullable` annotations where specific parameters or return values can be `null`.
   
  -Both annotations are meta-annotated with https://jcp.org/en/jsr/detail?id=305[JSR 305] meta-annotations (a dormant JSR but supported by tools
  -like IDEA, Eclipse, Findbugs, etc.) to provide useful warnings to Java developers.
  +Both annotations are meta-annotated with https://jcp.org/en/jsr/detail?id=305[JSR 305]
  +meta-annotations (a dormant JSR but supported by tools like IDEA, Eclipse, Findbugs, etc.)
  +to provide useful warnings to Java developers.
   
   On the Kotlin side - as of the https://blog.jetbrains.com/kotlin/2017/08/kotlin-1-1-4-is-out/[Kotlin 1.1.4 release] -
   these annotations https://github.com/Kotlin/KEEP/blob/jsr-305/proposals/jsr-305-custom-nullability-qualifiers.md[are recognized by Kotlin]
  -in order to provide null-safety for the whole Spring API. That means you should never have `NullPointerException` in your code when
  -using Spring 5 and Kotlin because the compiler will not allow it.
  -
  -For now, you need to use a `-Xjsr305-annotations=enable` flag (specified via the `freeCompilerArgs` peroperty with Maven or Gradle Kotlin
  -plugin), but that will became the default behavior in an upcoming release of Kotlin.
  +in order to provide null-safety for the whole Spring Framework API. That means you should
  +never have `NullPointerException` in your code when using Spring Framework and Kotlin because
  +the compiler will not allow it.
  +
  +For now, you need to use a `-Xjsr305-annotations=enable` flag (specified via the
  +`freeCompilerArgs` property with Maven or Gradle Kotlin plugins), but that should become
  +the default behavior in an upcoming release of Kotlin.
   
   Make sure to https://github.com/sdeleuze/spring-kotlin-functional/blob/2d6ac07adfc2b8f25e91681dbb2b58a1c6cdf9a7/build.gradle.kts#L57[include JSR-305 JAR]
  -until Kotlin 1.1.5 is released (it will include https://youtrack.jetbrains.com/issue/KT-19419[KT-19419] fix).
  -
  -Currently null-safety does not apply to generic type parameters, but that could change in the future, the related issue is
  -https://youtrack.jetbrains.com/issue/KT-19592[KT-19592].
  +until Kotlin 1.1.5 is released (it will fix https://youtrack.jetbrains.com/issue/KT-19419[KT-19419]).
  +
  +Currently null-safety does not apply to generic type parameters, but that could change in
  +the future, the related issue is https://youtrack.jetbrains.com/issue/KT-19592[KT-19592].
   
   [NOTE]
   ====
  
positive.code: === Easy testing Kotlin and JUnit 5
  
  Kotlin allows to specify meaningful test function names betweeen backticks,
  and as of JUnit 5.0 Kotlin test classes can use `@TestInstance(TestInstance.Lifecycle.PER_CLASS)`
  to enable a single instantiation of test classes which allows to use `@BeforeAll` and `@AfterAll`
  annotations on non-static methods, which is a good fit for Kotlin.
  
  
negative.code: == Support for Kotlin classes
  
  Spring Framework 5 now supports various Kotlin constructs like instantiating Kotlin classes
  via primary constructors, immutable classes data binding and function optional parameters
  with default values.
  
  https://github.com/FasterXML/jackson-module-kotlin[Jackson Kotlin module] which is required
  for serializing / deserializing JSON data is automatically registered when present in the
  classpath, and will log a warning message if Jackson + Kotlin are detected without Jackson
  Kotlin module.
  
  [NOTE]
  ====
  As of Spring Boot 2.0, Jackson Kotlin module is automatically provided via the JSON starter.
  ====
  
  == Leveraging null-safety in Spring annotations
  
  Spring Framework also takes advantage of https://kotlinlang.org/docs/reference/null-safety.html[Kotlin null-safety]
  to determine if an HTTP parameter is required without having to define explicitly the `required` attribute.
  That means `@RequestParam name: String?` with be treated as not required and `@RequestParam name: String` as required.
  
  This is also supported on Spring Messaging `@Header` annotation.
  
  In a similar fashion, Spring bean injection with `@Autowired` or `@Inject` uses this information
  to know if a bean is required or not. `@Autowired lateinit var foo: Foo` implies that a bean
  of type `Foo` must be registered in the application context while `@Autowired lateinit var foo: Foo?`
  won’t raise an error if such bean does not exist.
  
  == Spring WebFlux functional DSL
  
  Spring Framework 5 comes with a
  {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/-router-function-dsl/[Kotlin routing DSL]
  that allows you to leverage the <<webflux-fn,WebFlux functional API] with clean and idiomatic Kotlin code:
  
  [source,kotlin]
  ----
  