Cleanup ToC, #22901

* remove old intro / getting started
* other modules, community projects

akka-docs/src/main/paradox/java.md

@@ -5,14 +5,14 @@
 @@@ index
 
 * [security/index](java/security/index.md)
-* [intro/index-java](java/intro/index-java.md)
+* [java/guide](java/guide/index.md)
 * [general/index](java/general/index.md)
 * [java/index-actors](java/index-actors.md)
-* [java/index-futures](java/index-futures.md)
 * [java/index-network](java/index-network.md)
-* [java/index-utilities](java/index-utilities.md)
 * [java/stream/index](java/stream/index.md)
-* [java/http/index](java/http/index.md)
+* [java/index-futures](java/index-futures.md)
+* [java/index-utilities](java/index-utilities.md)
+* [common/other-modules](java/common/other-modules.md)
 * [java/howto](java/howto.md)
 * [java/scala-compat](java/scala-compat.md)
 * [dev/index](java/dev/index.md)

akka-docs/src/main/paradox/java/hello-world.md

@@ -1,21 +0,0 @@
-# The Obligatory Hello World
-
-The actor based version of the tough problem of printing a
-well-known greeting to the console is introduced in a ready to run [Akka Main sample](@exampleCodeService@/akka-samples-main-java)
-together with a tutorial. The source code of this sample can be found in the
-[Akka Samples Repository](@samples@/akka-sample-main-java).
-
-The tutorial illustrates the generic launcher class `akka.Main` which expects only
-one command line argument: the class name of the application’s main actor. This
-main method will then create the infrastructure needed for running the actors,
-start the given main actor and arrange for the whole application to shut down
-once the main actor terminates.
-
-There is also a [Gitter8](http://www.foundweekends.org/giter8/) template in the same problem domain
-that is named [Hello Akka!](https://github.com/akka/hello-akka.g8).
-It describes the basics of Akka in more depth. If you have *sbt* already installed, you can create a project
-from this template by running:
-
-```
-sbt new akka/hello-akka.g8
-```

akka-docs/src/main/paradox/java/http/index.md

@@ -1,4 +0,0 @@
-# Akka HTTP Documentation (Java) moved!
-
-Akka HTTP has been released as independent stable module (from Akka HTTP 10.x onwards).
-The documentation is available under [doc.akka.io/akka-http/current/](http://doc.akka.io/docs/akka-http/current/java.html).

akka-docs/src/main/paradox/java/index-utilities.md

@@ -10,6 +10,5 @@
 * [../scala/common/duration](../scala/common/duration.md)
 * [../scala/common/circuitbreaker](../scala/common/circuitbreaker.md)
 * [extending-akka](extending-akka.md)
-* [../scala/intro/deployment-scenarios](../scala/intro/deployment-scenarios.md)
 
 @@@

akka-docs/src/main/paradox/java/intro

@@ -1 +0,0 @@
-../scala/intro

akka-docs/src/main/paradox/java/scala-compat.md

@@ -1,5 +1,11 @@
 # Java 8 and Scala Compatibility
 
+## Scala and Java APIs
+
+Akka has both a @ref:[Scala Documentation](../scala.md) and a @ref:[Java Documentation](../java.md).
+
+## Java 8 types
+
 Starting with Akka 2.4.2 we have begun to introduce Java 8 types (most
 prominently `java.util.concurrent.CompletionStage` and
 `java.util.Optional`) where that was possible without breaking binary or

akka-docs/src/main/paradox/java/stream/stream-quickstart.md

@@ -3,7 +3,7 @@
 # Quick Start Guide
 
 Create a project and add the akka-streams dependency to the build tool of your
-choice as described in @ref:[Using a build tool](../../scala/intro/getting-started.md#build-tool).
+choice as described in @ref:[Using a build tool](../../java/guide/quickstart.md).
 
 A stream usually begins at a source, so this is also how we start an Akka
 Stream. Before we create one, we import the full complement of streaming tools:

akka-docs/src/main/paradox/scala.md

@@ -4,16 +4,15 @@
 
 @@@ index
 
-* [scala/guide](scala/guide/index.md)
 * [security/index](scala/security/index.md)
-* [intro/index-scala](scala/intro/index-scala.md)
+* [scala/guide](scala/guide/index.md)
 * [general/index](scala/general/index.md)
 * [scala/index-actors](scala/index-actors.md)
-* [scala/index-futures](scala/index-futures.md)
 * [scala/index-network](scala/index-network.md)
-* [scala/index-utilities](scala/index-utilities.md)
 * [scala/stream/index](scala/stream/index.md)
-* [scala/http/index](scala/http/index.md)
+* [scala/index-futures](scala/index-futures.md)
+* [scala/index-utilities](scala/index-utilities.md)
+* [common/other-modules](scala/common/other-modules.md)
 * [scala/howto](scala/howto.md)
 * [dev/index](scala/dev/index.md)
 * [project/index](scala/project/index.md)

akka-docs/src/main/paradox/scala/additional/index.md

@@ -9,5 +9,6 @@
 * [faq](faq.md)
 * [books](books.md)
 * [osgi](osgi.md)
+* [TODO](leftovers.md)
 
 @@@

akka-docs/src/main/paradox/scala/additional/leftovers.md

@@ -1,57 +1,66 @@
-# Getting Started
+# TODO
+
+These topics should be incorporated somewhere?
 
 ## Prerequisites
 
 Akka requires that you have [Java 8](http://www.oracle.com/technetwork/java/javase/downloads/index.html) or
 later installed on your machine.
 
-[Lightbend Inc.](http://www.lightbend.com) provides a commercial build of Akka and related projects such as Scala or Play
+## Akka can be used in different ways
-as part of the [Lightbend Reactive Platform](http://www.lightbend.com/platform) which is made available
-for Java 6 in case your project can not upgrade to Java 8 just yet. It also includes additional commercial features or libraries.
 
-## Download
+Akka is a toolkit, not a framework: you integrate it into your build like any other library
+without having to follow a particular source code layout. When expressing your systems as collaborating
+Actors you may feel pushed more towards proper encapsulation of internal state, you may find that
+there is a natural separation between business logic and inter-component communication.
 
-There are several ways to download Akka. You can download it as part of the Lightbend Platform
+Akka applications are typically deployed as follows:
-(as described above). You can download the full distribution, which includes all modules.
-Or you can use a build tool like Maven or SBT to download dependencies from the Akka Maven repository.
 
-## Modules
+ * as a library: used as a regular JAR on the classpath or in a web app.
+ * packaged with [sbt-native-packager](https://github.com/sbt/sbt-native-packager).
+ * packaged and deployed using [Lightbend ConductR](http://www.lightbend.com/products/conductr).
+ 
+## How can I use and deploy Akka?
 
-Akka is very modular and consists of several JARs containing different features.
+Akka can be used in different ways:
 
- * `akka-actor` – Classic Actors, Typed Actors, IO Actor etc.
+ * As a library: used as a regular JAR on the classpath and/or in a web app, to
- * `akka-agent` – Agents, integrated with Scala STM
+be put into `WEB-INF/lib`
- * `akka-camel` – Apache Camel integration
+ * As an application packaged with [sbt-native-packager](https://github.com/sbt/sbt-native-packager)
- * `akka-cluster` – Cluster membership management, elastic routers.
+ * As an application packaged and deployed using [Lightbend ConductR](http://www.lightbend.com/products/conductr).
- * `akka-cluster-sharding` – Cluster Sharding of actors.
- * `akka-cluster-tools` – Additoinal Cluster utilities, such as Singleton, Pub/Sub and Client.
- * `akka-distributed-data` – Cluster data with CRDTs.
- * `akka-osgi` – Utilities for using Akka in OSGi containers
- * `akka-osgi-aries` – Aries blueprint for provisioning actor systems
- * `akka-remote` – Remote Actors
- * `akka-slf4j` – SLF4J Logger (event bus listener)
- * `akka-stream` – Reactive stream processing
- * `akka-testkit` – Toolkit for testing Actor systems
 
-In addition to these stable modules there are several which are on their way
+### Native Packager
-into the stable core but are still marked @ref:[may change](../common/may-change.md) at this point. This
-does not mean that they do not function as intended, it primarily means that
-their API has not yet solidified enough in order to be considered frozen. You
-can help accelerating this process by giving feedback on these modules on our
-mailing list.
 
- * `akka-contrib` – an assortment of contributions which may or may not be
+[sbt-native-packager](https://github.com/sbt/sbt-native-packager) is a tool for creating
-moved into core modules, see <!-- FIXME: unresolved link reference: akka-contrib --> akka-contrib for more details.
+distributions of any type of application, including Akka applications.
 
-The filename of the actual JAR is for example `@jarName@` (and analog for
+Define sbt version in `project/build.properties` file:
-the other modules).
 
-How to see the JARs dependencies of each Akka module is described in the
+```none
-<!-- FIXME: More than one link target with name dependencies in path Some(/intro/getting-started.rst) --> dependencies section.
+sbt.version=0.13.13
+```
 
-## Using a release distribution
+Add [sbt-native-packager](https://github.com/sbt/sbt-native-packager) in `project/plugins.sbt` file:
 
-Download the release you need from [http://akka.io/downloads](http://akka.io/downloads) and unzip it.
+```none
+addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.1.5")
+```
+
+Follow the instructions for the `JavaAppPackaging` in the [sbt-native-packager plugin documentation](http://sbt-native-packager.readthedocs.io/en/latest/archetypes/java_app/index.html).
+
+### In a Docker container
+
+You can use both Akka remoting and Akka Cluster inside of Docker containers. But note
+that you will need to take special care with the network configuration when using Docker,
+described here: @ref:[Akka behind NAT or in a Docker container](../../scala/remoting.md#remote-configuration-nat)
+
+For an example of how to set up a project using Akka Cluster and Docker take a look at the
+["akka-docker-cluster" sample](https://github.com/muuki88/activator-akka-docker).
+
+## Commercial Support
+
+Akka is available from Lightbend Inc. under a commercial license which includes
+development or production support, read more [here](http://www.lightbend.com/how/subscription).
 
 ## Using a snapshot version
 
@@ -70,16 +79,6 @@ The use of Akka SNAPSHOTs, nightlies and milestone releases is discouraged unles
 
 Akka can be used with build tools that support Maven repositories.
 
-## Maven repositories
-
-For Akka version 2.1-M2 and onwards:
-
-[Maven Central](https://repo1.maven.org/maven2/)
-
-For previous Akka versions:
-
-[Akka Repo](http://repo.akka.io/releases/)
-
 ## Using Akka with Maven
 
 The simplest way to get started with Akka and Maven is to download the ready to run sample
@@ -230,10 +229,8 @@ Strange behavior has been reported by users that have tried it.
 ## Build from sources
 
 Akka uses Git and is hosted at [Github](https://github.com).
-
+ 
- * Akka: clone the Akka repository from [https://github.com/akka/akka](https://github.com/akka/akka)
+Continue reading the [CONTRIBUTING](https://github.com/akka/akka/blob/master/CONTRIBUTING.md)
-
-Continue reading the page on @ref:[Building Akka](../dev/building-akka.md)
 
 ## Need help?
 
@@ -241,4 +238,4 @@ If you have questions you can get help on the [Akka Mailing List](https://groups
 
 You can also ask for [commercial support](https://www.lightbend.com).
 
-Thanks for being a part of the Akka community.
+Thanks for being a part of the Akka community.

akka-docs/src/main/paradox/scala/common/other-modules.md

@@ -0,0 +1,11 @@
+# Other Akka modules
+
+* [Akka HTTP](http://doc.akka.io/docs/akka-http/current/scala.html)
+* [Alpakka](http://developer.lightbend.com/docs/alpakka/current/)
+* [Akka Streams Kafka](http://doc.akka.io/docs/akka-stream-kafka/current/home.html)
+* [Cassandra Plugins for Akka Persistence](https://github.com/akka/akka-persistence-cassandra)
+* [Akka Management](http://developer.lightbend.com/docs/akka-management/current/)
+
+## Community Projects
+
+Akka has a vibrant and passionate user community, the members of which have created many independent projects using Akka as well as extensions to it. See [Community Projects](http://akka.io/community/).

akka-docs/src/main/paradox/scala/general/index.md

@@ -1,4 +1,4 @@
-# General
+# General Concepts
 
 @@toc { depth=2 }
 

akka-docs/src/main/paradox/scala/guide/index.md

@@ -1,14 +1,14 @@
-# Akka Documentation
+# Getting Started Guide
 
 @@@ index
 
- * [What is Akka?](introduction.md)
+ * [introduction](introduction.md)
- * [What are Actors?](actors-intro.md)
+ * [actors-intro](actors-intro.md)
- * [Akka Libraries and Modules](modules.md)
+ * [modules](modules.md)
- * [Your First Akka Application - Hello World](quickstart.md)
+ * [quickstart](quickstart.md)
- * [Your Second Akka Application, Part 1: Top-level Architecture](tutorial_1.md)
+ * [part1](tutorial_1.md)
- * [Your Second Akka Application, Part 2: The Device Actor](tutorial_2.md)
+ * [part2](tutorial_2.md)
- * [Your Second Akka Application, Part 3: Device Groups](tutorial_3.md)
+ * [part3](tutorial_3.md)
- * [Your Second Akka Application, Part 4: Querying a Group of Devices](tutorial_4.md)
+ * [part4](tutorial_4.md)
 
 @@@

akka-docs/src/main/paradox/scala/guide/quickstart.md

@@ -1,4 +1,4 @@
-# Your First Akka Application - Hello World
+# Quickstart
 
 After all this introduction, we are ready to build our first actor system. We will do so in three chapters.
 This first chapter will help you to set up your project, tools and have a simple "Hello World" demo running.

akka-docs/src/main/paradox/scala/guide/tutorial_1.md

@@ -1,4 +1,4 @@
-# The Second Akka Application, Part 1: Top-level Architecture
+# Part 1: Top-level Architecture
 
 In this and the following chapters, we will build a sample Akka application to introduce you to the language of
 actors and how solutions can be formulated with them. It is a common hurdle for beginners to translate their project

akka-docs/src/main/paradox/scala/guide/tutorial_2.md

@@ -1,4 +1,4 @@
-# Your Second Akka Application, Part 2: The Device Actor
+# Part 2: The Device Actor
 
 In part 1 we explained how to view actor systems _in the large_, i.e. how components should be represented, how
 actors should be arranged in the hierarchy. In this part, we will look at actors _in the small_ by implementing an

akka-docs/src/main/paradox/scala/guide/tutorial_3.md

@@ -1,4 +1,4 @@
-# Your Second Akka Application, Part 3: Device Groups and Manager
+# Part 3: Device Groups and Manager
 
 In this chapter, we will integrate our device actors into a component that manages devices. When a new device comes
 online, there is no actor representing it. We need to be able to ask the device manager component to create a new

akka-docs/src/main/paradox/scala/guide/tutorial_4.md

@@ -1,4 +1,4 @@
-# Your Second Akka Application, Part 4: Querying a Group of Devices
+# Part 4: Querying a Group of Devices
 
 The conversational patterns we have seen so far were simple in the sense that they required no or little state to be kept in the
 actor that is only relevant to the conversation. Our device actors either simply returned a reading, which required no

akka-docs/src/main/paradox/scala/hello-world.md

@@ -1,21 +0,0 @@
-# The Obligatory Hello World
-
-The actor based version of the tough problem of printing a
-well-known greeting to the console is introduced in a ready to run [Akka Main sample](@exampleCodeService@/akka-samples-main-scala)
-together with a tutorial. The source code of this sample can be found in the
-[Akka Samples Repository](@samples@/akka-sample-main-scala).
-
-The tutorial illustrates the generic launcher class `akka.Main` which expects only
-one command line argument: the class name of the application’s main actor. This
-main method will then create the infrastructure needed for running the actors,
-start the given main actor and arrange for the whole application to shut down
-once the main actor terminates.
-
-There is also a [Gitter8](http://www.foundweekends.org/giter8/) template in the same problem domain
-that is named [Hello Akka!](https://github.com/akka/hello-akka.g8).
-It describes the basics of Akka in more depth. If you have *sbt* already installed, you can create a project
-from this template by running:
-
-```
-sbt new akka/hello-akka.g8
-```

akka-docs/src/main/paradox/scala/http/index.md

@@ -1,4 +0,0 @@
-# Akka HTTP Documentation (Scala) moved!
-
-Akka HTTP has been released as independent stable module (from Akka HTTP 10.x onwards).
-The documentation is available under [doc.akka.io/akka-http/current/](http://doc.akka.io/docs/akka-http/current/scala.html).

akka-docs/src/main/paradox/scala/index-utilities.md

@@ -10,6 +10,5 @@
 * [../scala/common/duration](../scala/common/duration.md)
 * [../scala/common/circuitbreaker](../scala/common/circuitbreaker.md)
 * [extending-akka](extending-akka.md)
-* [../scala/intro/deployment-scenarios](../scala/intro/deployment-scenarios.md)
 
 @@@

akka-docs/src/main/paradox/scala/intro/deployment-scenarios.md

@@ -1,38 +0,0 @@
-# Use-case and Deployment Scenarios
-
-## How can I use and deploy Akka?
-
-Akka can be used in 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 an application packaged with [sbt-native-packager](https://github.com/sbt/sbt-native-packager)
- * As an application packaged and deployed using [Lightbend ConductR](http://www.lightbend.com/products/conductr).
-
-## Native Packager
-
-[sbt-native-packager](https://github.com/sbt/sbt-native-packager) is a tool for creating
-distributions of any type of application, including Akka applications.
-
-Define sbt version in `project/build.properties` file:
-
-```none
-sbt.version=0.13.13
-```
-
-Add [sbt-native-packager](https://github.com/sbt/sbt-native-packager) in `project/plugins.sbt` file:
-
-```none
-addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.1.5")
-```
-
-Follow the instructions for the `JavaAppPackaging` in the [sbt-native-packager plugin documentation](http://sbt-native-packager.readthedocs.io/en/latest/archetypes/java_app/index.html).
-
-## In a Docker container
-
-You can use both Akka remoting and Akka Cluster inside of Docker containers. But note
-that you will need to take special care with the network configuration when using Docker,
-described here: @ref:[Akka behind NAT or in a Docker container](../../scala/remoting.md#remote-configuration-nat)
-
-For an example of how to set up a project using Akka Cluster and Docker take a look at the
-["akka-docker-cluster" sample](https://github.com/muuki88/activator-akka-docker).

akka-docs/src/main/paradox/scala/intro/index-java.md

@@ -1,14 +0,0 @@
-# Introduction
-
-@@toc { depth=2 }
-
-@@@ index
-
-* [what-is-akka](what-is-akka.md)
-* [why-akka](why-akka.md)
-* [getting-started](getting-started.md)
-* [../hello-world](../hello-world.md)
-* [deployment-scenarios](deployment-scenarios.md)
-* [use-cases](use-cases.md)
-
-@@@

akka-docs/src/main/paradox/scala/intro/index-scala.md

@@ -1,14 +0,0 @@
-# Introduction
-
-@@toc { depth=2 }
-
-@@@ index
-
-* [what-is-akka](what-is-akka.md)
-* [why-akka](why-akka.md)
-* [getting-started](getting-started.md)
-* [../hello-world](../hello-world.md)
-* [deployment-scenarios](deployment-scenarios.md)
-* [use-cases](use-cases.md)
-
-@@@

akka-docs/src/main/paradox/scala/intro/use-cases.md

@@ -1,62 +0,0 @@
-# Examples of use-cases for Akka
-
-We see Akka being adopted by many large organizations in a big range of industries
-all from investment and merchant banking, retail and social media, simulation,
-gaming and betting, automobile and traffic systems, health care, data analytics
-and much more. Any system that have the need for high-throughput and low latency
-is a good candidate for using Akka.
-
-There is a great discussion on use-cases for Akka with some good write-ups by production
-users [here](http://stackoverflow.com/questions/4493001/good-use-case-for-akka/4494512#4494512)
-
-## Here are some of the areas where Akka is being deployed into production
-
-### Transaction processing (Online Gaming, Finance/Banking, Trading, Statistics, Betting, Social Media, Telecom)
-
->
-Scale up, scale out, fault-tolerance / HA
-
-### Service backend (any industry, any app)
-
->
-Service REST, SOAP, Cometd, WebSockets etc
-Act as message hub / integration layer
-Scale up, scale out, fault-tolerance / HA
-
-### Concurrency/parallelism (any app)
-
->
-Correct
-Simple to work with and understand
-Just add the jars to your existing JVM project (use Scala, Java, Groovy or JRuby)
-
-### Simulation
-
->
-Master/Worker, Compute Grid, MapReduce etc.
-
-### Batch processing (any industry)
-
->
-Camel integration to hook up with batch data sources
-Actors divide and conquer the batch workloads
-
-### Communications Hub (Telecom, Web media, Mobile media)
-
->
-Scale up, scale out, fault-tolerance / HA
-
-### Gaming and Betting (MOM, online gaming, betting)
-
->
-Scale up, scale out, fault-tolerance / HA
-
-### Business Intelligence/Data Mining/general purpose crunching
-
->
-Scale up, scale out, fault-tolerance / HA
-
-### Complex Event Stream Processing
-
->
-Scale up, scale out, fault-tolerance / HA

akka-docs/src/main/paradox/scala/intro/what-is-akka.md

@@ -1,80 +0,0 @@
-# What is Akka?
-
-**«resilient elastic distributed real-time transaction processing»**
-
-We believe that writing correct distributed, 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 we raise the abstraction level and provide a better platform to
-build scalable, resilient and responsive applications—see the [Reactive
-Manifesto](http://reactivemanifesto.org/) for more details. For
-fault-tolerance we adopt the "let it crash" model which the telecom industry
-has used with great success to build applications that self-heal and systems
-that never stop. Actors also provide 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](http://akka.io/downloads).
-
-Please note that all code samples compile, so if you want direct access to the sources, have a look
-over at the Akka Docs subproject on github: for [Java](@github@/akka-docs/rst/java/code/docs) 
-and [Scala](@github@/akka-docs/rst/scala/code/docs).
-
-## Akka implements a unique hybrid
-
-### Actors
-
-Actors give you:
-
- * Simple and high-level abstractions for distribution, concurrency and parallelism.
- * Asynchronous, non-blocking and highly performant message-driven programming model.
- * Very lightweight event-driven processes (several million actors per GB of heap memory).
-
-See the chapter for @ref:[Scala](../../scala/actors.md) or @ref:[Java](../../java/actors.md).
-
-### Fault Tolerance
-
- * Supervisor hierarchies with "let-it-crash" semantics.
- * Actor systems can span over multiple JVMs to provide truly fault-tolerant systems.
- * Excellent for writing highly fault-tolerant systems that self-heal and never stop.
-
-See @ref:[Fault Tolerance (Scala)](../../scala/fault-tolerance.md) and @ref:[Fault Tolerance (Java)](../../java/fault-tolerance.md).
-
-### Location Transparency
-
-Everything in Akka is designed to work in a distributed environment: all
-interactions of actors use pure message passing and everything is asynchronous.
-
-For an overview of the cluster support see the @ref:[Java](../../java/cluster-usage.md)
-and @ref:[Scala](../../scala/cluster-usage.md) documentation chapters.
-
-### Persistence
-
-State changes experienced by an actor can optionally be persisted and replayed when the actor is started or
-restarted. This allows actors to recover their state, even after JVM crashes or when being migrated
-to another node.
-
-You can find more details in the respective chapter for @ref:[Java](../../java/persistence.md) or @ref:[Scala](../../scala/persistence.md).
-
-## Scala and Java APIs
-
-Akka has both a @ref:[Scala Documentation](../../scala.md) and a @ref:[Java Documentation](../../java.md).
-
-## Akka can be used in different ways
-
-Akka is a toolkit, not a framework: you integrate it into your build like any other library
-without having to follow a particular source code layout. When expressing your systems as collaborating
-Actors you may feel pushed more towards proper encapsulation of internal state, you may find that
-there is a natural separation between business logic and inter-component communication.
-
-Akka applications are typically deployed as follows:
-
- * as a library: used as a regular JAR on the classpath or in a web app.
- * packaged with [sbt-native-packager](https://github.com/sbt/sbt-native-packager).
- * packaged and deployed using [Lightbend ConductR](http://www.lightbend.com/products/conductr).
-
-## Commercial Support
-
-Akka is available from Lightbend Inc. under a commercial license which includes
-development or production support, read more [here](http://www.lightbend.com/how/subscription).

akka-docs/src/main/paradox/scala/intro/why-akka.md

@@ -1,49 +0,0 @@
-# Why Akka?
-
-## What features can the Akka platform offer, over the competition?
-
-Akka provides scalable real-time transaction processing.
-
-Akka is a unified runtime and programming model for:
-
- * Scale up (Concurrency)
- * Scale out (Remoting)
- * Fault tolerance
-
-One thing to learn and admin, with high cohesion and coherent semantics.
-
-Akka is a very scalable piece of software, not only in the context of performance
-but also in the size of applications it is useful for. The core of Akka, akka-actor,
-is very small and easily dropped into an existing project where you need
-asynchronicity and lockless concurrency without hassle.
-
-You can choose to include only the parts of Akka you need in your application.
-With CPUs growing more and more cores every cycle, Akka is the alternative that
-provides outstanding performance even if you're only running it on one machine.
-Akka also supplies a wide array of concurrency-paradigms, allowing users to choose
-the right tool for the job.
-
-## What's a good use-case for Akka?
-
-We see Akka being adopted by many large organizations in a big range of industries:
-
- * Investment and Merchant Banking
- * Retail
- * Social Media
- * Simulation
- * Gaming and Betting
- * Automobile and Traffic Systems
- * Health Care
- * Data Analytics
-
-and much more. Any system with the need for high-throughput and low latency
-is a good candidate for using Akka.
-
-Actors let you manage service failures (Supervisors), load management (back-off
-strategies, timeouts and processing-isolation), as well as both horizontal and
-vertical scalability (add more cores and/or add more machines).
-
-Here's what some of the Akka users have to say about how they are using Akka:
-[http://stackoverflow.com/questions/4493001/good-use-case-for-akka](http://stackoverflow.com/questions/4493001/good-use-case-for-akka)
-
-All this in the ApacheV2-licensed open source project.

akka-docs/src/main/paradox/scala/stream/stream-quickstart.md

@@ -3,7 +3,7 @@
 # Quick Start Guide
 
 Create a project and add the akka-streams dependency to the build tool of your
-choice as described in @ref:[Using a build tool](../../scala/intro/getting-started.md#build-tool).
+choice as described in @ref:[Using a build tool](../../scala/guide/quickstart.md).
 
 A stream usually begins at a source, so this is also how we start an Akka
 Stream. Before we create one, we import the full complement of streaming tools: