anchor.diff:  `JBossLauncher`, increases the memory limits for the Dev Mode JVM, and
   asks its JIT compiler to be more aggressive in generating native
   code. We've done some experimenting and found a compile threshold of
  -1000 allows Dev Mode to start up a little faster. The
  -`errai-client-local-class-hider` is a Java agent that strips out the
  -contents of client-only classes while they are being loaded into the
  -VM. This allows development-time deployments to succeed without having
  -to exclude them from the deployment. For production, we simply exclude
  -these same classes from the .war file (see the discussion around
  -`<packagingExcludes> for more details).
  +1000 allows Dev Mode to start up a little faster.
  +
  +Putting Weld (the CDI implementation in WildFly) into non-portable
  +mode allows an UberFire CDI extension that was designed for CDI 1.0 to
  +continue to work in newer Weld containers, which implement CDI
  +1.1. This is a stopgap solution until a permanent fix for
  +https://issues.jboss.org/browse/UF-133[UF-133] is found.
  +
  +The `errai-client-local-class-hider` is a Java agent that strips out
  +the contents of client-only classes while they are being loaded into
  +the VM. This allows development-time deployments to succeed without
  +having to exclude them from the deployment. For production, we simply
  +exclude these same classes from the .war file (see the discussion
  +around `<packagingExcludes> for more details).
   
   Next up, we configure `maven-war-plugin`, which produces the WAR file
   during the build's _package_ phase:
  
positive.code: create as many `@EntryPoint` classes as you want, but you can't
  specify what order they will be instantiated in. Usually, you'll just
  have one.
  
  The `earlyInit()` method is a CDI `@PostConstruct` method. It's
  executed after the constructor has been called footnote:[in this case,
  we don't have an explicit constructor, so CDI will invoke the implicit
  public no-args constructor provided by the Java compiler] and all
  `@Inject` fields have been filled in. This will happen very early in
  the life of the client application, so it's a good place to set global
  properties and preferences, but a bad place to interact with the DOM
  (which will still be empty at this point) or to make RPC requests to
  the server (the message bus will not be connected yet).
  
  The `finalInit()` method is a CDI observer method. The UberFire
  Workbench framework fires an `ApplicationReadyEvent` when the
  
negative.code: bundled in the WAR file. Maven does not provide a mechanism for
  inheriting provided-scope transitive dependencies, so we have to list
  them all here separately to ensure they are not bundled in the WAR.
  
  [TIP]
  .Extra Step for Eclipse Users
  ------
  The uberfire-workbench-processors module includes Java annotation
  processors that must run every time you compile your app's client-side
  code. Netbeans, IntelliJ IDEA, and the Maven Compiler Plugin will all
  discover and activate these annotation processors during
  compilation. However, Eclipse has this feature turned off by
  default. If you are using Eclipse, you have to
  link:m2e-apt-setup{link-suffix}[set up the m2e-apt annotation
  processing configurator] before developing an UberFire application.
  ------
  
  Now on to the `<build>` section, where we define the behaviour of
  several plugins we'll need in order to get the project built. The
  