Some updates to docs

akka-docs/index.rst

@@ -26,7 +26,7 @@ Links
 
 * :ref:`other-doc`
 
-* `Akka Modules Documentation <http://akka.io/docs/akka-modules/1.1/>`_.
+* `Akka Modules Documentation <http://akka.io/docs/akka-modules/1.1/>`_
 
 * :ref:`issue_tracking`
 

akka-docs/intro/deployment-scenarios.rst

@@ -1,37 +1,74 @@
+
 .. _deployment-scenarios:
 
-Use-case and Deployment Scenarios
-=================================
+###################################
+ Use-case and Deployment Scenarios
+###################################
 
-**How and in which use-case and deployment scenarios can I use Akka?**
+How can I use and deploy Akka?
+==============================
 
 Akka can be used in two different ways:
 
-* As a library: used as a regular JAR on the classpath and/or in a web app, to be put into ‘WEB-INF/lib’
-* As a microkernel: stand-alone microkernel, embedding a servlet container along with many other services.
+- As a library: used as a regular JAR on the classpath and/or in a web app, to
+  be put into ``WEB-INF/lib``
+
+- As a microkernel: stand-alone microkernel, embedding a servlet container along
+  with many other services
+
 
 Using Akka as library
 ---------------------
 
-This is most likely what you want if you are building Web applications.
-There are several ways you can use Akka in Library mode by adding more and more modules to the stack.
+This is most likely what you want if you are building Web applications. There
+are several ways you can use Akka in Library mode by adding more and more
+modules to the stack.
 
 Actors as services
 ^^^^^^^^^^^^^^^^^^
 
-The simplest way you can use Akka is to use the actors as services in your Web application. All that’s needed to do that is to put the Akka charts as well as its dependency jars into ‘WEB-INF/lib’. You also need to put the ‘akka.conf’ config file in the ‘$AKKA_HOME/config’ directory.
-Now you can create your Actors as regular services referenced from your Web application. You should also be able to use the Remoting service, e.g. be able to make certain Actors remote on other hosts. Please note that remoting service does not speak HTTP over port 80, but a custom protocol over the port is specified in ‘akka.conf’.
+The simplest way you can use Akka is to use the actors as services in your Web
+application. All that’s needed to do that is to put the Akka charts as well as
+its dependency jars into ``WEB-INF/lib``. You also need to put the ``akka.conf``
+config file in the ``$AKKA_HOME/config`` directory.  Now you can create your
+Actors as regular services referenced from your Web application. You should also
+be able to use the Remoting service, e.g. be able to make certain Actors remote
+on other hosts. Please note that remoting service does not speak HTTP over port
+80, but a custom protocol over the port is specified in ``akka.conf``.
+
 
 Using Akka as a stand alone microkernel
 ---------------------------------------
 
-Akka can also be run as a stand-alone microkernel. It implements a full enterprise stack:
+Akka can also be run as a stand-alone microkernel. It implements a full
+enterprise stack. See the :ref:`add-on-modules` for more information.
 
-Use BivySack for packaging your application
--------------------------------------------
+Using the Akka sbt plugin to package your application
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-"BivySack" For Akka - SBT plugin which creates a full akka microkernel deployment for your project.
+The Akka sbt plugin can create a full Akka microkernel deployment for your sbt
+project.
 
-Quick and dirty SBT Plugin for creating Akka Microkernel deployments of your SBT Project. This creates a proper "akka deploy" setup with all of your dependencies and configuration files loaded, with a bootable version of your project that you can run cleanly.
+To use the plugin, first add a plugin definition to your SBT project by creating
+``project/plugins/Plugins.scala`` with::
 
-Read more about it here `<http://github.com/bwmcadams/sbt-akka-bivy>`_.
+   import sbt._
+
+   class Plugins(info: ProjectInfo) extends PluginDefinition(info) {
+     val akkaRepo = "Akka Repo" at "http://akka.io/repository"
+     val akkaPlugin = "se.scalablesolutions.akka" % "akka-sbt-plugin" % "1.1"
+   }
+
+Then mix the ``AkkaKernelProject`` trait into your project definition. For
+example::
+
+  class MyProject(info: ProjectInfo) extends DefaultProject(info) with AkkaKernelProject
+
+This will automatically add all the Akka dependencies needed for a microkernel
+deployment (download them with ``sbt update``).
+
+Place your config files in ``src/main/config``.
+
+To build a microkernel deployment use the ``dist`` task::
+
+   sbt dist

akka-docs/intro/getting-started.rst

@@ -42,7 +42,7 @@ Modules
 
 Akka is split up into two different parts:
 
-* Akka - The core modules. Reflects all the sections under :ref:`scala_api` and :ref:`java_api`.
+* Akka - The core modules. Reflects all the sections under :ref:`scala-api` and :ref:`java-api`.
 * Akka Modules - The microkernel and add-on modules, described in :ref:`add-on-modules`.
 
 Akka is very modular and has many JARs for containing different features. The core distribution has seven modules:

akka-docs/intro/what-is-akka.rst

@@ -1,18 +1,31 @@
-What is Akka?
-=============
 
-**Akka**
---------
+.. _what-is-akka:
+
+###############
+ What is Akka?
+###############
+
 
 **Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors**
 
-We believe that writing correct concurrent, fault-tolerant and scalable applications is too hard. Most of the time it's because we are using the wrong tools and the wrong level of abstraction. Akka is here to change that. Using the Actor Model together with Software Transactional Memory we raise the abstraction level and provide a better platform to build correct concurrent and scalable applications. For fault-tolerance we adopt the Let it crash/Embrace failure model which have been used with great success in the telecom industry to build applications that self-heals, systems that never stop. Actors also provides the abstraction for transparent distribution and the basis for truly scalable and fault-tolerant applications. Akka is Open Source and available under the Apache 2 License.
+We believe that writing correct concurrent, fault-tolerant and scalable
+applications is too hard. Most of the time it's because we are using the wrong
+tools and the wrong level of abstraction. Akka is here to change that. Using the
+Actor Model together with Software Transactional Memory we raise the abstraction
+level and provide a better platform to build correct concurrent and scalable
+applications. For fault-tolerance we adopt the Let it crash/Embrace failure
+model which have been used with great success in the telecom industry to build
+applications that self-heals, systems that never stop. Actors also provides the
+abstraction for transparent distribution and the basis for truly scalable and
+fault-tolerant applications. Akka is Open Source and available under the Apache
+2 License.
 
 
-Download from `<http://akka.io/downloads/>`_
+Download from http://akka.io/downloads/
 
-Akka implements a unique hybrid of:
------------------------------------
+
+Akka implements a unique hybrid
+===============================
 
 - :ref:`untyped-actors-java`, which gives you:
 
@@ -20,16 +33,30 @@ Akka implements a unique hybrid of:
   - Asynchronous, non-blocking and highly performant event-driven programming model.
   - Very lightweight event-driven processes (create ~6.5 million actors on 4GB RAM).
 
-- :ref:`fault-tolerance-java` through supervisor hierarchies with "let-it-crash" semantics. Excellent for writing highly fault-tolerant systems that never stop, systems that self-heal.
+- :ref:`fault-tolerance-java` through supervisor hierarchies with "let-it-crash"
+  semantics. Excellent for writing highly fault-tolerant systems that never
+  stop, systems that self-heal.
+
 - :ref:`stm-java` (STM). (Distributed transactions coming soon).
-- :ref:`transactors-java`: combine actors and STM into transactional actors. Allows you to compose atomic message flows with automatic retry and rollback.
-- :ref:`remote-actors-java`: highly performant distributed actors with remote supervision and error management.
-- Java and Scala API.
 
-Akka can be used in two different ways:
----------------------------------------
+- :ref:`transactors-java`: combine actors and STM into transactional
+  actors. Allows you to compose atomic message flows with automatic retry and
+  rollback.
 
-- As a library: used by a web app, to be put into ‘WEB-INF/lib’ or as a regular JAR on your classpath.
-- As a microkernel: stand-alone kernel, embedding a servlet container and all the other modules.
+- :ref:`remote-actors-java`: highly performant distributed actors with remote
+  supervision and error management.
 
-See the ref:`deployment-scenarios` for details.
+- :ref:`java-api` and :ref:`scala-api`
+
+
+Akka can be used in two different ways
+======================================
+
+- As a library: used by a web app, to be put into ‘WEB-INF/lib’ or as a regular
+  JAR on your classpath.
+
+- As a microkernel: stand-alone kernel, embedding a servlet container and all
+  the other modules.
+
+
+See the :ref:`deployment-scenarios` for details.

akka-docs/java/index.rst

@@ -1,4 +1,4 @@
-.. _java_api:
+.. _java-api:
 
 Java API
 =========

akka-docs/scala/index.rst

@@ -1,4 +1,4 @@
-.. _scala_api:
+.. _scala-api:
 
 Scala API
 =========