anchor.diff:      }
   }
   ----
  -<1> A package-private constructor injection.
  -
  +<1> A package-private constructor injection. `@Inject` is optional in this particular case.
   
   [[supported_features]]
   == Supported Features
  
positive.code: <1> Value is a group id for a dependency identified by name `acme`.
  <2> Value is an artifact id for a dependency identified by name `acme`.
  
  == Private Members
  
  Quarkus is designed with Substrate VM in mind.
  One of the limitations is the usage of https://github.com/oracle/graal/blob/master/substratevm/LIMITATIONS.md#user-content-reflection[Reflection, window="_blank"].
  Substrate VM does support reflective calls but for a price of a bigger native executable.
  Quarkus must use reflection fallback to access private members.
  That's why Quarkus users are encouraged __not to use private members__ in their beans.
  This involves injection fields, constructors and initializers, observer methods, producer methods and fields, disposers and interceptor methods.
  
  You can use for example package-private modifiers:
  
  [source,java]
  ----
  
negative.code: * Interceptor methods on superclasses are not implemented yet
  * `BEFORE_COMPLETION`, `AFTER_COMPLETION`, `AFTER_FAILURE` and `AFTER_SUCCESS` transactional observers are not implemented yet
  
  == Non-standard Features
  
  === Qualified Injected Fields
  
  In CDI, if you declare a field injection point you need to use `@Inject` and optionally required qualifiers:
   
  [source,java]
  ----
    @Inject
    @ConfigProperty(name = "cool")
    String coolProperty;
  ----
  
  In Quarkus, you can skip the `@Inject` annotation completely if an injected field declares at least one qualifier:
  
  [source,java]
  ----
    @ConfigProperty(name = "cool")
    String coolProperty;
  ----
  
  NOTE: `@Inject` is still required for constructor and method injection.
  
  === Simplified Constructor Injection
  
  In CDI, a normal scoped bean must always declare a no-args constructor (this constructor is normally generated by the compiler unless you declare any other constructor).
  However, this requirement complicates constructor injection - you need to provide a dummy no-args constructor to make things work in CDI.
  
  [source,java]
  ----
  @ApplicationScoped
  public class MyCoolService {
  
    private SimpleProcessor processor;
  
    MyCoolService() { // dummy constructor needed
    }
    
    @Inject // constructor injection
    MyCoolService(SimpleProcessor processor) {
      this.processor = processor;
    }
  }
  ----
  
  There is no need to declare dummy constructors for normal scoped bean in Quarkus - they are generated automatically.
  Also if there's only one constructor there is no need for `@Inject`.
  
  [source,java]
  ----
  @ApplicationScoped
  public class MyCoolService {
  
    private SimpleProcessor processor;
  
    MyCoolService(SimpleProcessor processor) {
      this.processor = processor;
    }
  }
  ----
  
  NOTE: We don't generate a no-args constructor automatically if a bean class extends a class that does not declare a no-args constructor.
  
  [[remove_unused_beans]]
  === Removing Unused Beans
  
  The container attempts to remove all unused beans during build by default.
  This optimization can be disabled by setting `quarkus.arc.remove-unused-beans` to `none` or `false`.
  
  An unused bean:
  
  * is not a built-in bean or an interceptor,
  * is not eligible for injection to any injection point,
  * is not excluded by any extension,
  * does not have a name,
  * does not declare an observer,
  * does not declare any producer which is eligible for injection to any injection point,
  * is not directly eligible for injection into any `javax.enterprise.inject.Instance` or `javax.inject.Provider` injection point
  
  This optimization applies to all forms of bean declarations: bean class, producer method, producer field.
  
  Users can instruct the container to not remove any of their specific beans (even if they satisfy all the rules specified above) by annotating them with `io.quarkus.arc.Unremovable`.
  This annotation can be placed on the types, producer methods, and producer fields.
   
  Furthermore, extensions can eliminate possible false positives by producing `UnremovableBeanBuildItem`.
  
  Finally, Quarkus provides a middle ground for the bean removal optimization where application beans are never removed whether or not they are unused,
  while the optimization proceeds normally for non application classes. To use this mode, set `quarkus.arc.remove-unused-beans` to `fwk` or `framework`.
  
  When using the dev mode (running `mvn clean compile quarkus:dev`), you can see more information about which beans are being removed
  by enabling additional logging via the following line in your `application.properties`.
  
  ----
  quarkus.log.category."io.quarkus.arc.processor".level=DEBUG
  ----
  
  [[default_beans]]
  === Default Beans
  
  Quarkus adds a capability that CDI currently does not support which is to conditionally declare a bean if no such bean has been declared in the typical ways Quarkus supports.
  This is done using the `@io.quarkus.arc.DefaultBean` annotation and is best explained with an example.
  
  Say there is a Quarkus extension that among other things declares a few CDI beans like the following code does:
  
  [source,java]
  ----
  @Dependent
  public class TracerConfiguration {
  
      @Produces
      public Tracer tracer(Reporter reporter, Configuration configuration) {
          return new Tracer(reporter, configuration);
      }
  
      @Produces
      @DefaultBean
      public Configuration configuration() {
          // create a Configuration
      }
  
      @Produces
      @DefaultBean
      public Reporter reporter(){
          // create a Reporter
      }
  }
  ----
  
  The idea is that the extension auto-configures things for user, eliminating a lot of boilerplate - we can just `@Inject` a `Tracer` wherever it is needed.
  Now imagine that in our application we would like to utilize the configured `Tracer`, but we need to customize it a little, for example by providing a custom `Reporter`.
  The only thing that would be needed in our application would be something like the following:
  
  
  [source,java]
  ----
  @Dependent
  public class CustomTracerConfiguration {
  
      @Produces
      public Reporter reporter(){
          // create a custom Reporter
      }
  }
  ----
  
  `@DefaultBean` allows extensions (or any other code for that matter) to provide defaults while backing off if beans of that type are supplied in any
  way Quarkus supports.
  
  
  == Build Time Extension Points
  
  [[portable_extensions]]
  