Understanding Symfony Versions and Roadmap

One of the key reasons for Symfony’s popularity is its predictable release cycle and the fact that the Symfony developer team follow it so reliably. This predictability enables developers and organizations to plan their development cycles and upgrades with a high degree of certainty and makes it much easier for those using the framework.

In this article, we’ll take a deeper dive into Symfony’s versioning scheme, how it works, and how it helps developers use the framework.

Semantic Versioning (Semver)

Symfony follows semantic versioning, a versioning scheme also known as semver. Semver is a widely adopted versioning scheme and is followed by numerous open-source projects to convey the changes made in a version release.

Semver uses a three-part version number: major, minor and patch. Here’s what each one means:

1. Major: Major versions contain breaking changes so you’ll likely need to edit your application/project before upgrading to ensure backwards compatibility. Major versions of Symfony come out bi-annually in November of odd years (e.g. — 2019, 2021, 2023). The previous major version (Symfony 7.0) was released in November 2023, and the next major version (Symfony 8.0) will be released in November 2025.
2. Minor: Minor versions are primarily used to push bug fixes and sometimes small new features. They can contain deprecations but don’t include breaking changes thanks to Symfony’s backwards compatibility promise. Minor versions of Symfony come out every 6 months, one in May and one in November.
3. Patch: Patches only contain bug fixes. Again, you can safely upgrade your applications without worrying about backwards compatibility. Patches for Symfony come out roughly each month.

So, if you see version 5.2.7, you know it’s the 7th patch of the 2nd minor release in the 5th major version. The semver system means you can understand the nature of changes between versions at a glance and makes it much easier to manage dependencies and updates.

Long Term Support (LTS) vs. Standard

Starting with the 3.x branch, the number of minor versions is limited to five (e.g., 3.0, 3.1, 3.2, 3.3, and finally 3.4) per release. The last minor version of a branch is considered the LTS version, and others are considered standard versions.

What differentiates LTS and standard versions is how long they are supported and how long security bug fixes are issued.

• For the Long Term Support Version — bug fixes are issued for 3 years and security fixes — 4 years.
• For the Standard Version — bug fixes and security fixes are issued for 8 months.

These LTS releases are designed for projects that prioritize stability over having the latest features. This long-term commitment makes LTS versions ideal for enterprise projects, large-scale applications, other frameworks and libraries, or any scenario where frequent updates might be challenging or risky.

Along with an LTS version release, Symfony also releases the latest version of the previous branch as well. For example, the Symfony 6.4 (minor version) and 7.0 (major version) releases happen at the same time.

Both versions share the latest features but differ in terms of deprecated features. The updated minor version (6.4 in this case) retains all deprecated features, whereas the major version (7.0) removes them entirely.

This approach enables you to first upgrade your projects to the latest minor version, identify and address all deprecation warnings, and then (hopefully) seamlessly transition to the major version.

The complete development cycle for each major or minor version spans six months and is split into two distinct phases:

1. Development phase: This four-month period focuses on introducing new features and enhancing existing ones.
2. Stabilization phase: Following development, this two-month phase addresses bug fixes, prepares for release, and ensures compatibility across the Symfony ecosystem (including third-party libraries, bundles, and Symfony-based projects).

Throughout the development phase, any new feature may be rolled back if it cannot be completed on schedule or lacks the necessary stability to be included in the upcoming final release.

Deprecations

Large software projects like Symfony often have to make critical decisions that go beyond new features and bug fixes. Some of these decisions involve renaming configuration options, modifying method arguments, and improving performance and if they’re not released correctly, could mean the upgrade won’t work successfully.

To address this, Symfony employs a strategy centred on deprecations. When introducing a change, Symfony maintains the old behaviour (marking it as deprecated) while simultaneously adding support for the new behaviour. This approach allows Symfony to generate log messages like below whenever an application uses a deprecated feature, alerting developers to future changes.

It’s worth noting that some deprecations can lead to minor performance impacts. If Symfony were to accumulate deprecations indefinitely, the cumulative effect on performance would become significant over time. To mitigate this, all deprecations are fully removed every two years with the release of the new major version.

Handling Deprecations in Symfony

The deprecation process usually unfolds like so:

• Symfony 6.0 (Nov. 2021): No deprecations
• Symfony 6.1 (May 2022): Introduces some deprecations
• Symfony 6.2 (Nov. 2022): Includes 6.1 deprecations + new deprecations
• Symfony 6.3 (May 2023): Includes 6.1, 6.2 deprecations + new deprecations
• Symfony 6.4 (Nov. 2023): Includes 6.1, 6.2, 6.3 deprecations + new deprecations
• Symfony 7.0 (Nov. 2023): No deprecations

As we saw earlier, Symfony marks the last minor version (X.4) as the LTS release. When 6.4 is released, 7.0 is also released at the same time. The differences between 6.4 and 7.0 are minimal — 7.0 will not contain any deprecated code which was accumulated during the development of the 6.x branch.

This means that developers can upgrade to the 6.4 branch just like any other branch, see all the deprecations, and replace deprecated implementations with suggested implementations. This makes the software upgrade process less frightening.

Symfony Release Schedule

Symfony follows a predictable release schedule, with new versions coming out twice a year. Major and minor releases are consistently launched in May and November. This consistent schedule helps the Symfony community stay up-to-date with the latest features and improvements while providing ample time for testing and preparation between releases.

The release schedule was implemented to enhance predictability and transparency and has some great benefits:

1. It makes planning upgrade cycles for projects much easier as new features and improvements can be released reliably on a set schedule.
2. Other projects using Symfony can sync up their timelines and more easily plan their tech roadmaps.
3. The whole Symfony ecosystem (bundles, translations, docs) has time to catch up and new features can be planned with plenty of time to spare.

If you’d like to see a timeline of this release schedule, you can find one on the Symfony releases page.

PHP Version Compatibility

The Symfony release cycle also works with PHP’s own release cycle and helps ensure Symfony supports all PHP versions throughout its lifetime. The minimum PHP version for each major Symfony release is also decided ahead of time making it easier for those planning the product roadmap. When a new PHP version is released (around the end of each year) you can be sure that all supported Symfony versions will work with it.

Simplifying Change Management for Developers

Change management is often considered one of the most challenging aspects of software development. The fear of breaking existing functionality or introducing incompatibilities can sometimes discourage people from maintaining and upgrading their software. At the heart of this challenge lies the critical issue of backward compatibility.

To address these concerns, Symfony has established a clear Backward Compatibility Promise to serve as a cornerstone for decision-making regarding Symfony releases.

It states that:

“Ensuring smooth upgrades of your projects is our first priority. That’s why we promise you backward compatibility (BC) for all minor Symfony releases. You probably recognize this strategy as Semantic Versioning. In short, Semantic Versioning means that only major releases (such as 5.0, 6.0 etc.) are allowed to break backward compatibility. Minor releases (such as 5.1, 5.2 etc.) may introduce new features, but must do so without breaking the existing API of that release branch (5.x in the previous example).”

Clearly, the Symfony team is committed to ensuring that updates to Symfony projects will maintain compatibility with previous versions as much as possible.

Symfony and Open Source

Symfony is also open source and has thousands of contributors, many PHP applications either use Symfony components or are based on the framework itself. It powers thousands of web applications and many popular PHP projects including Drupal and the CMS, Joomla! The fact it’s so popular just shows how reliable and versatile the framework is.

Because it’s open source, Symfony also follows all the open-source community standards that any good project should adhere to. Its roadmap and development are predictable and dependable and the open source nature encourages collaboration and feedback from developers globally.

The Symfony community also plays a pivotal role in its evolution, continuously improving documentation, providing support through forums and user groups, and driving the framework forward with new features and optimizations.

Wrapping Up

Symfony’s approach to versioning allows for a stable, predictable environment for you and other developers and businesses alike, and shows just why it’s so popular and trusted in the PHP community. By following semver, Symfony ensures clarity and transparency in each release, empowering developers to plan upgrades with confidence.

The framework’s LTS releases mean that enterprises and large-scale applications can rely on it as they know it offers stability and extended support periods crucial for critical projects. Its open-source nature also helps encourage collaboration and innovation.

With a robust ecosystem supported by thousands of contributors worldwide, Symfony continues to evolve, delivering cutting-edge features while maintaining backward compatibility and still being one of the most popular PHP frameworks out there today!

Originally published at https://accesto.com.