The VDC initiative is now several months under way, and fantastic progress has been made. As part of this progress, in addition to making excellent progress toward making the codebase Drupal core-worthy, today we are announcing that Dries has promoted the project from a community initiative to an official initiative.
The team has grown significantly, and even though I haven’t personally been able to participate as much as would be liked, the team has more than made up for me. We are more or less on schedule to meet our goals.
What are our goals? Ultimately, our goal is to move the complete Views 8.x-3.x codebase into Drupal core by the Drupal 8 feature freeze date (December 1), and then to continue improving Views through the core development process for the rest of the Drupal 8 release cycle. Over the past four months, we've made this possible by coming at the task from both sides, through the Drupal core issue queue and within Views itself. We have just a few remaining dependencies to resolve, and then we will open a Drupal core sandbox (with a corresponding core issue) that includes Views as a core module.
Now that VDC is an official Drupal 8 initiative, we'll be collaborating more directly with project lead Dries Buytaert (Dries), Drupal 8 release manager Nat Catchpole (catch), and the leads of the other Drupal 8 initiatives to ensure that our initiative is consistent with the overall vision for Drupal 8.
What follows is a detailed overview of our roadmap for the initiative, summarizing our progress so far as well as our plans through the rest of the Drupal 8 release cycle.
What we've already done
Since we announced the VDC initiative in late May of this year, we've completely ported Views to run on the ever-evolving 8.x branch of Drupal core. The team was able to create an initial port without difficulty thanks to Drupal.org's new change notification system, but we've also had to keep on top of actively developed core APIs.
In addition to porting Views to Drupal 8, we've also begun leveraging new Drupal 8 core subsystems like the D8 Configuration system, the Entity API, and the Plugin system in place of Views' previous custom solutions. This work has been beneficial to core development in general, because we continue to uncover (and help resolve) underlying issues in these core systems.
What we've completed to date:
- Initial port of Views and dependencies to Drupal 8.
- Over 300 existing handlers, plugins, tests, and other objects converted to PSR-0 and reorganized.
- Most CTools dependencies completely or partially resolved.
- 230+ handlers and plugins converted to the new core plugin architecture with annotations.
- Request handling converted to the HTTP Kernel.
- Updated to the new Cache API.
- Converted default views to YAML for the configuration system.
- Converted to a new ViewStorage class (extending Configurable Entities) for loading all View objects.
- Improved the View object's architecture by refactoring its components into the ViewStorage and ViewExecutable classes.
- Updated, simplified, and modernized all CSS.
- Refactored the Views administrative listing user interface.
- Significant basic code cleanup and refactoring.
(You can see all these changes in the Views 8.x-3.x branch.)
All this work would not have been possible without contributions from numerous individuals and companies. (Read below for more information on contributions to the initiative.)
What we still need to do
Our timeline is short. While we still have approximately a year before the release of Drupal 8, much of our work needs to be ready much sooner. Therefore, we've sorted our remaining tasks into three phases, based on what needs to be completed before feature freeze, before code freeze, and before release. (For more details on the Drupal 8 timeline, see Dries' blog post.) If you'd like to contribute to getting Views into core, the timelines below explain how you can help effectively during each phase and when certain tasks should be prioritized.
Before feature freeze (Dec. 1, 2012)
December 1, 2012 is the beginning of feature freeze for Drupal 8. This means we must have Views ready to be added to core by that date. The following tasks must be completed before we can add Views to core:
- Add basic test coverage for all Views plugins and default views, to ensure that optimization and refactoring can be done during feature freeze without risking critical regressions.
- Resolve all Views' remaining external dependencies (also see the Drupal.org meta issue):
- Views administrative listing, a.k.a the "CTools export UI" (Drupal.org issue: Add an API for listing (configuration) entities).
- TempStore, a.k.a. the "CTools object cache" (Drupal.org issue: Add TempStore for persistent, limited-term storage of non-cache data).
- CTools autosubmit (Drupal.org issue: Figure out what to do with ctools autosubmit in exposed form.
- Dropbutton (Drupal.org issue: Add CTools dropbutton to core).
- Open a Drupal core sandbox and corresponding meta issue to move Views into core.
- Convert all storage and export functionality to core APIs. (Drupal.org issue: [META] Ensure the Configuration and ConfigEntity systems fully support Views CRUD and status operations).
- Move core module-specific Views integrations into their respective modules.
- Convert a core listing to Views to demonstrate the minimum viable product. (We will most likely start with the promoted node listing at /node.)
The next two months are crucial, so we need plenty of attention on these issues. We will open the core sandbox and meta issue soon, once the above dependencies are resolved or worked around, so that contributors can begin to explore what it means for Views to be in core.
We are planning one last major sprint before feature freeze in the week preceding BADCamp. (Pantheon will be hosting this sprint; more details soon.) The BADCamp sprint will be our chance to coordinate our final push to make Views core-ready. Once Views is committed to core, all further work will take place in our sandbox and the Drupal core issue queue.
Before code freeze (Apr. 1, 2013)
April 1, 2013, is the beginning of code freeze for Drupal 8. Before code freeze, the core Views API needs to be stabilized and all major refactorings should be completed. Between Dec. 1 and Apr. 1, we will focus on cleaning up the Views API to core standards, improving Views' architecture, and migrating core listings to Views:
- Clean up the base test class.
- Convert method names to core standards.
- Convert remaining core listings to Views.
- Finish converting the query plugin to load entities after queries are executed.
- Add core API and UI for modal dialogs. (Drupal.org issues: Add abstracted views modal to core, Research and implement accessible / reusable modal dialog).
- Explore further integrations with other new core features (e.g., the Field and Entity APIs, Blocks and Layouts, other core query builders, etc.), potentially including:
- Add a generalized entity views controller and leverage the Entity Property API (Drupal.org issues: Implement an entity views data controller and Entity Property API blocker Add a uniform Entity Property API). (Dependent on the Entity Property API.)
- Ensure Views properly implements core multilingual functionality. (Dependent on the Multilingual Initiative.)
- Integrate Views' display architecture with new Drupal 8 blocks and layouts functionality. (Dependent on the Blocks and Layouts Initiative.)
- Test the deployment workflow for Views using the configuration system. (Dependent on the Configuration Management Initiative.)
- Additional cleanup and refactoring.
Before release (Sept. 2013)
During code freeze, core APIs need to remain stable so that site builders and contributed module developers can begin testing. (This is one of the greatest advantages of having Views in core, because hundreds of contributed modules rely on the Views API.) The goal during this phase will be to make Views (and the rest of core) ready for production release. After April 1, we will focus on the upgrade path, non-API cleanups, bugfixes, QA, performance, documentation, and user-facing improvements:
- Provide complete upgrade path from Views 7.x-3.x to core Views.
- Provide full functional and unit test coverage.
- Provide full API documentation.
- Move the old advanced help documentation onto Drupal.org and update it for the new architecture.
- Consider mobile-friendly administration for Views (evaluate both the configurable listing controller UI and the main Views administrative UI). (Dependent on the Mobile initiative.)
- Identify and address any performance concerns.
- Explore ways to provide user feedback on specific views that are not well-optimized.
As you can see, a lot of work remains throughout the rest of the Drupal 8 development cycle. If having Views in Drupal core is valuable to your business or usecase, please contribute to the initiative so that we can meet these goals. We need your help.
Contributions to VDC
Daniel Wehner (dawehner), Damian Lee (damiankloip), Jess M. (xjm), and Tim Plunkett (tim.plunkett) form the main VDC developer team. Many additional developers have contributed to date, including (among others):
- Pablo Cerda (citlacom)
- Alasdair Cowie-Fraser (ACF)
- Bram Goffings (aspilicious)
- Laurence Liss (lliss)
- Pedro Lozano (Pedro Lozano)
- Andrei Mateescu (amateescu)
- Salva Molina (slv_)
- Pascal Morin (bellesmanieres)
- Károly Négyesi (chx)
- Meghan Palagyi (dead_arm)
- Lee Rowlands (larowlan)
- Kris Vanderwater (EclipseGc)
- Bojan Živanović (bojanz)
Much of the work on the initiative thus far has been made possible by contributions of weekly developer time. New Digital Partnership is contributing 40% of Damian's weekly hours, Zivtech is contributing 20% of Tim's, and erdfisch is contributing 50% of Daniel's. xjm has been funded on an hourly basis by a portion of the money from the community chip-in, which has raised over $12,500 from over 300 individuals and companies.
Other sponsorship from the chip-in, along with additional direct contributions, has allowed us to hold five VDC sprints at DrupalCamp Twin Cities, Drupal Developer Days Barcelona, Drupaldelphia, the Midwest Developer Summit, and (most recently) a sprint in Paris hosted by Code Enigma. The Paris sprint was an important milestone for the initiative, so please thank Code Enigma for their contribution! Additional thanks to:
- Acquia, for sponsoring Earl's attendance at DrupalCamp Twin Cities.
- chx, for sponsoring xjm's flight to Barcelona.
- Sponsors of the Midwest Developer Summit, for making it possible to provide scholarships to Earl and Daniel for that event.
- New Digital Partnership, Zivtech, and erdfisch for sending their respective developers to several events.
- Chip-in contributors, for providing additional funding for the Barcelona and Paris sprints.
How to get involved
As you can see above, we still have plenty to do, and the next two months are critical! Here's how you can contribute to the initiative:
- Help fix and review Drupal.org issues tagged with VDC.
- Join the #drupal-vdc channel in IRC to discuss the initiative.
- Clone the 8.x-3.x branch of Views (and, for now, CTools 8.x-1.x as well), and test things out!
- Follow our progress on the Drupal 8 core initiatives page.
- Contribute funding to the community chip-in.
- Contact us if you're interested in participating in the BADCamp VDC sprint (space may be limited) or in helping sponsor VDC team members to attend.