Removed "A Symfony Request in Action"

The user doesn't know anything about routing, controllers, etc. yet. This
article focuses on the main picture, the next articles should focus on the
routing and controller topics.

Author: wouterj

http_fundamentals.rst

@@ -368,157 +368,6 @@ It's that easy! To review:
 
 * The HTTP headers and content of the ``Response`` object are sent back to the client.
 
-A Symfony Request in Action
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Without diving into too much detail, here is this process in action. Suppose
-you want to add a ``/contact`` page to your Symfony application. First, start
-by adding an entry for ``/contact`` to your routing configuration file:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/routing.yml
-        contact:
-            path:     /contact
-            defaults: { _controller: AppBundle:Main:contact }
-
-    .. code-block:: xml
-
-        <!-- app/config/routing.xml -->
-        <?xml version="1.0" encoding="UTF-8" ?>
-        <routes xmlns="http://symfony.com/schema/routing"
-            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-            xsi:schemaLocation="http://symfony.com/schema/routing
-                http://symfony.com/schema/routing/routing-1.0.xsd">
-
-            <route id="contact" path="/contact">
-                <default key="_controller">AppBundle:Main:contact</default>
-            </route>
-        </routes>
-
-    .. code-block:: php
-
-        // app/config/routing.php
-        use Symfony\Component\Routing\Route;
-        use Symfony\Component\Routing\RouteCollection;
-
-        $collection = new RouteCollection();
-        $collection->add('contact', new Route('/contact', array(
-            '_controller' => 'AppBundle:Main:contact',
-        )));
-
-        return $collection;
-
-When someone visits the ``/contact`` page, this route is matched, and the
-specified controller is executed. As you'll learn in the
-:ref:`routing chapter <controller-string-syntax>`, the ``AppBundle:Main:contact``
-string is a short syntax that points to a specific controller - ``contactAction()`` -
-inside a controller class called - ``MainController``::
-
-    // src/AppBundle/Controller/MainController.php
-    namespace AppBundle\Controller;
-
-    use Symfony\Component\HttpFoundation\Response;
-
-    class MainController
-    {
-        public function contactAction()
-        {
-            return new Response('<h1>Contact us!</h1>');
-        }
-    }
-
-In this example, the controller creates a
-:class:`Symfony\\Component\\HttpFoundation\\Response` object with the HTML
-``<h1>Contact us!</h1>``. In the :doc:`Controller chapter </book/controller>`,
-you'll learn how a controller can render templates, allowing your "presentation"
-code (i.e. anything that actually writes out HTML) to live in a separate
-template file. This frees up the controller to worry only about the hard
-stuff: interacting with the database, handling submitted data, or sending
-email messages.
-
-.. _symfony2-build-your-app-not-your-tools:
-
-Symfony: Build your App, not your Tools
----------------------------------------
-
-You now know that the goal of any app is to interpret each incoming request
-and create an appropriate response. As an application grows, it becomes more
-difficult to keep your code organized and maintainable. Invariably, the same
-complex tasks keep coming up over and over again: persisting things to the
-database, rendering and reusing templates, handling form submissions, sending
-emails, validating user input and handling security.
-
-The good news is that none of these problems is unique. Symfony provides
-a framework full of tools that allow you to build your application, not your
-tools. With Symfony, nothing is imposed on you: you're free to use the full
-Symfony Framework, or just one piece of Symfony all by itself.
-
-.. index::
-    single: Symfony Components
-
-.. _standalone-tools-the-symfony2-components:
-
-Standalone Tools: The Symfony *Components*
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-So what *is* Symfony? First, Symfony is a collection of over twenty independent
-libraries that can be used inside *any* PHP project. These libraries, called
-the *Symfony Components*, contain something useful for almost any situation,
-regardless of how your project is developed. To name a few:
-
-:doc:`HttpFoundation </components/http_foundation/introduction>`
-    Contains the ``Request`` and ``Response`` classes, as well as other classes for
-    handling sessions and file uploads.
-
-:doc:`Routing </components/routing/introduction>`
-    Powerful and fast routing system that allows you to map a specific URI
-    (e.g. ``/contact``) to information about how that request should be handled (e.g.
-    that the ``contactAction()`` controller method should be executed).
-
-:doc:`Form </components/form/introduction>`
-    A full-featured and flexible framework for creating forms and handling form
-    submissions.
-
-`Validator`_
-    A system for creating rules about data and then validating whether or not
-    user-submitted data follows those rules.
-
-:doc:`Templating </components/templating/introduction>`
-    A toolkit for rendering templates, handling template inheritance (i.e. a
-    template is decorated with a layout) and performing other common template tasks.
-
-:doc:`Security </components/security/introduction>`
-    A powerful library for handling all types of security inside an application.
-
-:doc:`Translation </components/translation/introduction>`
-    A framework for translating strings in your application.
-
-Each one of these components is decoupled and can be used in *any* PHP project,
-regardless of whether or not you use the Symfony Framework. Every part is
-made to be used if needed and replaced when necessary.
-
-.. _the-full-solution-the-symfony2-framework:
-
-The Full Solution: The Symfony *Framework*
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-So then, what *is* the Symfony *Framework*? The *Symfony Framework* is
-a PHP library that accomplishes two distinct tasks:
-
-#. Provides a selection of components (i.e. the Symfony Components) and
-   third-party libraries (e.g. `Swift Mailer`_ for sending emails);
-
-#. Provides sensible configuration and a "glue" library that ties all of these
-   pieces together.
-
-The goal of the framework is to integrate many independent tools in order
-to provide a consistent experience for the developer. Even the framework
-itself is a Symfony bundle (i.e. a plugin) that can be configured or replaced
-entirely.
-
 Symfony provides a powerful set of tools for rapidly developing web applications
 without imposing on your application. Normal users can quickly start development
 by using a Symfony distribution, which provides a project skeleton with