anchor.diff:  
   In this guide we're going to describe the basic principles of the Quarkus programming model that is based on the http://docs.jboss.org/cdi/spec/2.0/cdi-spec.html[Contexts and Dependency Injection for Java 2.0, window="_blank"] specification.
   
  -== _Q: OK. Let's start simple. What is a bean?_
  -
  -A: Well, a bean is a _container-managed_ object that supports a set of basic services, such as injection of dependencies, lifecycle callbacks and interceptors.
  -
  -== _Q: Wait a minute. What does "container-managed" mean?_
  -
  -A: Simply put, you don't control the lifecycle of the object instance directly.
  +== OK. Let's start simple. What is a bean?
  +
  +Well, a bean is a _container-managed_ object that supports a set of basic services, such as injection of dependencies, lifecycle callbacks and interceptors.
  +
  +== Wait a minute. What does "container-managed" mean?
  +
  +Simply put, you don't control the lifecycle of the object instance directly.
   Instead, you can affect the lifecycle through declarative means, such as annotations, configuration, etc.
   The container is the _environment_ where your application runs.
   It creates and destroys the instances of beans, associates the instances with a designated context, and injects them into other beans.
   
  -== _Q: What is it good for?_
  -
  -A: An application developer can focus on the business logic rather than finding out "where and how" to obtain a fully initialized component with all of its dependencies.
  +== What is it good for?
  +
  +An application developer can focus on the business logic rather than finding out "where and how" to obtain a fully initialized component with all of its dependencies.
   
   NOTE: You've probably heard of the _inversion of control_ (IoC) programming principle. Dependency injection is one of the implementation techniques of IoC. 
   
  -== _Q: What does a bean look like?_
  -
  -A: There are several kinds of beans.
  +== What does a bean look like?
  +
  +There are several kinds of beans.
   The most common ones are class-based beans:
   
   .Simple Bean Example
  
positive.code: <2> This is a field injection point. It tells the container that `Translator` depends on the `Dictionary` bean. If there is no matching bean the build fails.
  <3> This is an interceptor binding annotation. In this case, the annotation comes from the MicroProfile Metrics. The relevant interceptor intercepts the invocation and updates the relevant metrics. We will talk about <<interceptors,interceptors>> later.
  
  == _Q: Nice. How does the dependency resolution work? I see no names or identifiers._
  
  A: That's a good question.
  In CDI the process of matching a bean to an injection point is *type-safe*.
  Each bean declares a set of bean types.
  In our example above, the `Translator` bean has two bean types: `Translator` and `java.lang.Object`.
  
negative.code: The reason is that `@Inject Translator` is automatically transformed to `@Inject @Default Translator` during typesafe resolution.
  And since our `SuperiorTranslator` does not declare `@Default` only the original `Translator` bean is assignable.
  
  == Looks good. What is the bean scope?
  
  The scope of a bean determines the lifecycle of its instances, i.e. when and where an instance should be created and destroyed.
  
  NOTE: Every bean has exactly one scope.
  
  == What scopes can I actually use in my Quarkus application?
  
  You can use all the built-in scopes mentioned by the specification except for `javax.enterprise.context.ConversationScoped`.
  
  [options="header",cols="1,1"]
  |===
  