anchor.diff:  }
   ----
   
  -The typical use case for `@RequestMapping` is to map an handler method to a specific path
  -+ method. In Java, it is possible to specify single value for annotation array attribute,
  -they will be automatically converted to arrays. That's why you can write
  +The typical use case for `@RequestMapping` is to map a handler method to a specific path
  +and method. In Java, it is possible to specify a single value for the
  +annotation array attribute and it will be automatically converted to an array.
  +
  +That's why one can write
   `@RequestMapping(value = "/foo", method = RequestMethod.GET)` or
   `@RequestMapping(path = "/foo", method = RequestMethod.GET)`.
   
  -In Kotlin, you will have to write `@RequestMapping("/foo", method = arrayOf(RequestMethod.GET))`.
  +However, in Kotlin, one will have to write `@RequestMapping("/foo", method = arrayOf(RequestMethod.GET))`.
   The variant using `path` is not recommended as it need to be written
   `@RequestMapping(path = arrayOf("/foo"), method = arrayOf(RequestMethod.GET))`.
   
  -A workaround for this specific `method` attribute (the most common one)  is to use shortcut
  -annotation like `@GetMapping`, `@PostMapping`, etc.
  -
  -[NOTE]
  -====
  -Remininder: if you don't specify `@RequestMapping` `method` attribute, all HTTP methods will be matched,
  -not just `GET` ones.
  -====
  -
  -Improving syntax and consistency of Kotlin annotation array attributes is discussed in
  +A workaround for this specific `method` attribute (the most common one) is to
  +use a shortcut annotation such as `@GetMapping` or `@PostMapping`, etc.
  +
  +[NOTE]
  +====
  +Remininder: if the `@RequestMapping` `method` attribute is not specified, all HTTP methods will be matched,
  +not only the `GET` methods.
  +====
  +
  +Improving the syntax and consistency of Kotlin annotation array attributes is discussed in
   https://youtrack.jetbrains.com/issue/KT-11235[this Kotlin language design issue].
   
   === Testing
   
  -Kotlin allows to specify meaningful test function names betweeen backticks,
  -and as of JUnit 5 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`
  +Kotlin allows one to specify meaningful test function names between backticks,
  +and as of JUnit 5 Kotlin test classes can use the `@TestInstance(TestInstance.Lifecycle.PER_CLASS)`
  +annotation to enable a single instantiation of test classes which allows the use of `@BeforeAll` and `@AfterAll`
   annotations on non-static methods, which is a good fit for Kotlin.
   
  -It is also now possible to change the default behavior to `PER_CLASS` thanks to a
  +It is now possible to change the default behavior to `PER_CLASS` thanks to a
   `junit-platform.properties` file with a
   `junit.jupiter.testinstance.lifecycle.default = per_class` property.
   
  
positive.code: }
  ----
  
  If you have any existing code (like Spring Boot actuators or `@LocalServerPort`) that is
  using the `${...}` syntax, you should declare the following beans in your configuration:
  
  [source,kotlin]
  ----
  
negative.code: 
  As of version 4.3, Spring Framework provides a
  http://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/view/script/ScriptTemplateView.html[ScriptTemplateView]
  to render templates using script engines that supports
  https://www.jcp.org/en/jsr/detail?id=223[JSR-223].
  Spring Framework 5 goes even further by extending this feature to WebFlux and supporting
  https://jira.spring.io/browse/SPR-15064[i18n and nested templates].
  
  Kotlin provides similar support and allows the rendering of Kotlin based templates, see
  https://github.com/spring-projects/spring-framework/commit/badde3a479a53e1dd0777dd1bd5b55cb1021cf9e[this commit] for details.
  
  This enables some interesting use cases like writing type-safe templates using
  https://github.com/Kotlin/kotlinx.html[kotlinx.html] DSL or simply using Kotlin multiline `String` with interpolation.
  
  This can allow one to write Kotlin templates with full autocompletion and
  refactoring support in a supported IDE:
  
  [source,kotlin]
  ----
  