DOC: Strange link names, see #3259

akka-docs/rst/general/actors.rst

@@ -7,7 +7,8 @@ The previous section about :ref:`actor-systems` explained how actors form
 hierarchies and are the smallest unit when building an application. This
 section looks at one such actor in isolation, explaining the concepts you
 encounter while implementing it. For a more in depth reference with all the
-details please refer to :ref:`actors-scala` and :ref:`untyped-actors-java`.
+details please refer to
+:ref:`Actors (Scala) <actors-scala>` and :ref:`Untyped Actors (Java) <untyped-actors-java>`.
 
 An actor is a container for `State`_, `Behavior`_, a `Mailbox`_, `Children`_
 and a `Supervisor Strategy`_. All of this is encapsulated behind an `Actor

akka-docs/rst/general/configuration.rst

@@ -182,7 +182,7 @@ and parsed by the actor system can be displayed like this:
 .. code-block:: java
 
   final ActorSystem system = ActorSystem.create();
-  println(system.settings());
+  System.out.println(system.settings());
   // this is a shortcut for system.settings().config().root().render()
 
 A Word About ClassLoaders

akka-docs/rst/intro/deployment-scenarios.rst

@@ -13,7 +13,7 @@ Akka can be used in different ways:
   be put into ``WEB-INF/lib``
 
 - As a stand alone application by instantiating ActorSystem in a main class or
-  using the :ref:`microkernel-scala` / :ref:`microkernel-java`
+  using the :ref:`Microkernel (Scala) <microkernel-scala>` / :ref:`Microkernel (Java) <microkernel-java>`
 
 
 Using Akka as library
@@ -28,5 +28,5 @@ Using Akka as a stand alone microkernel
 ----------------------------------------
 
 Akka can also be run as a stand-alone microkernel. See
-:ref:`microkernel-scala` / :ref:`microkernel-java` for
+:ref:`Microkernel (Scala) <microkernel-scala>` / :ref:`Microkernel (Java) <microkernel-java>` for
 more information.

akka-docs/rst/intro/getting-started.rst

@@ -107,7 +107,7 @@ application jar in the ``deploy`` directory and use the scripts in the ``bin``
 directory.
 
 More information is available in the documentation of the
-:ref:`microkernel-scala` / :ref:`microkernel-java`.
+:ref:`Microkernel (Scala) <microkernel-scala>` / :ref:`Microkernel (Java) <microkernel-java>`.
 
 .. _build-tool:
 

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

@@ -36,7 +36,7 @@ Actors give you:
   - Asynchronous, non-blocking and highly performant event-driven programming model.
   - Very lightweight event-driven processes (approximately 2.7 million actors per GB RAM).
 
-See :ref:`actors-scala` and :ref:`untyped-actors-java`
+See :ref:`Actors (Scala) <actors-scala>` and :ref:`Untyped Actors (Java) <untyped-actors-java>`
 
 Fault Tolerance
 ---------------
@@ -45,7 +45,7 @@ Fault Tolerance
   - Supervisor hierarchies 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` and :ref:`fault-tolerance-java`
+See :ref:`Fault Tolerance (Scala) <fault-tolerance-scala>` and :ref:`Fault Tolerance (Java) <fault-tolerance-java>`
 
 Location Transparency
 ---------------------
@@ -60,7 +60,7 @@ Transactors
 Transactors combine actors and Software Transactional Memory (STM) into transactional actors.
 It allows you to compose atomic message flows with automatic retry and rollback.
 
-See :ref:`transactors-scala` and :ref:`transactors-java`
+See :ref:`Transactors (Scala) <transactors-scala>` and :ref:`Transactors (Java) <transactors-java>`
 
 
 Scala and Java APIs