diff --git a/form/form_collections.rst b/form/form_collections.rst
index fa650cbfa82..3441db6e799 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -12,27 +12,27 @@ that Task, right inside the same form.
 .. note::
 
     In this article, it's loosely assumed that you're using Doctrine as your
-    database store. But if you're not using Doctrine (e.g. Propel or just
-    a database connection), it's all very similar. There are only a few parts
-    of this tutorial that really care about "persistence".
+    database store. But if you're not using Doctrine, it's all very similar.
+    There are only a few parts of this tutorial that really care about
+    persistence.
 
     If you *are* using Doctrine, you'll need to add the Doctrine metadata,
-    including the ``ManyToMany`` association mapping definition on the Task's
-    ``tags`` property.
+    including the ``ManyToMany`` association mapping definition on the
+    ``tags`` property of ``Task``.
 
 First, suppose that each ``Task`` belongs to multiple ``Tag`` objects. Start
 by creating a simple ``Task`` class::
 
-    // src/AppBundle/Entity/Task.php
-    namespace AppBundle\Entity;
+    // src/App/Entity/Task.php
+    namespace App\Entity;
 
     use Doctrine\Common\Collections\ArrayCollection;
 
     class Task
     {
-        protected $description;
+        private $description;
 
-        protected $tags;
+        private $tags;
 
         public function __construct()
         {
@@ -64,8 +64,8 @@ by creating a simple ``Task`` class::
 Now, create a ``Tag`` class. As you saw above, a ``Task`` can have many ``Tag``
 objects::
 
-    // src/AppBundle/Entity/Tag.php
-    namespace AppBundle\Entity;
+    // src/App/Entity/Tag.php
+    namespace App\Entity;
 
     class Tag
     {
@@ -84,10 +84,10 @@ objects::
 
 Then, create a form class so that a ``Tag`` object can be modified by the user::
 
-    // src/AppBundle/Form/Type/TagType.php
-    namespace AppBundle\Form\Type;
+    // src/App/Form/TagType.php
+    namespace App\Form;
 
-    use AppBundle\Entity\Tag;
+    use App\Entity\Tag;
     use Symfony\Component\Form\AbstractType;
     use Symfony\Component\Form\FormBuilderInterface;
     use Symfony\Component\OptionsResolver\OptionsResolver;
@@ -114,14 +114,15 @@ form itself, create a form for the ``Task`` class.
 Notice that you embed a collection of ``TagType`` forms using the
 :doc:`CollectionType </reference/forms/types/collection>` field::
 
-    // src/AppBundle/Form/Type/TaskType.php
-    namespace AppBundle\Form\Type;
+    // src/App/Form/TaskType.php
+    namespace App\Form;
 
-    use AppBundle\Entity\Task;
+    use App\Entity\Task;
     use Symfony\Component\Form\AbstractType;
     use Symfony\Component\Form\FormBuilderInterface;
     use Symfony\Component\OptionsResolver\OptionsResolver;
     use Symfony\Component\Form\Extension\Core\Type\CollectionType;
+    use Symfony\Component\Form\Extension\Core\Type\SubmitType;
 
     class TaskType extends AbstractType
     {
@@ -133,6 +134,7 @@ Notice that you embed a collection of ``TagType`` forms using the
                 'entry_type' => TagType::class,
                 'entry_options' => array('label' => false),
             ));
+            $builder->add('submit', SubmitType::class);
         }
 
         public function configureOptions(OptionsResolver $resolver)
@@ -145,18 +147,23 @@ Notice that you embed a collection of ``TagType`` forms using the
 
 In your controller, you'll create a new form from the ``TaskType``::
 
-    // src/AppBundle/Controller/TaskController.php
-    namespace AppBundle\Controller;
+    // src/App/Controller/TaskController.php
+    namespace App\Controller;
 
-    use AppBundle\Entity\Task;
-    use AppBundle\Entity\Tag;
-    use AppBundle\Form\Type\TaskType;
     use Symfony\Component\HttpFoundation\Request;
-    use Symfony\Bundle\FrameworkBundle\Controller\Controller;
-
-    class TaskController extends Controller
+    use Symfony\Component\Routing\Annotation\Route;
+    use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+    use Doctrine\ORM\EntityManagerInterface;
+    use App\Entity\Task;
+    use App\Entity\Tag;
+    use App\Form\TaskType;
+
+    class TaskController extends AbstractController
     {
-        public function newAction(Request $request)
+        /**
+         * @Route("/task/new")
+         */
+        public function new(Request $request, EntityManagerInterface $em)
         {
             $task = new Task();
 
@@ -175,7 +182,9 @@ In your controller, you'll create a new form from the ``TaskType``::
             $form->handleRequest($request);
 
             if ($form->isSubmitted() && $form->isValid()) {
-                // ... maybe do some form processing, like saving the Task and Tag objects
+                // ... maybe do some form processing, like saving the Task and Tag objects:
+                $em->persist($task);
+                $em->flush();
             }
 
             return $this->render('task/new.html.twig', array(
@@ -186,16 +195,17 @@ In your controller, you'll create a new form from the ``TaskType``::
 
 The corresponding template is now able to render both the ``description``
 field for the task form as well as all the ``TagType`` forms for any tags
-that are already related to this ``Task``. In the above controller, I added
-some dummy code so that you can see this in action (since a ``Task`` has
-zero tags when first created).
+that are already related to this ``Task``. The above controller has some
+dummy code so that you can see this in action (since a newly created ``Task``
+has zero tags).
 
 .. code-block:: html+twig
 
-    {# app/Resources/views/task/new.html.twig #}
+    {# templates/task/new.html.twig #}
 
     {# ... #}
-
+    
+    <h2>New Task</h2>
     {{ form_start(form) }}
         {# render the task's only field: description #}
         {{ form_row(form.description) }}
@@ -211,7 +221,7 @@ zero tags when first created).
 
     {# ... #}
 
-When the user submits the form, the submitted data for the ``tags`` field are
+When the user submits the form, the submitted data for the ``tags`` field is
 used to construct an ``ArrayCollection`` of ``Tag`` objects, which is then set
 on the ``tag`` field of the ``Task`` instance.
 
@@ -220,12 +230,12 @@ and can be persisted to the database or used however you need.
 
 So far, this works great, but this doesn't allow you to dynamically add new
 tags or delete existing tags. So, while editing existing tags will work
-great, your user can't actually add any new tags yet.
+great, your users can't actually add any new tags yet.
 
 .. caution::
 
     In this article, you embed only one collection, but you are not limited
-    to this. You can also embed nested collection as many levels down as you
+    to this. You can also embed nested collections as many levels down as you
     like. But if you use Xdebug in your development setup, you may receive
     a ``Maximum function nesting level of '100' reached, aborting!`` error.
     This is due to the ``xdebug.max_nesting_level`` PHP setting, which defaults
@@ -245,47 +255,47 @@ Allowing "new" Tags with the "Prototype"
 
 Allowing the user to dynamically add new tags means that you'll need to
 use some JavaScript. Previously you added two tags to your form in the controller.
-Now let the user add as many tag forms as they need directly in the browser.
-This will be done through a bit of JavaScript.
+Now let the users add as many tag forms as they need directly in the browser.
 
 The first thing you need to do is to let the form collection know that it will
 receive an unknown number of tags. So far you've added two tags and the form
-type expects to receive exactly two, otherwise an error will be thrown:
-``This form should not contain extra fields``. To make this flexible,
+type expects to receive exactly two. If it gets more, the following error will be
+thrown: ``This form should not contain extra fields``. To make the number flexible,
 add the ``allow_add`` option to your collection field::
 
-    // src/AppBundle/Form/Type/TaskType.php
+    // src/App/Form/TaskType.php
 
     // ...
-    use Symfony\Component\Form\FormBuilderInterface;
-
     public function buildForm(FormBuilderInterface $builder, array $options)
     {
-        $builder->add('description');
-
+        // ...
         $builder->add('tags', CollectionType::class, array(
-            'entry_type' => TagType::class,
-            'entry_options' => array('label' => false),
+            // ...
             'allow_add' => true,
         ));
     }
 
-In addition to telling the field to accept any number of submitted objects, the
-``allow_add`` also makes a *"prototype"* variable available to you. This "prototype"
-is a little "template" that contains all the HTML to be able to render any
-new "tag" forms. To render it, make the following change to your template:
+In addition to telling the field to accept any number of submitted objects,
+``allow_add`` also makes a ``prototype`` variable available to you. This
+"prototype" is a little "template" that contains all the HTML needed to dynamically
+render any new "tag" forms with JavaScript. To render the prototype, add the following
+``data-prototype`` attribute to the existing ``<ul>`` in your template:
 
 .. code-block:: html+twig
 
     <ul class="tags" data-prototype="{{ form_widget(form.tags.vars.prototype)|e('html_attr') }}">
-        ...
-    </ul>
 
-.. note::
+On the rendered page, the result will look something like this:
 
-    If you render your whole "tags" sub-form at once (e.g. ``form_row(form.tags)``),
-    then the prototype is automatically available on the outer ``div`` as
-    the ``data-prototype`` attribute, similar to what you see above.
+.. code-block:: html
+
+    <ul class="tags" data-prototype="&lt;div&gt;&lt;label class=&quot; required&quot;&gt;__name__&lt;/label&gt;&lt;div id=&quot;task_tags___name__&quot;&gt;&lt;div&gt;&lt;label for=&quot;task_tags___name___name&quot; class=&quot; required&quot;&gt;Name&lt;/label&gt;&lt;input type=&quot;text&quot; id=&quot;task_tags___name___name&quot; name=&quot;task[tags][__name__][name]&quot; required=&quot;required&quot; maxlength=&quot;255&quot; /&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;">
+
+
+.. seealso::
+
+    If you want to customize the HTML code in the prototype, see
+    :ref:`form-custom-prototype`.
 
 .. tip::
 
@@ -299,113 +309,89 @@ new "tag" forms. To render it, make the following change to your template:
 
         {{ form_widget(form.tags.vars.prototype.name)|e }}
 
-On the rendered page, the result will look something like this:
-
-.. code-block:: html
+.. note::
 
-    <ul class="tags" data-prototype="&lt;div&gt;&lt;label class=&quot; required&quot;&gt;__name__&lt;/label&gt;&lt;div id=&quot;task_tags___name__&quot;&gt;&lt;div&gt;&lt;label for=&quot;task_tags___name___name&quot; class=&quot; required&quot;&gt;Name&lt;/label&gt;&lt;input type=&quot;text&quot; id=&quot;task_tags___name___name&quot; name=&quot;task[tags][__name__][name]&quot; required=&quot;required&quot; maxlength=&quot;255&quot; /&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;">
+    You can also render the entire "tags" sub-form at once (e.g. ``form_row(form.tags)``).
+    In this case the ``data-prototype`` attribute is automatically added to the containing ``div``,
+    and you need to adjust the following JavaScript accordingly.
 
-The goal of this section will be to use JavaScript to read this attribute
-and dynamically add new tag forms when the user clicks a "Add a tag" link.
-To make things simple, this example uses jQuery and assumes you have it included
-somewhere on your page.
+Now we need some JavaScript to read this attribute and dynamically add new tag forms
+when the user clicks an "Add a tag" link. To make things simple, this example uses `jQuery`_.
 
-Add a ``script`` tag somewhere on your page so you can start writing some JavaScript.
+First, add the link somewhere in your template:
 
-First, add a link to the bottom of the "tags" list via JavaScript. Second,
-bind to the "click" event of that link so you can add a new tag form (``addTagForm()``
-will be show next):
+.. code-block:: html+twig
 
-.. code-block:: javascript
+    {# templates/task/new.html.twig #}
+    
+    {# ... #}
+    
+    {{ form_start(form) }}
+    
+        {# ... #}
 
-    var $collectionHolder;
+        <a href="#" class="add_tag_link">Add a tag</a>
+        
+    {{ form_end(form) }}
 
-    // setup an "add a tag" link
-    var $addTagButton = $('<button type="button" class="add_tag_link">Add a tag</button>');
-    var $newLinkLi = $('<li></li>').append($addTagButton);
+    {# ... #}
 
-    jQuery(document).ready(function() {
-        // Get the ul that holds the collection of tags
-        $collectionHolder = $('ul.tags');
+Now add the required functionality with JavaScript:
 
-        // add the "add a tag" anchor and li to the tags ul
-        $collectionHolder.append($newLinkLi);
+.. code-block:: javascript
 
-        // count the current form inputs we have (e.g. 2), use that as the new
-        // index when inserting a new item (e.g. 2)
-        $collectionHolder.data('index', $collectionHolder.find(':input').length);
+    // JavaScript
 
-        $addTagButton.on('click', function(e) {
-            // add a new tag form (see next code block)
-            addTagForm($collectionHolder, $newLinkLi);
+    $(document).ready(function() {
+        $('.add_tag_link').click(function(e) {
+            e.preventDefault();
+            addTagForm();
         });
     });
+    
+    function addTagForm() {
+        var collectionHolder = 'ul.tags';
+        // Set up a new `li` with the contents of the prototype:
+        var newForm = '<li>' + $(collectionHolder).data('prototype') + '</li>';
 
-The ``addTagForm()`` function's job will be to use the ``data-prototype`` attribute
-to dynamically add a new form when this link is clicked. The ``data-prototype``
-HTML contains the tag ``text`` input element with a name of ``task[tags][__name__][name]``
-and id of ``task_tags___name___name``. The ``__name__`` is a little "placeholder",
-which you'll replace with a unique, incrementing number (e.g. ``task[tags][3][name]``).
-
-The actual code needed to make this all work can vary quite a bit, but here's
-one example:
-
-.. code-block:: javascript
-
-    function addTagForm($collectionHolder, $newLinkLi) {
-        // Get the data-prototype explained earlier
-        var prototype = $collectionHolder.data('prototype');
+        // Get the index of the new `li`:
+        var index = $(collectionHolder + ' li').length;
 
-        // get the new index
-        var index = $collectionHolder.data('index');
+        // Replace `__name__` in the prototype's HTML with the current index:
+        newForm = newForm.replace(/__name__/g, index);
 
-        var newForm = prototype;
         // You need this only if you didn't set 'label' => false in your tags field in TaskType
         // Replace '__name__label__' in the prototype's HTML to
         // instead be a number based on how many items we have
         // newForm = newForm.replace(/__name__label__/g, index);
-
-        // Replace '__name__' in the prototype's HTML to
-        // instead be a number based on how many items we have
-        newForm = newForm.replace(/__name__/g, index);
-
-        // increase the index with one for the next item
-        $collectionHolder.data('index', index + 1);
-
-        // Display the form in the page in an li, before the "Add a tag" link li
-        var $newFormLi = $('<li></li>').append(newForm);
-        $newLinkLi.before($newFormLi);
+        
+        // Convert the HTML string to a jQuery object. This is needed later, when we add a "delete this tag" link:
+        var $newForm = $(newForm);
+        $(collectionHolder).append($newForm);        
     }
 
-.. note::
-
-    It is better to separate your JavaScript in real JavaScript files than
-    to write it inside the HTML as is done here.
-
-Now, each time a user clicks the ``Add a tag`` link, a new sub form will
-appear on the page. When the form is submitted, any new tag forms will be converted
-into new ``Tag`` objects and added to the ``tags`` property of the ``Task`` object.
+The ``data-prototype`` HTML contains the tag ``text`` input element with a name of
+``task[tags][__name__][name]`` and id of ``task_tags___name___name``. The ``__name__``
+is a little "placeholder", which is replaced with a unique, incrementing number
+(e.g. ``task[tags][3][name]``).
 
 .. seealso::
 
     You can find a working example in this `JSFiddle`_.
 
-.. seealso::
-
-    If you want to customize the HTML code in the prototype, read
-    :ref:`form-custom-prototype`.
+Now, each time a user clicks the ``Add a tag`` link, a new sub form will
+appear on the page. When the form is submitted, any new tag forms will be converted
+into new ``Tag`` objects and added to the ``tags`` property of the ``Task`` object.
 
 To make handling these new tags easier, add an "adder" and a "remover" method
 for the tags in the ``Task`` class::
 
-    // src/AppBundle/Entity/Task.php
-    namespace AppBundle\Entity;
+    // src/App/Entity/Task.php
 
     // ...
     class Task
     {
         // ...
-
         public function addTag(Tag $tag)
         {
             $this->tags->add($tag);
@@ -413,19 +399,18 @@ for the tags in the ``Task`` class::
 
         public function removeTag(Tag $tag)
         {
-            // ...
+            // empty for now
         }
     }
 
 Next, add a ``by_reference`` option to the ``tags`` field and set it to ``false``::
 
-    // src/AppBundle/Form/Type/TaskType.php
+    // src/App/Form/TaskType.php
 
     // ...
     public function buildForm(FormBuilderInterface $builder, array $options)
     {
         // ...
-
         $builder->add('tags', CollectionType::class, array(
             // ...
             'by_reference' => false,
@@ -447,24 +432,23 @@ you will learn about next!).
 
 .. sidebar:: Doctrine: Cascading Relations and saving the "Inverse" side
 
-    To save the new tags with Doctrine, you need to consider a couple more
-    things. First, unless you iterate over all of the new ``Tag`` objects and
-    call ``$entityManager->persist($tag)`` on each, you'll receive an error from
-    Doctrine:
+    To save the new tags with Doctrine, you need to consider two more things. First,
+    unless you iterate over all of the new ``Tag`` objects and call
+    ``$entityManager->persist($tag)`` on each, you'll receive this error from Doctrine:
 
         A new entity was found through the relationship
-        ``AppBundle\Entity\Task#tags`` that was not configured to
+        ``App\Entity\Task#tags`` that was not configured to
         cascade persist operations for entity...
 
     To fix this, you may choose to "cascade" the persist operation automatically
     from the ``Task`` object to any related tags. To do this, add the ``cascade``
-    option to your ``ManyToMany`` metadata:
+    option to your mapping:
 
     .. configuration-block::
 
         .. code-block:: php-annotations
 
-            // src/AppBundle/Entity/Task.php
+            // src/App/Entity/Task.php
 
             // ...
 
@@ -475,8 +459,8 @@ you will learn about next!).
 
         .. code-block:: yaml
 
-            # src/AppBundle/Resources/config/doctrine/Task.orm.yml
-            AppBundle\Entity\Task:
+            # src/App/Resources/config/doctrine/Task.orm.yml
+            App\Entity\Task:
                 type: entity
                 # ...
                 oneToMany:
@@ -486,14 +470,14 @@ you will learn about next!).
 
         .. code-block:: xml
 
-            <!-- src/AppBundle/Resources/config/doctrine/Task.orm.xml -->
+            <!-- src/App/Resources/config/doctrine/Task.orm.xml -->
             <?xml version="1.0" encoding="UTF-8" ?>
             <doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping
                                 http://doctrine-project.org/schemas/orm/doctrine-mapping.xsd">
 
-                <entity name="AppBundle\Entity\Task">
+                <entity name="App\Entity\Task">
                     <!-- ... -->
                     <one-to-many field="tags" target-entity="Tag">
                         <cascade>
@@ -503,19 +487,18 @@ you will learn about next!).
                 </entity>
             </doctrine-mapping>
 
-    A second potential issue deals with the `Owning Side and Inverse Side`_
-    of Doctrine relationships. In this example, if the "owning" side of the
-    relationship is "Task", then persistence will work fine as the tags are
-    properly added to the Task. However, if the owning side is on "Tag", then
-    you'll need to do a little bit more work to ensure that the correct side
-    of the relationship is modified.
-
-    The trick is to make sure that the single "Task" is set on each "Tag".
-    One easy way to do this is to add some extra logic to ``addTag()``,
-    which is called by the form type since ``by_reference`` is set to
-    ``false``::
+    The second potential issue deals with the `Owning Side and Inverse Side`_
+    of Doctrine relationships. In the many-to-many association of this example,
+    if the "owning" side of the relationship is ``Task``, then persistence will
+    work fine as the tags are properly added to the task.
+    
+    However, if you have a **one-to-many** association, the owning side is always the
+    "many" side (``Tag`` in our example). In this case you have to make sure that
+    the ``Task`` is set on each ``Tag``. This can be done by adding a single line
+    to the "adder" we created above, which is called by the form type since
+    ``by_reference`` is set to ``false``::
 
-        // src/AppBundle/Entity/Task.php
+        // src/App/Entity/Task.php
 
         public function addTag(Tag $tag)
         {
@@ -525,15 +508,14 @@ you will learn about next!).
             // for a many-to-one association:
             $tag->setTask($this);
 
-            $this->tags->add($tag);
+            // ...
         }
 
-    If you're going for ``addTask()``, just make sure you have an appropriate method
-    that looks something like this::
+    In case of the many-to-many association, just make sure you have an appropriate
+    method inside ``Tag`` that looks something like this::
 
-        // src/AppBundle/Entity/Tag.php
+        // src/App/Entity/Tag.php
 
-        // ...
         public function addTask(Task $task)
         {
             if (!$this->tasks->contains($task)) {
@@ -543,21 +525,19 @@ you will learn about next!).
 
 .. _form-collections-remove:
 
-Allowing Tags to be Removed
+Allowing Tags to Be Removed
 ---------------------------
 
 The next step is to allow the deletion of a particular item in the collection.
-The solution is similar to allowing tags to be added.
 
 Start by adding the ``allow_delete`` option in the form Type::
 
-    // src/AppBundle/Form/Type/TaskType.php
+    // src/App/Form/TaskType.php
 
     // ...
     public function buildForm(FormBuilderInterface $builder, array $options)
     {
         // ...
-
         $builder->add('tags', CollectionType::class, array(
             // ...
             'allow_delete' => true,
@@ -566,66 +546,63 @@ Start by adding the ``allow_delete`` option in the form Type::
 
 Now, you need to put some code into the ``removeTag()`` method of ``Task``::
 
-    // src/AppBundle/Entity/Task.php
+    // src/App/Entity/Task.php
 
     // ...
     class Task
     {
         // ...
-
         public function removeTag(Tag $tag)
         {
             $this->tags->removeElement($tag);
         }
     }
 
-Template Modifications
-~~~~~~~~~~~~~~~~~~~~~~
-
 The ``allow_delete`` option means that if an item of a collection
 isn't sent on submission, the related data is removed from the collection
 on the server. In order for this to work in an HTML form, you must remove
 the DOM element for the collection item to be removed, before submitting
 the form.
 
-First, add a "delete this tag" link to each tag form:
+First, prepare a JavaScript function that adds a "delete this tag" link:
 
 .. code-block:: javascript
 
-    jQuery(document).ready(function() {
-        // Get the ul that holds the collection of tags
-        $collectionHolder = $('ul.tags');
+    function addDeleteLink($tagFormLi) {
+        var $removeFormButton = $('<a href="#">Delete this tag</a>');
+        $tagFormLi.append($removeFormButton);
 
-        // add a delete link to all of the existing tag form li elements
-        $collectionHolder.find('li').each(function() {
-            addTagFormDeleteLink($(this));
+        $removeFormButton.click(function(e) {
+            e.preventDefault();
+            $tagFormLi.remove();
         });
+    }
 
-        // ... the rest of the block from above
-    });
+Now call this function in ``addTagForm()`` function from above:
+
+.. code-block:: javascript
 
     function addTagForm() {
         // ...
-
-        // add a delete link to the new form
-        addTagFormDeleteLink($newFormLi);
+        addDeleteLink($newForm);
     }
 
-The ``addTagFormDeleteLink()`` function will look something like this:
+This adds the "delete" link to all tag forms that were created by JavaScript
+(i.e. after the user clicked the "add new tag" link from above). But what
+about any tags that already existed on the server? You could easily add the
+"delete" link inside the ``for`` loop of your Twig template, but you'd have
+to adjust the JavaScript a little. Or you can just create them with JavaScript
+too:
 
 .. code-block:: javascript
 
-    function addTagFormDeleteLink($tagFormLi) {
-        var $removeFormButton = $('<button type="button">Delete this tag</button>');
-        $tagFormLi.append($removeFormButton);
-
-        $removeFormButton.on('click', function(e) {
-            // remove the li for the tag form
-            $tagFormLi.remove();
+    $(document).ready(function() {
+        $('ul.tags').find('li').each(function() {
+            addDeleteLink($(this));
         });
-    }
+    });
 
-When a tag form is removed from the DOM and submitted, the removed ``Tag`` object
+When a tag form is removed from the DOM on submission, the removed ``Tag`` object
 will not be included in the collection passed to ``setTags()``. Depending on
 your persistence layer, this may or may not be enough to actually remove
 the relationship between the removed ``Tag`` and ``Task`` object.
@@ -649,9 +626,9 @@ the relationship between the removed ``Tag`` and ``Task`` object.
     on the removed tag. This assumes that you have some ``editAction()`` which
     is handling the "update" of your Task::
 
-        // src/AppBundle/Controller/TaskController.php
+        // src/App/Controller/TaskController.php
 
-        use AppBundle\Entity\Task;
+        use App\Entity\Task;
         use Doctrine\Common\Collections\ArrayCollection;
 
         // ...
@@ -716,6 +693,7 @@ the relationship between the removed ``Tag`` and ``Task`` object.
     elements of the collection. More advanced functionality like moving or duplicating
     an element in the collection and customizing the buttons is also possible.
 
-.. _`Owning Side and Inverse Side`: http://docs.doctrine-project.org/en/latest/reference/unitofwork-associations.html
+.. _`Owning Side and Inverse Side`: https://www.doctrine-project.org/projects/doctrine-orm/en/current/reference/unitofwork-associations.html
+.. _`jQuery`: http://jquery.com/
 .. _`JSFiddle`: http://jsfiddle.net/847Kf/4/
 .. _`symfony-collection`: https://github.com/ninsuo/symfony-collection