Drupal Changed Our Lives

It is very rare that something so powerful can change a company overnight. Our long history as a web development company can be defined in single word: "Custom". Custom web designs, custom web programming, and custom web applications. These skills are things that we are most proud to promote. However, a "custom" Website doesn’t have to mean starting from scratch. Today, with the power of the entire contributed Drupal community, things are different. There have been so many advances in Drupal’s open source solutions that it is impossible for any web development company to ignore. The Drupal framework only enhanced our ability to develop custom Websites for our clients. Drupal changed our lives — It opened up new doors for all of us at Nu-Designs and our clients.

What is Drupal?

Drupal is an open source platform for creating a Website. Thousands of web developers world wide use the Drupal platform. Many of these developers have contributed additional functions to the platform. These new functions are contributed to the Drupal community in the form of a Module. A Drupal module is a widget of code that works with the Drupal framework. The module basically plugs into the Website, adds new functionality and can be configured in a variety of ways. Today there is a library of over 8,000 Drupal modules available for any project. As a Drupal developer, Nu-Designs can leverage this module library for the benefit of our customers. We can utilize existing modules or we can make "custom" modules to meet our clients needs. The point is: why do something from scratch when it has already been done before? To find out more information about the Drupal framework, visit the Drupal.org Website.

If you are a Drupal developer be sure to check out our Drupal community site Made With Drupal.

Video: 

News and Updates from Drupal.org

February 12, 2016

Drupal.org, the home of the Drupal community, has grown organically for many years. At some point it grew so large that a clear decision making structure became a necessity. The Drupal Association staff was not in the place to provide it at that time: our entire technology team for Drupal.org, including all its sub-sites and services, consisted of only two people, myself and Neil Drumm—so we turned to community for help.

In the summer of 2013, the three Drupal.org Working Groups were announced. Governance committees, consisting of community members and staff, created to act as a collective 'product owner' for the website. In the following two and a half years, with their guidance and feedback, we implemented many new features, performed user research, developed content strategy, and drastically improved the infrastructure behind Drupal.org.

At the same time the Drupal Association staff kept growing. We hired our first full-time infrastructure staff member, brought in the CTO and customer service coordinator a few months later, then a developer and two more infrastructure team members. And finally, we hired a project manager, a web designer, and one more Drupal developer. Our communications team grew, too: over the last two years, the Drupal Association brought in a content strategist and a dedicated writer. Overall, our capacity increased and a lot of gaps in skills and experience were filled.

Having skilled staff working full-time on Drupal.org, we were finally able to provide product direction, set a roadmap, and execute on it. We adopted Scrum as our project management methodology, with a new sprint starting every two weeks. This encourages iteration and pivoting based on the situation, instead of working against a 'set in stone' year long plan. As our staffing situation changed, we started to realize that the valuable time of dedicated community volunteers can be spent more efficiently than making them sit in countless planning and update meetings with staff.

At the end of last year, the Drupal Association Board, with the input of several Working Group members, made a decision that it is time for staff to work on Drupal.org improvements directly with the community. This means that the Drupal.org Working Groups will transition into an advisory group, with former Drupal.org Working Groups members available as advisors to provide feedback and input on specific initiatives the team is working on, relevant to their own skills and expertise.

The only requirement the Board and Drupal.org Working Groups themselves put out before the transition could happen is this: they asked that the Association staff create a clear process for community members to be able to suggest items on the Drupal.org roadmap, and provide a path for those community members to volunteer to help with implementation. With the input from the Working Groups and the Board, we created such a process. It was
launched last week.

As we reach the end of an era, I'd like to personally thank each member who served at various times on Drupal.org Working Groups over the past three years. Your time, skills, and experience you shared with us has been invaluable.

Gerhard Killesreiter / killes
Narayan Newton / nnewton
Melissa Anderson / eliza411
Angela Byron / webchick
Kim Pepper / kim.pepper
George DeMet / gdemet
Jeff Eaton / eaton
Roy Scholten / yoroy
David Hernandez / davidhernandez
Cathy Theys / YesCT

Thank you! It's been a pleasure to share all those moments, conversations, ideas, debates, and workshops.

While the role of these wonderful people is shifting to a less formal advisory one, we will still be calling on their expertise and help as we continue our work on making Drupal.org a better place.

--
Image by Roy Scholten.

February 10, 2016

Republished from buytaert.net

There has been a lot of discussion around the future of the Drupal front end both on Drupal.org (#2645250, #2645666, #2651660, #2655556) and on my blog posts about the future of decoupled Drupal, why a standard framework in core is a good idea, and the process of evaluating frameworks. These all relate to my concept of "progressive decoupling", in which some portions of the page are handed over to client-side logic after Drupal renders the initial page (not to be confused with "full decoupling").

My blog posts have drawn a variety of reactions. Members of the Drupal community, including Lewis Nyman, Théodore Biadala and Campbell Vertesi, have written blog posts with their opinions, as well as Ed Faulkner of the Ember community. Last but not least, in response to my last blog post, Google changed Angular 2's license from Apache to MIT for better compatibility with Drupal. I read all the posts and comments with great interest and wanted to thank everyone for all the feedback; the open discussion around this is nothing short of amazing. This is exactly what I hoped for: community members from around the world brainstorming about the proposal based on their experience, because only with the combined constructive criticism will we arrive at the best solution possible.

Based on the discussion, rather than selecting a client-side JavaScript framework for progressive decoupling right now, I believe the overarching question the community wants to answer first is: How do we keep Drupal relevant and widen Drupal's adoption by improving the user experience (UX)?

Improving Drupal's user experience is a topic near and dear to my heart. Drupal's user experience challenges led to my invitation to Mark Boulton to redesign Drupal 7, the creation of the Spark initiative to improve the authoring experience for Drupal 8, and continued support for usability-related initiatives. In fact, the impetus behind progressive decoupling and adopting a client-side framework is the need to improve Drupal's user experience.

It took me a bit longer than planned, but I wanted to take the time to address some of the concerns and share more of my thoughts about improving Drupal's UX (and JavaScript frameworks).

To iterate or to disrupt?

In his post, Lewis writes that the issues facing Drupal's UX "go far deeper than code" and that many of the biggest problems found during the Drupal 8 usability study last year are not resolved with a JavaScript framework. This is true; the results of the Drupal 8 usability study show that Drupal can confuse users with its complex mental models and terminology, but it also shows how modern features like real-time previews and in-page block insertion are increasingly assumed to be available.

To date, much of our UX improvements have been based on an iterative process, meaning it converges on a more refined end state by removing problems in the current state. However, we also require disruptive thinking, which is about introducing entirely new ideas, for true innovation to happen. It's essentially removing all constraints and imagining what an ideal result would look like.

I think we need to recognize that while some of the documented usability problems coming out of the Drupal 8 usability study can be addressed by making incremental changes to Drupal's user experience (e.g. our terminology), other well-known usability problems most likely require a more disruptive approach (e.g. our complex mental model). I also believe that we must acknowledge that disruptive improvements are possibly more impactful in keeping Drupal relevant and widening Drupal's adoption.

At this point, to get ahead and lead, I believe we have to do both. We have to iterate and disrupt.

From inside-out to outside-in

Let's forget about Drupal for a second and observe the world around us. Think of all the web applications you use on a regular basis, and consider the interaction patterns you find in them. In popular applications like Slack, the user can perform any number of operations to edit preferences (such as color scheme) and modify content (such as in-place editing) without incurring a single full page refresh. Many elements of the page can be changed without the user's flow being interrupted. Another example is Trello, in which users can create new lists on the fly and then add cards to them without ever having to wait for a server response.

Contrast this with Drupal's approach, where any complex operation requires the user to have detailed prior knowledge about the system. In our current mental model, everything begins in the administration layer at the most granular level and requires an unmapped process of bottom-up assembly. A user has to make a content type, add fields, create some content, configure a view mode, build a view, and possibly make the view the front page. If each individual step is already this involved, consider how much more difficult it becomes to traverse them in the right order to finally see an end result. While very powerful, the problem is that Drupal's current model is "inside-out". This is why it would be disruptive to move Drupal towards an "outside-in" mental model. In this model, I should be able to start entering content, click anything on the page, seamlessly edit any aspect of its configuration in-place, and see the change take effect immediately.

Drupal 8's in-place editing feature is actually a good start at this; it enables the user to edit what they see without an interrupted workflow, with faster previews and without needing to find what thing it is before they can start editing.

Making it real with content modeling

Eight years ago in 2007, I wrote about a database product called DabbleDB. I shared my belief that it was important to move CCK and Views into Drupal's core and learn from DabbleDB's integrated approach. DabbleDB was acquired by Twitter in 2010 but you can still find an eight-year-old demo video on YouTube. While the focus of DabbleDB is different, and the UX is obsolete, there is still a lot we can learn from it today: (1) it shows a more integrated experience between content creation, content modeling, and creating views of content, (2) it takes more of an outside-in approach, (3) it uses a lot less intimidating terminology while offering very powerful capabilities, and (4) it uses a lot of in-place editing. At a minimum, DabbleDB could give us some inspiration for what a better, integrated content modeling experience could look like, with the caveat that the UX should be as effortless as possible to match modern standards.

Other new data modeling approaches with compelling user experiences have recently entered the landscape. These include back end-as-a-service (BEaaS) solutions such as Backand, which provides a visually clean drag-and-drop interface for data modeling and helpful features for JavaScript application developers. Our use cases are not quite the same, but Drupal would benefit immensely from a holistic experience for content modeling and content views that incorporates both the rich feature set of DabbleDB and the intuitive UX of Backand.

This sort of vision was not possible in 2007 when CCK was a contributed module for Drupal 6. It still wasn't possible in Drupal 7 when Views existed as a separate contributed module. But now that both CCK and Views are in Drupal 8 core, we can finally start to think about how we can more deeply integrate the two. This kind of integration would be nontrivial but could dramatically simplify Drupal's UX. This should be really exciting because so many people are attracted to Drupal exactly because of features like CCK and Views. Taking an integrated approach like DabbleDB, paired with a seamless and easy-to-use experience like Slack, Trello and Backand, is exactly the kind of disruptive thinking we should do.

What most of the examples above have in common are in-place editing, immediate previews, no page refreshes, and non-blocking workflows. The implications on our form and render systems of providing configuration changes directly on the rendered page are significant. To achieve this requires us to have robust state management and rendering on the client side as well as the server side. In my vision, Twig will provide structure for the overall page and non-interactive portions, but more JavaScript will more than likely be necessary for certain parts of the page in order to achieve the UX that all users of the web have come to expect.

We shouldn't limit ourselves to this one example, as there are a multitude of Drupal interfaces that could all benefit from both big and small changes. We all want to improve Drupal's user experience — and we have to. To do so, we have to constantly iterate and disrupt. I hope we can all collaborate on figuring out what that looks like.

Special thanks to Preston So and Kevin O'Leary for contributions to this blog post and to Wim Leers for feedback.

Continue the conversation on buytaert.net

Front page news: Drupal NewsDrupal version: Drupal 8.x

February 5, 2016

Look at our Roadmap highlighting how this work falls into our priorities set by the Drupal Association staff with the direction from the Board and collaboration with the community.

Drupal.org Updates Following the Conversation

One of the most requested features from a wide swath of the community has been a better way to follow content on Drupal.org and receive email notifications. The issue queues have had this follow functionality for some time, but the implementation was quite specific to issues, and not easily extensible to the rest of the site.

Because of the volume of content on Drupal.org we have to be careful that our implementation will scale well. We now use a notification system based on the Message stack which functions much more generically and therefore can be applied to many content types on Drupal.org.

Follow functionality is now available for comments on Forum topics, Posts (like this one), Case Studies, and documentation Book Pages.

In the future we intend to extend this follow functionality to include notification of new revisions (for relevant content types, particularly documentation).

Community Elections for the Board

Nominations for the position of At-Large Director from the community are now open. There are two of these positions on the board, each elected on alternating years. For this year's elections process we've made several small refinements:

  • Candidates are now no longer required to display their real names on their candidate profile. We will now default to the Drupal.org username.
  • Candidates do not have to provide a photo, we will default to a generic avatar.
  • There is now an elections landing page with complete details about the elections process.

We encourage members of the community to nominate themselves!

Drupal.org Enhancements

A number of smaller enhancements made it into the January sprints as well. One of the key ones was the ability to configure an arbitrary one-off test in the issue queues against a custom branch. This is a small step towards ensuring that the DrupalCI testing framework will support the wider testing matrix required for feature branching, so that Drupal can always be shippable.

We also spent some time in January reviewing the results of the documentation survey that was placed on all existing documentation pages on the site. This information is helping to inform the next big item on the roadmap - improved Documentation section on Drupal.org.

Finally, we've continued our battle against spam with the help of Technology Supporter, Distil Networks. We've seen some very promising results in initial trials to prevent spam account registrations from happening in the first place, and will continue to work on refining our integration.

Sustaining support and maintenance

DrupalCon New Orleans Full -Site Launched!

In January we also launched the full -site for DrupalCon New Orleans with registration and the call for papers. As part of this launch, Events.drupal.org now supports multiple, simultaneous event registrations with multiple currencies, payment processors, and invoice formats. This was a significant engineering lift, but has made Events.drupal.org even more robust.

DrupalCon New Orleans is happening from May 9-13th, and will be the first North American DrupalCon after the release of Drupal 8!

DrupalCon Dublin

The next European DrupalCon will also be here before you know it, and we've been working with the local community and our designer to update the DrupalCon Dublin splash page with a new logo that we will carry through into the design for the full-site once that is ready to launch.

Permissions for Elevated Users

In January we also focused on auditing the users with elevated privileges on Drupal.org, both to ensure that they had the permissions they needed, and to enforce our principle of least-access. Users at various levels of elevated privileges were contacted to see if they were still needed, and if not those privileged roles were removed.

The following privileges were also fixed or updated: webmasters can now view a user's' public ssh keys; content moderators can administer comments and block spam users without user profile editing privileges. We also fixed taxonomy vocabulary access and now both content moderators and webmasters have access to edit tags in various vocabularies such as Issue tags, giving more community members access to clean those up and fight duplicates or unused tags.

Updates traffic now redirects to HTTPS

SSL is now the default for FTP traffic from Drupal.org and for Updates.drupal.org itself. This helps to enforce a best practice of using SSL wherever possible, and helps to address an oblique attack surface where a man-in-the-middle could potentially hijack an update for someone running their Drupal installation on an unprotected network (i.e. development environments on a personal laptop in a coffee shop).

Devwww2 Recovery

Drupal.org pre-production environments were affected by some instability in January, particulary the devwww2 server. A combination of a hard restart due to losing a NIC on the machine and some file-system level optimizations in the database containers lead to corruption on the dev site databases. Drupal.org infrastructure engineers restored the system and recovered the critical dev sites, and while some instability continues the system has been recovering more cleanly as they work to resolve the issue permanently.

———

As always, we’d like to say thanks to all the volunteers who work with us, and to the Drupal Association Supporters, who made it possible for us to work on these projects.

Follow us on Twitter for regular updates: @drupal_org, @drupal_infra