As a recovering English major, I’d like to believe words alone are enough to tell a tale on the web. A text-only page is fast: even a long article can load nearly instantly. Add photos, and the web slows down. Yet great images bring emotion, a connection with others and the world around us. They’re often worth the tradeoff in time to load a page.

People don’t want to wait around longer than necessary, though. Any benefit you get from a great image vanishes once someone’s neck begins to tense up as the loading bar slowly creeps from one side of the URL bar to the other.

undefined

Images also lose their emotional impact if they’re blurry and someone has to squint to see the subject.

If you take an image that looks nice and crisp on a phone, then share that same file on a big desktop screen, it’s going to look fuzzy. Switch it around with a nice, big image that looks great on desktop, and somebody looking at the same file on a phone will grow impatient, waiting for the file to load.

We want the best of both worlds: images that look great no matter which screen they’re viewed on, while loading as quickly as possible.

Thankfully there’s a great solution to this problem due to the work of the Responsive Images Community Group. They worked with browser developers to develop new markup options such as the picture element and the sizes and srcset attributes. With these tools, we can provide a selection of image files so your browser can pick the right one depending on how someone is viewing it. This can help to make sure photos download as fast as possible while still being enjoyed in all their glory.

There are a lot of great resources that help explain the new responsive images specification. I highly recommend Jason Grigsby’s article series, Responsive Images 101, as well as Eric Portis’ Responsive Image Guide.  You can read the actual specifications for the picture element or the srcset and sizes attributes, although specs can be pretty dry reading. Understanding the specifications and syntax are important, but you still need to make a number of key decisions on how you’ll use responsive images with a particular site.

I’ve set up responsive images on a number of large sites like NYU Langone, and I also help to maintain the Responsive Image and Breakpoint modules for Drupal 8, so I wanted to share some of my experiences in working with responsive images.

In this article, I’ll be explaining some of the key concepts for responsive images, as well as providing an overview of a few different responsive image tactics. The solutions used for any particular image will vary. Understanding those options will help you to set out on the right path.

I’ll dig into more technical detail in future articles focused on some of those individual tactics. Right now, let’s start looking at the various ways we can make sure our images look awesome and load fast.

Picking the right method to make your images responsive

The biggest difference in how you’ll handle making images responsive is what you’ll do for images that are photos, versus how you’ll handle logos and icons.

Photos—often referred to as raster images—do not scale so easily. The word raster comes from the Latin word rastrum, or rake. Old cathode ray tubes created images on screens by literally drawing one line at a time, raking each across the screen. These days raster images are created by hundreds of thousands to millions of individual dots, or pixels, on a screen. It takes a lot of data to tell a browser what color each of those dots should be in order to recreate an image.

undefined

Logos and icons on the other hand often use vector graphics. These images can be specified using mathematical vectors—a series of points on lines along with information that describes the curves connecting those points. The simpler shapes and colors in vector graphics can scale really easily to a wide variety of sizes, because math can easily calculate the color needed for each pixel.

For vector graphics, you’ll want to use SVG files. SVG means Scalable Vector Graphics, and the name really says it all. SVGs are text files which use XML to describe the vectors necessary to create an image. Use an SVG plus a little CSS, and your logos and icons will be responsive.

I would not recommend using an older technique to load icons through a webfont containing multiple icons. The goal of that was to avoid multiple requests to a server: with the the advent of the http/2 protocol, that’s not as much of an issue. Icon fonts also have major accessibility issues, since they use a specific letter of a font for each icon. For people using a screen reader, that’s not so awesome.

For photos and other raster images, the techniques you use might vary a bit, depending on if the images are loaded through CSS or HTML.

There are ways to make background images added to a site through CSS responsive, but unfortunately browser support can be a bit shaky.

Thankfully, images used as content within a site, which are loaded through the HTML markup for a page, have great options that we can use. These sorts of images are generally what people are referring to when you hear the term responsive images.

So we’ll be focusing mostly on raster images that appear as content on your site. Even there, however, there a few important variations to keep in mind.

How do images vary across breakpoints?

When we’re talking about making images responsive, we mean that we want to provide some variation in how those images appear depending on how they’re viewed.

Sometimes we want an image to essentially look the same whether you’re on mobile or desktop. For example the image always appears as a square or a rectangle. It might only fill a sidebar column on desktop, while filling the full width of the screen on mobile. However, it retains the same aspect ratio—the relationship between the height and the width of the image. 

We call this use case viewport sizing, and typically this ends up being the most common way that images are made responsive.

For viewport sizing, we typically just need a good ol’ img element with two new attributes: sizes and srcset. We’ll get into how those new attributes work, but the short version is that sizes tells a browser how much space an image takes up in a site’s layout at various screen sizes, while srcset provides some image file options the browser can choose between.

<img src="small.jpg" srcset="large.jpg 1024w, medium.jpg 640w, small.jpg 320w" sizes="(min-width: 36em) 33.3vw, 100vw" alt="A swirling nebula">

Sometimes we need images to change a bit more at various screen sizes. Maybe we need a square image on mobile but a rectangle on desktop. Sometimes we also need to change the cropping of an image across breakpoints, showing a close-up image on mobile, while using a wider shot on desktop. Changes to aspect ratio and cropping are often called art direction, and they require a more complicated solution.

For art direction, we’ll need to use the picture element, which serves as a wrapper around a series of source elements, along with an img element. Each source element has its own media attribute: the media query defines the viewport size range where that source should be used to select the particular file that will be used for the img element contained inside the picture element.

You can also provide a sizes and srcset attribute on a source element so the browser has a number of files it can choose between for a particular viewport range.

<picture> <source media="(min-width: 70em)" sizes="40vw" srcset="nebula-artsy-wide-2800.jpg 2800w, nebula-artsy-wide-2240.jpg 2240w, nebula-artsy-wide-1400.jpg 1400w, nebula-artsy-wide-1120.jpg 1120w"> <source media="(min-width: 35em)" sizes="36vw" srcset="nebula-artsy-square-1120.jpg 1120w, nebula-artsy-square-900.jpg 900w, nebula-artsy-square-560.jpg 560w, nebula-artsy-square-450.jpg 450w"> <img src="nebula-artsy-tight.jpg" alt="An artsy cat"> </picture>

Using the picture element is overkill when you’re just dealing with viewport sizing. Having separate source elements is great for art direction, though, because you can provide a set of files on one source element with a certain aspect ratio or cropping level, while using a different aspect ratio or cropping level on another source element.

There’s very good browser support for the picture element, as well as the sizes and srcset attributes. IE11 is the main browser that still needs a little help, and for that you will want to make sure you’re using the Picturefill polyfill. Doing so may change what you use as a fallback src on the img inside the picture element. See the example on the Picturefill site for details.

For either viewport sizing or art direction, you’ll likely want to use the sizes and srcset attributes, so let’s dig a little deeper into what purpose those attributes are serving. In short, it’s all about pixels versus percentages.

Responsive image grudge match: Pixels versus percentages

Responsive design typically specifies a site’s layout in percentages, while raster images like photos are defined in pixels. It’s a grudge match, and our job is to serve as referees.

In one corner, we have responsive web design, where percentages define layout. By using a percentage, we allow the browser to do the heavy lifting of figuring out for an element like a sidebar exactly how many pixels wide it should be for a particular screen size. This is great, since like vector images, a browser can easily calculate layout boxes through the power of mathematics.

In our other corner, we have photographic images. Photos are more difficult to resize, because we need to give a browser detailed instructions about every single pixel in the image. As a result, photos don’t flex so easily.

undefined

Image files are essentially information with instructions detailed enough to create a photo at a particular size. A browser can figure out how to make an image smaller than its file size would suggest, because it has enough information to do so. Making an image bigger is much trickier, because if a browser doesn’t have enough detailed instructions for a larger size, it has to start guessing. And inevitably, it will guess wrong at least some of the time, which leads to images looking blurry.

However, that doesn’t mean we can just give a browser so much information that it can draw an image at any potential size. A high-res image file is going to be way bigger than necessary for a much smaller, low-res screen. More information, bigger file size, longer download time.

Because pixels matter so much, we also have to keep in mind screen resolution. Some displays use a larger number of pixels in the same amount of physical space in order to create a more detailed image. For a low-res display, a sidebar that has a layout width of 500px will use 500 physical pixels in a screen to create that width. For a high-res “retina” screen, there may be 1000 physical pixels in that same space. That means we need a higher resolution image to account for that difference.

So we want to figure out for one particular type of image how many pixels of information we need in the file for the amount of space it takes up in a percentage of the site’s layout at a certain screen size and resolution. It’s okay if the file has a few more pixels of info, although not too many more, but we definitely want to avoid having too few pixels of info, so we can avoid blurry images.

The sizes attribute helps us to tell the browser about the layout percentages for a particular image, while srcset provides information about the number of pixels in each image file. Why do we need to put this information into HTML markup, though?

Why browsers need a sizes attribute

We need sizes because of how browsers process a web page that is being loaded. Once a browser receives the HTML for a page from the server, it begins scanning the document to look for other resources it will need to load. It finds all the CSS and JS documents that need to be loaded, as well as any image files, then begins prioritizing how it will download those files.

CSS files are a top priority, because they provide so much critical information about how a page’s HTML should be styled, and because CSS files often contain links to other resources that need to also be downloaded, such as web fonts and background images. JS is also a big priority, as it can change around the order of DOM elements that will need to be styled based on CSS rules. What’s critical to understand is that browsers improve overall performance by starting to download images while the CSS and JS files are still being processed.

That’s been a big challenge for responsive images, because you can’t just use CSS and JS to select an image file with the right width for a particular image slot, as doing so would mean waiting until all of the CSS and JS has been processed to fully understand the final layout of a page and thus the width of an image slot.

We can solve this tricky problem by using a key part of the responsive images spec: the sizes attribute. This attribute on an img element (or on a source element within a picture element) tells the browser how large that element will be once layout rules are applied.

So, within our sizes attribute, we provide a set of widths and accompanying media conditions. A media condition is simpler than a media query and consists only of something like (min-width: 1000px). For our example, we could provide the following sizes attribute:

sizes="(min-width: 36em) 33.3vw, 100vw"

The first thing to note is that we’re providing the media condition for the largest possible viewport first, as the browser will pick the first option that matches.  Next, note the units we’re using:

• Using em for widths in media conditions is a good practice, because it provides extra flexibility for people who change the settings in their browser to use larger than normal default font sizes. The typical default font size is 16px for 1em, so 36em is the equivalent of 576px. So we’re saying when the browser has a minimum width of 576px, this image takes up 33.3vw space in the layout.
• The vw unit stands for viewport width: 1vw is equal to 1% of the width of the viewport; 33.3vw is 33.3% of the viewport width. The vw unit is used instead of percentages to make clear that this is a percentage of the viewport, not the width of the containing element.

Finally, the comma indicates the next set of media conditions and layout data. You can have as many commas as necessary within a sizes attribute. Here we just have one, so we’re saying that for viewports smaller than 576px wide, this image takes up 100% of the viewport space.

Let the browser choose with srcset

The sizes attribute needs to be paired with a srcset attribute on the same element (either an img element or a source element). This attribute will contain a comma-separated list of the URLs of image files: after each URL there is a space, then a number signifying the width of the image followed by the letter w. For example:

srcset="image235.jpg 235w, image290.jpg 290w, image365.jpg 365w, image470.jpg 470w, image580.jpg 580w, image730.jpg 730w, image940.jpg 940w, image1160.jpg 1160w"

• The browser will take a look at these image files and use the number with the w to calculate which image file will best fit within the amount of space we’ve defined in the sizes attribute.
• The browser knows the viewport size, so it can pick the right media condition and then use the width value next to the media condition to calculate how many pixels are needed to fill that space.
• The browser also knows the resolution density of the screen, so it can take that into account with its calculations as well.

The browser can also in theory take into account the bandwidth you have available, providing a lower-res source if you’re on a 3G connection perhaps.

You don’t need to worry about that, though. All you need to do is provide the layout information in the sizes attribute and the possible image sources that can fit within that space, and the browser will take care of matching up the right source file with the image slot.

Make images fluid with CSS

To make images responsive, we still need to write CSS rules that will make the image flexible. For example:

img { width: 100%; height: auto; }

If you’ve provided a set of images in srcset with sufficient widths for the amount of space defined in sizes, this should be all you need. If you don’t have a way to guarantee that, you could also add a max-width: 100%; rule that ensures images are never made larger in the layout than the number of pixels within the image. This can cause design discrepancies if your images are supposed to take up a certain amount of space in a grid design, so I tend to leave off this rule.

If I want to have an image take up a certain amount of space within its container, I find it works better to put a wrapper div around the img or picture element and then set layout rules on that wrapper. That way I can have one consistent CSS rule for all images, but then modify the width of the wrapper in the situations that need that.

Next steps

Hopefully you now have a better understanding of a few different types of images and how you might make each responsive.

The sizes and srcset attributes are often key to making images responsive. In an upcoming article, I’ll talk through how to look at a particular type of image for a site, and then determine what values to use for sizes and srcset. Creating that sort of plan is really key to a successful responsive images solution.

Once you have a plan, you still need to create all the image file variations, and if at all possible you should find a way to avoid creating those image files manually. In a separate article I’ll go over how to use Drupal 8’s built-in tools to automate this process. In a decoupled site, you may find a cloud-based tool works well for that part of the process: Kris Bulman will be going over how to do that in a future article.

Other articles in this series may go over topics like how to implement art direction for responsive images in Drupal 8.

The payoff for this effort is that your images look nice and crisp at all viewport sizes, while still downloading efficiently. No more super slow mobile sites that take forever to load images! That makes a huge difference for those visiting your site. Downloading image files tends to be a big chunk of the work that browsers do when visiting a new site. Speed that up and everybody wins.

The final day of DrupalCon Europe talks

#DrupalConEur is 3 days of talks surrounded by a day of summits and a day of collaboration sprints. Thursday was the 3rd and final day of presentations.

John Albin Fri, 09/29/2017 - 18:09

Most importantly for me, Thursday was the day after I finished giving my talk, so I was able to stop tweaking my slides and focus on learning. I started my day by grabbing a hazelnut croissant and coffee in the underground and headed to the community keynote by Joe Shindelar, “Everyone Has Something to Share”.

After that I went to Everett Zufelt’s ”JavaScript and Accessibility: Don't Blame the Language”. Everett busted several myths about accessibility including the pointed “Our web application is accessible (but we’ve never tested it)” And the most useful part of his talk was describing ways that websites get accessibility right. I've now added “ARIA Live Regions” to my TO DO list and highly recommend anyone making websites to watch the video for his presentation.

While I was grabbing a quick lunch, Tamás Hajas presented, as part of the Frontend Track, “What’s new in CSS? Introduction to CSS Grid and CSS Custom Properties”. I added the video to my YouTube “to watch” list and headed to Chris Ruppel’s “Houdini, the Future of CSS”. Chris’s talk was part of the Horizons track, which focuses on the future of Drupal and the web. Houdini is a proposed API that will go into web browsers that will give CSS developers the same ability that JavaScript developers already have; the capability to polyfill proposed changes to the CSS spec. With Houdini, CSS developers could potentially create new syntax (like nested selectors or element queries) and use that in their production code.

Earlier in the week, the Drupal Association announced there would be no DrupalCon Europe in 2018 and that they had formed a committee to determine if and/or how a DrupalCon Europe 2019 could happen. So with this in mind, Théodore Biadala, whose session was scheduled in the final time slot of the day, started his ”Offline Core” presentation by saying ”Thank you for coming to the last session of the last day of the last DrupalCon Europe. Ever.” Awwwww… (Hopefully it won’t be, but that’s another blog post) The “Offline Core” session was a part of the Core Conversations track and after a short presentation about his idea for supporting Progressive Web Apps (PWA) and Service Workers in core, Théodore facilitated a lively discussion with the session attendees on multiple facets of the idea. We even solved a potentially tricky problem: how to turn off a Service Worker (code running on a user's browser) after the website owner has disabled the Service Worker's module in Drupal.

For the past six years, the closing session is followed by Drupal Trivia Night! The Drupal-related trivia questions are written by the wonderful Drupal Ireland community. I attended the first trivia night at DrupalCon Chicago 2011 and never miss it when I go to DrupalCon. Tonight was the 15th Trivia Night. I know because this was one of the trivia questions (Dang it! I wrote down "16" as my answer.)

Since I’ve been in the Drupal Community for 13 years, I know a lot of trivia, but as usual, I did horribly. But winning Trivia Night is not the goal, having fun is and the Drupal Ireland team does a great job of getting everyone involved and happy while losing badly. For example, my team won an award for "favorite team name"; the team name we picked was "We love the Irish!"

Sometimes we need to do similar coding in different places, such as for account settings email templates (Welcome email template, Forget password email template, from UI to get the same results. In this scenario, it's always suggested to create a custom token and use that in different types of email templates (account setting email templates) from Drupal UI in [token:type] format.

In our previous blog, we explored about creating custom tokens in Drupal 7 and in this, we will take a brief look at what is token? How to create it in Drupal 8?

In the vein of first thing first, what is token?

Tokens are very small bits of data or text that we use or place into…

Drupal newbie? Or maybe you are a mature developer that’s in charge of training the youth? Then keep on reading!

The following article was written based on the experience of our junior developer Sophia. In a short term she had to learn the Drupal 8 specifics and be able to write custom modules in Drupal 8.

We’re going to examine the main OOP features that were implemented in Drupal 8 and create a module. Code samples are included.

 

Check this tutorial on writing a module in Drupal 8

 

 

In 2017, 77% of Americans own a smartphone, a phenomenal increase from just 35% in 2011 (source: Pew Research Center Mobile Fact Sheet). And we are not just talking about a single screen size here! There are a multitude of screen sizes to consider from different versions of iPhones, android. And outside of smartphones, you probably want to consider iPads, tablets, desktops, tvs, to name a few.

Drupal Modules: The One Percent — Linked Field (video tutorial) NonProfit Thu, 09/28/2017 - 22:17 Episode 37

Here is where we seek to bring awareness to Drupal modules running on less than 1% of reporting sites. Today we'll consider Linked Field, a module which will allow you to easily wrap a link around another field.

Session Schedule Posted, Training Classes Open for Registration! Anne Thu, 09/28/2017 - 6:05pm Sessions Lineup Now Posted!

Ready yourselves, fellow adventurers -- this year’s session and speaker lineup have been revealed! There will be sessions spanning the worlds of development, design, strategy, project management, technology communities and everything in between.

A hearty thank you to all the valiant souls who submitted over 187 session proposals, your contributions, year after year, are what make BADCamp excellent. And for those whose hearts still burn to speak, there will be BoF opportunities throughout the event.

Drupal Training Classes

Are you prepared to gain mastery of your Drupal Skills? BADCamp has two full days of Drupal Training offered from some of the most talented leaders in the Drupal community.

Join the masters on Wednesday and Thursday while they unfold the magic. This year BADCamp offers skills training in DevOps, theming, module development, content strategy, and much more!

BADCamp has historically provided a completely free training thanks to the overwhelming generosity of our sponsors. However, this year we must charge a nominal fee of $25 to cover operating expenses as we are short on sponsorship funding. We sincerely apologize for this short notice. We needed to find ways at the last minute to break even.

This was a really difficult decision for the BADCamp organizers to make.

If you can't afford the $25 or its super complicated to get funding, please reach out to the BADCamp organizers via the contact form and we will help! We have already had generous attendees offer to donate extra seats in the classes.

Sign up for the BADCamp 2017 newsletter to stay in touch (bottom of Homepage).

Do you think BADCamp is awesome?

BADCamp is 100% volunteer run and 100% funded by our sponsors and the support of our local community. Thank you for your support.

Would you have been willing to pay for your ticket?  If so, then you can give back to the camp by purchasing an individual sponsorship at the level most comfortable for you. As our thanks, we will be handing out some awesome BADCamp swag as our thanks.

We need your help!

BADCamp is 100% volunteer driven and we need your hands! We need stout hearts to volunteer and help set up, tear down, give directions and so much more!  If you are able to help us, please sign up on our Volunteer Form.

Sponsors

A BIG thanks to our sponsors, especially Acquia & Pantheon, who have committed and supported us. Without them, this magical event wouldn’t be possible. Interested in sponsoring BADCamp? Contact matt@badcamp.net or anne@badcamp.net

Drupal Planet

Drush 9 features a deep rewrite of our app, both user facing and internals. We created and open sourced AnnotatedCommand (example), OutputFormatters, and Config. We leveraged Symfony Console for our CLI fundamentals. For details on Drush9, see the video or slides from our Drupalcon Vienna presentation.

For the past year, I’ve been experimenting with how to integrate content within the user interface of the Webform module with a goal of improving the overall user experience. These experiments include adding inline videos, help documentation, a "How can we help you?" menu, and promotions. As I work towards a stable release, it’s time to document the lessons that I’ve learned from these experiments and decide on a final approach.

The Webform module makes it easy to build feature-rich, powerful, and flexible forms. Within this user interface, I’m aiming to provide users with user experience that helps them understand the Webform module and the Drupal community.

Providing help and documentation is a requirement for all software, including Open Source. The open source nature of Drupal led me to have three primary requirements:

• Make users feel comfortable and supported when using the Webform module.
• Promote the Drupal community to new and existing members. 
• Raise awareness of my work. 

Making users comfortable

The most immediate way to make someone comfortable is to start a conversation - to talk to them, to ask questions and to listen. Early on, as part of the Webform modules development, I started producing video tutorials and demos to provide a show-n-tell experience. At the end of more recent videos, I promote myself using the question, "How can I help you?".

Overall, I’m happy with how the videos have been received by the Drupal community and I think this feature is going to remain AS-IS. Once the Webform module has a release candidate, I’m going to redo all the screencasts and apply some of...Read More

Running custom migrations via a Web UI

The Migrate API is almost stable and the majority of its basic functions and ways that folks interface with it are are to see the state of a migration, execute (import) a migration, or revert (rollback) a migration. However, until now, you had to all this via a command line interface (Drush or Drupal Console). The community has been working hard to get all these functions to run through a web user interface (UI).

Here we'll discuss some of the various options for running a migration via a web UI. There are several options that we are aware in various levels of stability.

Edys Meza Thu, 09/28/2017 - 13:01

Loopbacks and Regeneration

Since 2003, Maestro had the concept of "Regeneration".  Regeneration for Maestro on Drupal 7 was a rather nebulous concept if you didn't understand the complexities that exist within the original engine.  Most administrators would simply check the regeneration option to "on" and the option to "recreate all in production tasks" and never worry about what it actually meant.  Simply put, as a human reading a workflow diagram, we can understand when a logic condition causes a loop-back over already executed tasks. However, for a machine to detect when we're looping-back over already executed tasks produces a set of logical issues that are not easily overcome.

Javascript has a reputation in developer circles as a terrible language. It’s classless, loosely typed, and plagued by cross browser issues. Douglas Crockford, author of JavaScript: The Good Parts, said “JavaScript contains some of the best ideas ever put into a programming language and it contains some of the worst ideas ever put into a programming language.” It was created in just 10 days in 1995, and not standardized by ECMA until almost 3 years later. Microsoft initially decided not to implement the new standards, almost putting an end to the language in its infancy.

Automatic Drupal Updates - WTF or FTW?

Automatic updates have been discusses since years already. The pro's and con's of letting Drupal update itself are discussed in different Drupal.org issues queues. It was not a big surprise that Dries mentioned automatic Drupal core updates as part of the strategic roadmap of Drupal in his Driesnote at DrupalCon Vienna 2017.

Drupalcon Drupal Drupal Community Drupal Planet Automation Events Driesnote

Rapid conferencing - DrupalCon Wednesday

Vienna is my first #DrupalConEUR and due to family obligations, I could only attend 1.5 days out of the full week of events, so I made the most of my time. Here’s a quick recap.

Fran Garcia Thu, 09/28/2017 - 10:06

Before

Preparation - deciding which talks to attend - wasn’t as easy as you'd think. The schedule is full of interesting talks, so I needed to pick and choose the ones that I really wanted to attend. I’ll expand on the talks, which I did attend, later on.

During

I arrived in Vienna on Tuesday night and went straight to a restaurant to have dinner and meet some of my colleagues, who were already there. In the room, we had people from South Africa, Switzerland, Tunisia, Spain… We had a great time, but this was just the warm-up for Wednesday’s events.

After some sleep, my first DrupalCon experience was about to begin, where I could do some catching up, in the keynote, with colleagues and old friends. After this, we also found some time to do actual problem-solving in real life!

I finally opted to go to:

• Tour of the 35 Symfony Components: where we learned loads about this PHP framework that empowers Drupal 8. It was really interesting to find out the components that we were already using and the ones we weren’t but could very easily hook into Drupal.
• Building amazing searches with Search API: the creator/main maintainer of the module showed us how all the Search API modules tie together in Drupal 8 with live demos of the code. 
• Motion design - improving UX through animations: this was a small Amazee’s gathering to view and support Sarah & Lisa in their presentation where they took us through some really cool animations and discussed dos and don'ts of good animations.
• Power to the people - How using containers can make your life easier: given by our AmazeeIO peers, they talked about how we can use containers for our production sites, the pros and cons of them, and we had a quick peek into the possible future and the possible things we could achieve with containers.
• CSS-in-JS: unexpected lessons for Drupal component design: a really nice and cool talk by John Albin, in which he explained lessons learned from years of working with JS and CSS, and how to nicely pack them all into components. Awesome way to close up the first DrupalCon day. 

I know I did miss some very amazing talks, but I also knew that they’d be available on YouTube so I will be catching up on those during the next weeks.

Amazee dinner

However, the day was far from over, as the night was reserved for our amazing team dinner! This was a great opportunity to catch up on our #DrupalConEUR talks and experiences so far, but also, for remote people like me, it was the time to catch up, in real life, with the people I work with every day.

The dinner was just amazing. I had my second Schnitzel in my short time in Vienna, but just found out that I was still far from Michael’s five! We were there until they literally asked us to go, chatting, laughing and sharing awesome stories with one another. It was a great bonding night for the team and we all learned new things from and about our other colleagues.

After

I’ll catch a flight in a few hours. It’s hard to believe that my DrupalCon experience took less than two days. I’m taking back loads of really nice experiences, the warmth of the Amazee team (I’ll need this in the UK…) and I can now say that I’ve gone to my first DrupalCon!

 

Short and sweet - that’s how I’ll remember it.

TechPong - Supporting Britannia Secondary School’s Youth TechPong is an annual heart-racing ping pong tournament for charity organized by Chimp, Unbounce and Science World on October 19th. For the 3rd year, Appnovation will send our best doubles team and solo team to duke it out against other Vancouver companies. This year they are expecting 1000 attendees to make it the biggest T...

We have published a blog post about Top Drupal 8 books before. We have looked at the best books the newest version of Drupal has to offer. That was at the beginning of this year. So, around nine months later, we decided it was time to once again look at this area and explore, which Drupal 8 books were published during that time. Drupal 8 features are being explored every day. Many Drupal modules are getting properly migrated to Drupal 8 and many more are getting developed. Nevertheless, Drupal 8 books also offer many insights, so here are some, which were published in the last nine months… READ MORE

Migration From Field Collection to Paragraphs in D8

If you need to migrate field collections from Drupal 7 into Drupal 8, here's a walk through of how to do it. But before you start reading, I'd like you to stop and see how you can make this process better. In this Meta issue, we have a plan to automate all parts of this process. As the heir aparent to Field collections, we are working with the larger Drupal community to include for support migrating directly into Drupal 8 from field collections.

Ada Hernández Wed, 09/27/2017 - 16:27

Social media needs to be a part of your search engine optimization strategy. While the level of involvement in social media can be determined by your market and your customers, ignoring social media can no longer be an option. Smart Drupal SEO strategies include building authority in social media channels.

Search engine algorithms for social media vary

Google has stated clearly that social signals such as the number of Facebook likes and Twitter followers are not factored into Google’s search algorithm. To Google, each individual tweet or Facebook post is considered a web page on its own. On the other hand, Bing says that it does look at the social authority of a user. “We look at how many people you follow, how many follow you, and this can add a little weight to a listing in... Read the full article: Is Your Drupal Website Antisocial?

This blog has been re-posted with permission from Dries Buytaert's blog. Please leave your comments on the original post.

Yesterday, I shared my State of Drupal presentation at DrupalCon Vienna. In addition to sharing my slides, I wanted to provide some more detail on how Drupal is evolving, who Drupal is for, and what I believe we should focus on.

Drupal is growing and changing

I started my keynote by explaining that Drupal is growing. Over the past year, we've witnessed a rise in community engagement, which has strengthened Drupal 8 adoption.

This is supported by the 2017 Drupal Business Survey; after surveying 239 executives from Drupal agencies, we can see that Drupal 8 has become the defacto release for them and that most of the Drupal businesses report to be growing.

While the transition from Drupal 7 to Drupal 8 is not complete, Drupal 8's innovation continues to accelerate. We've seen the contributed modules ecosystem mature; in the past year, the number of stable modules has more than doubled. Additionally, there are over 4,000 modules in development.

In addition to growth, both the vendor and technology landscapes around Drupal are changing. In my keynote, I noted three primary shifts in the vendor landscape. Single blogs, portfolio sites and brochure sites, which represent the low end of the market, are best served by SaaS tools. On the other side of the spectrum, a majority of enterprise vendors are moving beyond content management into larger marketing suites. Finally, the headless CMS market segment is growing rapidly, with some vendors growing at a rate of 500% year over year.

There are also significant changes in the technology landscape surrounding Drupal, as a rising number of Drupal agencies have also started using modern JavaScript technologies. For example, more than 50% of Drupal agencies are also using Node.js to support the needs of their customers.

While evolving vendor and technology landscapes present many opportunities for Drupal, it can also introduce uncertainty. After listening to many people in the Drupal community, it's clear that all these market and technology trends, combined with the long development and adoption cycle of Drupal 8, has left some wondering what this all means for Drupal, and by extension also for them.

Drupal is no longer for simple sites

Over the past year, I've explained why I believe Drupal is for ambitious digital experiences, in both my DrupalCon Baltimore keynote and on my blog. However, I think it would be valuable to provide more detail on what I mean by "ambitious digital experiences". It's important that we all understand who Drupal is for, because it drives our strategy, which in turn allows us to focus our efforts.

Today, I believe that Drupal is no longer for simple sites. Instead, Drupal's sweetspot is sites or digital experiences that require a certain level of customization or flexibility — something I refer to as "richness".

Ambitious is much more than just enterprise

This distinction is important because I often find that the term "ambitious" becomes conflated with "enterprise". While I agree that Drupal is a great fit for the enterprise, I personally never loved that categorization. It's not just large organizations that use Drupal. Individuals, small startups, universities, museums and nonprofits can be equally ambitious in what they'd like to accomplish and Drupal can be an incredible solution for them.

An example of this could be a small business that manages 50 rental properties. While they don't have a lot of traffic (reach), they require integrations with an e-commerce system, a booking system, and a customer support tool to support their business. Their allotted budget is $50,000 or less. This company would not be considered an enterprise business; however, Drupal would be a great fit for this use case. In many ways, the "non-enterprise ambitious digital experiences" represent the majority of the Drupal ecosystem. As I made clear in my presentation, we don't want to leave those behind.

Addressing the needs of smaller organizations

The Drupal ecosystem majority are organizations with sites that require medium-to-high richness, which SaaS builders cannot support. However, they also don't need to scale at the level of enterprise companies. As the Drupal community continues to consider how we can best support this majority, a lot of smaller Drupal agencies and end-users have pointed out that they would benefit from the following two things:

1. Powerful site building tools. They want easy-to-use site building tools that are simple to learn, and don't require dozens of contributed modules to be installed and configured. They would also prefer to avoid writing a lot of custom code because their clients have smaller budgets. Great examples of tools that would improve site building are Drupal's upcoming layout builder, workspaces and media library. To make some of Drupal's own administrative UIs more powerful and easier to use, I proposed that we add a modern JavaScript to core.
2. Easier updates and maintenance. While each Drupal 8 site benefits from continuous innovation, it also needs to be updated more often. The new Drupal 8 release cycle has monthly patch releases and 6-month minor releases. In addition, organizations have to juggle ad-hoc updates from contributed modules. In addition, site updates has often become more complex because our dependency on third-party libraries and because not everyone can use Composer. Many smaller users and agencies would benefit tremendously from auto-updates because maintaining and updating their Drupal 8 sites can be too manual, too complex and too expensive.

The good news is that we have made progress in both improving site builder tools and simplifying updates and maintenance. Keep an eye on future blog posts about these topics. In the meantime, you can watch a recording of my keynote (starting at 22:10), or you can download a copy of my slides (56 MB).

State of Drupal keynote, DrupalCon Vienna from Dries Buytaert State of Drupal keynote, DrupalCon Vienna from Dries Buytaert

We’ve worked with many amazing clients who had to be careful about their budget or needed a project completed rather quickly. You may be one of those clients. If you’re in the process of hiring a design firm to help improve your product or website but are concerned about investing in user research and testing because of budget or timeline constraints, you’re in good company. What follows are some practical ideas your designers can use to increase your chances of success without breaking the bank. 

Research to conduct during the project kickoff “People ignore design that ignores people.” - Frank Chimero, Author of The Shape of Design Conducting User and Stakeholder Interviews

A clear understanding of the problems you’re solving and who you’re solving them for is critical to the success of any design project. A site’s “users” are made up of not just the end users or target audience of the site, but also the business users: the product stakeholders, content editors, designers, and the team that will use the site over time to reach that audience. Those business users are an ideal starting point for research. The people who create and manage the content, run sales for the organization or handle customer service are often a wealth of information about the target audience they’re serving and their common needs and challenges. These same stakeholders also help clarify the true purpose and goals of the project and any potential pitfalls.

Before any collaborative workshopping, we always try to conduct individual interviews with at least a representative of each of these kinds of stakeholders (e.g., content and editorial, marketing, sales, customer service, leadership, etc.). We’ve found this process to be hugely beneficial for things like:

• Clarifying project goals
• Clarifying the audience and its various segments
• Clarifying the known problem space
• Clarifying the existing, driving assumptions about the site’s users that perhaps need more research
• Surfacing internal conflicts that need resolution
• Surfacing potential pitfalls for the project

undefined

This early information you easily get from these interviews can be invaluable as you begin crafting interview protocols, surveys, and other research methods to learn from the site’s audience. Conducting research with a site’s audience (the external user base) is often where the bulk of the cost lies, so getting as much clarity up front to help refine that work can save a lot of time and cost.

Sharing Relevant Documentation

Another highly effective way to reduce research costs in your project is to make sure that your design team can leverage all of the past research your team or others have already done. Designers can learn a great deal very quickly by reviewing the results of past annual surveys or support requests. Below is a list of the kinds of things you should look for and be sure to share with your design team to save time and ensure a better end product.

• Existing internal persona documents that define your audience
• Access to site analytics
• Past surveys of your audience
• Notes, audio or video of any past user tests or interviews
• Existing user flows
• Existing documentation or reports from customer service teams on common problems or guides for those customer service reps

Collecting your team’s knowledge about your audience and summarizing it in an audience inventory worksheet can also help save your designer time when reading through the research.

undefined Competitive Analysis

Conducting a competitive analysis of your competition can also be used to evaluate your audience and make a comparison of how your product or site stacks up against the competition. Designers can usually complete these within a day or two, if not within a few hours. They’ll use a set of heuristics such as design consistency, the grouping of common tasks, functionality, mobile friendliness, and placement of links or calls to action, to help evaluate your site against the competition. This evaluation will help set up a strong design strategy that distinguishes your site.  

Research to conduct during the design process In Process Usability Testing “To design an easy-to-use interface, pay attention to what users do, not what they say. Self-reported claims are unreliable, as are user speculations about future behavior.” - Jakob Nielsen, User Advocate and principal of the Nielsen Norman Group

Even when you think you understand the problems users have, there are times when your designers will need to ensure that the ideas they’re proposing resonate with your audience. Will they understand how to use a certain component? Does the marketing copy answer their questions? Does the visual design accurately reflect the core values and mission of the company? These are all questions your designers should be asking themselves throughout the design process. Conducting usability tests early and throughout the design process with actual users can help them answer these questions and validate that the design is on the right track.

Usability testing doesn’t have to be a long, expensive process. There are ways your designers can test their ideas with users rather quickly. Tree testing can be a quick way to test your site's IA hierarchy and navigation nomenclature without producing a bunch of artifacts such as wireframes or prototypes that are often needed for usability testing. Your designers can also use wireframes or paper prototypes to conduct efficient usability tests during the exploration phase. At Lullabot, we’ve used a combination of the above to help conduct usability tests in an efficient manner. Conducting usability tests throughout the process with help ensure that the design and strategy are on the right track, and also sets the site up for success.

undefined Research to Conduct After Launch

Your project has launched! Hopefully, everything went smoothly, and now there’s a sigh of relief. But there's still work to be done. The ultimate form of user testing is launching a site! The best designers want to keep on learning and iterating. What follows are a few affordable ways to do this. 

Conducting Surveys Placing an optional survey on the site is an inexpensive way to collect user feedback that doesn’t require a lot of time to set up. Surveying can identify if something is not working correctly on the site and can help quickly collect user feedback to address in possible future iterations.  Surveying establishes a user pool for future usability testing. Keeping surveys short (5 brief questions or less) increases the number of users who are likely to complete the survey. Tools like SurveyMonkey, Ethnio, and Typeform can easily integrate into your site. 

Another option is to place a link somewhere on the site where users can give feedback. An example of this might be if you're rolling out a restructured navigation. Placing a link titled “can’t find what you’re looking for?” in the navigation that links to a form can help users quickly give feedback on how the new structure is working for them and help to identify any changes that may need to be addressed in the new navigational structure.

Usability Testing

Conducting usability tests on a recently launched site is another way to quickly gather user feedback on how well the site is working for the audience. Since conducting usability sites on the actual launched site requires no prototyping, it can be fairly quick to set up and conduct these tests. You can also save time with recruitment by reusing the same user pool that you had gathered during the in-process usability tests.  

Post Launch Meetings

Finally, another inexpensive practice we highly recommend is scheduling regular design check-ins post-launch. Set an interval of either quarterly or biannually to ensure that there's time for real data to come in from real users, but also regular enough to perhaps take action and roll out small improvements based on the data. In these regular meetings, we recommend you do at least the following:

• Review anything that’s gone well, and has been surprising or concerning when it comes to users interacting with the site.
• Review any feedback that your team may collect from actual users
• Review and discuss any changes to the goals business or the goals of the site 
• Discuss the progress of the site in relation to the goals that were set. Are they on target?

Adding user research to your project process can be beneficial to everyone involved to help understand your audience’s behavior, their goals, and can help inform how to improve your site after it’s launched. Not every project will have an ample budget or timeline for an in-depth research process, but there are small ways to validate ideas to create a site that’s successful and communicates to your audience. If you’re concerned about how user research can affect the budget, I hope you’ll take some of the above into consideration when discussing user research with your designers and collaborate with them to find small ways to work user research into your process. If you’re interested in learning more, I’d recommend reading Just Enough Research by Erika Hall and The User Experience Team of One: A Research and Design Survival Guide by Leah Buley.