Symfony Glossary

Acme is a sample company name used in Symfony demos and documentation.
It's used as a namespace where you would normally use your own company's
name (e.g. Acme\BlogBundle).

Action

An action is a PHP function or method that executes, for example,
when a given route is matched. The term action is synonymous with
controller, though a controller may also refer to an entire PHP
class that includes several actions. See the Controller Chapter.

Annotation

Annotations are metadata written alongside your code. They can either be explanatory and will be
ignored during execution or add functionality to the line of code directly below as a means of
configuration. For example, the annotation @var describes the type of a variable, whereas in
Symfony2 @Assert can add validation to a member variable of a class (see Validation chapter).

Application

An Application is a directory containing the configuration for a
given set of Bundles.

Asset

An asset is any non-executable, static component of a web application,
including CSS, JavaScript, images and video. Assets may be placed
directly in the project's web directory, or published from a Bundle
to the web directory using the assets:install console task.

Bundle

A Bundle is a directory containing a set of files (PHP files,
stylesheets, JavaScripts, images, ...) that implement a single
feature (a blog, a forum, etc). In Symfony, (almost) everything
lives inside a bundle. (see The Bundle System)

Controller

A controller is a PHP function that houses all the logic necessary
to return a Response object that represents a particular page.
Typically, a route is mapped to a controller, which then uses information
from the request to process information, perform actions, and ultimately
construct and return a Response object.

Dependency Injection

The Dependency Injection is a design pattern highly used in the Symfony Framework.
It encourages loosely coupled and more maintainable architecture of an application.
The main principle of this pattern is that it allows developers to inject objects
(also known as services) in other objects, generally passing them as parameters.
Different levels of coupling between these objects can be established
depending on the method used to inject objects together.
The Dependency Injection pattern is the more often associated
to another specific type of object: the Service Container.

Distribution

A Distribution is a package made of the Symfony Components, a
selection of bundles, a sensible directory structure, a default
configuration, and an optional configuration system.

Environment

An environment is a string (e.g. prod or dev) that corresponds
to a specific set of configuration. The same application can be run
on the same machine using different configuration by running the application
in different environments. This is useful as it allows a single application
to have a dev environment built for debugging and a prod environment
that's optimized for speed.

Firewall

In Symfony, a Firewall doesn't have to do with networking. Instead,
it defines the authentication mechanisms (i.e. it handles the process
of determining the identity of your users), either for the whole
application or for just a part of it. See the
Security chapters.

Front Controller

A Front Controller is a short PHP script that lives in the web directory
of your project. Typically, all requests are handled by executing
the same front controller, whose job is to bootstrap the Symfony
application.

HTTP Specification

The HTTP Specification is a document that describes the Hypertext
Transfer Protocol - a set of rules laying out the classic client-server
request-response communication. The specification defines the format
used for a request and response as well as the possible HTTP headers
that each may have. For more information, read the HTTP Wikipedia
article or the HTTP 1.1 RFC.

A Project is a directory composed of an Application, a set of
bundles, vendor libraries, an autoloader, and web front controller
scripts.

Service

A Service is a generic term for any PHP object that performs a
specific task. A service is usually used "globally", such as a database
connection object or an object that delivers email messages. In Symfony,
services are often configured and retrieved from the service container.
An application that has many decoupled services is said to follow
a service-oriented architecture.

Service Container

A Service Container, also known as a Dependency Injection Container,
is a special object that manages the instantiation of services inside
an application. Instead of creating services directly, the developer
trains the service container (via configuration) on how to create
the services. The service container takes care of lazily instantiating
and injecting dependent services. See Service Container
chapter.

Vendor

A vendor is a supplier of PHP libraries and bundles including Symfony
itself. Despite the usual commercial connotations of the word, vendors
in Symfony often (even usually) include free software. Any library you
add to your Symfony project should go in the vendor directory. See
The Architecture: Using Vendors.

YAML

YAML is a recursive acronym for "YAML Ain't a Markup Language". It's a
lightweight, human friendly data serialization language used extensively in
Symfony's configuration files. See the The Yaml Component
chapter.