- What is this?
- How to help
- Courses
- SF3C1. Getting Started with Symfony 3
- SF3C2. Mastering Symfony 3
- Dependency Injection and Service Container
- Contracting a Quality Insurance with Automated Tests
- Interacting with the End User and Forms
- Restricting Access to Secured Areas of the Application
- Improving Application Performances with HTTP Caching and ESI
- Querying a Relational Database System with Doctrine
- SF3C3. Extending & Hacking Symfony 3
Just a heads up. This is not official and is not sponsored by Sensio Labs or any of the Symfony developers. This document has been put together by users of the Symfony framework using their own free time.
SensioLabs® and Symfony® are all trademarks or registered trademarks of SensioLabs in the United States and/or other countries. These terms and all related materials, logos, and images are copyright © SensioLabs. This document is in no way associated with or endorsed by SensioLabs®.
SensioLab's courses are great for those who can afford it and the time needed to fly out wherever they are being held. For others like me, I need to be able to do this without missing a day of work and without breaking the bank. This is a list of courses that are being taught for Symfony 3.0 and their respective topics. I did my best to connect topics of a course to the relevant Symfony documentation for a self-taught learning session.
Please note that the links to documentation are for current versions. At the time this is being written, it is Symfony 3.1.
- Symfony 3.0 Certification
- Training Courses
- Provide URLs for topics that are not linked.
- Provide URLs that are more relevant than the ones already set.
- Provide URLs for free resources that may be helpful for the courses.
- Classes and objects
- Properties and methods
- Constructor and destructor methods
- Class inheritance
- Attributes and methods scopes
- Error handling with exceptions
- Namespaces
- Introducing the Symfony framework and its ecosystem
- Installing the Symfony « Standard Edition Distribution »
- Discovering the Symfony project architecture (application, bundles, libraries, bundles etc.)
- Understanding the HTTP request processing workflow
- Understanding the concept of environment (development, production and testing)
- Introducing the coding and files naming conventions
- Discovering the concept of a « Bundle »
- Getting help from the « Web Debug Toolbar »
- Introspecting the recorded logs
- Profiling HTTP requests thanks to the « Web Profiler » application
- Spotting problems thanks to explicit errors and exceptions stack traces
- Using the Debug and VarDumper components features
- Comparing the supported built-in configuration format: XML, YAML and PHP
- Configuring the application thanks to global parameters
- Configuration application’s routes and URLs with annotations
- Overriding the configuration defined by a built-in or third-party « bundle »
- Introducing the Twig templates engine
- Comparing Twig and raw PHP templating strategies
- Accessing global variables from Twig templates (request, session, user)
- Using tags, filters and function to generate and format contents in a Twig template
- Making templates truly extensible thanks to the template inheritance feature
- Splitting templates into smaller templates chunks to avoid code duplications
- Rendering a Symfony controller from within a Twig template
- Generating URLs based on the application’s routes configuration
- Rendering Symfony forms with custom Twig view helpers
- Designing a controller class with its action methods
- Mapping URL patterns to Symfony controllers thanks to annotations
- Generating raw responses and Twig templates based responses
- Accessing client’s information from the Request objecthttps://symfony.com/doc/current/controller.html#the-request-object-as-a-controller-argument
- Reading and writing session data
- Reading and writing cookies data
- Triggering a 404 error page when the resource is not found
- Triggering an internal redirect to another controller to avoid code duplications
- Redirecting the user to another page
- Discovering the « Form » component
- Designing and processing simple web forms
- Adding validation constraints on submitted form fields’ data
- Prototyping the form rendering thanks to Twig view helpers
- Gathering the form submitted data and processing them
- Sending the form validated and filtered data by e-mail to some recipient
- Discovering the « Translation » component
- Changing the default user’s locale
- Defining custom abstract translation keys in Twig templates
- Generating XLIFF translation catalogues skeletons
- Translating abstract translation keys in XLIFF catalogues
- Dealing with dynamic translations including pluralized sentences
- Understanding the dependency injection principle
- Getting started with the Symfony service container
- Listing all built-in Symfony services thanks to the command line tools
- Registering new custom business services in the dependency injection container
- Accessing a registered service from the service container
- Creating and accessing global configuration parameters from the container
- Discovering the PHPUnit tests automation framework
- Understanding the goals of automating tests (unit and functional tests)
- Configuring an automated tests suite
- Designing and executing a unit tests suite
- Designing and executing a functional tests suite
- Generating code coverage reports
- Designing and processing web forms
- Automating form rendering with Twig view helpers
- Customizing form rendering with built-in and custom Twig form themes
- Configuring form field types as services
- Applying built-in validation constraint rules on submitted data
- Applying custom validation constraint rules on submitted data
- Contextualizing the data validation thanks to validation groups
- Getting started with authentication and authorization principles
- Securing some application’s pages thanks to a form based authentication strategy
- Implementing the Security Guard sub component to handle authentication
- Setting up an access control policy based on user’s roles
- Testing user’s permissions from a controller and a Twig template
- Registering custom authorization rules thanks to the security « voters »
- Getting started with the HTTP caching workflows
- Discovering the different kind of cache systems
- Comparing the expiration and validation cache strategies
- Applying expiration and validation cache constraints to generated web pages
- Caching page fragments thanks to the ESI technology (« Edge Side Includes »)
- Installing and configuring the Symfony’s built-in reverse-proxy cache
- Discovering the basics of the Doctrine ORM
- Understanding the concepts of « entities » and « repositories »
- Automating PHP classes and SQL queries code generation with Doctrine
- Persisting data to the database thanks to the Doctrine ORM entity manager
- Fetching data back from the database thanks to Doctrine
- Building and executing custom SQL queries thanks to the Doctrine Query Builder object
- Discovering the Symfony Console component
- Automating heavy tasks thanks to the command line
- Designing and enabling interactive
- Using the « Formatter » helper to colorize the console
- Using the « ProgressBar » helper to develop progression bars
- Using the « Table » helper pour display tabular data in the console output
- Analyzing collected data from the profiler
- Analyzing collected data from the application’s code
- Configuring the web profiler for the production environment
- Designing custom data collectors to extend the Symfony Profiler
- Extending the « Web Debug Toolbar » and the « Web Profiler » with new debug panels
- Rediscovering some basics about the dependency injection principles
- Registering custom business services in the service container
- Understanding the concept of services « tags » to extend the framework built-in tools
- Developing custom « compiler passes » objects to optimize the container compilation
- Developing a custom user provider class
- Recording the last connection date and time of the user
- Triggering custom business code when the user impersonates another user
- Setting up a fined grained resources access control policy thanks to security voters
- Understanding the internals of the « Form » component
- Extending or overriding built-in form field types
- Developing custom form field types
- Registering new form field types as services
- Developing new custom data transformers
- Modifying the form’s data and structure thanks to form events listeners
- Displaying form fields depending on user’s permissions thanks to form field types extensions
- Developing new custom data constraint validators
- Discovering the kernel events and other components built-in events
- Extending the kernel behaviors with custom kernel events listeners
- Dispatching custom business events to make the code truly extensible
- Connecting custom event listeners to custom business events