Layouts for Drupal 8
At the Web Services and Context Core initiative sprint earlier this month, we attempted to re-scope the initiative so that it was more manageable and less daunting. We decided to spin off one of the major components of what it was trying to tackle into its own separate initiative, the Layout initiative.
The goal of the Layout initiative is to make all elements on the page into contextual blocks that can be rearranged and organized into flexible layouts (and even layouts within layouts) through a drag and drop interface.
Specifically, the initiative breaks down as:
- Contextual blocks: Provide the ability to pass in relevant configuration data to blocks so they can react on something other than the URL of the request.
- Blocks everywhere: Make all page elements—from the site logo to menus to the main page content—into blocks which can be treated the same.
- Multiple page layouts: Choose from either pre-configured layouts such as "3-Column" and "Grid" or make your own custom layouts for pages.
- Partial page rendering: Allow for individual page components to be loaded and rendered independently, allowing for better performance and independent AJAX requests.
- Better UI/UX to manage blocks: A visual, drag and drop interface for creating page layouts and populating with blocks.
This approach to building pages yields a number of benefits, including the ability to customize the look and feel of a site based on a variety of contextual information, the ability to render parts of the page independently for performance, increased consistency, and increased flexibility for site builders to re-use page elements in a number of contexts.
I've asked Kris "EclipseGc" Vanderwater to head up the Layout initiative team. Kris has spent a lot of time working with Panels and Page Manager, and intends to work closely with Earl Miles and other maintainers of the CTools suite. Read Kris's blog post for an overview of the initiatives' goals. Note that like all initiatives, they don't actually materialize unless people decide to help. Please join the discussions in the Blocks and Layouts Everywhere Initiative on groups.drupal.org and help work on Layout issues on drupal.org.
Jennifer Hodgdon
As the Documentation Team lead, Jennifer "jhodgdon" Hodgdon has done a fantastic job of not only keeping Drupal core's API documentation high-quality and consistent, but also of on-boarding new Drupal core contributors through the "Novice" issue queue.
Since documentation improvement patches are always welcome, and since they are unlikely to break other parts of the system, I'm happy to announce the promotion of Jennifer as a Drupal core co-maintainer for version 7 and 8. Her responsibility will be solely around documentation and code style patches, plus occasional help on "emergency" commits such as a required rollback of an accidental patch commit in order to get our automated test suite passing again.
The hope is that delegating responsibility for documentation and code style patches to Jennifer will help increase the velocity of Drupal 8 development. Not only will documentation changes go in faster, it also allows catch, webchick and myself to focus our time on bigger patches.
Welcome to the core committer team, Jennifer! :-)
The future is a RESTful Drupal
Last weekend, we held a sprint at the Acquia offices for the Web Services and Context Core (WSCCI) Initiative for Drupal 8. This was an important sprint for the future of Drupal. This blog post provides a high-level overview of what was discussed and agreed upon; the different sprint participants will be laying out more technical details in follow-up blog posts.
Overall, a wide range of experience levels, skill sets, and perspectives were brought to the table, with the goal of the sprint being to clearly define the initiative’s scope, get agreement on what we wanted to accomplish and why, and lay out a clear plan for how to accomplish this.
In attendance were:
- Larry "Crell" Garfield, lead architect of the WSCCI initiative
- Daniel "sun" Kudwien, top Drupal core contributor
- Fabien "fabpot" Potencier, lead developer of the Symfony project
- Kris "EclipseGc" Vanderwater and James "neclimdul" Gilliland, who have helped develop and implement the plugin system as part of WSCCI
- Greg "heyrocker" Dunlap, initiative lead of the Configuration Management Initiative for Drupal 8
- Moshe Weitzman, long-time Drupal core contributor
- Angela "webchick" Byron, community cat herder and Drupal 7 core co-maintainer
- Randy "rfay" Fay, Justin "beejeebus" Randall and Alex "effulgentsia" Bronstein, core developers and sane voices of reason with an outside perspective
- Dries Buytaert (me), project lead
Scope
The WSCCI initiative, as envisioned by Larry Garfield, was originally set to address Drupal's web services and flexible page layout capabilities. We discovered that both would require significant changes to Drupal core, and it was difficult to build consensus online, so we decided to get together for 3 days and to flesh out what we actually wanted to accomplish, and how.
At the sprint, we first attempted to articulate all of the problems that WSCCI was trying to solve, which included: multiple page layouts, better UI/UX to manage blocks, partial page rendering (ESI, AHAH), contextual blocks, different response types per delivery callback/URL, plugin system / swappable subsystems, lazy loading bootstrap (convert subsystems to PSR-0 classes), infrastructure for building web services, dependency injection, and so on.
We then did a round of voting where we could each choose 3 of those things in order to try to determine which of those were the most important.
Two things became instantly clear during this exercise:
- The items encompassed under WSCCI really spanned at least 3 separate major areas: Web Services, more robust ESI-based layouts (think Panels only more powerful), and cleaning up our underlying toolset to be a more loosely-coupled framework.
- The underlying architecture to support RESTful calls to Drupal that makes all of the other things possible was deemed the most important thing to focus on.
Scope resolution
After a good chunk of discussions, all were in agreement to scale back the scope of the initiative to just the "Web Services" piece, and spin off the Layout/blocks/related-UI parts to a separate effort.
Furthermore, some efforts, such as PSR-0 and Unified Plugin system, were only semi-related to the WSCCI initiative in the first place, and just happened to become relevant for it. Work on those efforts will continue as part of the general Framework community efforts.
Architecture
Fabien was able to offer a tremendous number of insights as to how various Symfony2 components could help provide underlying structure for Drupal core to support Web Services out of the box. Essentially, most of what the WSCCI team had been trying to work toward, in the abstract, was already implemented within Symfony2. While some implementation details were different than what we had in mind, the end result is almost exactly what we have been trying to accomplish. We therefore agreed that the best way forward was to leverage several Symfony2 components within Drupal as a way to speed progress toward that end.
Benefits
Some of the concrete benefits that would come out of these changes are
- An underlying framework that is a first-class REST citizen. That means developing web services becomes easier and more efficient, because the plumbing is already in place. An HTML page is a particular case of a REST service.
- Because the core system will be fully REST-ified, we'll be able to improve existing APIs and expose Drupal content in a natively RESTful way. For example, our current AJAX system doesn't comply with REST standards, but with these changes, can be cleaned up to do so.
- That in turn makes Drupal-to-Drupal communication, content staging, content sharing, and a host of other related tasks easier.
- The use of widely used libraries and techniques makes Drupal more approachable to new developers.
Why does this matter?
As it has evolved into an increasingly powerful system, Drupal has gotten increasingly complex and is not as easy to start developing with as it once was. Many developers are nervous about continuing that trend. Managing complexity is a challenge faced by many software projects, and one approach is to use standardized patterns and components.
Due to its long support for PHP 4, as well as some unique needs, Drupal does not take full advantage of standardized patterns and components. The complexity of the custom code that’s used and the non-standard architecture combines to create a barrier to entry for developers new to Drupal (both experienced and novice developers alike).
Meanwhile, the web is constantly changing around us. Web services and mobile are more important than ever, and with that comes the need to have more flexible page and layout capabilities. Now feels like the right time to modernize Drupal’s capabilities to bring it to the forefront of modern PHP systems and web systems in general.
While changing Drupal's core plumbing to address these needs, it's also a good opportunity to do so using more widely understood and modern techniques and libraries. Leveraging the work of a fellow open source community lets us get a jump on these changes to build a more powerful, more flexible, and more easily learnable system in less time than it would take to go it our own.
While these changes may seem large, and some of them are, we believe that they will achieve the right balance between empowering Drupal's design and architecture, and moving toward more modern, standard, well-tested code and techniques to empower a new generation of developers. I hope you are as excited as we are!
Drupal 8 feature freeze: December 1st, 2012
Last summer, I blogged about how I think about Drupal release date planning, tying it to the Gartner hype cycle and the corollary Drupal mood cycle.
The release timeline I laid out in my previous blog post was a Drupal 8 release 18 months after Drupal 7 had achieved the “Plateau of Productivity", the point in time where developing in Drupal 6 seems mostly pointless due to the maturity of Drupal 7.
At that time, I said that I felt that Drupal 7’s “plateau of productivity" was about 6-9 months away. Today, almost 9 months later, I think that by any reasonable measure we are currently there. There are over 300,000 live Drupal 7 installations, which represents nearly 50% of all reported Drupal sites. The top Drupal modules all have Drupal 7 releases, the vast majority of which are either stable releases or release candidates.
Having reached the “plateau of productivity" also means that I feel comfortable announcing the Drupal 8 release timeline (after catch and I talked about it). Without further ado, here is how the rest of the Drupal release cycle breaks down:
Timeline:
- December 1, 2012: Feature freeze. No new features are allowed (unless specifically exempted), focus turns instead to API and UI clean-ups and polishing of existing features.
- February 1, 2013: Code freeze: focus on bug fixes, stabilization. No API changes, instead focusing on bug fixing, preparing for release, and getting the count of critical bugs down to 0.
- August, 2013 (DrupalCon Europe 2013): Drupal 8 released, to wild, international fanfare. :-)
This means that Drupal 8 is 18 months away. Time to shift Drupal 8 core development into higher gear!
The ~6-month window for bug fixes laid out here is obviously much shorter than the 18-month window for bug fixes we ended up having with Drupal 7, but the hope is that the issue count thresholds that we’ve introduced this release will ensure this process is much shorter than in Drupal 7, since we’ll be going from approximately 15 down to 0, rather than approximately 300 to 0.
This timeline also means that if there are Drupal 8 initiatives you’d like to see happen, or other specific features or things you want to see fixed in Drupal core, now is the time to make those things happen. If you’ve never helped with Drupal core development before and would like to, stop by IRC during Core office hours, or join us at DrupalCon Denver. There will also be plenty of other sprints at DrupalCon around various Drupal core initiatives, and you can always start your own!
See you in Denver and in the issue queue! :-)
Mollom.com website redesign (Woot!)
We're proud to present a new design for the Mollom.com website.
We first launched the Mollom.com site in 2007. For more than four years, Mollom.com was using the same design. As we grew Mollom, we wanted to address some of the issues that we've been stewing over since our original design. We have been planning to redesign the site for over a year now but work on the Mollom web service and developing new Mollom products have always had a higher priority so we haven't found the time to complete the new design until now.
The old Mollom.com design that we used from 2007 to early 2012.
The new design is the first step in our plans to reorganize the website. We still have updates to make to the content of some pages, for example. Already, we think the new design is a fresh new change that improves usability.
Take a look at the new mollom.com, we hope you like it!
The new Mollom.com website design.
Core Conversations at DrupalCon Denver
Like at previous DrupalCon's, I'm co-organizing a Core Conversations track at DrupalCon Denver.
The Core Conversations track is a place for people actively working on Drupal or Drupal.org to meet and plan the future of Drupal. Each session is either two 15 minute or one 30 minute presentation, followed by 30 minutes of discussion.
I know a lot of you contribute to Drupal or want to start contributing. If so, Core Conversations are a unique opportunity to present in front of key Drupal contributors, and to make the case for why we need to do more of A or B (e.g. authoring experience improvements, API overhauls, etc.). We need UX conversations, performance conversations, feature conversations, etc. Please share your ideas with the world through Drupal core.
If you have ideas for Drupal core, and you are attending DrupalCon, I suggest that you submit a proposal as soon as possible. The deadline is February 1st so don't wait too long. To get your ideas flowing, here are our conversations from Drupalcon London and Drupal Chicago.
Drupal Association community elections
When we designed a new governance structure for the Drupal Association last year, we decided that most of the board is selected through a nominating committee with the goal to carefully balance many factors like needed skills and geographical and sector representation. However, it was also deemed important that we have directors chosen directly by the Drupal community to make sure that the community is always well-represented.
I'm excited that we're holding our first open community elections. Two community "at large" directors will be elected to the Drupal Association Board of Directors. If you'd like to consider running, please have a look at the "At-large" nominations page. And if you're a Drupal community member, please make time to participate in discussions with candidates and of course to vote, starting January 26. (This process was vetted openly in the community by the Elections Committee and numerous community volunteers at http://groups.drupal.org/drupal-association.)
Your participation will help us take this next important step in implementing a new improved governance structure to strengthen the Drupal Association. Thanks!
