Drupal Release: 8.0.0

TL;DR

Drupal 8.0.0 marks a major milestone in Drupal's evolution, representing a complete architectural overhaul of the CMS. This release introduces modern PHP practices, Symfony components, and a new theming engine with Twig. Key improvements include a mobile-first responsive design, built-in web services for headless implementations, improved multilingual capabilities, and a more intuitive content authoring experience. This is a significant upgrade that requires careful migration planning from Drupal 7, but delivers substantial improvements in flexibility, performance, and developer experience.

Highlight of the Release

• Complete architectural overhaul with modern PHP practices and Symfony components
• New configuration management system for easier deployment across environments
• Mobile-first responsive design for both front-end and administrative interfaces
• Built-in web services for headless CMS implementations
• Improved multilingual capabilities with better translation workflows
• Views in core for creating custom content displays without custom code
• Enhanced content authoring experience with CKEditor integration
• New theme engine based on Twig templates for improved security and flexibility
• Entity-based architecture providing consistent APIs across content types
• Improved accessibility and better support for assistive technologies

Migration Guide

Preparing for Migration

Assess Your Current Site

Before migrating to Drupal 8, thoroughly audit your Drupal 7 site:

• Identify all contributed modules and custom code
• Document content types, fields, and views
• List all themes and custom templates
• Inventory all users, roles, and permissions

Check Module Compatibility

1. Verify which of your current modules have Drupal 8 versions
2. Identify alternatives for modules without Drupal 8 versions
3. Plan for custom module rewrites where necessary

Environment Requirements

Ensure your hosting environment meets Drupal 8 requirements:

• PHP 5.5.9 or higher
• MySQL 5.5.3/MariaDB 5.5.20/Percona Server 5.5.8 or higher with InnoDB as primary storage engine
• PostgreSQL 9.1.2 or higher
• SQLite 3.7.11 or higher
• At least 64MB PHP memory limit (128MB recommended)

Migration Approaches

Using the Migrate API

Drupal 8 includes a migration system in core that can import content and configuration from Drupal 6 or 7:

1. Install a fresh Drupal 8 site
2. Enable the required migration modules:
   • Migrate
   • Migrate Drupal
   • Migrate Drupal UI (for UI-based migration)
3. Run the migration through the UI or Drush commands

Manual Rebuild

For complex sites or when significant architectural changes are desired:

1. Build a new Drupal 8 site from scratch
2. Recreate content types, fields, and views
3. Export content from Drupal 7 and import to Drupal 8 using custom scripts or the Migrate API

Post-Migration Tasks

Verify Content and Configuration

• Check that all content has migrated correctly
• Verify that field values and relationships are intact
• Ensure permissions and user roles are properly set up

Theme Development

Drupal 8 uses Twig templates instead of PHPTemplate:

• Convert your custom theme to use Twig templates
• Update CSS to work with the new HTML structure
• Consider using Classy or Stable as a base theme

Custom Code Updates

Rewrite custom modules following Drupal 8 coding standards:

• Use namespaces and PSR-4 autoloading
• Convert hooks to services, plugins, or event subscribers
• Update database queries to use the new Database API
• Replace render arrays with the new render pipeline

Performance Optimization

• Configure the new cache system
• Set up BigPipe if needed for dynamic content
• Optimize entity queries and views
• Configure proper caching headers

Common Migration Challenges

Field Migrations

Some complex field types may require special handling:

• Text fields with text processing settings
• File and image fields with complex configurations
• Entity reference fields with specific selection handlers

Views Migration

While Views is now in core, some complex views may need manual adjustment:

• Custom views handlers and plugins
• Views with complex relationships
• Views using contributed modules' functionality

Custom Code

Custom code requires the most significant changes:

• Hooks must be properly namespaced and placed in .module files
• Custom entities need to follow the new entity API
• Form API usage has changed significantly
• Theme functions must be converted to Twig templates

Resources for Migration

• Drupal.org Migration Guide
• API Documentation
• Drupal 8 Module Upgrader
• Acquia's Drupal 8 Migration Guide

Upgrade Recommendations

For Simple Sites

For simple sites with minimal custom code and primarily using popular contributed modules, we recommend:

• Plan for a direct migration using the core Migrate modules
• Allocate sufficient time for testing and troubleshooting
• Upgrade when most of your critical contributed modules have stable Drupal 8 releases
• Consider waiting for Drupal 8.1.x if you're not in a rush, as it will include additional stability improvements

For Complex Sites

For complex sites with significant custom code, custom themes, or specialized functionality:

• Plan for a phased migration with a longer timeline
• Consider rebuilding the site architecture to take advantage of Drupal 8's new capabilities
• Allocate resources for retraining developers and content editors
• Budget for custom module rewrites and theme development
• Start with a proof-of-concept migration of a small section to identify challenges

For Enterprise Sites

For large enterprise sites:

• Develop a comprehensive migration strategy with clear milestones
• Consider engaging Drupal experts or partners with Drupal 8 migration experience
• Plan for parallel development during the transition period
• Implement a robust testing strategy including automated tests
• Consider a gradual rollout using a decoupled architecture if appropriate

Timeline Considerations

• Development sites: Migrate now to gain experience with Drupal 8
• Non-critical sites: Plan migration within 6-12 months
• Critical business sites: Develop a migration plan now, but consider implementing after Drupal 8.1.x or 8.2.x for additional stability
• Sites with many custom modules: Allow additional time for code rewrites and testing

Post-Upgrade Support

After upgrading to Drupal 8:

• Plan for regular minor version updates (8.1.x, 8.2.x, etc.)
• Allocate resources for ongoing maintenance and security updates
• Consider implementing automated testing to ensure stability during updates
• Document your new architecture and development workflows

Long-term Planning

Drupal 8's new release cycle means more frequent, smaller updates:

• Minor versions will be released approximately every 6 months
• Security and bug fix releases will be more frequent
• Plan for a continuous update strategy rather than major version jumps
• Future upgrades (to Drupal 9 and beyond) should be much easier than the Drupal 7 to 8 transition

Bug Fixes

Path Alias Handling

Fixed inconsistent path alias handling across different database drivers, ensuring case-insensitive path handling for all systems.

Entity Reference Field Validation

Resolved issues with entity reference field validation, allowing selection handlers to properly validate field values.

Views REST Export

Fixed issues with Views REST export not supporting exposed filters, improving the functionality of REST APIs.

CKEditor Plugin Issues

Several fixes to CKEditor plugins, including:

• Fixed issues with linking images in CKEditor
• Resolved problems with HTML filtering in text formats
• Fixed the Link button not showing when HTML filtering is enabled

Multilingual Fixes

• Fixed issues with translation of menu links and taxonomy terms
• Resolved problems with language detection and selection
• Fixed bugs in content translation workflows

Cache System Fixes

• Fixed issues with CSS/JS asset caching that could cause cache to be invalidated unnecessarily
• Resolved problems with cache contexts and tags not being properly bubbled up

Migration Path Issues

• Fixed issues with migration of UID 1 (admin user) during upgrades
• Resolved problems with file migrations and URL encoding
• Fixed migration of text fields with text processing settings

Entity System Fixes

• Fixed issues with entity creation and translation
• Resolved problems with entity references and field validation
• Fixed bugs in entity revision handling

Form API Fixes

• Fixed issues with form validation and submission
• Resolved problems with AJAX form handling
• Fixed bugs in form element rendering

Theme System Fixes

• Fixed issues with theme inheritance and overrides
• Resolved problems with template discovery and rendering
• Fixed bugs in CSS and JS asset handling

Performance Issues

• Fixed memory leaks in various components
• Resolved performance bottlenecks in entity loading and rendering
• Fixed issues with cache invalidation that could impact performance

New Features

Configuration Management System

Drupal 8 introduces a robust configuration management system that allows for easier deployment of configuration changes between environments. Site configurations are now stored as YAML files that can be exported, imported, and tracked in version control.

Views in Core

The popular Views module is now included in core, allowing site builders to create custom displays of content without writing custom code. This integration provides a consistent interface for creating lists, grids, blocks, and other content displays.

Twig Templating Engine

Drupal 8 replaces PHPTemplate with Twig, a modern, secure, and flexible templating engine. This change improves security by removing PHP from templates and provides a cleaner syntax for theme developers.

Multilingual Capabilities

Comprehensive multilingual features are now built into core, including improved content translation, configuration translation, and interface translation. Language detection and selection are more flexible, with better support for RTL languages.

Web Services

RESTful web services are now included in core, allowing Drupal to function as a headless CMS. Content can be consumed via JSON, XML, or HAL+JSON formats, enabling integration with mobile apps, JavaScript frameworks, and other systems.

Mobile-First Responsive Design

Both the front-end and administrative interfaces are now responsive by default, providing a better experience on mobile devices. The new Bartik theme is fully responsive, and the administrative interface adapts to different screen sizes.

CKEditor Integration

A WYSIWYG editor (CKEditor) is now included in core, providing a more intuitive content authoring experience. The editor is highly configurable and integrates with Drupal's text formats and filters.

In-Place Editing

Content can now be edited directly on the page with the new Quick Edit feature, allowing for faster content updates without navigating to separate edit forms.

Improved Accessibility

Drupal 8 has improved accessibility throughout the system, with better support for assistive technologies, keyboard navigation, and ARIA attributes.

Plugin System

A new plugin system provides a standardized way to create reusable components, making the code more modular and maintainable.

Entity System Improvements

The entity system has been completely revamped, providing a consistent API for all content types and making it easier to create custom entity types.

Field UI Improvements

The Field UI has been redesigned for better usability, with improved field management and display options.

Responsive Images

Support for responsive images is now built into core, allowing for different image sizes to be served based on the device and viewport size.

Improved Cache System

The cache system has been completely rebuilt, with better granularity and context-aware caching for improved performance.

Blocks Everywhere

Blocks can now be placed in any region and can contain fields, making them more powerful and flexible.

Security Updates

Twig Template Engine

The adoption of Twig as the templating engine significantly improves security by removing PHP code from templates. This prevents potential PHP code injection vulnerabilities that were possible in Drupal 7's PHPTemplate system.

Improved Password Hashing

Security for password hashing has been hardened, with improved algorithms and practices for comparing hash values.

Secure Content Security Policy Support

Added support for Content Security Policy (CSP) headers, helping to prevent cross-site scripting (XSS) attacks by controlling which resources can be loaded.

Improved Input Sanitization

Enhanced input sanitization throughout the system, particularly in form handling and text processing, reducing the risk of XSS vulnerabilities.

Secure Cookie Handling

Fixed issues with cookie handling during redirects, improving security of session management.

Hardened Entity Access Control

The entity access system has been improved with more consistent permission checking and better integration with the cache system.

Improved CSRF Protection

Enhanced Cross-Site Request Forgery (CSRF) protection with improved form token handling and validation.

Secure File Handling

Improved security of file uploads and handling, with better validation of file types and content.

Sanitized HTML Output

Enhanced HTML filtering and sanitization, particularly in text formats and WYSIWYG editors, reducing the risk of XSS attacks.

Improved Error Handling

Better error handling and reporting, reducing the risk of information disclosure through error messages.

Performance Improvements

Improved Caching Architecture

Drupal 8 introduces a completely revamped caching system with cache tags and contexts, allowing for more granular and efficient cache invalidation. This means pages and components are only re-rendered when the specific data they depend on changes.

JavaScript Asset Optimization

JavaScript files are now loaded in the footer by default and can be aggregated more intelligently, improving page load times and perceived performance.

Entity Field Query Optimization

The new entity query API provides more efficient database queries when loading entities and their fields, reducing the number of queries needed for complex pages.

Lazy-Loading Services

Drupal 8's service container implements lazy loading of services, meaning components are only initialized when actually needed, reducing memory usage and bootstrap time.

BigPipe Support

While not enabled by default, Drupal 8's architecture supports the BigPipe rendering strategy, allowing for progressive page rendering where cached parts of a page are sent to the browser immediately while personalized content is rendered afterward.

Improved Database Connection Handling

Database connection handling has been improved to be more efficient, with better connection pooling and query optimization.

Optimized Class Loading

Drupal 8 uses Composer's optimized class autoloading, significantly improving performance compared to Drupal 7's registry system.

Twig Template Caching

Twig templates are compiled to PHP and cached, providing better rendering performance than the previous PHPTemplate system.

Preloaded Cache Optimization

Fixed issues with the preloaded cache in AliasManager that could grow excessively large, improving memory usage.

Reduced Bootstrap Time

The bootstrap process has been optimized to load only what's necessary for each request, reducing the time needed to start processing a request.

Impact Summary

Drupal 8.0.0 represents the most significant architectural change in Drupal's history, moving from a procedural codebase to a modern, object-oriented architecture built on Symfony components. This fundamental shift brings Drupal in line with modern PHP development practices while maintaining the flexibility and power that has made it a leading CMS.

The impact of this release extends across all aspects of Drupal development and usage:

For developers, the learning curve is steep but rewarding. The adoption of Symfony components, PSR standards, and modern PHP practices like namespaces and dependency injection creates a more maintainable and testable codebase. The plugin system and improved APIs provide greater flexibility for extending Drupal. However, this means existing custom modules will need significant refactoring to work with Drupal 8.

For site builders, the inclusion of Views in core and the new configuration management system dramatically improves the ability to create complex sites without custom code and deploy them across environments. The improved Field UI and Block system provide more flexibility in content modeling and display.

For content editors, the improved authoring experience with CKEditor integration, in-place editing, and a responsive administrative interface makes content management more intuitive and efficient, especially on mobile devices.

For multilingual sites, the comprehensive language handling capabilities now in core eliminate the need for complex module combinations that were required in Drupal 7, making multilingual sites much easier to build and maintain.

For performance and scalability, the improved caching architecture with cache tags and contexts allows for more efficient invalidation and rendering, though the more complex architecture may require more resources than Drupal 7 for equivalent functionality.

For security, the adoption of Twig templates eliminates PHP in templates, reducing the risk of code injection vulnerabilities, while improved input sanitization and access control enhance overall security.

The transition from Drupal 7 to 8 is significant and requires careful planning. Custom code needs to be rewritten, themes need to be rebuilt using Twig, and content migration requires thorough testing. However, the long-term benefits in terms of maintainability, flexibility, and future-proofing make this investment worthwhile for most sites.

Drupal 8's new release cycle also means more frequent, smaller updates rather than major version jumps, which should make future upgrades less disruptive than the 7 to 8 transition.