polygene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nic...@apache.org
Subject [2/3] zest-qi4j git commit: Replaced Qi4j with Zest in main documentation. Added trademark (tm) (™) to all Zest words.
Date Mon, 06 Jul 2015 14:54:37 GMT
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-build-system.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-build-system.txt b/manual/src/docs/tutorials/howto-build-system.txt
index cf6b7ea..79ab6e1 100644
--- a/manual/src/docs/tutorials/howto-build-system.txt
+++ b/manual/src/docs/tutorials/howto-build-system.txt
@@ -20,24 +20,24 @@
 [[build-system,Build System]]
 = Build System =
 
-This tutorial is intended for developpers who want to build the Qi4j SDK themselves.
-It describe the Qi4j SDK Build System from compilation to publication of artifacts for consumption by other
+This tutorial is intended for developpers who want to build the Zest� SDK themselves.
+It describe the Zest� SDK Build System from compilation to publication of artifacts for consumption by other
 applications.
 
-If instead you want to setup your project build system to depend on modules of the Qi4j SDK see the
+If instead you want to setup your project build system to depend on modules of the Zest� SDK see the
 <<howto-depend-on-qi4j,dedicated tutorial>>.
 
 
 == Gradle ==
 
 NOTE: All major Java IDEs have great Gradle support.
-Visit the http://www.gradle.org/tooling[Gradle Tooling] page to learn how to import the Qi4j SDK build into your
+Visit the http://www.gradle.org/tooling[Gradle Tooling] page to learn how to import the Zest� SDK build into your
 favorite IDE.
 
-Qi4j community migrated away from Maven after several years of frustration, especially around release management,
+Zest� community migrated away from Maven after several years of frustration, especially around release management,
 versioning and cross-module dependency resolution issues, in Feb 2011.
 The tool of choice is now Gradle, and it doesn't require any installation, there are +gradlew+ and +gradlew.bat+ in
-the root folder of the Qi4j SDK that will bootstrap Gradle if not done so already.
+the root folder of the Zest� SDK that will bootstrap Gradle if not done so already.
 
 If you are new to Gradle, you should keep the http://www.gradle.org/documentation[documentation] at hands.
 
@@ -48,7 +48,7 @@ http://gradle.org/docs/current/userguide/tutorial_this_and_that.html#sec:gradle_
 
 == Root project tasks ==
 
-The Qi4j SDK root project has tasks that work with the whole SDK.
+The Zest� SDK root project has tasks that work with the whole SDK.
 The default build, triggered when running gradle without any command line arguments, compiles the code and run the
 tests, but nothing else.
 A quick way to check that nothing broke.
@@ -109,7 +109,7 @@ To see all available tasks on a submodule issue the following command:
 ----
 
 This example will output all gradle tasks available in the +tests/performance+ module where you should find
-the +testPerf+ task that run the Qi4j performance test suite.
+the +testPerf+ task that run the Zest� performance test suite.
 
 
 == Versions ==
@@ -131,7 +131,7 @@ If a +version+ property is not defined, the build system will refuse to make a r
 
 == Tests ==
 
-NOTE: See the http://qi4j.org/community/ci.html[Qi4j Continuous Integration] for current tests results
+NOTE: See the http://qi4j.org/community/ci.html[Zest� Continuous Integration] for current tests results
 
 // TODO
 
@@ -144,7 +144,7 @@ They are not part of the default build.
 
 === Performance tests ===
 
-Performance tests provide performance mesurements for typical Qi4j use cases.
+Performance tests provide performance mesurements for typical Zest� use cases.
 They are not part of the default build.
 
 // TODO
@@ -179,12 +179,12 @@ We'll list here services that the unit tests will use if available.
 - MySQL for +extensions/entitystore-sql+ (need setup, see test source)
 
 
-== Releasing the Qi4j SDK ==
+== Releasing the Zest� SDK ==
 
 IMPORTANT: Remember that if a +version+ property is not defined, the build system will refuse to make a release and upload.
 
-The Qi4j SDK build system is setup for an easy release process.
-This is very useful to the Qi4j Core Team but can also be useful to third parties that want to cut a in-house release.
+The Zest� SDK build system is setup for an easy release process.
+This is very useful to the Zest� Core Team but can also be useful to third parties that want to cut a in-house release.
 In this regard, we try to make every aspect of the release process usable for such cases.
 
 The following sections describe various aspects of the release process.
@@ -193,12 +193,12 @@ By default you need to have a proper PGP setup, see below.
 
 === Release Criteria ===
 
-The Qi4j SDK modules are of varying maturity level and we try to maintain a STATUS (+dev-status.xml+) file indicating
+The Zest� SDK modules are of varying maturity level and we try to maintain a STATUS (+dev-status.xml+) file indicating
 how good the codebase, documentation and unit tests are for each of the modules. This is highly subjective and
 potentially different individuals will judge this differently, but at least it gives a ballpark idea of the situation
 for our users.
 
-The Qi4j SDK build system use the values from the +dev-status.xml+ files to filter out non-releasable modules out for
+The Zest� SDK build system use the values from the +dev-status.xml+ files to filter out non-releasable modules out for
 the +javadocs+ and +uploadArchives+ root project tasks.
 Moreover, the +release+ task ensure that no releasable module depends on module(s) that don't fit the release criteria
 and throw a detailed exception if need be.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-configure-service.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-configure-service.txt b/manual/src/docs/tutorials/howto-configure-service.txt
index 3022b33..e019d25 100644
--- a/manual/src/docs/tutorials/howto-configure-service.txt
+++ b/manual/src/docs/tutorials/howto-configure-service.txt
@@ -15,10 +15,10 @@
 
 [[howto-configure-service,Configure a Service]]
 = Configure a Service =
-Qi4j supports a Configuration system for services. The configuration instance itself is an Entity and is therefor
+Zest� supports a Configuration system for services. The configuration instance itself is an Entity and is therefor
 readable, writeable and queryable, just like other Entities. This should make Configuration management much simpler,
 since you can easily build GUI tools to allow editing of these in runtime. However, to simplify the initial values of
-the Configuration instance, Qi4j also does the initial bootstrapping of the Configuration entity for you. This HowTo is
+the Configuration instance, Zest� also does the initial bootstrapping of the Configuration entity for you. This HowTo is
 going to show how.
 
 If you want to reproduce what's explained in this tutorial, remember to depend on the Core Bootstrap artifact:
@@ -139,7 +139,7 @@ tag=params
 File: org/qi4j/manual/travel/OrbitzService.properties
 
 == Changing Configuration in runtime ==
-Unlike most frameworks, the Configuration in Qi4j is an active Entity, and once the properties file has been read once
+Unlike most frameworks, the Configuration in Zest� is an active Entity, and once the properties file has been read once
 at the first(!) startup, it no longer serves any purpose. The Configuration will always be retrieved from the
 EntityStore. Changes to the properties file are not taken into consideration if the Configuration entity is found in the
 entity store.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-create-concern.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-create-concern.txt b/manual/src/docs/tutorials/howto-create-concern.txt
index f5fc6d0..4438b4e 100644
--- a/manual/src/docs/tutorials/howto-create-concern.txt
+++ b/manual/src/docs/tutorials/howto-create-concern.txt
@@ -41,8 +41,8 @@ tag=allClass
 Note that we could have implemented the InventoryConcern as an abstract class if we were not interested in __all__ the methods in the Order interface.
 Extending the ConcernOf is a convenience mechanism, instead of an explicit @ConcernFor annotation on
 a private field, which can be used in rare occasions when you are not able to extend. This base class defines the next
-field, which is set up by the Qi4j runtime and points to the next fragment in the call stack. We can also see that the
-InventoryService is provided to the concern, which is done with dependency injection. Qi4j also supports dependency
+field, which is set up by the Zest� runtime and points to the next fragment in the call stack. We can also see that the
+InventoryService is provided to the concern, which is done with dependency injection. Zest� also supports dependency
 injection via constructors and methods.
 
 It can be used as follows;

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-create-entity.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-create-entity.txt b/manual/src/docs/tutorials/howto-create-entity.txt
index 1b69e14..ec16fe4 100644
--- a/manual/src/docs/tutorials/howto-create-entity.txt
+++ b/manual/src/docs/tutorials/howto-create-entity.txt
@@ -15,9 +15,9 @@
 
 [[howto-create-entity,Create an Entity]]
 = Create an Entity =
-One of the most common tasks in Qi4j is the management of the life cycle of Entities. Since Qi4j is capable of
+One of the most common tasks in Zest� is the management of the life cycle of Entities. Since Zest� is capable of
 delivering much higher performance than traditional Object-Relational Mapping technologies, we also expect that people
-use Entities more frequently in Qi4j applications, so it is a very important topic to cover.
+use Entities more frequently in Zest� applications, so it is a very important topic to cover.
 
 If you want to reproduce what's explained in this tutorial, remember to depend on the Core Bootstrap artifact:
 
@@ -39,7 +39,7 @@ Domain code typically don't need to know of the EntityComposite types directly,
 interface. The Visibility rules will be applied to associate the right EntityComposite when a domain type is requested.
 Ambiguities are not accepted and will result in runtime exceptions.
 
-Qi4j supports that each entity instance can have more than one entity type, and it is managed per instance. This feature
+Zest� supports that each entity instance can have more than one entity type, and it is managed per instance. This feature
 is beyond the scope of this HowTO and will be covered subsequently.
 
 == Good Practice ==
@@ -125,7 +125,7 @@ available as services.
 
 == The Entity Factory ==
 
-The entity factory is something you need to write yourself, but as with most things in Qi4j it will end up being a
+The entity factory is something you need to write yourself, but as with most things in Zest� it will end up being a
 fairly small implementation. So how is that done?
 
 [snippet,java]
@@ -134,7 +134,7 @@ source=manual/src/main/java/org/qi4j/manual/recipes/createEntity/CarEntityFactor
 tag=carFactory
 -----------
 
-That is just the domain interface. We now need to make the service interface, which Qi4j needs to identify services and
+That is just the domain interface. We now need to make the service interface, which Zest� needs to identify services and
 make it possible for the service injection later.
 
 [snippet,java]
@@ -151,7 +151,7 @@ source=manual/src/main/java/org/qi4j/manual/recipes/createEntity/CarEntityFactor
 tag=carFactoryMixin1
 -----------
 
-And doing that, first of all we need to request Qi4j runtime to give us the Module
+And doing that, first of all we need to request Zest� runtime to give us the Module
 that our code belongs to, and the UnitOfWork current context the execution is happening in.
 
 Injections that are related to the Visibility rules are handled by the @Structure annotation. And the easiest way for us
@@ -163,7 +163,7 @@ source=manual/src/main/java/org/qi4j/manual/recipes/createEntity/CarEntityFactor
 tag=carFactoryMixin2
 -----------
 
-Here Qi4j will inject the member module with the correct Module. In case we only need the Module
+Here Zest� will inject the member module with the correct Module. In case we only need the Module
 during the construction, we can also request it in the same manner as constructor argument.
 
 [snippet,java]

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-create-sideeffect.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-create-sideeffect.txt b/manual/src/docs/tutorials/howto-create-sideeffect.txt
index cd8ea72..5084a79 100644
--- a/manual/src/docs/tutorials/howto-create-sideeffect.txt
+++ b/manual/src/docs/tutorials/howto-create-sideeffect.txt
@@ -41,9 +41,9 @@ tag=allClass
 The MailNotifySideEffect is implemented as an abstract class, since we are not interested in the many other methods in
 the Confirmable interface. Extending the SideEffectOf is a convenience mechanism, instead of an explicit @SideEffectFor
 annotation on a private field, which can be used in rare occasions when you are not able to extend. This base class
-defines the next field, which is set up by the Qi4j runtime and points to the next fragment in the call stack. We can
+defines the next field, which is set up by the Zest� runtime and points to the next fragment in the call stack. We can
 also see that the MailService, HasLineItems and HasCustomer are provided to the side-effect, which is done with
-dependency injection. Qi4j also supports dependency injection via constructors and methods.
+dependency injection. Zest� also supports dependency injection via constructors and methods.
 
 It can be used as follows;
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-depend-on-qi4j.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-depend-on-qi4j.txt b/manual/src/docs/tutorials/howto-depend-on-qi4j.txt
index 7295648..938ce0c 100644
--- a/manual/src/docs/tutorials/howto-depend-on-qi4j.txt
+++ b/manual/src/docs/tutorials/howto-depend-on-qi4j.txt
@@ -17,8 +17,8 @@
  * under the License.
 ///////////////////////////////////////////////////////////////
 
-[[howto-depend-on-qi4j,Depend on Qi4j in your build]]
-= Depend on Qi4j in your build =
+[[howto-depend-on-qi4j,Depend on Zest™ in your build]]
+= Depend on Zest™ in your build =
 
 NOTE: Some of the <<libraries>> and <<extensions>> depend on artifacts that are not deployed in central, you'll need to
 add other repositories to your build scripts accordingly.
@@ -41,7 +41,7 @@ http://qi4j.org/downloads.html[download] the SDK distribution.
 
 == Using Maven ==
 
-First you need to register the Qi4j repositories:
+First you need to register the Zest™ repositories:
 
 [source,xml]
 ----
@@ -59,7 +59,7 @@ First you need to register the Qi4j repositories:
 </repositories>
 ----
 
-After that you can declare dependencies on Qi4j artifacts:
+After that you can declare dependencies on Zest™ artifacts:
 
 [source,xml]
 ----
@@ -84,11 +84,11 @@ After that you can declare dependencies on Qi4j artifacts:
 </dependencies>
 ----
 
-Where `QI4J_VERSION` is the Qi4j version you want to use.
+Where `QI4J_VERSION` is the Zest™ version you want to use.
 
 == Using Gradle ==
 
-First you need to register the Qi4j repositories:
+First you need to register the Zest™ repositories:
 
 [source,groovy]
 ----
@@ -98,7 +98,7 @@ repositories {
 }
 ----
 
-After that you can declare dependencies on Qi4j artifacts:
+After that you can declare dependencies on Zest™ artifacts:
 
 [source,groovy]
 ----
@@ -109,11 +109,11 @@ dependencies {
 }
 ----
 
-Where `QI4J_VERSION` is the Qi4j version you want to use.
+Where `QI4J_VERSION` is the Zest™ version you want to use.
 
 == Using Buildr ==
 
-First you need to register the Qi4j repositories:
+First you need to register the Zest™ repositories:
 
 [source,ruby]
 ----
@@ -121,7 +121,7 @@ repositories.remote << 'https://repository-qi4j.forge.cloudbees.com/release/'
 repositories.remote << 'https://repository-qi4j.forge.cloudbees.com/snapshot/'
 ----
 
-After that you can declare dependencies on Qi4j artifacts:
+After that you can declare dependencies on Zest™ artifacts:
 
 [source,ruby]
 ----
@@ -130,11 +130,11 @@ package(:war).with :libs => 'org.qi4j.core:org.qi4j.core.runtime:QI4J_VERSION'
 test.with 'org.qi4j.core:org.qi4j.core.testsupport:QI4J_VERSION'
 ----
 
-Where `QI4J_VERSION` is the Qi4j version you want to use.
+Where `QI4J_VERSION` is the Zest™ version you want to use.
 
 == Using SBT ==
 
-First you need to register the Qi4j repositories:
+First you need to register the Zest™ repositories:
 
 [source,scala]
 ----
@@ -143,7 +143,7 @@ resolvers += "qi4j-releases" at "https://repository-qi4j.forge.cloudbees.com/rel
 resolvers += "qi4j-snapshots" at "https://repository-qi4j.forge.cloudbees.com/snapshot/"
 ----
 
-After that you can declare dependencies on Qi4j artifacts:
+After that you can declare dependencies on Zest™ artifacts:
 
 [source,scala]
 ----
@@ -158,11 +158,11 @@ libraryDependencies += \
     withSources() withJavadoc()
 ----
 
-Where `QI4J_VERSION` is the Qi4j version you want to use.
+Where `QI4J_VERSION` is the Zest™ version you want to use.
 
 == Using Ivy ==
 
-First you need to register the Qi4j repositories in a `ivysettings.xml` file:
+First you need to register the Zest™ repositories in a `ivysettings.xml` file:
 
 [source,xml]
 ----
@@ -179,7 +179,7 @@ First you need to register the Qi4j repositories in a `ivysettings.xml` file:
 </ivysettings>
 ----
 
-After that you can declare dependencies on Qi4j artifacts:
+After that you can declare dependencies on Zest™ artifacts:
 
 [source,xml]
 ----
@@ -195,5 +195,5 @@ After that you can declare dependencies on Qi4j artifacts:
 </ivy-module>
 ----
 
-Where `QI4J_VERSION` is the Qi4j version you want to use.
+Where `QI4J_VERSION` is the Zest™ version you want to use.
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-leverage-properties.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-leverage-properties.txt b/manual/src/docs/tutorials/howto-leverage-properties.txt
index 24bde2c..8637662 100644
--- a/manual/src/docs/tutorials/howto-leverage-properties.txt
+++ b/manual/src/docs/tutorials/howto-leverage-properties.txt
@@ -16,7 +16,7 @@
 [[howto-leverage-properties,Leverage Properties]]
 = Leverage Properties =
 
-Qi4j does not follow the JavaBeans standard for property support. Instead, a much more explicit concept is in place. The
+Zest� does not follow the JavaBeans standard for property support. Instead, a much more explicit concept is in place. The
 advantages are enormous, and the only real downside is that people are already destroyed, thinking in so called POJO
 terms.
 
@@ -26,7 +26,7 @@ include::../../../../core/api/build/docs/buildinfo/artifact.txt[]
 
 At runtime you will need the Core Runtime artifact too. See the <<howto-depend-on-qi4j>> tutorial for details.
 
-So in Qi4j, instead of writing;
+So in Zest, instead of writing;
 
 [snippet,java]
 -----------
@@ -70,7 +70,7 @@ tag=create
 
 == Persistence ==
 
-The Property concept also allows a much better defined persistence model. In Qi4j, only Property and Association
+The Property concept also allows a much better defined persistence model. In Zest, only Property and Association
 instances are persisted, and that makes the semantics around the persistence system very clear.
 
 Properties reference values only, and these values must be Serializable, which means that Properties can not contain

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-use-io.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-use-io.txt b/manual/src/docs/tutorials/howto-use-io.txt
index ac1ae10..6d307cc 100644
--- a/manual/src/docs/tutorials/howto-use-io.txt
+++ b/manual/src/docs/tutorials/howto-use-io.txt
@@ -245,10 +245,10 @@ Inputs.text( source ).transferTo( Transforms.map(counter, Outputs.text(destinati
 System.out.println("Nr of lines:"+counter.getCount())
 --------------
 
-== Usage in the Qi4j SPI ==
+== Usage in the Zest™ SPI ==
 
 Now I can finally get back to my initial problem that led me to look into this: how to implement a good way to access
-EntityStates in a Qi4j EntityStore, and perform restores of backups. The current version of accessing EntityStates look
+EntityStates in a Zest™ EntityStore, and perform restores of backups. The current version of accessing EntityStates look
 like this:
 
 [source,java]
@@ -322,5 +322,5 @@ things properly it becomes easier to perform these tasks in a scalable, performa
 allowing these tasks to be decorated with extra features when needed.
 
 This article has outlined one way to do this, and the API and helpers that I've described are available in the current
-Qi4j Core 1.3-SNAPSHOT in Git (see Qi4j homepage for access details). The idea is to start using it throughout Qi4j
+Zest™ Core 1.3-SNAPSHOT in Git (see Zest™ homepage for access details). The idea is to start using it throughout Zest
 wherever we need to do I/O of the type described here.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-writing-docs.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-writing-docs.txt b/manual/src/docs/tutorials/howto-writing-docs.txt
index 2f501b5..5e7995b 100644
--- a/manual/src/docs/tutorials/howto-writing-docs.txt
+++ b/manual/src/docs/tutorials/howto-writing-docs.txt
@@ -18,7 +18,7 @@
 ///////////////////////////////////////////////////////////////
 
 [[community-docs,Writing Documentation]]
-= Writing Qi4j Documentation =
+= Writing Zest� Documentation =
 
 The documents use the asciidoc format, see:
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/userguide/core.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/userguide/core.txt b/manual/src/docs/userguide/core.txt
index 54ab652..6f046c8 100644
--- a/manual/src/docs/userguide/core.txt
+++ b/manual/src/docs/userguide/core.txt
@@ -24,20 +24,20 @@
 
 == Overview ==
 
-The Qi4j Core is composed of several artifacts described in this section.
+The Zest™ Core is composed of several artifacts described in this section.
 
 The following figure show the Core artifacts alongside <<libraries,libraries>> and <<extensions,extensions>>, and, in green,
 typical applications artifacts. This is not a full code dependency graph but should give you a good overview of how the
-pieces fit together. Find out more about each of the Qi4j Core artifacts below.
+pieces fit together. Find out more about each of the Zest™ Core artifacts below.
 
-.Qi4j Core Overview
+.Zest™ Core Overview
 image::core-overview.png[]
 
 //*<<core-api,Core API>>*
 === Core API ===
 
 //____
-The Qi4j Core API is the primary interface for client application code during the main execution phase, i.e. after the
+The Zest™ Core API is the primary interface for client application code during the main execution phase, i.e. after the
 application has been activated.
 
 <<core-api,Learn more>>
@@ -46,9 +46,9 @@ application has been activated.
 //*<<core-bootstrap-assembly,Core Bootstrap>>*
 === Core Bootstrap ===
 //____
-Qi4j has a distinct bootstrap phase, also known as the _Assembly_ of an application, where the applications structure
+Zest™ has a distinct bootstrap phase, also known as the _Assembly_ of an application, where the applications structure
 is defined programmatically. Once all the layers, modules and all the composite types in each module have been defined
-the model is instantiated into an application. This enables the entire _structure_ system in Qi4j, where types "belongs"
+the model is instantiated into an application. This enables the entire _structure_ system in Zest, where types "belongs"
 to a module and visibility rules define default behaviors, enforcement of architectural integrity and much more.
 
 <<core-bootstrap-assembly,Learn more>>
@@ -57,8 +57,8 @@ to a module and visibility rules define default behaviors, enforcement of archit
 //*<<core-testsupport,Core Test Support>>*
 === Core Test Support ===
 //____
-Qi4j comes with classes to help with testing. There is also some mocking support, to allow some of Qi4j’s unique
-aspects to be mocked, but since Qi4j is so flexible at a fine-granular level, we have found that mocking is seldom,
+Zest™ comes with classes to help with testing. There is also some mocking support, to allow some of Zest’s unique
+aspects to be mocked, but since Zest™ is so flexible at a fine-granular level, we have found that mocking is seldom,
 if ever, needed.
 
 <<core-testsupport,Learn more>>
@@ -67,9 +67,9 @@ if ever, needed.
 //*<<core-functional,Core Functional API>>*
 === Core Functional API ===
 //____
-The Qi4j Core Functional API is a generic package to work with Iterables in a "functional programming language" style.
+The Zest™ Core Functional API is a generic package to work with Iterables in a "functional programming language" style.
 
-This package is completely independent of everything else in Qi4j and may be used on its own in any kind of environment
+This package is completely independent of everything else in Zest™ and may be used on its own in any kind of environment
 such as Spring or Java EE applications.
 
 <<core-functional,Learn more>>
@@ -78,7 +78,7 @@ such as Spring or Java EE applications.
 //*<<core-io,Core I/O API>>*
 === Core I/O API ===
 //____
-The Qi4j Core I/O API tries to address the problem around shuffling data around from various I/O inputs and outputs,
+The Zest™ Core I/O API tries to address the problem around shuffling data around from various I/O inputs and outputs,
 possibly with transformations and filtering along the way.
 
 <<core-io,Learn more>>
@@ -87,7 +87,7 @@ possibly with transformations and filtering along the way.
 //*<<core-spi,Core Extension SPI>>*
 === Core Extension SPI ===
 //____
-The Qi4j Core Runtime has a number of extension points, which we call the _Qi4j Core Extension SPI_. These are defined
+The Zest™ Core Runtime has a number of extension points, which we call the _Qi4j Core Extension SPI_. These are defined
 interfaces used *only* by the Core Runtime and *never* directly by application code. <<extensions>> are assembled in
 applications during the bootstrap phase.
 
@@ -97,7 +97,7 @@ applications during the bootstrap phase.
 //*<<core-spi,Core Runtime>>*
 === Core Runtime ===
 //____
-Your code should *never*, *ever*, have a dependency on Qi4j Core Runtime. If you think you need this, you should
+Your code should *never*, *ever*, have a dependency on Zest™ Core Runtime. If you think you need this, you should
 probably contact qi4j-dev forum at Google Groups and see if your usecase can either be solved in a existing way or
 perhaps that a new Core Extension SPI is needed.
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/userguide/extensions.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/userguide/extensions.txt b/manual/src/docs/userguide/extensions.txt
index 2a6c3ef..107f418 100644
--- a/manual/src/docs/userguide/extensions.txt
+++ b/manual/src/docs/userguide/extensions.txt
@@ -24,7 +24,7 @@
 
 == Overview ==
 
-We try to keep the Qi4j Core Runtime as lean as possible, and a lot of the power to the Qi4j Platform comes via its
+We try to keep the Zest� Core Runtime as lean as possible, and a lot of the power to the Zest� Platform comes via its
 Extension SPI, which defines clear ways to extend the platform. There are currently the following Extensions types,
 each with possibly more than one implementation;
 
@@ -37,7 +37,7 @@ each with possibly more than one implementation;
    * Migration
 
 This section will go through each of the available extensions.
-The Qi4j Extensions are of varying maturity level and we try to maintain a STATUS (dev-status.xml) file indicating
+The Zest� Extensions are of varying maturity level and we try to maintain a STATUS (dev-status.xml) file indicating
 how good the codebase, documentation and unit tests are for each of the libraries. This is highly subjective and
 potentially different individuals will judge this differently, but at least it gives a ballpark idea of the situation
 for our users.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/userguide/faq.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/userguide/faq.txt b/manual/src/docs/userguide/faq.txt
index 3323466..7aba95f 100644
--- a/manual/src/docs/userguide/faq.txt
+++ b/manual/src/docs/userguide/faq.txt
@@ -20,7 +20,7 @@
 [[faq,FAQ]]
 = Frequently Asked Questions =
 
-Is it possible to use Scala with Qi4j?::
-        Short Answer: Yes. Scala traits can be used as Qi4j fragments, and Qi4j composites can be used in Scala.
+Is it possible to use Scala with Zest?::
+        Short Answer: Yes. Scala traits can be used as Zest� fragments, and Zest� composites can be used in Scala.
 
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/userguide/glossary.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/userguide/glossary.txt b/manual/src/docs/userguide/glossary.txt
index 9c59dc1..401b00b 100644
--- a/manual/src/docs/userguide/glossary.txt
+++ b/manual/src/docs/userguide/glossary.txt
@@ -24,7 +24,7 @@
 
 == Glossary ==
 
-There are a lot of concepts in Qi4j which may have different meanings in other contexts. So in true DDD-style
+There are a lot of concepts in Zest� which may have different meanings in other contexts. So in true DDD-style
 ubiquitous language, we are here listing the definitions of the terms and concepts that are being used.
 
 [glossary]
@@ -34,7 +34,7 @@ ubiquitous language, we are here listing the definitions of the terms and concep
 An Abstract Mixin is an implementation of the <<def-mixin-type>> interface, but is an abstract class and has not
 implemented all the methods.
 
-The Qi4j runtime can use multiple <<def-mixin,Mixins>> for each <<def-mixin-type>> interface. It is also possible to let
+The Zest� runtime can use multiple <<def-mixin,Mixins>> for each <<def-mixin-type>> interface. It is also possible to let
 a <<def-generic-mixin>> handle the remaining missing methods.
 --
 
@@ -53,10 +53,10 @@ will not be part of the <<def-invocation-stack>> of those methods.
 [[def-application,Application]]Application::
 +
 --
-Application is the top level concept handled by the Qi4j runtime instance. It holds the information about the
+Application is the top level concept handled by the Zest� runtime instance. It holds the information about the
 <<def-layer,Layers>> in the application architecture. See <<def-structure>> for more information.
 
-There is one and only one Application instance per Qi4j Runtime instance.
+There is one and only one Application instance per Zest� Runtime instance.
 --
 
 
@@ -102,7 +102,7 @@ by the thread boundaries. Use-cases for this include user credentials on which b
 [[def-composite-metatype,Composite Meta Type]]Composite Meta Type::
 +
 --
-There are 5 Composite Meta Types defined in Qi4j, which each share the composition features but have distinct
+There are 5 Composite Meta Types defined in Zest, which each share the composition features but have distinct
 semantic differences.
 
 * <<def-entitycomposite>>
@@ -120,7 +120,7 @@ CompositeType is the Java interface that declares the composition, from which <<
 created.
 
 Composite Type interfaces must be a sub-type of one of the 5 <<def-composite-metatype,Composite Meta Types>> defined in
-Qi4j otherwise it can not be instantiated.
+Zest� otherwise it can not be instantiated.
 --
 
 
@@ -140,7 +140,7 @@ involves;
 
 Concerns are established by the use of the @Concerns annotation on composites.
 
-Concern is one of the 3 kinds of <<def-modifier,Modifiers>> defined in Qi4j.
+Concern is one of the 3 kinds of <<def-modifier,Modifiers>> defined in Zest.
 --
 
 
@@ -153,7 +153,7 @@ stored permanently in configured Entity Stores. Configuration Composites are als
 properties files first time. Note that on consequent start-ups the properties file is not read, as the configuration is
 read from the EntityStore.
 
-ConfigurationComposite is one of the 5 <<def-composite-metatype,Composite Meta Types>> defined in Qi4j.
+ConfigurationComposite is one of the 5 <<def-composite-metatype,Composite Meta Types>> defined in Zest.
 
 See <<howto-configure-service>> to learn how to use Configuration Composites.
 --
@@ -162,7 +162,7 @@ See <<howto-configure-service>> to learn how to use Configuration Composites.
 [[def-constraint,Constraint]]Constraint::
 +
 --
-Constraints are a kind of validators, which are consulted prior to invoking the method call. Qi4j currently only
+Constraints are a kind of validators, which are consulted prior to invoking the method call. Zest� currently only
 supports ParameterConstraints on methods and value constraints on <<def-property,Properties>>, but future versions will
 include Constraint types for checking complete method calls and return values.
 
@@ -172,7 +172,7 @@ See <<library-constraints>> for ready to use Constraints.
 
 See <<howto-create-constraint>> to learn how to write your own Constraints.
 
-Constraint is one of the 3 kinds of <<def-modifier,Modifiers>> defined in Qi4j.
+Constraint is one of the 3 kinds of <<def-modifier,Modifiers>> defined in Zest.
 --
 
 
@@ -182,7 +182,7 @@ Constraint is one of the 3 kinds of <<def-modifier,Modifiers>> defined in Qi4j.
 An Entity Composite, or just Entity for short, is a persisted composite with an <<def-identity>>. An entity only has
 scope within an <<def-unitofwork>> and is therefor inherently thread-safe.
 
-EntityComposite is one of the 5 <<def-composite-metatype,Composite Meta Types>> defined in Qi4j.
+EntityComposite is one of the 5 <<def-composite-metatype,Composite Meta Types>> defined in Zest.
 --
 
 
@@ -235,11 +235,11 @@ For each method, Qi4J will create and re-use an Invocation Stack. It will be bui
 <<def-modifier,Modifiers>> and an end-point that will link into the stateful <<def-mixin>>.
 
 It is important to recognize that, for memory footprint reasons, Invocation Stacks are shared across
-<<def-composite,Composites>> of the same <<def-composite-type>>. They are however thread-safe, in that Qi4j will never
+<<def-composite,Composites>> of the same <<def-composite-type>>. They are however thread-safe, in that Zest� will never
 bind the same Invocation Stack to more than one <<def-composite>> instance during a method call, but that between method
 invocations the <<def-modifier,Modifiers>> in the Invocation Stack can not assume that it is bound to the same
 <<def-composite>> instance. Therefor, <<def-modifier,Modifiers>> are not expected to keep state between method
-invocations, and when it needs to do that, then it should reference a <<def-mixin>> via the @This annotation. Qi4j will
+invocations, and when it needs to do that, then it should reference a <<def-mixin>> via the @This annotation. Zest� will
 during the binding of the Invocation Stack to the <<def-composite>>, also ensure that all referenced
 <<def-mixin,Mixins>> are correctly injected in the Invocation Stack.
 --
@@ -248,7 +248,7 @@ during the binding of the Invocation Stack to the <<def-composite>>, also ensure
 [[def-layer,Layer]]Layer::
 +
 --
-Qi4j promotes a Layered application design, where Layers can only access lower Layers and not higher Layers or Layers at
+Zest� promotes a Layered application design, where Layers can only access lower Layers and not higher Layers or Layers at
 the same level.
 --
 
@@ -345,7 +345,7 @@ See the <<howto-leverage-properties>> how-to.
 --
 Service Composite is a subtype of <<def-composite>>, and has a range of features built into it.
 
-ServiceComposite is one of the 5 <<def-composite-metatype,Composite Meta Types>> defined in Qi4j.
+ServiceComposite is one of the 5 <<def-composite-metatype,Composite Meta Types>> defined in Zest.
 
 See the <<core-api-service,Service Composite chapter>>.
 --
@@ -370,24 +370,24 @@ involves;
 
 SideEffects are established by the use of the @SideEffects annotation on composites.
 
-SideEffect is one of the 3 kinds of <<def-modifier,Modifiers>> defined in Qi4j.
+SideEffect is one of the 3 kinds of <<def-modifier,Modifiers>> defined in Zest.
 --
 
 
 [[def-structure,Structure]]Structure::
 +
 --
-Qi4j promotes a conventional view of application structure, that computer science has been using for decades.
+Zest� promotes a conventional view of application structure, that computer science has been using for decades.
 
 The definition is as follows;
 
-* One <<def-application>> per Qi4j runtime instance.
+* One <<def-application>> per Zest� runtime instance.
 * One or more <<def-layer,Layers>> per <<def-application>>.
 * Zero, one or more <<def-module,Modules>> per <<def-layer>>.
 * Zero, one or more Assemblies per <<def-module>>.
 
 The principle of this Structure is to assist the programmer to create well modularized applications, that are easily
-extended and maintained. Qi4j will restrict access between <<def-module,Modules>>, so that code can only reach
+extended and maintained. Zest� will restrict access between <<def-module,Modules>>, so that code can only reach
 <<def-composite,Composites>> and Objects in <<def-module,Modules>> (including itself) of the same or lower
 <<def-layer,Layers>>.
 
@@ -424,7 +424,7 @@ immutable and can be compared by value instead of memory reference. Concurrency
 the value exists or it doesn't, no need for synchronization. Values are typically very easy to test and very robust to
 refactoring.
 
-Qi4j defines values as a primary meta type through the ValueComposite, as we think the benefits of values are great.
+Zest� defines values as a primary meta type through the ValueComposite, as we think the benefits of values are great.
 The ValueComposite is very light-weight compared to the <<def-entitycomposite>>, and its value can still be persisted as
 part of an <<def-entitycomposite>> via a <<def-property>>.
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/userguide/index.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/userguide/index.txt b/manual/src/docs/userguide/index.txt
index a236d54..e65328d 100644
--- a/manual/src/docs/userguide/index.txt
+++ b/manual/src/docs/userguide/index.txt
@@ -17,7 +17,7 @@
  * under the License.
 ///////////////////////////////////////////////////////////////
 
-= Qi4j v{revnumber} User Guide =
+= Zest� v{revnumber} User Guide =
 
 :qi4j-version: {revnumber}
 :qi4j-buildnumber: {revnumber}

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/userguide/libraries.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/userguide/libraries.txt b/manual/src/docs/userguide/libraries.txt
index 1efdcde..c6f26b8 100644
--- a/manual/src/docs/userguide/libraries.txt
+++ b/manual/src/docs/userguide/libraries.txt
@@ -24,7 +24,7 @@
 
 == Overview ==
 
-The Qi4j Libraries are of varying maturity level and we try to maintain a STATUS (dev-status.xml) file indicating
+The Zest� Libraries are of varying maturity level and we try to maintain a STATUS (dev-status.xml) file indicating
 how good the codebase, documentation and unit tests are for each of the libraries. This is highly subjective and
 potentially different individuals will judge this differently, but at least it gives a ballpark idea of the situation
 for our users.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/userguide/preface.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/userguide/preface.txt b/manual/src/docs/userguide/preface.txt
index 2d7442f..fd47975 100644
--- a/manual/src/docs/userguide/preface.txt
+++ b/manual/src/docs/userguide/preface.txt
@@ -20,19 +20,19 @@
 [[preface, Preface]]
 = Preface =
 
-This is the reference manual for Qi4j version {qi4j-version}, written by members of the Qi4j Community.
+This is the reference manual for Zest� version {qi4j-version}, written by members of the Zest� Community.
 
 The main parts of the manual are:
 
-* <<introduction>> -- introducing Composite Oriented Programming concepts and Qi4j.
-* <<tutorials>> -- learn how to use Qi4j.
-* <<core-api>> -- detailed information on how to use Qi4j.
-* <<libraries>> -- detailed information on the many libraries available for Qi4j.
-* <<extensions>> -- detailed information each of the Qi4j extensions, such as entity stores,
+* <<introduction>> -- introducing Composite Oriented Programming concepts and Zest.
+* <<tutorials>> -- learn how to use Zest.
+* <<core-api>> -- detailed information on how to use Zest.
+* <<libraries>> -- detailed information on the many libraries available for Zest.
+* <<extensions>> -- detailed information each of the Zest� extensions, such as entity stores,
 indexing, caching and runtime metrics.
 
 The material is practical, technical, and focused on answering specific questions. 
-It addresses how things work, what to do and what to avoid to successfully use Qi4j in domain rich applications.
+It addresses how things work, what to do and what to avoid to successfully use Zest� in domain rich applications.
  
 The goal is to be thumb-through and rule-of-thumb friendly.
 
@@ -40,7 +40,7 @@ Each section should stand on its own, so you can hop right to whatever interests
 When possible, the sections distill "rules of thumb" which you can keep in mind whenever you wander out of the house
 without this manual in your back pocket.
 
-The included code examples are executed when Qi4j is built and tested.
+The included code examples are executed when Zest� is built and tested.
 
 _Who should read this?_
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/userguide/tools.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/userguide/tools.txt b/manual/src/docs/userguide/tools.txt
index 982f6d6..2be9669 100644
--- a/manual/src/docs/userguide/tools.txt
+++ b/manual/src/docs/userguide/tools.txt
@@ -24,11 +24,11 @@
 
 == Overview ==
 
-The Qi4j SDK comes with usefull development tools. Theses tools can come in
+The Zest� SDK comes with usefull development tools. Theses tools can come in
 handy when assembled into your <<def-application>> in development
 <<def-application-mode>>.
 
-The tools are available in the +tools/+ directory of the Qi4j SDK.
+The tools are available in the +tools/+ directory of the Zest� SDK.
 
 :leveloffset: 2
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/website/home.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/website/home.txt b/manual/src/docs/website/home.txt
index 56341e1..36cb6d2 100644
--- a/manual/src/docs/website/home.txt
+++ b/manual/src/docs/website/home.txt
@@ -19,24 +19,31 @@
 
 :leveloffset: 1
 
-[[home,Qi4j Home Page]]
-= Qi4j =
+[[home,Zest™ Home Page]]
+= Zest™ =
 
-IMPORTANT: This is the documentation for *Qi4j {revnumber}*. Use the version switcher on the left to browse other
+IMPORTANT: This is the documentation for *Zest™ {revnumber}*. Use the version switcher on the left to browse other
 versions documentation.
 
-== What is Qi4j™? ==
-The short answer is that Qi4j™ is a framework for domain centric application development, including evolved concepts
-from http://en.wikipedia.org/wiki/Aspect-oriented_programming[AOP],
+== What is Apache Zest™ ? ==
+The short answer is that Apache Zest™ is a framework for domain centric application development, including evolved
+concepts from http://en.wikipedia.org/wiki/Aspect-oriented_programming[AOP],
 http://en.wikipedia.org/wiki/Dependency_injection[DI] and http://en.wikipedia.org/wiki/Domain-driven_design[DDD].
 
-Qi4j™ is an implementation of Composite Oriented Programming, using the standard Java platform, without the use of
+Zest™ is an implementation of Composite Oriented Programming, using the standard Java platform, without the use of
 any pre-processors or new language elements. Everything you know from Java still applies and you can leverage both
 your experience and toolkits to become more productive with Composite Oriented Programming today.
 
-Moreover, Qi4j™ enables Composite Oriented Programming on the Java platform, including both Java and Scala as primary
+Moreover, Zest™ enables Composite Oriented Programming on the Java platform, including both Java and Scala as primary
 languages as well as many of the plethora of languages running on the JVM as bridged languages.
 
+We strongly recommend the <<intro, introduction>> section.
+
+== Brief History ==
+Apache Zest™ started its life in 2007 as Qi4j™, initially at OPS4J's infrastructure and later on GitHub.
+In March 2015, Apache Zest™ was created with the Qi4j™ codebase as the base, existing Apache Members as the
+bootstrap Project Management Committee (PMC).
+
 image:intro-qi.png["Qi",align="center"]
 
 Qi4j™ is pronounced "chee for jay". This website is out of scope to explain the many
@@ -44,4 +51,3 @@ facets and history of Qi, so we refer the interested to read the http://en.wikip
 Wikipedia. For us, Qi is the force/energy within the body, in this case the Java platform. Something that makes Java
 so much better, if it is found and channeled into a greater good.
 
-We strongly recommend the <<intro, introduction>> section.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/website/related.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/website/related.txt b/manual/src/docs/website/related.txt
index d49d5d0..453d078 100644
--- a/manual/src/docs/website/related.txt
+++ b/manual/src/docs/website/related.txt
@@ -20,9 +20,9 @@
 [[related,Related publications and projects]]
 = Related publications & projects =
 
-Qi4j addresses a wide range of concepts, the related publications and projects you'll find in this section span accross
+Zest™ addresses a wide range of concepts, the related publications and projects you'll find in this section span accross
 all theses concepts. Please note that this is not an exhaustive list but only some pointers to help you understand which
-principles Qi4j is based on.
+principles Zest™ is based on.
 
 
 == Publications ==

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/website/samples.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/website/samples.txt b/manual/src/docs/website/samples.txt
index 94737a4..5d09260 100644
--- a/manual/src/docs/website/samples.txt
+++ b/manual/src/docs/website/samples.txt
@@ -24,16 +24,16 @@
 
 == Overview ==
 
-The Qi4j SDK comes with several sample applications. This is a very good place
+The Zest� SDK comes with several sample applications. This is a very good place
 to look for code examples and recipes.
 
-The samples are available in the +samples/+ directory of the Qi4j SDK.
+The samples are available in the +samples/+ directory of the Zest� SDK.
 
 [[sample-dci, DCI Sample]]
 == DCI Sample ==
 
 Sample of how DCI (Data, Context & Interaction) pattern is implemented using
-Qi4j core only.
+Zest� core only.
 
 https://github.com/Qi4j/qi4j-sdk/tree/develop/samples/dci[Browse Source]
 
@@ -41,7 +41,7 @@ https://github.com/Qi4j/qi4j-sdk/tree/develop/samples/dci[Browse Source]
 == DCI Cargo Sample ==
 
 Sample of how DCI (Data, Context & Interaction) pattern is implemented with
-Qi4j, for Eric Evans DDD sample.
+Zest�, for Eric Evans DDD sample.
 
 This sample, contributed by Marc Grue, is described in details on his
 website: http://marcgrue.com/
@@ -67,7 +67,7 @@ https://github.com/Qi4j/qi4j-sdk/tree/develop/samples/rental[Browse Source]
 // [[sample-scala,Scala Sample]]
 // == Scala Sample ==
 //
-// Sample of how to use Scala with Qi4j.
+// Sample of how to use Scala with Zest�.
 //
 // https://github.com/Qi4j/qi4j-sdk/tree/develop/samples/scala[Browse Source]
 
@@ -76,7 +76,7 @@ https://github.com/Qi4j/qi4j-sdk/tree/develop/samples/rental[Browse Source]
 
 NOTE: This sample use PostgreSQL and drop all of its data once run in order to be runnable multiple times.
 
-Sample of how to fully use Qi4j SQL support : <<library-sql>>, <<extension-es-sql>> and <<extension-indexing-sql>>.
+Sample of how to fully use Zest� SQL support : <<library-sql>>, <<extension-es-sql>> and <<extension-indexing-sql>>.
 
 https://github.com/Qi4j/qi4j-sdk/tree/develop/samples/sql-support[Browse Source]
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/website/tutorials.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/website/tutorials.txt b/manual/src/docs/website/tutorials.txt
index a028411..274c700 100644
--- a/manual/src/docs/website/tutorials.txt
+++ b/manual/src/docs/website/tutorials.txt
@@ -25,15 +25,15 @@
 == Overview ==
 
 TIP: Theses tutorials are based on actual code found in the `tutorials/` directory of the
-http://qi4j.org/downloads.html[Qi4j SDK sources]. You should start your favorite editor and find the code related to
+http://qi4j.org/downloads.html[Zest� SDK sources]. You should start your favorite editor and find the code related to
 this tutorial, run it and play with it.
 
-In this section you will find a comprehensive set of tutorials about Composite Oriented Programming using Qi4j.
+In this section you will find a comprehensive set of tutorials about Composite Oriented Programming using Zest�.
 
-[[tutorials-intro,Qi4j in 2 hours 42 minutes]]
-=== Qi4j in 2 hours 42 minutes ===
+[[tutorials-intro,Zest� in 2 hours 42 minutes]]
+=== Zest� in 2 hours 42 minutes ===
 
-This quite long introduction to Qi4j will start by brushing up an overview of the problems Qi4j solve, teach you what
+This quite long introduction to Zest� will start by brushing up an overview of the problems Zest� solve, teach you what
 Composite Oriented Programming is and guide you through the process of writing a complete Application around an adapted
 Hello World example.
 
@@ -42,9 +42,9 @@ Hello World example.
 - <<thirty-minutes-intro>>
 - <<two-hours-intro>>
 
-=== Getting real with Qi4j ===
+=== Getting real with Zest� ===
 
-Throughout this set of tutorials it will be shown how to depend on Qi4j in your build, how to assemble a complete
+Throughout this set of tutorials it will be shown how to depend on Zest� in your build, how to assemble a complete
 application, how to create and work with Composites and Services, how to use contextual fragments and leverage
 properties.
 
@@ -67,10 +67,10 @@ typical application.
 - <<howto-configure-service>>
 - <<howto-use-io>>
 
-=== Qi4j Development ===
+=== Zest� Development ===
 
-This last set of tutorials you'll learn how to build the Qi4j SDK from sources including this very documentation website
-, the Qi4j manual, binaries and sources distributions.
+This last set of tutorials you'll learn how to build the Zest� SDK from sources including this very documentation website
+, the Zest� manual, binaries and sources distributions.
 
 - <<build-system>>
 - <<community-docs>>

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/samples/dci-cargo/README.txt
----------------------------------------------------------------------
diff --git a/samples/dci-cargo/README.txt b/samples/dci-cargo/README.txt
index 24f12fc..4f71f53 100644
--- a/samples/dci-cargo/README.txt
+++ b/samples/dci-cargo/README.txt
@@ -1,7 +1,7 @@
 DCI Sample
 ==========
 
-This is a port of the DDD Sample application to the DCI paradigm using Java, Qi4j and Wicket.
+This is a port of the DDD Sample application to the DCI paradigm using Java, Zest� and Wicket.
 
 The code is licensed under the Apache Software License 2.0 and lastest revisions are
 available from https://github.com/dci.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/src/bin-dist/NOTICE.txt
----------------------------------------------------------------------
diff --git a/src/bin-dist/NOTICE.txt b/src/bin-dist/NOTICE.txt
index 7a0eb20..b16082a 100644
--- a/src/bin-dist/NOTICE.txt
+++ b/src/bin-dist/NOTICE.txt
@@ -1,4 +1,4 @@
-Apache Zest Qi4j SDK Binary Distribution
+Apache Zest� (Java Edition) SDK Binary Distribution
 Copyright 2015 The Apache Software Foundation.
 
 This product includes software developed at

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/src/bin-dist/README.txt
----------------------------------------------------------------------
diff --git a/src/bin-dist/README.txt b/src/bin-dist/README.txt
index 259f7ee..b29c306 100644
--- a/src/bin-dist/README.txt
+++ b/src/bin-dist/README.txt
@@ -1,14 +1,14 @@
 
-Welcome to the world of Apache Zest Qi4j
+Welcome to the world of Apache Zest
    - Composite Oriented Programming on the Java platform.
 
 
-This Apache Zest Qi4j Binary Distribution contains everything you need to
-create Qi4j applications.
+This Apache Zest� Binary Distribution contains everything you need to
+create Zest� applications.
 
 
-Qi4j started in 2007, and is still in heavy development under the umbrella of
-the Apache Zest project at the Apache Software Foundation. We would like
+Zest� (then Zest�) started in 2007, and is still in heavy development
+at the Apache Software Foundation. We would like
 developers around the world to participate in the advancement of this
 cool, new and challenging technology. We are especially interested in
 people willing to help improve the SDK, samples, tutorials, documentation
@@ -19,21 +19,21 @@ Please see https://zest.apache.org for more information.
 
 Licensing
 ---------
-All Apache Zest Qi4j code is licensed under an Apache License.
+All Apache Zest� code is licensed under an Apache License.
 
 Third-Party Dependencies may be licensed under other terms. The only
 required dependencies are SLF4J (MIT Licence), ASM (BSD Licence) and
 Joda-Time (Apache Licence).
 
-Finally, Qi4j TestSupport depends on JUnit 4.x and its dependencies, which
+Finally, Zest� TestSupport depends on JUnit 4.x and its dependencies, which
 is also not included in the SDK itself, as it is present among most Java
 developers.
 
 
 Dependencies not included
 -------------------------
-The binary distributions contains Qi4j artifacts only to keep the download
-size small. Each Qi4j artifact comes with a file prefixed ..-runtime-deps.txt
+The binary distributions contains Zest� artifacts only to keep the download
+size small. Each Zest� artifact comes with a file prefixed ..-runtime-deps.txt
 that contains the list of its dependencies. Moreover, at the binary
 distribution's root, you'll find both Maven (go-offline.pom) and Gradle
 (go-offline.gradle) build files whoses sole purpose is to easily download all
@@ -43,8 +43,8 @@ If you prefer to use a dependency management system, go to:
 https://zest.apache.org/qi4j/latest/howto-depend-on-qi4j.html
 
 
-Thank you for trying out Apache Zest Qi4j and Composite Oriented Programming.
+Thank you for trying out Apache Zest� and Composite Oriented Programming.
 
 
--- Apache Zest Qi4j Team
+-- Apache Zest� Team
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tools/envisage/src/docs/envisage.txt
----------------------------------------------------------------------
diff --git a/tools/envisage/src/docs/envisage.txt b/tools/envisage/src/docs/envisage.txt
index c9bcb88..9ad460f 100644
--- a/tools/envisage/src/docs/envisage.txt
+++ b/tools/envisage/src/docs/envisage.txt
@@ -20,7 +20,7 @@
 [[tools-envisage,Envisage Tool]]
 = Envisage =
 
-Envisage is a Swing based visualization tool for the Qi4j Application model.
+Envisage is a Swing based visualization tool for the Zest� Application model.
 Visualizations can be printed to PDFs.
 
 == Usage ==

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/composites/src/docs/step1.txt
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/docs/step1.txt b/tutorials/composites/src/docs/step1.txt
index 8ba0a1a..e49d127 100644
--- a/tutorials/composites/src/docs/step1.txt
+++ b/tutorials/composites/src/docs/step1.txt
@@ -22,7 +22,7 @@
 
 == Initial Hello World ==
 
-This whole tutorial describes how to step-by-step modify a typical HelloWorld "application" into a full-fledged Qi4j 
+This whole tutorial describes how to step-by-step modify a typical HelloWorld "application" into a full-fledged Zest�
 Composite Oriented application. Here is the initial code of HelloWorld.
 
 [snippet,java]
@@ -36,7 +36,7 @@ tag=initial
 In this step we start with a basic Java class, which when invoked will concatenate the two properties "phrase" 
 and "name". If invoked with the properties set to "Hello" and "World" respectively it will hence return "Hello World".
 
-Qi4j relies heavily on the use of interfaces. This makes it possible for an object to externally implement a number of 
+Zest� relies heavily on the use of interfaces. This makes it possible for an object to externally implement a number of
 interfaces which internally is backed by a number of Mixins, some of which you may have written yourself, and some of 
 which may have been reused. This also makes it easy to introduce Modifiers (aka "interceptors", aka "advice"), which 
 are Fragments which execute before and/or after the method on the Mixin is invoked.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/composites/src/docs/step2.txt
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/docs/step2.txt b/tutorials/composites/src/docs/step2.txt
index 0e55043..80b675c 100644
--- a/tutorials/composites/src/docs/step2.txt
+++ b/tutorials/composites/src/docs/step2.txt
@@ -29,8 +29,8 @@ Constraints. In this tutorial we will only use Mixins. When a TransientComposite
 framework will inspect the interface to determine what the TransientComposite instance should look like in terms of 
 used Fragments.
 
-In Qi4j all method parameters are considered mandatory unless marked as @Optional. Therefore you can remove the null 
-checks in the Mixin. If a null value is passed in an exception will be thrown by Qi4j.
+In Zest� all method parameters are considered mandatory unless marked as @Optional. Therefore you can remove the null
+checks in the Mixin. If a null value is passed in an exception will be thrown by Zest�.
 
 Steps for this tutorial:
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/composites/src/docs/step5.txt
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/docs/step5.txt b/tutorials/composites/src/docs/step5.txt
index ba52b8c..79cdd0c 100644
--- a/tutorials/composites/src/docs/step5.txt
+++ b/tutorials/composites/src/docs/step5.txt
@@ -27,7 +27,7 @@ restriction we can make is to denote a type. Any other constraints on the input
 optional, integer ranges, string regular expressions, and so on, cannot be expressed, and so we have to put this into
 Javadoc, and then manually add these checks in the implementation class.
 
-In Qi4j there is the option to use Constraints, which are further restrictions on the parameters. This is implemented
+In Zest� there is the option to use Constraints, which are further restrictions on the parameters. This is implemented
 by having an annotation that describes what the Constraint does, and then an implementation class that checks whether a
 specific value fulfills the Constraint or not.
 
@@ -35,8 +35,8 @@ NOTE: The previous steps had a dependency to the <<core-api>> only. The constrai
 introduce a new dependency to the <<library-constraints>>, where all the constraint related classes reside. So
 update your classpath settings accordingly.
 
-There are a number of pre-written constraints in Qi4j which you can use. The null check of the original HelloWorld
-version is already handled by default since Qi4j considers method parameters to be mandatory if not explicitly marked
+There are a number of pre-written constraints in Zest� which you can use. The null check of the original HelloWorld
+version is already handled by default since Zest� considers method parameters to be mandatory if not explicitly marked
 with the @Optional annotation. So, instead of doing that check we will add other checks that are useful to make, such
 as ensuring that the passed in string is not empty.
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/composites/src/docs/step7.txt
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/docs/step7.txt b/tutorials/composites/src/docs/step7.txt
index 2d97ad9..8f6e561 100644
--- a/tutorials/composites/src/docs/step7.txt
+++ b/tutorials/composites/src/docs/step7.txt
@@ -22,11 +22,11 @@
 
 Previous step was <<tut-composites-step6>>.
 
-One of the goals of Qi4j is to give you domain modeling tools that allow you to more concisely use domain concepts in 
+One of the goals of Zest� is to give you domain modeling tools that allow you to more concisely use domain concepts in
 code. One of the things we do rather often is model Properties of objects as getters and setters. But this is a very 
 weak model, and does not give you any access to metadata about the property, and also makes common tasks like UI binding
 non-trivial. There is also a lot of repetition of code, which is unnecessary. Using JavaBeans conventions one typically 
-have to have code in five places for one property, whereas in Qi4j the same thing can be achieved with one line of code.
+have to have code in five places for one property, whereas in Zest� the same thing can be achieved with one line of code.
 
 But lets start out easy. To declare a property you have to make a method in a mixin type that returns a value of the 
 type Property, and which does not take any parameters. Here's a simple example:
@@ -43,14 +43,14 @@ For now you will be responsible for implementing these methods, but later on the
 reducing Properties to one-liners!
 
 In the Mixin implementation of the interface with the Property declaration you should have an injection of the Property, 
-which is created for you by Qi4j. The injection can be done in a field like this:
+which is created for you by Zest�. The injection can be done in a field like this:
 
 [source,java]
 ----
 @State Property<String> name;
 ----
 
-The State dependency injection annotation means that Qi4j will inject the Property for you. The field has the name 
+The State dependency injection annotation means that Zest� will inject the Property for you. The field has the name
 "name", which matches the name in the interface, and therefore that Property is injected. You can then implement the 
 method trivially by just returning the "name" field.
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/composites/src/docs/step8.txt
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/docs/step8.txt b/tutorials/composites/src/docs/step8.txt
index 636bf38..c41208f 100644
--- a/tutorials/composites/src/docs/step8.txt
+++ b/tutorials/composites/src/docs/step8.txt
@@ -33,7 +33,7 @@ java.lang.proxy.InvocationHandler. This has a single "invoke" method which is pa
 TransientComposite in this case), the method, and the arguments. The Fragment is then allowed to implement the method 
 any way it wants.
 
-Since interfaces with only Properties is such a common case Qi4j already has a generic Mixin that implements the 
+Since interfaces with only Properties is such a common case Zest� already has a generic Mixin that implements the
 Properties management described above, but for the builtin Property type instead of the getter/setter variant. The 
 class is aptly named PropertyMixin.
 
@@ -43,7 +43,7 @@ Steps for this tutorial:
 
 - Remove the HelloWorldStateMixin
 - Add a GenericPropertyMixin, and have it implement InvocationHandler
-- Inject "@State StateHolder state" in the mixin. The StateHolder interface will give you access to the Properties for the TransientComposite which Qi4j manages for you
+- Inject "@State StateHolder state" in the mixin. The StateHolder interface will give you access to the Properties for the TransientComposite which Zest� manages for you
 - On call to invoke(), delegate to the StateHolder interface to get the Property for the invoked method
 - Add an @AppliesTo annotation to the Mixin and implement the AppliesToFilter with a rule that matches only methods that return Property values.
 - Add the mixin to the TransientComposite.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/composites/src/docs/step9.txt
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/docs/step9.txt b/tutorials/composites/src/docs/step9.txt
index 19d7453..6addfd3 100644
--- a/tutorials/composites/src/docs/step9.txt
+++ b/tutorials/composites/src/docs/step9.txt
@@ -31,7 +31,7 @@ This forces the mixin to implement the TransientComposite type, which would norm
 implement all methods, including those found in the TransientComposite interface. However, since we are only really 
 interested in implementing the say() method we will mark this by declaring that the Mixin "implements" the 
 TransientComposite type, but is also "abstract". This, using pure Java semantics, makes it possible to avoid having to 
-implement all methods. Qi4j will during the initialization phase detect that the Mixin only handles the say() method, 
+implement all methods. Zest� will during the initialization phase detect that the Mixin only handles the say() method,
 and therefore only map it to that specific method. In order to instantiate the Mixin it will generate a subclass which 
 implements the remaining methods in the TransientComposite type, as no-ops. These will never be called however, and is 
 there purely for the purpose of being able to instantiate the Mixin. The Mixin is considered to be an Abstract Fragment.
@@ -39,7 +39,7 @@ there purely for the purpose of being able to instantiate the Mixin. The Mixin i
 To hide the state from the client we need to use what is called Private Mixins. A Private Mixin is any mixin that is 
 referenced by another Mixin by using the @This injection, but which is not included in the TransientComposite type. As 
 long as there is a Mixin implementation declared for the interface specified by the @This injection it will work, since 
-Qi4j can know how to implement the interface. But since it is not extended by the TransientComposite type there is no 
+Zest� can know how to implement the interface. But since it is not extended by the TransientComposite type there is no
 way for a user of the TransientComposite to access it. That Mixin becomes an implementation detail. This can be used 
 either for encapsulation purposes, or for referencing utility mixins that help the rest of the code implement some 
 interface, but which itself should not be exposed.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/composites/src/docs/tut-composites.txt
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/docs/tut-composites.txt b/tutorials/composites/src/docs/tut-composites.txt
index 239bc48..cb06854 100644
--- a/tutorials/composites/src/docs/tut-composites.txt
+++ b/tutorials/composites/src/docs/tut-composites.txt
@@ -21,14 +21,14 @@
 = Transient Composites Tutorial =
 
 TIP: Theses tutorials are based on actual code found in the `tutorials/` directory of the
-http://qi4j.org/downloads.html[Qi4j SDK sources]. You should start your favorite editor and find the code related to
+http://qi4j.org/downloads.html[Zest� SDK sources]. You should start your favorite editor and find the code related to
 this tutorial, run it and play with it.
 
 Throughout this set of tutorials it will be shown how to create and work with Composites, which
-is the basic element in Qi4j. We will refactor one HelloWorld class to take advantage of the various
-features in Qi4j. These refactorings will make it easier to reuse parts of the class,
+is the basic element in Zest�. We will refactor one HelloWorld class to take advantage of the various
+features in Zest�. These refactorings will make it easier to reuse parts of the class,
 and introduce new features without having to change existing code. We will also look
-at some of the existing classes, or Fragments, available in Qi4j that you can reuse
+at some of the existing classes, or Fragments, available in Zest� that you can reuse
 so that you don't have to write everything yourself.
 
 - <<tut-composites-step1>>

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/introduction/src/docs/background.txt
----------------------------------------------------------------------
diff --git a/tutorials/introduction/src/docs/background.txt b/tutorials/introduction/src/docs/background.txt
index f68e419..a24f821 100644
--- a/tutorials/introduction/src/docs/background.txt
+++ b/tutorials/introduction/src/docs/background.txt
@@ -19,22 +19,22 @@
 
 [[introduction-background,Background]]
 = Background =
-Qi4j is the first Composite Oriented Programming implementation leveraging the Java 5 platform, so that everything you
-know from Java 5 still applies. You can mix Qi4j with your ordinary Java code as much as you want. All your existing
-Java tools works just like before, and Qi4j does not introduce any new programming language, no special development
+Zest� is the first Composite Oriented Programming implementation leveraging the Java 5 platform, so that everything you
+know from Java 5 still applies. You can mix Zest� with your ordinary Java code as much as you want. All your existing
+Java tools works just like before, and Zest� does not introduce any new programming language, no special development
 tools needed and no XML is required.
 
 == Purpose ==
-Qi4j addresses the programming problems from the top-down, starting with the Domain Model and Business Rules needs,
+Zest� addresses the programming problems from the top-down, starting with the Domain Model and Business Rules needs,
 and let those requirements flow downwards in the software stack and dictate the requirements for underlying layers
 such as persistence, messaging, querying and more. This means that the business value developer is left to
 concentrate on the domain models and the actual application bringing the value, instead of creating massive amounts
 of glue code to tie underlying technologies together.
 
 == Problem Descriptions ==
-Qi4j didn't appear out of the blue, when the founders of the project had nothing better to do. It is the result of
+Zest� didn't appear out of the blue, when the founders of the project had nothing better to do. It is the result of
 observation of problems in real applications, and the experience from previous attempts to address or correct these
-problems, that has led to the Qi4j vision.
+problems, that has led to the Zest� vision.
 
 == Object Oriented Programming (OOP) ==
 How can OOP be a problem? We and others have observed that there is a fundamental flaw in the OOP model. In fact, we
@@ -117,4 +117,4 @@ ServerContextualInvoiceEntity, and then persist the changes.
 Composite Oriented Programming is heavily influenced by the book "Domain Driven Design" by Eric Evans. And we are
 trying to use his analysis of the problem to provide the mechanisms needed to get the job done quicker and more
 reliably. Mr Evans talks about Applications, Layers, Modules, Specifications, SideEffects and so forth, and all of
-these should be present in a Composite Oriented Programming implementation, and to a large extent it is in Qi4j.
+these should be present in a Composite Oriented Programming implementation, and to a large extent it is in Zest�.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/introduction/src/docs/highlights.txt
----------------------------------------------------------------------
diff --git a/tutorials/introduction/src/docs/highlights.txt b/tutorials/introduction/src/docs/highlights.txt
index 0eeea51..263096b 100644
--- a/tutorials/introduction/src/docs/highlights.txt
+++ b/tutorials/introduction/src/docs/highlights.txt
@@ -83,11 +83,11 @@ irrelevant to the domain model, introduced by the underlying framework, from the
 
 image:classes-are-dead.gif[]
 
-Qi4j™ is trying to address the flaws of OOP and introduce Composite Oriented Programming to the world, without
+Zest™ is trying to address the flaws of OOP and introduce Composite Oriented Programming to the world, without
 introducing new programming languages, or awkward constructs. Heck, we don't even use any XML.
 
-Qi4j™ is not a framework. It is a new way to write code. Other people might create frameworks using Qi4j™, or create a
-framework optimized for Qi4j™, but here at Qi4j™ we concentrate to make Qi4j™ behave well in existing frameworks,
+Zest™ is not a framework. It is a new way to write code. Other people might create frameworks using Zest™, or create a
+framework optimized for Zest™, but here at Zest™ we concentrate to make Zest™ behave well in existing frameworks,
 application servers, platforms and environments.
 
 You are to embark on a new journey. Enjoy!

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/introduction/src/docs/qi4j-cop.txt
----------------------------------------------------------------------
diff --git a/tutorials/introduction/src/docs/qi4j-cop.txt b/tutorials/introduction/src/docs/qi4j-cop.txt
index b1dc78b..175ce7b 100644
--- a/tutorials/introduction/src/docs/qi4j-cop.txt
+++ b/tutorials/introduction/src/docs/qi4j-cop.txt
@@ -17,6 +17,6 @@
  * under the License.
 ///////////////////////////////////////////////////////////////
 
-[[qi4j-cop,COP with Java and Qi4j]]
-= COP with Java and Qi4j =
+[[qi4j-cop,COP with Java and Zest�]]
+= COP with Java and Zest� =
 

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/introduction/src/docs/state-modeling.txt
----------------------------------------------------------------------
diff --git a/tutorials/introduction/src/docs/state-modeling.txt b/tutorials/introduction/src/docs/state-modeling.txt
index 26d8a74..0dff931 100644
--- a/tutorials/introduction/src/docs/state-modeling.txt
+++ b/tutorials/introduction/src/docs/state-modeling.txt
@@ -18,11 +18,11 @@
 ///////////////////////////////////////////////////////////////
 
 [[state-modeling,State Modeling]]
-= Qi4j and state modeling =
+= Zest� and state modeling =
 
 (From Rickard Oberg's blog, http://www.jroller.com/rickard/entry/qi4j_and_state_modeling, 2009-02-19)
 
-In the Qi4j project we strive to being able to express our domain as directly as possible, with as little translation
+In the Zest� project we strive to being able to express our domain as directly as possible, with as little translation
 as possible between how we think about a domain and how it is actually coded.
 This then affects our entire view of how application frameworks should be constructed, and what we consider good and
 bad ways of implementing certain features.
@@ -36,7 +36,7 @@ In Domain Driven Design terms, POJOs are not in our Ubiquitous Language.
 
 From a DDD perspective we want to talk about Entities and Values, Properties and Associations.
 If our code does not reflect this, then there is translation going on, and translation inevitably leads to information loss.
-In Qi4j, where Composites and not Objects, are the basic construct, we have created specialized forms to model these
+In Zest�, where Composites and not Objects, are the basic construct, we have created specialized forms to model these
 concepts more explicitly.
 We have EntityComposites and ValueComposites, each with different ways of creating them and managing them.
 Both EntityComposites and ValueComposites can then have Properties, as first-class objects, but Properties in
@@ -93,7 +93,7 @@ For Collections they are set to empty collections of the type indicated.
 "@UseDefaults Property<List<String>> addresses();" would be initialized to an empty ArrayList, for example.
 
 In addition I have set surName() to be @Optional.
-In Qi4j we have defined all properties to be not-null as the default, and the same goes for all parameters in method
+In Zest� we have defined all properties to be not-null as the default, and the same goes for all parameters in method
 invocations.
 If you explicitly want to allow properties to be null, so that for example "Madonna" would be an acceptable name,
 then you can mark it as @Optional.
@@ -134,7 +134,7 @@ What should have been a neat and tidy little package is instead a anorectic litt
 around your code, looking all soggy and unappetizing.
 
 What to do about this?
-One of the great inventions of Qi4j, I believe, is the notion of private mixins.
+One of the great inventions of Zest�, I believe, is the notion of private mixins.
 That we can have mixins in an object which are explicitly HIDDEN from usage outside of it.
 How can we use this for state modeling?
 What you'd want to do is to model the state of an Entity as a private mixin, which is hidden from clients, and then
@@ -164,10 +164,10 @@ Entity doesn't need the "Listable" interface the mixin will never be instantiate
 
 And so much more...
 
-The above is just a small taste of what you can do with state modeling in Qi4j.
+The above is just a small taste of what you can do with state modeling in Zest�.
 There is also support for associations and many-associations, the notion of aggregates, and a complete pluggable
 system for persistence and indexing/querying of data.
-To end with, here's a sample of how some other state modeling concepts can be expressed in Qi4j:
+To end with, here's a sample of how some other state modeling concepts can be expressed in Zest�:
 
 [snippet,java]
 -----------
@@ -177,5 +177,5 @@ tag=more
 
 I hope they are self-explanatory.
 
-My hope is that with Composite Oriented Programming and Qi4j we can come one step closer to being able to express our
+My hope is that with Composite Oriented Programming and Zest� we can come one step closer to being able to express our
 domain as clearly as possible in code.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/introduction/src/docs/what-is-composite-oriented-programming.txt
----------------------------------------------------------------------
diff --git a/tutorials/introduction/src/docs/what-is-composite-oriented-programming.txt b/tutorials/introduction/src/docs/what-is-composite-oriented-programming.txt
index 93ffa08..f1493c3 100644
--- a/tutorials/introduction/src/docs/what-is-composite-oriented-programming.txt
+++ b/tutorials/introduction/src/docs/what-is-composite-oriented-programming.txt
@@ -24,7 +24,7 @@ We found this very well written blog entry on the Internet, which very well desc
 Programming really is.
 
 The article uses C# and a "show by example" approach to explaining COP, and this shows clearly that COP is not
-Java specific, and although Qi4j was (to our knowledge) first to introduce the name, it applies across languages and
+Java specific, and although Zest™ was (to our knowledge) first to introduce the name, it applies across languages and
 potentially deserves one or more languages on its own.
 
 
@@ -41,7 +41,7 @@ We would like to thank Fredrik Kalseth for his explicit approval as well.
 
 I've written a series of post on AOP lately (here, here and here), and in the last part I promised to tackle mixins
 and introductions in a future post. When I was doing my research for just that, I came cross a Java framework (just
-humor me :p) called Qi4j (that's 'chee for jay'), written by Swedish Richard Öberg, pioneering the idea of Composite
+humor me :p) called Zest™ (that's 'chee for jay'), written by Swedish Richard Öberg, pioneering the idea of Composite
 Oriented Programming, which instantly put a spell on me. Essentially, it takes the concepts from Aspect Oriented
 Programming to the extreme, and for the past week I’ve dug into it with a passion. This post is the first fruits of
 my labor.
@@ -49,7 +49,7 @@ my labor.
 === OOP is Not Object Oriented! ===
 
 One of the things that Richard Öberg argues, is that OOP is not really object oriented at all, but rather class
-oriented. As the Qi4j website proclaims, "class is the first class citizen that objects are derived from. Not objects
+oriented. As the Zest™ website proclaims, "class is the first class citizen that objects are derived from. Not objects
 being the first-class citizen to which one or many classes are assigned". Composite oriented programming (COP) then,
 tries to work around this limitation by building on a set of core principles; that behavior depends on context, that
 decoupling is a virtue, and that business rules matter more. For a short and abstract explanation of COP,
@@ -324,5 +324,5 @@ I hope this post has whet your appetite for more on this subject, as I will cert
 posts. I’ve already implemented a prototype framework that supports the above examples, which builds on my
 http://www.iridescence.no/Posts/Implementing-an-AOP-Framework-Part-2.aspx[previously posted AOP framework], and I’ll
 post the source code for that soon. If you want to dig deeper right now (and don’t mind
-a bit of Java), then I suggest you head over to the Qi4j website and poke about there.
+a bit of Java), then I suggest you head over to the Zest™ website and poke about there.
 http://rickardoberg.wordpress.com/[Richard Öbergs blog] also provides great insight.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/tutorials/introduction/src/docs/whats-an-object.txt
----------------------------------------------------------------------
diff --git a/tutorials/introduction/src/docs/whats-an-object.txt b/tutorials/introduction/src/docs/whats-an-object.txt
index a3a7e98..08009e0 100644
--- a/tutorials/introduction/src/docs/whats-an-object.txt
+++ b/tutorials/introduction/src/docs/whats-an-object.txt
@@ -47,7 +47,7 @@ is the OBSERVER of the object, meaning, the algorithm, that gets to decide what
 
 This is the same in real life. I don't get to decide how I communicate with you. I have to use english, and I have to
 use email, and I have to send it to a specific mailing list. It is the algorithm of the interaction between us, the
-Qi4j dev mailing list, that has set these rules, not *I* as a participant in this interaction. The same should,
+Zest� dev mailing list, that has set these rules, not *I* as a participant in this interaction. The same should,
 obviously, be the case for objects.
 
 So, with the understanding that algorithms should define roles for collaborating objects, and objects should then
@@ -63,7 +63,7 @@ This "solution", which is caused by this fundamental flaw in "class oriented pro
 causes a number of other problems, such as the "self schizophrenia" problem, whereby there is no way to tell where the
 object really is. There is no "this" pointer that has any relevant meaning.
 
-The Composite pattern, as implemented in COP and Qi4j, gets around this by simply saying that the composite, as a
+The Composite pattern, as implemented in COP and Zest�, gets around this by simply saying that the composite, as a
 whole, is an object. Tada, we now have a "this" pointer, and a coherent way to deal with the object graph as though it
 was a single object. We are now able to get back to the strengths of the procedural approach, which allows the
 implementer of the algorithm to define the roles needed for the algorithm. The roles can either be specific to an
@@ -77,7 +77,7 @@ necessary to read composite code when trying to understand algorithms. The assum
 more algorithms than composites, therefore it has to be easy to ready algorithms, and only when necessary dive down into
 composite code.
 
-When talking about Composites as Objects in Qi4j it is most relevant to look at Entities, since these represent physical
+When talking about Composites as Objects in Zest� it is most relevant to look at Entities, since these represent physical
 objects in a model, rather than algorithms or services, or other non-instance-oriented things.
 
 If Entities should implement roles, via mixins, in order to interact with each other through algorithms, then the
@@ -134,7 +134,7 @@ code and read it. If we have read the mixin code once, and the same mixin is reu
 it easier for us to understand it the next time we see it being used in another algorithm.
 
 To summarize thus far, we have looked at why OOP so far has not worked out, why this is the case, and how COP deals
-with it, and how we can implement a better solution of Entities using Qi4j. All is well!
+with it, and how we can implement a better solution of Entities using Zest�. All is well!
 
 The next step is to start using these Entities in algorithms. Algorithms are usually stateless, or at least they don't
 have any state that survives the execution of the algorithm. There is input, some calculation, and then output. In
@@ -189,15 +189,15 @@ The interaction method "delegate" is testable, both with mocks of the input, and
 roles. The implementations are also testable, and if the same mixin is used over and over for the implementation, then
 only one set of tests is needed for each role interface.
 
-To summarize we have in COP/Qi4j a way to get the best from procedural and object-oriented programming. As we have seen
+To summarize we have in COP/Zest� a way to get the best from procedural and object-oriented programming. As we have seen
 the functionality falls into three categories, the entities implementing objects, the services implementing
 interactions, and the user interface implementing the context. This also maps well to the ideas of ModelViewController,
 which in turn maps well to the new ideas from Mr Reenskaug (inventor of MVC) called DCI: Data-Context-Interaction. As a
-side-effect of this discussion we have therefore also seen how COP/Qi4j can be used to implement DCI, which is an
+side-effect of this discussion we have therefore also seen how COP/Zest� can be used to implement DCI, which is an
 important next step in understanding objects and their interactions, the fundamentals of which (I believe) are captured
 on this page.
 
 That's it. Well done if you've read this far :-)
 
 Comments and thoughts to qi4j-dev forum at Google Groups on this are highly appreciated. This is very very important topics,
-and crucial to understanding/explaining why COP/Qi4j is so great! :-)
+and crucial to understanding/explaining why COP/Zest� is so great! :-)


Mime
View raw message