PreviousNext: Introducing the Media File Delete module

The media and media library modules have improved Drupal’s file handling capabilities considerably, but one oft-requested feature of clients is the ability to remove files from disk when removing the associated media entity.

This is where the Media file delete module can help

by
lee.rowlands
/

Configuring the module

The module has no configuration, so it should be as simple as enabling it and you’re off.

By default it takes over the Media entity delete form and adds an additional checkbox allowing the editor to also removed the associated file if:

  • the media-type has an associated file or image field
  • there are no associated file usage records for the file
  • the user has permission to delete the file
Screenshot showing the option to also delete the file

A word about access

By default, Drupal core’s access handler for files allows editors to only delete files which they own, which can be prohibitive in an environment where several editors create and edit media.

To alleviate this, the module also comes with a ‘Delete any file’ permission, which can be granted to allow trusted users to delete files they don’t own.

Summary

All in all, its a pretty simple module – but its a common requirement for our clients, and as a result at least two of them are already running it in production.

Take it for a spin and let us know your thoughts either here or via the issue queue.

Tagged

Media


Go to Source
Author:

Envato Tuts+: New Code eBooks Available for Subscribers

Do you want to learn more about asynchronous Android programming? How about the Ionic framework, or JavaScript design patterns? Our latest batch of eBooks will teach you all you need to know about these topics and more.

New Code eBooks on Envato Tuts

Our Latest Selection of eBooks

This month we’ve made eight new eBooks available for Envato Tuts+ subscribers to download. Here’s a summary of those books and what you can learn from them.

  • Xamarin: Cross-Platform Mobile Application Development

    Developing a mobile application for just one platform is becoming a thing of the past. Companies expect their apps to be supported on iOS, Android and Windows Phone, while leveraging the best native features on all three platforms. Xamarin’s tools help ease this problem by giving developers a single toolset to target all three platforms. The main goal of this book is to equip you with knowledge to successfully analyze, develop, and manage Xamarin cross-platform projects using the most efficient, robust, and scalable implementation patterns.

  • Drupal 8 Theming With Twig

    Drupal 8 is an open-source content management system and powerful framework that helps deliver great websites to individuals and organizations, including non-profits, commercial, and government around the globe. Starting from the bottom up, in this eBook you will learn to install, set up, and configure Drupal 8. You’ll get a walk-through of a real-world project to create a Twig theme from concept to completion while adopting best practices to implement CSS frameworks and JavaScript libraries. You will see just how quick and easy it is to create beautiful, responsive Drupal 8 websites while avoiding the common mistakes that many front-end developers make.

  • Asynchronous Android Programming: Second Edition

    Asynchronous programming has acquired immense importance in Android programming, especially when we want to make use of the number of independent processing units (cores) available on the most recent Android devices. With this guide in your hands, you’ll be able to bring the power of asynchronous programming to your own projects, and make your Android apps more powerful than ever before!

  • Ionic Framework by Example

    With Ionic, mobile development has never been so simple, so elegant and obvious. By helping developers to harness AngularJS and HTML5 for mobile development, it’s the perfect framework for anyone obsessed with performance, and anyone that understands just how important a great user experience really is. This book shows you how to get started with Ionic framework immediately. But it doesn’t just give you instructions and then expect you to follow them. Instead it demonstrates what Ionic is capable of through three practical projects you can follow and build yourself.

  • Sass and Compass Designer’s Cookbook

    Sass and Compass Designer’s Cookbook helps you to get most out of CSS3 and harness its benefits to create engaging and receptive applications. This book will help you develop faster and reduce the maintenance time for your web development projects by using Sass and Compass. You will learn how to use with CSS frameworks such as Bootstrap and Foundation and understand how to use other libraries of pre-built mixins. You will also learn setting up a development environment with Gulp.

  • Android Sensor Programming by Example

    Android phones available in today’s market have a wide variety of powerful and highly precise sensors. This book will give you the skills required to use sensors in your Android applications. It will walk you through all the fundamentals of sensors and will provide a thorough understanding of the Android Sensor Framework. By the end of the book, you will be well versed in the use of Android sensors and programming to build interactive applications.

  • Mastering Yii

    The successor of Yii Framework 1.1, Yii2 is a complete rewrite of Yii Framework, one of the most popular PHP 5 frameworks for making modern web applications. This book has been written to enhance your skills and knowledge with Yii Framework 2. Starting with configuration and how to initialize new projects, you’ll learn how to configure, manage, and use every aspect of Yii2 from Gii, DAO, Query Builder, Active Record, and migrations, to asset manager. With this book by your side, you’ll have all the skills you need to quickly create rich modern web and console applications with Yii2.

  • Mastering JavaScript Design Patterns: Second Edition

    In this book, you will explore how design patterns can help you improve and organize your JavaScript code. You’ll get to grips with creational, structural and behavioral patterns as you discover how to put them to work in different scenarios. Then, you’ll get a deeper look at patterns used in functional programming, as well as model view patterns and patterns to build web applications. By the end of the book, you’ll be saved of a lot of trial and error and developmental headaches, and you will be on the road to becoming a JavaScript expert.

Start Learning With a Yearly Subscription

Subscribe to Envato Tuts+ for access to our library of hundreds of eBooks. With a Yearly subscription, you can download up to five eBooks per month, while the Yearly Pro subscription gives you unlimited access.

You can also build on your newfound knowledge by using some of the fantastic code scripts and plugins on Envato Market.


Go to Source
Author:

Envato Tuts+: Top 10 Most Usable Content Management Systems

There are plenty of options when it comes to picking a content management system for a development project. Depending on how advanced you need the CMS to be, what language it’s built in, and who is going to be using it, it can be a nightmare trying to find the “perfect” CMS for a project.

However, some CMSs have a slight edge over the rest of the competition because of the usability of the software. Some are just easier to install, use and extend, thanks to some thoughtful planning by the lead developers. 

We have a number of themes and resources to support these top content management systems. If you’re looking for WordPress Themes, Drupal Themes, or Joomla Themes we have you covered on Envato Market

We support a number of additional popular CMS systems. And a gallery of WordPress Plugins, Drupal Plugins, Joomla plugins and more. Visit our ThemeForest or CodeCanyon marketplaces to browse through a ton of professional options.  

Here are 10 of the most usable CMSs on the web to use in your next project, so you can choose the one that fits your needs best.

1. WordPress

WordPress

What is there left to say about WordPress that hasn’t already been said? The PHP blogging platform is far and away the most popular CMS for blogging, and probably the most popular CMS overall. It’s a great platform for beginners, thanks to their excellent documentation

and super-quick installation wizard. Five minutes to a running CMS is pretty good. Not to mention the fact that the newest versions auto-update the core and plugins from within the backend, without having to download a single file.

For those users not familiar with HTML or other markup language, a WYSIWYG editor is provided straight out of the box. The backend layout is streamlined and intuitive, and a new user should be able to easily find their way around the administration section. Wordpres also comes with built-in image and multimedia uploading support.

For developers, the theming language is fairly simple and straightforward, as well the Plugin API.

The WordPress Community is a faithful and zealous bunch. WordPress probably has the widest base of plugins and themes to choose from. We have thousands of professional WordPress Themes and WordPress Plugins available for sale on Envato Market, with a full suite of styles and options to choose from. 

A great part about the WordPress community is the amount of help and documentation online you can find on nearly every aspect of customizing WordPress. If you can dream it, chances are it’s already been done with WordPress and documented somewhere.

If you need help with anything from installing a theme to optimizing the speed of your WordPress site, you can find plenty of experienced WordPress developers to help you on Envato Studio.

2. Drupal

Drupal

Drupal is another CMS that has a very large, active community. Instead of focusing on blogging as a platform, Drupal is more of a pure CMS. A plain installation comes with a ton of optional modules that can add lots of interesting features like forums, user blogs, OpenID, profiles and more. It’s trivial to create a site with social features with a simple install of Drupal. In fact, with a few 3rd party modules you can create some interesting site clones with little effort.

One of Drupal’s most popular features is the Taxonomy module, a feature that allows for multiple levels and types of categories for content types. And you can find plenty of professional Drupal Themes, which are ready to be customized and worked with. You can also grab Drupal Plugins.

Drupal also has a very active community powering it, and has excellent support for plugins and other general questions. 

You can also hire a developer to complete a range of tasks for your Drupal site for a reasonable fixed fee.

3. Joomla!

Joomla

Joomla is a very advanced CMS in terms of functionality. That said, getting started with Joomla is fairly easy, thanks to Joomla’s installer. Joomla’s installer is meant to work on common shared hosting packages, and is a very straightforward considering how configurable the software is.

Joomla is very similar to Drupal in that it’s a complete CMS, and might be a bit much for a simple portfolio site. It comes with an attractive administration interface, complete with intuitive drop-down menus and other features. The CMS also has great support for access control protocols like LDAP, OpenID and even Gmail.com.

The Joomla site hosts more than 3,200 extensions, so you know the developer community behind the popular CMS is alive and kicking. Like WordPress, you can add just about any needed functionality with an extension. However, the Joomla theme and extension community relies more on paid resources, so if you’re looking for customizations, be ready to pull out your wallet. You can also grab Joomla plugins, or hire Joomla developers to help you get your store set up right.

4. ExpressionEngine

EE

ExpressionEngine (EE) is an elegant, flexible CMS solution for any type of project. Designed to be extensible and easy to modify, EE sets itself apart in how clean and intuitive their user administration area is. It takes only a matter of minutes to understand the layout of the backend and to start creating content or modify the look. It’s fantastic for creating websites for less-than-savvy clients that need to use the backend without getting confused.

ExpressionEngine is packed with helpful features like the ability to have multiple sites with one installation of software. For designers, EE has a powerful templating engine that has custom global variables, custom SQL queries and a built in versioning system. Template caching, query caching and tag caching keep the site running quickly too.

One of my favorite features of EE that is the global search and replace functionality. Anyone who’s ever managed a site or blog knows how useful it is to change lots of data without having to manually search and open each page or post to modify it.

ExpressionEngine is quite different than other previously-mentioned CMS in that it’s paid software. The personal license costs $99.95, and the commercial license costs $249.99. You can also get help with ExpressionEngine on Envato Studio.

5. TextPattern

Textpattern

Textpattern is a popular choice for designers because of its simple elegance. Textpattern isn’t a CMS that throws in every feature it can think of. The code base is svelte and minimal. The main goal of Textpattern is to provide an excellent CMS that creates well-structured, standards-compliant pages. Instead of providing a WYSIWYG editor, Textpattern uses textile markup in the textareas to create HTML elements within the pages. The pages that are generated are extremely lightweight and fast-loading.

Even though Textpattern is deliberately simple in design, the backend is surprisingly easy to use and intuitive. New users should be able to find their way around the administration section easily.

While Textpattern may be very minimal at the core level, you can always extend the functionality by 3rd party extensions, mods or plugins. Textpattern has an active developer community with lots of help and resources at their Textpattern.org site.

6. Radiant CMS

Radiant

The content management systems that we’ve listed so far are all PHP programs. PHP is the most popular language for web development, but that doesn’t mean we should overlook other popular web languages like Ruby. Radiant CMS is a fast, minimal CMS that might be compared to Textpattern. Radiant is built on the popular Ruby framework Rails, and the developers behind Radiant have done their best to make the software as simple and elegant as possible, with just the right amount of functionality. Like Textpattern, Radiant doesn’t come with a WYSIWYG editor and relies on Textile markup to create rich HTML. Radiant also has it’s own templating language Radius which is very similar to HTML for intuitive template creation.

7. Cushy CMS

Cushy CMS

Cushy CMS is a different type of CMS altogether. Sure, it has all the basic functionality of a regular content management system, but it doesn’t rely on a specific language. In fact, the CMS is a hosted solution. There are no downloads or future upgrades to worry about.

How Cushy works is it takes FTP info and uploads content on to the server, which in turn the developer or the designer can modify the layout, as well as the posting fields in the backend, just by changing the style classes of the styles. Very, very simple.

Cushy CMS is free for anyone, even for professional use. There is an option to upgrade to a pro account to use your own logo and color scheme, as well as other fine-grain customizations in the way Cushy CMS functions.

8. SilverStripe

SilverStripe

SilverStripe is another PHP CMS that behaves much like WordPress, except has many more configurable options and is tailored towards content management, and not blogging. SilverStripe is unique because it was built upon its very own PHP framework Saphire. It also provides its own templating language to help with the design process.

SilverStripe also has some interesting features built in to the base, like content version control and native SEO support. What’s really unique with SilverStripe is that developers and designers can customize the administration area for their clients, if need be. While the development community isn’t as large as other projects there are some modules, themes and widgets to add functionality. Also, you’ll want to modify the theme for each site, as SilverStripe doesn’t provide much in terms of style, to give the designer more freedom.

9. Alfresco

Alfresco

Alfresco is a JSP is a beefy enterprise content management solution that is surprisingly easy to install. A really useful feature of Alfresco is the ability to drop files into folders and turn them into web documents. Alfresco might be a little bit more work than some of the other CMS and isn’t as beginner-friendly, it certainly is quite usable given the massive power of the system. The administration backend is clean and well-designed.

While Alfresco might not be a great choice for most simple sites, it’s an excellent choice for enterprise needs.

10. TYPOlight

TYPOlight

TYPOlight seems to have the perfect balance of features built into the CMS. In terms of functionality, TYPOlight ranks with Drupal and ExpressionEngine, and even offers some unique bundled modules like newsletters and calendars. Developers can save time with the built-in CSS generator, and there are plenty of resources for learning more about the CMS.

If there is a downside to TYPOlight, it’s that it has so many features and configurable options. Even though the backend is thoughtfully organized, there are still a lot of options to consider. But if you’re wanting to build a site with advanced functionality and little extra programming, TYPOlight could be a great fit.


Go to Source
Author:

Droptica: Drupal Update. How to Properly Take Care of It?

.

Many people probably wonder why system creators recommend regular updating to the latest version and why we are informed at every step by pop-ups that the latest patch or other fix has been released, sometimes changing only a few lines of code in the software. Using Drupal as an example, I’ll try to explain why it’s so crucial. Although the system works properly, it can contain many errors and surprise you with unstable work.

Why should you update your systems?

The first and most important reason why you should carry out regular updates (including the ones related to Drupal) is the security of the system itself. If the authors or the community discover a software flaw, with an update they can immediately fix it and protect users from threats (such as hacker attacks) that lurk at every step.

In the case of Drupal, new versions of the software not only protect you against dangerous attacks, but may also provide new functionalities. Usually options of this type appear in the “major” versions, such as 8.2, 8.3. You can check the update plan at any time on the roadmap on the Drupal website.

System personalization is important for every user and thanks to an update you can gain new modules or additional options that’ll make your work easier. It’s also worth keeping in mind that regular updates protect you from unnecessary programming work in the future, because the older your Drupal version is, the more difficult it is to install the latest update. Another advantage is the continuity of the webpage’s operation, because you avoid time-consuming failures and minimise the risk of unstable system operation.

When is it worth performing an update?

As we’ve already mentioned, it’s best to perform updates on a regular basis. As soon as you receive a notification about a new version or find out about it from another source, you should plan that update in the near future.

In the case of Drupal, updates are released approximately twice a month. You should also remember that monitoring the date until which support for a given version of Drupal is provided is sometimes a matter of several years. Therefore, you should bear in mind that every version has its “end of life” planned, and usually a migration to the newer version should be performed when updating. If you want to protect your system from hacker attacks and downtime, as well as keep the website running smoothly, you should remember to always use the latest version (or the one that is supported).

In addition, there are also updates of the modules themselves (depending on which ones are currently installed) and the PHP itself. In the case of modules, you don’t always have to act so quickly, because when they are released, the information about what exactly has been fixed and who is at risk is provided. If the given problem doesn’t concern you, you can do it at a time that’s more convenient for you. You should pay attention in the case of PHP – it’s worth acting quickly in this case, especially if the new release fixes security holes from the previous version.

To sum up, when you don’t have time to install the latest update (such situations, unfortunately, sometimes happen), try to use a version that’s currently supported. In the case of modules, you can take care of the ones you use most often first. This will ensure stress-free work and the certainty that you’ll always be able to count on quick help in the event of unexpected errors.

Drupal update – upgrading to a higher version

A Drupal update within the same major version usually runs smoothly and doesn’t cause many bugs. However, if you change major versions of Drupal, updating may be much more difficult.

Upgrading from Drupal 7 to 8

The update from version 7 to 8 can’t be performed automatically, unfortunately. In most cases, you need to write the page from scratch. Drupal 8 has significantly changed the way content and configuration are stored in the database. Therefore, the database and other files must be transferred to the new page based on version 8. The configuration data include content types, user roles, and field definitions. You must also remember that not all modules have automatic update paths. Manual code tampering or custom migration will sometimes be required.

The structure of the themes has changed compared to version 7. This is another thing that needs to be rebuilt for the content to display properly in version 8. To facilitate this task, it’s best to obtain the appropriate tools from the official Drupal website:

Another thing that’ll help you migrate is an analysis of the Drupal modules. You need to determine which modules are most important to you (preferably in the form of a list), and whether their installation on Drupal 8 is really necessary. Also, remember to update Drupal 7 to the latest version. This’ll make it easier to transfer the configuration and content data. The last step before the migration is to back up your current page, based on version 7. If anything goes in the wrong direction, you’ll have a guarantee that you won’t lose the page and data.

Upgrading Drupal 7 to 8 is a complicated operation, but it brings many benefits.

  1. Lots of new features and modules have been added to the Drupal 8 core, e.g. Media and Layout Builder.
  2. Drupal 8 has access to more modern technologies – it uses more modern tools that facilitate an editor’s work. Thanks to this, the configuration is easier and better adapted to people who are just starting their adventure with this CMS.
  3. In Drupal 8, part of the core is the Views module, which easily presents the added content to you in many different ways. In addition, the main page itself is a separate view, therefore you can easily manage individual elements.
  4. The core also includes the modules that provide new field types (such as phone, e-mail, link, meta tags, entity reference and contact forms).

In addition, Drupal 8 is much better suited for larger pages than Drupal 7, because it can be optimized (it has a much more advanced cache system, controlled by tags and contexts), which makes it smooth and fast to work with. It’s based on the components of the Symfony framework, which is considered in the world of PHP development to be the best solution for creating complex applications.

Upgrading from Drupal 8 to 9

Drupal 9 doesn’t differ significantly from version 8. One important piece of information is the upgrade to Symfony 4, which ensures compliance with the latest standards – thanks to this you can program in accordance with the latest specifications. Besides, Drupal 9 is an improved variant of the previous version. Some of the old code has been removed, Symfony and Twig have been updated, so you can be sure that the system will always work effectively and without any problems. The quick and easy update between releases (i.e. switching from 8 to 9) has also been kept. Also, the modules’ updates will not require many additional changes. You should also keep in mind that Drupal 9 uses PHP 7.3 or higher versions.

The migration to the latest version will certainly require you to verify the application’s code. You should remove the items marked as “deprecated” from it. You can use the drupal-check tool for this, which will automatically track down the obsolete code fragments. Then you can proceed with an automated process, the execution time of which depends on the page, and which will provide you with the latest version of the software.

How to test the system after the update?

One of the most important steps you should take after any software update is to test the introduced changes or the entire application or system. There are situations when an update is associated with data loss, system crash or unexpected errors. In the case of Drupal, you can, for example, use smoke tests. They allow you to check whether all subpages are displayed without critical errors. Another option is any visual tests that compare the previous look of the page to the new one. It would also be necessary to verify the operation of individual forms and modules and check whether the data entered on the pages is assigned to the correct fields.

To sum up, you should check the website both visually and functionally. Technically the page should work fine. You can correct minor changes to its appearance later.

Summary

Software, whether it is for a web page (as in the case of Drupal) or an operating system or other application, should be updated regularly. This ensures the support of the producer or creators and may protect you from any external attacks. In addition, you often have at your disposal new functions, modules or improvements that can significantly change your comfort of working with a particular system.

If you aren’t sure how to update your CMS’s version, find out how we can help you with Drupal support.


Go to Source
Author:

Acro Media: Drupal Commerce Checkout: Headless Ready Ecommerce | AcroMedia

Headless commerce is quickly becoming the gold standard in content management system architecture. In this article, Josh Miller delves into the capabilities of Drupal Commerce 2 for a headless setup.

Using Drupal Commerce 2 checkout for headless ecommerce

  • Example in action: a checkout newsletter subscription. A brief explanation via an example of how Drupal Commerce checkout handles a newsletter subscription.
  • Headless decoupling breeds better code using events. Events in Drupal 8 give developers a new way to extend and modify how interactions with core and other modules work.
  • Entity + event-based instead of form-based. Using the method outlined in this section, your customer gets subscribed to your newsletter when they, and you, expect them to. No forms are needed.

Drupal Commerce 2, like Drupal 9, was a big change from previous versions. The codebase is much different and it’s quite a learning curve when moving from older versions of Drupal, like 7 or 8. However, this is good. The new versions are modern and all-around better. I’ve had a number of revelations while working with Drupal Commerce 2 and Drupal 8 that made me smile. (If you haven’t upgraded to Drupal 9, check out my blog Drupal 8 to Drupal 9: The Easiest Major Upgrade in a Decade

In this post, I’ll explore one revelation I had while working with Drupal Commerce 2’s checkout handling and how its forward-thinking development has paved the way (and encourages all new checkout panes to follow suit) for headless ecommerce using Drupal.

Drupal Commerce 2 checkout is not a form. Say what!?

Generally, when you think of checkout, you think of it as a sequence of events and one big final submission. This is further driven home by the idea that you can, and should, be able to go back and edit your checkout choices before the final submission. In Drupal Commerce 2, going back and forth between checkout steps is supported, but there is no final submission handler that saves everything.

Wait, what? That’s right, there’s no need to save all the data on the checkout form once checkout is completed. You see, all checkout panes (a step in the checkout process) have a submission event that gets called when it’s time to save the data. So if you’re going to save data in a checkout pane, you have to do it after your customer has moved forward in the checkout process but before your customer is ready to commit to the checkout pane’s final value state (complete checkout). Submission is perceived to be at the end of checkout, not before.

On the surface that might make sense, in fact, this workflow being so obvious might even blind you to the implications. Since each pane is basically handling its own submission workflow, you can’t allow your form state to persist choices and not make a decision until the end. You’re probably, like me, thinking that saving data and reacting to data is the same thing. But this assumption is old, out-of-date, incompatible with best practices, and in checkout for Commerce 2, causes design problems.

Click to discover your ideal architecture with our analysis.

Explanation through an example: A checkout newsletter subscription

A common want is to include a little checkbox underneath a contact information email field where new or returning customers can opt-in to a newsletter. Sure, that’s no big deal, right?

Our customer expects that things in checkout aren’t real until they complete checkout (i.e. nothing is saved until they actually place the order). On the other hand, Drupal Commerce 2 expects all panes to save their data after a “continue to next-step” button gets clicked, submitting that pane.

Here’s how the checkbox would be made using our current form submission logic:

  1. Create a CheckoutPaneBase object that collects data through a checkbox.
  2. On the pane form submission, subscribe the customer to your newsletter.

Do you see the problem? If we react on pane submission (our only choice in our current way of thinking), we’ll subscribe the customer to our newsletter well before they are done with checkout. In fact, each time they see the first page of checkout and proceed to the second, they will be subscribed to our newsletter. Not only is this not what the customer would expect, but subscribing them multiple times is totally unnecessary and would likely cause problems. Subscribing the customer on pane form submission is the wrong approach.

This is where things get really trippy — and awesome and beautiful and wonderfully clever and great. You see, Drupal 8, which Commerce 2 is built around, has been designed to not require forms, form states and value persistence in order to trigger important actions. This is a whole new way of thinking and maybe the most important to our discussion. Previous to this, most Drupal 7 developers would have assumed that all forms require user-facing interfaces that would be submitted, but that is a pretty brutal assumption and has plagued a lot of Drupal installations over the years. If that was still the case, then form submissions are something that headless implementations of Drupal would never really trigger. There must be a better way.

Headless decoupling breeds better code using events.

If checkout was a single form with a final submission handler that submitted payment, subscribed users to newsletters, saved addresses to profiles, and did all the things you would expect all at once, then all the code that manages these things would have to react to a single form submission.

However, if we use Drupal’s built-in event system instead, we suddenly have a much greater degree of control. But before we get into that, let’s first take a quick look at what events are and where they come from.

Drupal 8 made a big shift towards being object-oriented by adopting Symfony within its framework. Symfony provides a number of components useful in modern object-oriented programming, one of which is events. Events in Drupal 8 give developers a new way to extend and modify how interactions with core and other modules work. If you’re already familiar with Drupal 7, events are basically meant to replace hooks. Drupal 8’s event system documentation helps us to understand the basic concepts and components making up the event system.

  • Event Subscribers — Sometimes called “Listeners”, are callable methods or functions that react to an event being propagated throughout the Event Registry.
  • Event Registry — Where event subscribers are collected and sorted.
  • Event Dispatcher — The mechanism in which an event is triggered, or “dispatched” throughout the system.
  • Event Context — Many events require a specific set of data that is important to the subscribers to an event. This can be as simple as a value passed to the Event Subscriber, or as complex as a specially created class that contains the relevant data.

Source: Drupal.org documentation, Subscribe to and dispatch events (link)

Getting back to our checkout scenario, if you use the events system and your checkout completion is simply a state transition from Draft to Completed, then other modules could subscribe to that transition event, take the saved data from the different pane submissions, and do whatever they want with it.

Do you see the beauty here? By forcing checkout panes to submit before the final submission, we (module builders, implementers, etc.) have a baked-in reason to store checkout decisions on the order so that order events can access them separately, giving us the ability to create orders with checkout decisions saved that can skip checkout completely and still have the events trigger the needed actions. This is quite powerful and opens up a whole new world of possibilities. Of course, since this is an implicit design choice, it’s up to the author of the module or code to see the reasons and embrace them.

Entity + event-based instead of form-based

So to complete our newsletter subscription pane example using our new knowledge of events instead of form submissions, here’s what we would do:

  1. Create a CheckoutPaneBase object that collects data through a checkbox and saves it to the order (either through a field value or the ->setData typed data interface.
  2. Save this value on pane submission but don’t act on the value (i.e. don’t subscribe the user).
  3. Create an event subscriber and use the transition event you want to use as a trigger. Completing checkout makes the most sense.
  4. Treat the order value as a “request subscription to newsletter.” Then, when the event fires and the event subscriber runs, it can look for the saved value and set the user to subscribed or not after it returns. This allows us to handle someone going through an event twice for some reason, like for multiple orders, etc.

Your customer gets subscribed to your newsletter when they, and you, expect them to. No forms are needed. ISN’T THAT AMAZING!

Thanks to the many authors of Drupal Commerce 2, including Bojan Živanović and Matt Glaman, who implemented this design choice years ago, many modules and implementations are simply technically better and likely ready for headless implementations now that headless is all-the-rage.

And best of all, from a developer standpoint, this also means the bulk of your most critical automated tests that interact with your code doesn’t have to access the checkout form. They simply have to have orders that get transitioned. This makes writing tests, which equates to better code, simpler.

Your Drupal Commerce experts

As a full-service Drupal agency, Acro Media has significant expertise in digital commerce architecture, ecommerce consulting and design, customer experience, Drupal development and hosting architecture. We would love the opportunity to work with you.

View Our Drupal Commerce Services

Editor’s note: This article was originally published on October 28, 2019, and has been updated for freshness, accuracy and comprehensiveness.


Go to Source
Author:

Matthew Tift: Contribution Recognition and the Drupal Project

Contribution Recognition and the Drupal Project

Image
Hands offering a Drupal logo

mtift
Mon, 07/12/2021 – 13:00

This article was co-authored with Tim Lehnen, CTO of the Drupal Association, and cross-posted on Drupal.org.

Sustaining open-source projects is the challenge of this decade. Understanding how contributions are made—by volunteers, sponsored by an organization, or both—can create incentives for ongoing support. The Drupal project has measured contributions in Drupal.org issues since 2015 using an issue credit system that captures contributions—including code, documentation, speaking at events, security review, etc.—from both individuals and organizations. This insight is used to shape incentives for the business entities that participate in the Drupal ecosystem.

Issue trackers can explain what changes have occurred and why they are important. Version control systems such as Git track changes to a code repository, who changed what, and when. Drupal’s issue credit system dramatically expands the kinds of questions that we can ask about an open source project to include questions such as, “How much do volunteers contribute to the project?” or “How many of the contributions to this project are sponsored?”

In this article, we will describe how Drupal’s issue credit system works and why we would like to bring it to GitLab and other code collaboration platforms. We hope that other free/libre and open-source projects and organizations that want to understand their return on investment in open source can model their approach on this issue credit system and benefit from the insights we have learned in the Drupal community.

How It Works

Drupal’s issue credit system provides an interface that allows a person to describe the circumstances that facilitated their contributions for each issue on Drupal.org. Each issue on Drupal.org can credit multiple people, and may pertain to a code contribution, Drupal initiative meetings, Drupal event planning, podcast, and more. For instance, for each meeting for the group of people working on Drupal’s new front-end theme, Olivero, Matthew creates an issue that is tagged as “meetings,” the meeting notes are posted in the issue, and each attendee for that meeting receives credit.

Use of the issue credit system is optional, and there are three potential aspects of each issue credit.

First, a Drupal.org user can optionally attribute their participation in a specific issue to a company that allotted time for them to work on the issue. This is typically an employer that pays that person’s salary or wage. This organization must be directly tied to the contributor’s user profile on Drupal.org as a current or past employer and the organization must have an organization profile on Drupal.org. For instance, in Drupal issues, Matthew can credit his employer, Lullabot, whereas Tim can credit his employer, the Drupal Association.

Second, in addition to attributing a contribution to an organization, the credit system also allows someone to attribute their work to a “customer” (client), which also must have an organization profile on Drupal.org. Thus, in addition to crediting Lullabot, Matthew could also give credit to Georgia Public Broadcasting (GPB) when he is doing work on their behalf, such as porting the NPR and PBS Media Manager modules to Drupal 8. Tim, who works for a nonprofit, does not usually do work on behalf of a “customer” and would not typically use this field.

Third, for each issue, someone can check a box that indicates they volunteered their own time to work on the issue. For instance, Matthew has a long history of working in public media, feels a deep connection to the mission of public media organizations, and often added features to the public media modules on his own time after work. He added features that were not necessarily useful for GPB, but that would allow other public media organizations to use the module. Therefore some of his work was on behalf of his employer, for a customer, and volunteer. These are the sort of contributions that are difficult to measure without Drupal’s credit system.

Finally, because we don’t want to overwhelm our contributors with “paperwork,” the credit system remembers a user’s attributions as the default for their next issue.

This shows how the UI works:

Image
Drupal's credit system UI

The project maintainer can then select which issue comments truly contributed to the resolution of the issue, and all of the individuals and organizations attributed in those comments will receive credit:

Image
Drupal's UI for assigning credit

Why and how do we use this data?

We have been using the issue credit system in the Drupal project since 2015. We created the first analysis of the data in 2016 in a report titled Who Sponsors Drupal Development? that has been updated each year since.

Those reports contain answers to question such as:

  • What is the Drupal community working on?
  • Who is working on Drupal?
  • How much of the work is sponsored?
  • Who is sponsoring the work?
  • How diverse is Drupal?

The data are also used to determine the order of the organizations listed on Drupal’s Marketplace page. In contrast to a simple alphabetical ranking, or even paid placement for marketplace ranking, using the credit system in combination with other factors allows us to promote organizations that are good open source citizens first — and thus incentivize that behavior from other organizations. In addition to considering data from issue credits, those lists use an algorithm that also considers factors about an organization such as the number of case studies, whether they financially support the Drupal Association, and the number of projects supported.

Why We Want to Share

Every free/libre and open source project adopts slightly different values. Some projects consist entirely of contributions from people who are all doing work for one employer and Drupal’s issue credit system might not seem to be particularly useful to them. However, most organizations know that an open-source project with the support of just one company is a risk. For example, many of the open-source projects used in the financial sector were originally created by people working at a single company. However, the Fintech Open Source Foundation (FINOS), which works with companies in financial services, created a rubric to help organizations evaluate the health of open source projects, and one of their definitions of a healthy project is one that “is composed of individuals from 3+ organizations, ideally of 2+ org types, and including 1 bank.” A tool like Drupal’s issue credit system can help outsiders get a much better sense about the diversity of the contributors to a project.

Interestingly, FINOS also views it as a positive sign that “No requirement exists for developers to create a separate ‘work’ /corporate Github ID.” They encourage organizations to pay their employees to work on open source projects. They want people to contribute as part of their jobs, with contributing written into their job descriptions and NOT something they do in their volunteer time.

In addition to the FINOS rubric, there are other metrics that specifically refer to volunteer and organizational support. Here are a few examples:

  • Internews created the BASICS program (Building Analytical and Support Infrastructure for Critical Security tools) that includes a rubric to help reporters and organizations determine which open source tools they can trust. Among the questions they ask include “Are the maintainers primarily volunteers, or are they employed by an organization or company specifically to work on the tool?”
  • The Apache Maturity Model considers if “contributors act as themselves as opposed to representatives of a corporation or organization.”
  • The Community Health Analytics Open Source Software (CHAOSS) community, a Linux Foundation project focused on creating analytics and metrics to help define community health, suggests a wide variety of questions and considerations regarding “organizational diversity” such as, “What is the number of contributing organizations?” and a consideration of “ratio of contributors from a single company over all contributors.” This issue credit system also could help outsiders understand the potential “elephant factor,” which measures how dependent a project is on a small set of corporate contributors.

We’ve also seen end-user organizations begin to use Drupal’s contribution data in their formal RFPs when seeking a vendor for work. Because this contribution recognition system acts as a proxy for good open source citizenship, both private and public sector organizations have found value in asking companies to provide their contribution history as part of their bids. This feeds a virtuous cycle of continuous contribution.

We would love for other organizations and projects to benefit from the kind of insight we’ve been able to gather in the Drupal community. But for Drupal’s issue credit system to be useful to other organizations, it cannot only exist on Drupal.org, which is why we want to port our system to other development platforms, including GitLab, GitHub, and GNU Savannah. Drupal has already moved its code repository to GitLab and we have an open issue on GitLab to port Drupal’s issue credit system.

Limitations

Drupal’s issue credit system is clearly an improvement on previous systems that the Drupal community tried and later found insufficient, such as Certified to Rock (too opaque) or DrupalCores (only measures code contributions). However, the issue credit system is
not without limitations.

When Dries Buytaert first proposed that the Drupal community adopt a method for giving credit to organizations that contribute code to open source he did so in order to “encourage more organizations to contribute to Drupal and hire core developers.” Many of us who care about Drupal hoped this new system could be used to better recognize all aspects of contribution to the Drupal community. We saw people making a wide variety of useful contributions to the Drupal project and we wanted to give credit where it was due.

While there’s a common belief that we can use metrics to increase the number of organizational and individual contributors, a great deal of research suggests that trying to use metrics to shape communities can lead to undesirable results. In fact, Goodhart’s Law, named after British economist Charles Goodhart, states any measure used for control is unreliable. Indeed, we have found that Drupal’s issue credit system, like any public metric, has encouraged some people to shift their focus from making useful contributions to “gaming the system.” While some people have found ways to do the minimum amount of work in hopes of raising their profile or that of their employer, we encourage all contributors to break issues down into small parts so a large contribution doesn’t count the same as a small one.

Drupal’s credit system seems to avoid one of the pitfalls that Jerry Muller mentions in his book The Tyranny of Metrics: “measure output, not input.” Rather than giving people credit simply for trying, Drupal’s credit system captures committed changes to the Drupal codebase — the output. However, this system has grown to include many other kinds of contributions, including conference presentations, initiative meeting attendance, accessibility reviews, and much more. Consequently, it could be argued that Drupal’s issue credit system has grown to measure all sorts of inputs and the Drupal community has shifted focus toward one of the outputs of the issue credit system: the “leaderboard” on Drupal’s Marketplace page.

In some instances, leaderboards positively motivate community members. But leaderboards can also demoralize people when a change to the algorithm lowers their company’s rank on the Marketplace. For instance, a long-time Drupal contributor found a change to the algorithm that caused his company to drop down dozens of places on the Marketplace listing “incredibly demoralizing” and another well-known community member felt that his “contributions are now devalued.”

For everyone who feels proud to see their company placed highly on the Marketplace page there are many others who are left out. This is consistent with research on leaderboards in other communities that found how such rankings discourage contribution when “leaderboards elevate the top ten or twenty-five participants in populations of tens of thousands” and the “vast majority of members … perceive that they have no chance of making the list” (50).

This is an ongoing area of concern that requires careful attention for any community looking to implement such a system. For the Drupal community, we are careful to ensure that this contribution credit system is used to provide recognition for individuals, but not rank. We believe ranking individual contributors is an unhealthy model that doesn’t account for the privilege of free time.

On the other hand, because presenting an ecosystem of Drupal service providers creates a defacto ranking system—it’s in our best interest to choose one based on contribution behavior that promotes good open source citizenship, rather than something more capricious or arbitrary like a simple alphabetical or randomized list.

Start with a Goal, Not a Metric

The CHAOSS community recommends that free/libre and open-source communities adopt a Goal-Question-Metric format. In this format, a community first establishes goals. Then they need to establish questions that characterize the assessment or achievement of a specific goal. If the answer to the question does not matter, the community does not need information (metrics) and therefore does not need to measure.

Consequently, we view that Drupal’s issue credit system is most well suited to organizations that have specific goals and that have questions pertaining to sponsorship, volunteerism, diversity, and related topics. In the Drupal community, many people who had been participating for a decade or more saw a clear shift in the community from being that of primarily hobbyists to that of professional developers. If nothing else, Drupal’s issue credit system has shown us that organizations have played a significant, and growing, role in the development of Drupal. We can now state rather confidently that more and more contributions are sponsored, but volunteer contributions remain important to Drupal’s success. We know that of the people using the issue credit system, 5% were “purely volunteer” compared to 69% that were “purely sponsored.” We know that Drupal’s contributors have become more diverse, but that we would still like to increase diversity.

Despite its limitations, we feel that Drupal’s issue credit system offers significant value and we would like to see it adopted more widely. We are in the process of making individual and organizational credit an official metric of the CHAOSS project. We would like to see it adopted on GitLab, GitHub, GNU Savannah, and other platforms. Furthermore, if we standardize across these platforms, then the project health analytics researchers can study these attributes across all the projects and tooling ecosystems that support this data, and we can share the effort.

Would you like to know at a glance whether an open source project is primarily sustained by individuals or organizations?

Would you like to know who they are?

Would you like a window into good citizenship in your open source project?

Please join us! You can show your support by adding your own feedback on the issue to add the feature to GitLab.

Add new comment


Go to Source
Author:

Drupal Association blog: Contribution Recognition and the Drupal Project

In this retrospective post, guest author Matthew Tift of Lullabot reflects on Drupals contribution recognition system, how it has impacted open-source sustainability, and how it might be standardized and adopted by other open-source projects.

Matthew is a Lead Engineer at Lullabot. He has been involved in the Drupal project since 2010, helping to organize multiple Drupal core initiatives and writing extensively about the Drupal community.

Sustaining open-source projects is the challenge of this decade. Understanding how contributions are made—by volunteers, sponsored by an organization, or both—can create incentives for ongoing support. The Drupal project has measured contributions in Drupal.org issues since 2015 using an issue credit system that captures contributions—including code, documentation, speaking at events, security review, etc.—from both individuals and organizations. This insight is used to shape incentives for the business entities that participate in the Drupal ecosystem.

Issue trackers can explain what changes have occurred and why they are important. Version control systems such as Git track changes to a code repository, who changed what, and when. Drupal’s issue credit system dramatically expands the kinds of questions that we can ask about an open-source project to include questions such as, “How much do volunteers contribute to the project?” or “How many of the contributions to this project are sponsored?”

In this article, we will describe how Drupal’s issue credit system works and why we would like to bring it to GitLab and other code collaboration platforms. We hope that other free/libre and open-source projects and organizations that want to understand their return on investment in open source can model their approach on this issue credit system and benefit from the insights we have learned in the Drupal community.

How It Works

Drupal’s issue credit system provides an interface that allows a person to describe the circumstances that facilitated their contributions for each issue on Drupal.org. Each issue on Drupal.org can credit multiple people, and may pertain to a code contribution, Drupal initiative meetings, Drupal event planning, podcast, and more. For instance, for each meeting for the group of people working on Drupal’s new front-end theme, Olivero, Matthew creates an issue that is tagged as “meetings,” the meeting notes are posted in the issue, and each attendee for that meeting receives credit.

Use of the issue credit system is optional, and there are three potential aspects of each issue credit.

First, a Drupal.org user can optionally attribute their participation in a specific issue to a company that allotted time for them to work on the issue. This is typically an employer that pays that person’s salary or wage. This organization must be directly tied to the contributor’s user profile on Drupal.org as a current or past employer and the organization must have an organization profile on Drupal.org. For instance, in Drupal issues, Matthew can credit his employer, Lullabot, whereas Tim can credit his employer, the Drupal Association.

Second, in addition to attributing a contribution to an organization, the credit system also allows someone to attribute their work to a “customer” (client), which also must have an organization profile on Drupal.org. Thus, in addition to crediting Lullabot, Matthew could also give credit to Georgia Public Broadcasting (GPB) when he is doing work on their behalf, such as porting the NPR and PBS Media Manager modules to Drupal 8. Tim, who works for a nonprofit, does not usually do work on behalf of a “customer” and would not typically use this field.

Third, for each issue, someone can check a box that indicates they volunteered their own time to work on the issue. For instance, Matthew has a long history of working in public media, feels a deep connection to the mission of public media organizations, and often added features to the public media modules on his own time after work. He added features that were not necessarily useful for GPB, but that would allow other public media organizations to use the module. Therefore some of his work was on behalf of his employer, for a customer, and volunteer. These are the sort of contributions that are difficult to measure without Drupal’s credit system.

Finally, because we don’t want to overwhelm our contributors with ‘paperwork,’ the credit system remembers a user’s attributions as the default for their next issue.

This shows how the UI works:

Issue credit ui

The project maintainer can then select which issue comments truly contributed to the resolution of the issue, and all of the individuals and organizations attributed in those comments will receive credit: 

Maintainer credit ui

Why and how do we use this data?

We have been using the issue credit system in the Drupal project since 2015. We created the first analysis of the data in 2016 in a report titled Who Sponsors Drupal Development? that has been updated each year since: 2017 report, 2018 report, 2019 report, and the 2020 report. Those reports contain answers to questions such as:

  • What is the Drupal community working on?
  • Who is working on Drupal?
  • How much of the work is sponsored?
  • Who is sponsoring the work?
  • How diverse is Drupal?

The data are also used to determine the order of the organizations listed on Drupal’s Marketplace page. In contrast to a simple alphabetical ranking, or even paid placement for marketplace ranking, using the credit system in combination with other factors allows us to promote organizations that are good open source citizens first — and thus incentivize that behavior from other organizations. In addition to considering data from issue credits, those lists use an algorithm that also considers factors about an organization such as the number of case studies, whether they financially support the Drupal Association, and the number of projects supported.

Why We Want to Share

Every free/libre and open source project adopts slightly different values. Some projects consist entirely of contributions from people who are all doing work for one employer and Drupal’s issue credit system might not seem to be particularly useful to them. However, most organizations know that an open-source project with the support of just one company is a risk. For example, many of the open-source projects used in the financial sector were originally created by people working at a single company. However, the Fintech Open Source Foundation (FINOS), which works with companies in financial services, created a rubric to help organizations evaluate the health of open-source projects, and one of their definitions of a healthy project is one that “is composed of individuals from 3+ organizations, ideally of 2+ org types, and including 1 bank.” A tool like Drupal’s issue credit system can help outsiders get a much better sense about the diversity of the contributors to a project.

Interestingly, FINOS also views it as a positive sign that “No requirement exists for developers to create a separate ‘work’ /corporate Github ID.” They encourage organizations to pay their employees to work on open source projects. They want people to contribute as part of their jobs, with contributing written into their job descriptions and NOT something they do in their volunteer time.

In addition to the FINOS rubric, there are other metrics that specifically refer to volunteer and organizational support. Here are a few examples:

  • Internews created the BASICS program (Building Analytical and Support Infrastructure for Critical Security tools) that includes a rubric to help reporters and organizations determine which open source tools they can trust. Among the questions they ask include “Are the maintainers primarily volunteers, or are they employed by an organization or company specifically to work on the tool?”
  • The Apache Project Maturity Model considers if “contributors act as themselves as opposed to representatives of a corporation or organization.”
  • The Community Health Analytics Open Source Software (CHAOSS) community, a Linux Foundation project focused on creating analytics and metrics to help define community health, suggests a wide variety of questions and considerations regarding “organizational diversity” such as, “What is the number of contributing organizations?” and a consideration of “ratio of contributors from a single company over all contributors.” This issue credit system also could help outsiders understand the potential “elephant factor,” which measures how dependent a project is on a small set of corporate contributors.

We’ve also seen end-user organizations begin to use Drupal’s contribution data in their formal RFPs when seeking a vendor for work. Because this contribution recognition system acts as a proxy for good open-source citizenship, both private and public sector organizations have found value in asking companies to provide their contribution history as part of their bids. This feeds a virtuous cycle of continuous contribution. 

We would love for other organizations and projects to benefit from the kind of insight we’ve been able to gather in the Drupal community. But for Drupal’s issue credit system to be useful to other organizations, it cannot only exist on Drupal.org, which is why we want to port our system to other development platforms, including GitLab, GitHub, and GNU Savannah. Drupal has already moved its code repository to GitLab and we have an open issue on GitLab to port Drupal’s issue credit system.

Limitations

Drupal’s issue credit system is clearly an improvement on previous systems that the Drupal community tried and later found insufficient, such as Certified to Rock (too opaque) or DrupalCores (only measures code contributions). However, the issue credit system is not without limitations.

When Dries Buytaert first proposed that the Drupal community adopt a method for giving credit to organizations that contribute code to open source he did so in order to “encourage more organizations to contribute to Drupal and hire core developers.” Many of us who care about Drupal hoped this new system could be used to better recognize all aspects of contribution to the Drupal community. We saw people making a wide variety of useful contributions to the Drupal project and we wanted to give credit where it was due.

While there’s a common belief that we can use metrics to increase the number of organizational and individual contributors, a great deal of research suggests that trying to use metrics to shape communities can lead to undesirable results. In fact, Goodhart’s Law, named after British economist Charles Goodhart, states any measure used for control is unreliable. Indeed, we have found that Drupal’s issue credit system, like any public metric, has encouraged some people to shift their focus from making useful contributions to “gaming the system.” While some people have found ways to do the minimum amount of work in hopes of raising their profile or that of their employer, we encourage all contributors to break issues down into small parts so a large contribution doesn’t count the same as a small one.

Drupal’s credit system seems to avoid one of the pitfalls that Jerry Muller mentions in his book The Tyranny of Metrics: “measure output, not input.” Rather than giving people credit simply for trying, Drupal’s credit system captures committed changes to the Drupal codebase — the output. However, this system has grown to include many other kinds of contributions, including conference presentations, initiative meeting attendance, accessibility reviews, and much more. Consequently, it could be argued that Drupal’s issue credit system has grown to measure all sorts of inputs and the Drupal community has shifted focus toward one of the outputs of the issue credit system: the “leaderboard” on Drupal’s Marketplace page.

In some instances, leaderboards positively motivate community members. But leaderboards can also demoralize people when a change to the algorithm lowers their company’s rank on the Marketplace. For instance, a long-time Drupal contributor found a change to the algorithm that caused his company to drop down dozens of places on the Marketplace listing “incredibly demoralizing” and another well-known community member felt that his “contributions are now devalued.” 

For everyone who feels proud to see their company placed highly on the Marketplace page there are many others who are left out. This is consistent with research on leaderboards in other communities that found how such rankings discourage contribution when “leaderboards elevate the top ten or twenty-five participants in populations of tens of thousands” and the “vast majority of members … perceive that they have no chance of making the list” (50).

This is an ongoing area of concern that requires careful attention for any community looking to implement such a system. For the Drupal community, we are careful to ensure that this contribution credit system is used to provide recognition for individuals, but not rank. We believe ranking individual contributors is an unhealthy model that doesn’t account for the privilege of free time.

On the other hand, because presenting an ecosystem of Drupal service providers creates a defacto ranking system–it’s in our best interest to choose one based on contribution behavior that promotes good open-source citizenship, rather than something more capricious or arbitrary like a simple alphabetical or randomized list. 

Start with a Goal, Not a Metric

The CHAOSS community recommends that free/libre and open-source communities adopt a Goal-Question-Metric format. In this format, a community first establishes goals. Then they need to establish questions that characterize the assessment or achievement of a specific goal. If the answer to the question does not matter, the community does not need information (metrics) and therefore does not need to measure.

Consequently, we view that Drupal’s issue credit system is most well suited to organizations that have specific goals and that have questions pertaining to sponsorship, volunteerism, diversity, and related topics. In the Drupal community, many people who had been participating for a decade or more saw a clear shift in the community from being that of primarily hobbyists to that of professional developers. If nothing else, Drupal’s issue credit system has shown us that organizations have played a significant, and growing, role in the development of Drupal. We can now state rather confidently that more and more contributions are sponsored, but volunteer contributions remain important to Drupal’s success. We know that of the people using the issue credit system, 5% were “purely volunteer” compared to 69% that were “purely sponsored.” We know that Drupal’s contributors have become more diverse, but that we would still like to increase diversity.

Despite its limitations, we feel that Drupal’s issue credit system offers significant value and we would like to see it adopted more widely. We are in the process of making individual and organizational credit an official metric of the CHAOSS project. We would like to see it adopted on GitLab, GitHub, GNU Savannah, and other platforms. Furthermore, if we standardize across these platforms, then the project health analytics researchers can study these attributes across all the projects and tooling ecosystems that support this data, and we can share the effort. 

Would you like to know at a glance whether an open-source project is primarily sustained by individuals or organizations? 

Would you like to know who they are? 

Would you like a window into good citizenship in your open source project?

Please join us! You can show your support by adding your own feedback on the issue to add the feature GitLab


Go to Source
Author:

Evolving Web: Mastering Drupal for Content Editors

Do you work with web content? Are you just getting started with using Drupal to publish your site?

Our team has written extensively about the different things you’ll need to navigate in order to successfully deploy your content strategy with Drupal as your CMS. We broke down this guide into five key themes:


Demystifying Drupal

If you’re completely unfamiliar with Drupal, go download our beginner’s guide. It covers what this open-source digital experience platform is all about, what it can do for you and your content, and how to define key Drupal-isms and other important terminology.

Otherwise, you might be aware that Drupal has a bit of a reputation for being one of the more complicated CMSs to master. But dive into the latest version, Drupal 9, and you’ll see huge strides in user-friendliness.

The Drupal Association has been focusing on user experience for content editors and developers over the last several years, and the improvements make the CMS so much friendlier for beginners.

Take the new Layout Builder, for example, which introduces visual page editing functionality for content creators via the admin centre:

Drupal’s Layout Builder lets content editors build and modify pages visually using drag-and-drop, eliminating a lot of reliance on developers and speeding up marketing workflows. Using intuitive, block-style layout controls, designers and editors can:  

  • Build default page templates for different content types (e.g. blog posts or feature pages)
  • Autonomously override default settings when a small change to the usual layout is needed
  • Create structured single-use landing pages (e.g. for an offer or an event) that don’t necessarily follow a default template

Drupal 9 boasts lots of other improvements that benefit content creators, like better media handling and more fleshed out content moderation workflows. Learn more: 

And if Layout Builder isn’t your jam, Drupal has another page-building solution: Paragraphs.

Paragraphs is great for building structured content that is consistently formatted.

With Paragraphs, you get to create Paragraph Types, each of which has its own set of fields, that live within the parent content. The content editor can pick from a list of options (which the site builder can control), deciding which content components to add to the page.

With Paragraphs, the content editor is building a form, and then filling the content into that form. For example, they can add a call to action and then a video, and then a side-by-side text. And then they can fill in the content for all those elements. Later, they could reorder them.

Paragraphs provides a lot of control and more streamlined options for content editors. It requires fewer clicks to add a new piece of content. It’s great for situations where you want to keep things simple. Many situations don’t actually require variations in layout, but just to need to allow for a flexible content model.

Learn more about Drupal’s two main approaches to structuring and laying out content: Layout builder vs. paragraphs: designing a flexible content model with Drupal

When it comes to adding actual content to the page – and making sure everything looks good when you share it – some of Drupal’s core modules can help. Evolving Web trainer Trevor put together these videos to demonstrate a couple of ways in which Drupal can help integrate with your social media strategy.

If you prefer to read, these are the relevant articles:

Drupal vs. other DXPs/CMSs

What if you’re used to something different? You can get a great idea of the type of things to look for in a content management system in our article What we can learn from Contentful, Craft CMS, Squarespace, and WordPress, which recaps a user research exercise conducted by our co-founder Suzanne and UX lead Annika.

We asked participants for their first impressions of each platform, then asked them to do a few simple tasks: creating an article from content in a Google Doc, editing and previewing it, and then deleting the content. Then, we asked what they thought of the platform.

We also did a side-by-side comparison of Drupal and the most widely used competitor, WordPress, from the point of view of a content specialist.

Check out the recap below, and read the full article for the detailed breakdown.

A table comparing features of WordPress vs. Drupal


    Acing accessibility

    More than a simple legal requirement, accessible web content is a matter of human rights. So how do you make sure your site stacks up to the latest standards?

    Accessibility: The basics

    First things first: understand what web accessibility means in practice for your site – and why it’s also vital for your overall business. 

    “Equal access sounds nice, but why should I care about web accessibility? This seems like an extra headache that is going to cost me money.” In fact, the opposite is true: not caring about accessibility is an expensive proposition. If your website is not accessible, you risk losing a significant portion of potential clients since 20% of the population will not be able to use your site. Second, the law mandates it.

    In the US, Title III of the Americans with Disabilities Act includes websites and now applies to any public-facing businesses and private businesses in 12 categories, including sales, entertainment, service establishments, recreation and more. A business whose is deemed inaccessible to someone with a disability can be forced to immediately redesign the website in addition to paying monetary damages and the other party’s attorney fees.

    In Canada, four provinces currently have web accessibility laws: Quebec, Manitoba, Nova Scotia and Ontario. The Accessibility for Ontarians with Disabilities Act (AODA) is the most comprehensive of the four, and aims to create a barrier-free Ontario by 2025.

    To this end, by 2021 all private and non-profit organizations with more than 50 employees and all public organizations must make their websites compliant with Web Content Accessibility Guidelines (WCAG). The federal government is looking to pass web accessibility guidelines in the near future with the aim of enforcing WCAG. We can expect Canadian federal web accessibility laws to be rolled out soon.

    Read more about accessibility basics:

    Designing accessible content

    Even if you’re not a visual designer, you should have a good handle on how to showcase information in an accessible manner throughout your site.

    links
    From text spacing to hyperlink text, basic best practices go a long way in creating accessible content

    Read 7 design considerations for accessibility for an overview of the key best practices to follow when publishing content on your Drupal site.

    Accessibility testing and governance

    It’s a lot easier to design an accessible website if you consider accessibility from the get-go, but we don’t always have that luxury. You’re far more likely to have an existing site on your hands, and, if you’re reading this, you’re probably wondering how to determine how accessible it is currently so you can get a better idea of what needs to be done.

    In our in-depth guide How to test your Drupal site’s accessibility, we cover how to manually assess your site content for issues, which tools you can use to help test and monitor accessibility issues, and which Drupal modules are available to make accessibility easier to maintain across your site.

    Finally, maintaining accessible content can be challenging. One way to alleviate a lot of the time and effort spent fixing problems with accessibility is to deliberately implement an accessibility governance plan for your organization.

    Governance makes it easier to keep track of your progress towards meeting your accessibility goals. It also provides decentralized teams with a single shared point of reference for all things accessibility, which takes out a lot of guesswork and reduces the risk of human error.

    What’s more, having a documented governance plan is a great way to demonstrate to authorities that your institution is committed to making improvements. If accessibility becomes a legal requirement in your jurisdiction, you’ll be able to meet any noncompliance issues with a clear roadmap for a solution.

    Learn everything you need to know about governance and accessibility in our article Web accessibility governance for higher ed (it’s worth a read regardless of your industry!).

    More resources

    On-demand webinars by Evolving Web

    External links


    Understanding UX

    Many people – myself included – believe that content creation is part of the greater discipline of design, and for good reason: the way users experience content is just as much the realm of how the content itself is designed than it is of visual effects.

    Key concepts to study: 

    • User stories
    • Wireframes
    • UI elements
    • Gestures
    • Responsiveness
    • Microcopy

    As a content specialist, understanding the core tenets of good user experience design is key to elevating your practice. Here are a few articles we’ve put together with the help of our all-star designers that’ll get you up to speed fast.

    UX comparison table
    Check out a UX critique of provincial health websites in How to ensure critical health information reaches its audience

    Articles

    Tools and resources


    Organizing information

    From your site’s information architecture to your overarching content strategy, there’s a lot more than meets the eye when it comes to structuring content. In Drupal, it all starts with taxonomies:

    In Drupal, the taxonomy system (which you’ll find under Content Structure in the Admin menu) is made up of vocabularies, which each comprise a series of terms. For example, “red”, “blue”, and “green” are terms you might find in a “Colours” vocabulary.

    Read more: How to organize your Drupal content with taxonomies

    Key concepts to study:

    • Taxonomy
    • Content modeling
    • Labelling
    • Metadata
    • Wireframing
    • Navigation and hierarchy
    • User research

    Articles:

    External links:


    Getting the word out

    People need to be able to find the great content you’re putting out there. Here are a few guides on SEO basics and other marketing-related articles that should help you navigate that end of the content creation process.

    Key concepts to study:

    • Business objectives
    • Goals
    • Metrics
    • KPIs
    • Targets
    • Dimensions
    • Segments

    Articles:

    Other resources:

    Get trained on Drupal with a program designed for you

    Content creator track

    Evolving Web’s Content Creator training track features four in-depth courses that cover everything you need to know about using Drupal to manage and showcase your content. Get all the details and register for the next session here!
     
    + more awesome articles by Evolving Web


    Go to Source
    Author:

    Drupal Association blog: Drupal Steward now available to all

    Drupal StewardAfter several years of hard work, the Drupal Association and the Drupal Security team are pleased to announce that Drupal Steward is now available to all.

    What is Drupal Steward?

    Drupal Steward is a web application firewall that bridges the gap between the time when a security release is announced and when your site is fully updated with the new security patch. This globally distributed service from the Drupal Security Team and the Drupal Association provides immediate, affordable protection for your website while giving your IT team the flexibility to implement site updates without disrupting other priorities.

    How can Drupal Steward help me?

    Drupal security releases happen on Wednesdays. Both the good actors, site owners like you, and bad actors, people trying to hack your site, learn about a vulnerability at the same time. Rare highly critical vulnerabilities could potentially be exploited within four hours of the release. Because of this, your teams must stay on alert during any security release window for a highly critical vulnerability to update your site as soon as possible. 

    With Drupal Steward, you can update on your own time. 

    In the event of a highly critical vulnerability, the Drupal security team publishes a notification(PSA) in advance to warn users. When you’re protected, you *do not* have to be on red alert or pay staff overtime to be on call. You can schedule testing and implementation of the security update on a timeline that works for you.

    Please note: Not every vulnerability can be protected by the Drupal Steward program, but it is ideally suited to help protect you from those that are mass exploitable. Drupal Steward can only apply to vulnerabilities that involve exploiting a request to the webserver, which may not apply to some security issues. Also, a zero-day vulnerability (one that is discovered and publicized without the security team’s knowledge) is always possible.

    How much does it cost, and how do I sign up?

    We’ve worked very hard to supplement our pricing so that Drupal Steward is affordable to as many site owners as possible. Drupal Steward scales to the number of requests you receive, so check out the calculator on drupalsteward.org to estimate your pricing.

    Signing up for the service is as simple as creating an account on drupalsteward.org, adding your domain names to be covered, and updating your DNS settings to route requests through the Drupal Steward service. 

    Learn more      Sign up

    Why isn’t Drupal Steward free? How does Drupal Steward support the security team and the community?

    Code is and always will be free in the Drupal project, but a service by its nature is not.

    Drupal Steward requires a globally distributed infrastructure to ensure that the security layer doesn’t increase latency and degrade the experience of users anywhere in the world. 

    Funding from Drupal Steward directly supports the Drupal Association and our mission to help the community build Drupal. Furthermore, a portion of the funds are set aside specifically for proposals made by the Drupal Security Working Group on behalf of the Drupal Security team. 

    Thank you to our Partners

    We want to thank our founding partners, Acquia and Pantheon who have implemented Drupal Steward protection across their entire platforms so that any of their clients are already covered by this program. Their early support made it possible to bootstrap this community tier for all.

    We also want to thank our Supporting Partners, who are able to offer Drupal Steward to their clients at the preferred pricing level through the Drupal Association community tier.


    Go to Source
    Author:

    Web Wash: Create Infinite Scroll pages using Views Infinite Scroll in Drupal

    Infinite scrolling is a technique used to show more content as the user scrolls down a page eliminating the need for the user to click to go to the next page. This is commonly implemented in popular social media apps.

    This tutorial will demonstrate how to use the Views Infinite Scroll module to achieve this and also show options that can be used to customize the user interaction with the infinite scrolling behavior.


    Go to Source
    Author: