anchor.diff:  If you are using Spring Boot, you would probably be interested in using
   https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config-typesafe-configuration-properties[`@ConfigurationProperties`]
   instead of `@Value`, but currently you have to use it with nullable `var` (which is far from ideal)
  -properties since immutable classes initialized by constructor are not support yet.
  -See https://github.com/spring-projects/spring-boot/issues/8762[this issue] for more details.
  -====
  +properties since immutable classes initialized by constructor are not supported yet.
  +See these issues about https://github.com/spring-projects/spring-boot/issues/8762[`@ConfigurationProperties` binding for immutable POJOs]
  +and https://github.com/spring-projects/spring-boot/issues/1254[`@ConfigurationProperties` binding on interfaces]
  +for more details.
  +====
  +
  +=== Annotation array attributes
  +
  +Kotlin annotations are mostly similar to Java ones, but array attributes - which are
  +extensively used in Spring - behaves differently. As explained in https://kotlinlang.org/docs/reference/annotations.html[Kotlin documentation]
  +unlike other attributes, `value` attribute name can be omitted and when it is an array
  +attribute it is specified as a `vararg` parameter.
  +
  +To understand what that means more concretely, let's take `@RequestMapping`, which is one
  +of the most used Spring annotation as an example. This Java annotation is declared as following:
  +
  +[source,java]
  +----
  +public @interface RequestMapping {
  +
  +  @AliasFor("path")
  +  String[] value() default {};
  +
  +  @AliasFor("value")
  +  String[] path() default {};
  +
  +  RequestMethod[] method() default {};
  +
  +  // ...
  +}
  +----
  +
  +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
  +`@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))`.
  +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
  +https://youtrack.jetbrains.com/issue/KT-11235[this Kotlin language design issue].
   
   === Testing
   
  
positive.code: 
  == Bean definition DSL
  
  Spring Framework 5 introduces a new way to register beans in a functional way using lambda
  as an alternative to XML or JavaConfig with `@Configuration` and `@Bean`. In a nutshell,
  it makes it possible to register beans with a lambda that acts as a `FactoryBean`.
  It is very efficient and does not require any reflection or CGLIB proxies.
  
  
negative.code: 
  === WebFlux Functional DSL
  
  Spring Framework now 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 <<reactive-web#webflux-fn,WebFlux functional API>> with clean and idiomatic Kotlin code:
  
  