anchor.diff:  ## <a id='find-manifest'></a>How cf push Finds the Manifest ##
   
   
  -The `cf push` command looks for the `manifest.yml` file in the current working directory unless you give `cf` a non-standard manifest location and/or filename with the ``-f`` option.
  -
  -A plain `cf push` command find the manifest when it is named manifest.yml and located in the current working directory.
  +The `cf push` command looks for the `manifest.yml` file in the current working directory unless you use the ``-f`` option to provide a non-standard manifest location and/or filename.
  +
  +A plain `cf push` command finds the manifest when it is named manifest.yml and located in the current working directory.
   
   ~~~
   $ cf push
  
positive.code: With the `-f` option, a path with no filename means that the filename must be `manifest.yml`.
  
  ~~~
  cf push -f ./some_directory/some_other_directory/
  ~~~
  
  Finally, with the `-f` option, supply the path _and_ the filename if the manifest is named something other than  `manifest.yml`.
  
  ~~~
  cf push -f ./some_directory/some_other_directory/alternative_manifest.yml
  ~~~
  
  ## <a id='minimal-manifest'></a>A Minimal Manifest ##
  
  You can deploy some (but not all) applications without ever using a manifest. On the other hand, creating the manifest before you deploy offers greater consistency and reproducibility than other methods.
  
  Manifests are written in YAML. The illustration below shows a typical manifest for a minimal application.
  
  
negative.code: memory: 1G
  instances: 1
  services:
    clockwork-mysql
  applications:
  - name: springtock
    host: tock09876
    path: ./spring-music/build/libs/spring-music.war
  - name: springtick
    subdomain: tick09875
    path: ./spring-music/build/libs/spring-music.war
  ~~~
  
  In the next section we carry this principle further by distributing content across multiple manifests.
  
  ## <a id='multi-manifests'></a>Multiple Manifests with Inheritance ##
  
  A single manifest can describe multiple applications. Another powerful technique is to create multiple manifests with inheritance. Here, manifests have parent-child relationships such that children inherit descriptions from a parent. Children can use inherited descriptions as-is, extend them, or override them.
  
  Content in the child manifest overrides content in the parent manifest, if the two conflict.
  
  This technique helps in these and other scenarios:
  
  * An application has a set of different deployment modes, such as debug, local, and public. Each deployment mode is described in child manifests that extend the settings in a base parent manifest.
  