Browsing Tag: Designing

    web design

    Designing And Building With Fluid Type And Space Scales — Smashing Magazine

    04/01/2021

    About The Authors

    Trys Mudford (@trysmudford) is a front-end developer who sits at the intersection between design and engineering, helping translate between the two functions …
    More about
    James & Trys

    By systemizing the fundamentals of typography and space, and leaning into the inherent fluidity of the web, a free new CSS tool called Utopia offers an alternative to breakpoint-driven design. This shared language between design and development streamlines communication and encourages the creation of bespoke constraints for your projects to ensure consistent and harmonious designs.

    Two decades ago, as we embarked on our voyage from the comfortable, predictable shores of print design to the fluid and ever-changing open seas of the World Wide Web, John Allsopp encouraged the acceptance of “the ebb and flow of things”. Ten years later, Ethan Marcotte coined the term “responsive web design”, kickstarting a seismic shift from fixed-width desktop sites — and their separate mobile counterparts — to single codebases of flexible design.

    But we didn’t embrace the ebb and flow. Not really. Instead, we settled on a system of arbitrary breakpoints, and there the expedition ended. Rigid “magic numbers” tied to real-world devices plagued our CSS and directed our design processes. Developers today are often handed a collection of mockups for mobile (320px), large mobile (400px), tablet (768px), small desktop (1024px), and large desktop (1440px). The effort expended in generating so many discrete artifacts is an inefficient use of time and resources. It also perpetuates the archaic practice of creating device-specific websites.

    Furthermore, with so many unique reference materials in play, developers are often left to guess at the logic — if any — used in the design process. This can lead to a seemingly infinite number of similar values entering the codebase, needlessly increasing the weight of the CSS and the complexity of the project’s maintenance. This convolution swells exponentially with the number of device-specific mockups generated as well as the number of design contributors involved.

    The Promise Of Utopia

    One way to ensure our designs feel at home on more devices is to add more breakpoints, enabling more nuanced design tweaks at more screen sizes. This comes with the cost of a more laborious design process, more mockup generation, more code, and more documentation.

    Another way is to lean into the fluidity of the medium, recognizing this perceived limitation as the advantage it truly is. Instead of tightening our grip by loading up on breakpoints, we can let go, relinquishing some of that control and allowing the medium to share the load. We can embrace the ebb and flow with a more fluid and systematic approach to our design foundations.

    In conversations with clients and colleagues, we found ourselves struggling to articulate these somewhat nebulous concepts. To bring the idea into reality we gave it a name: Utopia. A single word to refer to a particular way of thinking about the fundamentals of fluid responsive web design. Here are the benefits as we see them:

    • Design and develop rapidly using a handful of related rules, building the system, not every permutation of its contents at arbitrary breakpoints.
    • Create bespoke constraints for your projects to ensure consistent and harmonious designs.
    • Streamline communication and collaboration between design and development.
    • Visualise the invisible: componentize responsive space, codifying its implementation and behavior.
    • Swap jarring breakpoint jumps for buttery-smooth interpolation, with programmatically tailored type and space scales for every screen size.

    The Origins Of Utopia

    Utopia emerged during years of work at the coalface, designing and developing in agency and product contexts. We spotted some common patterns and pitfalls, and have gradually zeroed in on a solution, iterating with real clients.

    We started with a simple spreadsheet-based calculator in 2018, but communicating the benefits of fluid responsive thinking was challenging. An informal sprint at Clearleft in early 2020 resulted in utopia.fyi, where we published some of our thoughts alongside a fluid type scale calculator.

    Fluid Type Scales

    Typesetting with modular scales isn’t a new concept. It’s a proven mathematical way to ensure harmonious relationships between type sizes in a design. But where traditional print-derived typographic systems are designed to work at specific page sizes, Utopia can unlock elegant typography for all devices.

    By defining a suitable type scale for a small screen and another for a large screen, we can let the browser interpolate smoothly between the two, based on the current viewport size. This results in a set of type sizes that is always in tune with itself, without manually setting sizes for multiple breakpoints.

    Thinking in terms of steps rather than values, we allow the computer to calculate the optimal sizes, rather than laboriously working them out ourselves. This declarative way of thinking chimes with how CSS itself works: we tell the browser what we want to happen and the browser works out how to do that.

    This also creates a shared, tailored language between designers and developers. Instead of referring to a heading size change from, say, “1.687rem to 2.3125rem”, this neat set of options lets you say: “Step 2 to Step 3”. By adding the intentional friction of named steps and embracing this self-imposed constraint, we can guard against an infinite number of magic number font sizes infiltrating our codebases and designs.

    A preview of a minor third type scale, at 1440px. With a fluid type scale calculator.

    Utopia encourages the curation of a system small enough to be held in short-term memory, rather than one so sprawling it must be constantly referred to.

    Designing With Fluid Typography

    We’ll typically start a project by defining a suitable body copy font and size at nominated min and max viewport widths. The exact sizes depend on a product’s fonts, visual style, content, layout, and audience. We do this by experimenting in Figma with chunks of realistic copy from the client, as well as any design direction insights we’ve uncovered together. At this point, we’re most interested in legibility, line lengths, line heights, size, and weight contrast — all the ingredients that combine to make an appropriate reading experience.

    After this experimentation, we’ll have a good idea of the scales that will work for the project and it’s time to visit the Utopia type scale calculator.

    You can specify scale steps, and the tool will map rough font sizes to mathematical type scales. (Large preview)

    Here we’ll map the rough font sizes to mathematical type scales, pulling the values into Figma — manually, for now — to confirm they’re suitable for the content.

    You can read more about designing with fluid type scales on the Utopia blog.

    Developing With Fluid Typography

    To pull these design foundations into code, the developer visits the same URL as the designer. They can export CSS directly from the tool and drop it into a project.

    The tool generates CSS for fluid type scale with CSS Custom Properties, but you can also use CSS Clamp. (Large preview)

    Utopia relies heavily on CSS custom properties and CSS locks. This has two benefits: it’s entirely opt-in, and the values are tweakable in the browser.

    Side note on keeping your values malleable: This is a crucial design decision in the Utopia calculator. We know from experience that all values are subject to change as a project proceeds. Digital design is a fluid process. Design tools like Figma are incredible, but they can’t show you how your fonts will render in every browser on every device. Content often changes during projects. Usability testing can throw up unforeseen issues. Stakeholders emerge with their own design preferences. Just remember the mantra: “A digital product is never finished” and allow the system to flex, change, and grow as you work.

    With the fluid sizes exposed by custom properties, there are two main ways to implement them. In any declaration, rather than set a font-size value as a static unit (e.g. px), we refer to the step size:

    h2 {
      font-size: var(--step-2);
    }
    

    Alternatively, by creating a small set of single-responsibility utilities, we can create fluid components with a single class:

    .u-step-2 {
      font-size: var(--step-2);
    }
    <h3 class="u-step-2">Heading</h3>
    

    Recommended reading: CSS-Only Fluid Modular Type Scales

    Fluid Space Palettes

    Space is often created ad-hoc by designers, and guessed at by developers. Utopia aims to solve this by standardizing the foundational unit of space used in design and development. This creates a shared understanding and a common set of intentional, fluid gaps to be used by both disciplines. The fluid space calculator is the latest tool in the Utopia collection.

    Taking “Step 0” from the fluid type scale as our base unit, we deploy a set of multipliers to create a selection of space units. To keep things simple, we refer to them as T-shirt sizes: (S)mall, (M)edium, (L)arge, etc. Thanks to the fluid base unit, these values subtly shrink and grow according to screen size.

    Similar to font sizes, but for space: meet the fluid space calculator. (Large preview)

    Where many systems swap space values at arbitrary breakpoints, Utopia has an alternative take. Each individual space unit can interpolate to a different unit between your min and max breakpoints. Out of the box, Utopia creates “single-step pairs” that take one step up the ladder of sizes (2XS → XS, XS → S, etc) but the tool also allows you to create any number of custom pairs.

    These pairs can create incredibly steep slopes (XS → 3XL), perfect for handling spacing for hero slats, or even reverse slopes that get smaller as the viewport width expands (2XL → XS).

    Creating systems with fluid spaces: the pairs can be perfect for handling growing spacing and reverse slopes that get smaller as the viewport width expands. (Large preview)

    Designing With Fluid Space

    Within Figma, we’ll create a set of space components for min- and max-sized spaces. Using variants, we can easily swap between each T-shirt size. A Figma plugin that automates this process is on our roadmap.

    Using the spacing system in Figma. (Large preview)

    Using these spaces as guides, we can place them between our components to ensure visual consistency. We’ve found that after a short period of time, the handful of space values commit themselves to your memory, and laying out conforming designs without the space guides becomes second nature.

    We’ve built a demo to show how this comes together in the browser, and how intentional space becomes with Utopia.

    A demo, with the spacing system in place. (Large preview)

    You can read more about designing with a fluid space palette on the Utopia blog.

    Developing With Fluid Space

    Much like the typographic tool, we can export CSS directly from the space calculator and implement it with custom properties or utility classes, like so:

    .grid-of-two {
      display: grid;
      grid-template-columns: repeat(2, 1fr);
      grid-gap: var(--space-s-l); // (S) 18px → (L) 44px
      margin-bottom: var(--space-xs); // 14px → 17px
    }
    

    With a shared palette of fluid spaces, we’ve found we no longer need mockups of every element at multiple viewport widths. As a developer using Utopia, you now take on some of the responsibility for the nuance of the responsive design of your project. This space system empowers you to paint the appropriate fluid space across your interface as you see fit.

    Where specific components require bespoke designs on smaller screens, a targeted mockup can be created. A site header is a good example. This allows the designer to spend their time more wisely, focusing on thorny design problems, rather than creating mockups of situations that are automatically resolved by Utopia.

    It’s no exaggeration to say that this approach has revolutionized the way we develop for the web, and has rapidly increased the speed at which we can turn flat designs into harmonious, fluid, and intentional digital layouts. It might feel somewhat unintuitive to design this way at first but once it clicks, you won’t want to go back.

    Recommended reading: Painting With A Fluid Space Palette

    Utopia In The Real World

    One of the key milestones in the development of Utopia was during Clearleft’s engagement with the Natural History Museum. We worked closely with the digital team to reimagine the Wildlife Photographer of the Year website, the online representation of the largest competition of its kind in the world.

    In the physical exhibition, the photographs are thoughtfully arranged, the supporting information beautifully typeset and carefully positioned. We committed to the same degree of consideration for the digital version. Working with this collection of awe-inspiring assets, the job of the new website was simple: “Make the photograph the star”.

    This mindset permeated through the design foundations and lent itself perfectly to applying our Utopian principles. If the aim was to display the imagery and associated content in the best possible way on every device, we had two options. We could either saturate our code with fixed breakpoints, or accept the ebb and flow, lean into the fluid medium of the web, and allow the computer to fit the content to its display.

    Every image has the space to breathe and feel in tune with its surroundings on any device, on the National History Museum website. (Large preview)

    The result of this project was an immersive digital incarnation of the physical experience, with every image given the space to breathe and feel in tune with its surroundings on any device. You can read more about the project in the case study, and hear about it on the Clearleft podcast.

    Conclusion

    With this approach, every character and every space in every component on every page is tied to a typographic step or space size. Although this approach shortcuts certain design decisions during the project, it’s not a substitute for good design — it takes a skilled designer to set up the appropriate type and space palettes and manage them as the design evolves.

    Whether we’re making a design system or something smaller, the pros of a systematic approach almost always outweigh the cons. Depending on the size and scope of a project, introducing a system can feel like overengineering. The Utopia approach is designed to be as lightweight as possible, suitable for use on projects of all shapes and sizes.

    Smashing Editorial
    (vf, il)

    Source link

    web design

    Designing Better Tooltips For Mobile User Interfaces — Smashing Magazine

    02/03/2021

    About The Author

    Eric is the founder of UX Culture Works. He has spent the past 20 years leading UX research and design projects for Fortune 500 companies in the finance, …
    More about
    Eric

    Tooltips are powerful design patterns implemented to enhance the design experience by providing additional information precisely when users need it. In this article, we show you how to design tooltips that will amplify your mobile designs and explain where mobile tooltips are most effective.

    Ideally, mobile designs would be seamless with no need for technical documentation, online help, or tooltips. In reality, even the best designs can benefit from supplemental information. A tooltip provides this supplemental information when users tap an icon, image, hyperlink, or other elements in a mobile user interface (UI). For example:

    Tooltip showing solid fill and radial fill on a mobile drawing app.
    Concise tooltips explain the purpose of each drawing icon. (Image Source: Sketchbook mobile app, gold arrows added by the author) (Large preview)

    By identifying the “Solid Fill” and “Radial Fill” functions, the tooltips shown above make it easy for users to find the drawing function they need. These tooltips appear in the proper context and are not obtrusive. A first-time user can easily understand the meaning of each icon while an experienced user is unlikely to find these tooltips distracting. In short, the designer has balanced the needs of new and seasoned users. The result of this successful balance is a set of tooltips that users will perceive as a natural extension of the design experience.

    Too often, however, tooltips are an afterthought as shown in the following example of a mobile contrast checker:

    Lengthy tooltip text on a mobile contrast checker.
    Lengthy tooltip text obscures important information on the screen. (Image source: Stark) (Large preview)

    While the explanation about the contrast checker is clear, the text is too long and covers important information on the screen. The result is a clunky tooltip that confuses as much as it elucidates. Avoiding troublesome tooltips requires thought and planning.

    How To Design Effective Tooltips

    The key to designing tooltips that fit seamlessly into the overall design is to plan for them early in the design process. Specifically, designing useful tooltips requires:

    • Proper timing
      Paying attention to tooltips and related design techniques during the sketching and early prototyping stages.
    • Proper implementation
      Carefully considering tooltip context, placement, and clarity.

    Timing

    Timing refers to when during the design process to consider tooltips. By referring to the widely use design sprint, developed by Jake Knapp, we can identify the right stages in the design process to make decisions about design elements like tooltips.

    Knapp’s sprint process consists of mapping out the problem, sketching solutions, choosing one solution, building a prototype, and then testing that prototype. In short, generate an idea, build it, and test it. The following image shows Knapp’s five-day design sprint process. I’ve added text to the sketching and prototype days to show when designers and developers should start thinking about tooltips.

    Sprint map from Google Ventures Design Sprint.
    Google Ventures Design Sprint. (Image Source: The Sprint Book, gold text added by the author) (Large preview)

    Sketching is the logical place to begin when considering tooltips because potential points of confusion emerge as the layout and preliminary content take shape. Because initial sketches often do not include complete or detailed content, it is not necessary to identify every possible tooltip or even to include all designated tooltips at this stage. Rather, the point is to identify parts of the UI where a well-designed tooltip would help users complete the task at hand or more easily understand content.

    For example, a tooltip on a field label makes it easier to fill out the form while also reducing data-entry errors. If it’s not yet clear whether a tooltip is necessary, simply include a callout with a question as shown in the figure below.

    rough sketch of a form with a callout pointing to a field where a tooltip might be useful.
    Sketching stage (Tuesday in Jake Knapp’s Design Sprint) with callout asking if a tooltip might be useful (Author’s drawing). (Large preview)

    The callout shown above serves as a reminder for the team to discuss before building the prototype. In the “CVV” example above, the team might decide that one persona represents users who are unfamiliar with financial terms and abbreviations. For this group, a CVV tooltip would likely be useful and could easily be incorporated into the prototype as shown below.

    Prototype of a form with a tooltip
    Prototype stage (Thursday in Jake Knapp’s Design Sprint) with information icon and tooltip shown in hover state. (Image source: Author’s drawing) (Large preview)

    Considering the need for tooltips and other supplemental information early in the design process increases the chance of developing a useful and usable prototype.

    Implementation

    The increasing complexity of mobile apps and limited space on mobile devices pose a significant challenge to designing effective tooltips.

    Designers can meet this challenge by focusing on:

    • Context
      Check, check, and re-check the context for every tooltip. What might appear obvious to you as the designer could easily confuse a first-time user. The principle of attending to context applies to all aspects of UX and UI design. It’s especially important for tooltips because their necessary brevity will leave users confused if the context is not clear.
    • Placement
      Tooltips should be prominent and easy to find but should not obstruct important information on the screen.
    • Clarity and brevity
      Edit each tooltip for clarity and brevity. As many editors tell their writers: “Cut, cut, and cut some more.” It’s okay to write longer tooltip text in early iterations as long as you remember to keep editing and condensing for clarity.

    The tooltip in the following example fulfills these criteria by providing essential information without disrupting the flow in the mobile form.

    Field-level tooltip text in the Mint mobile app.
    The field-level tooltip is well placed and easy to understand. (Image source: Mint mobile app) (Large preview)

    Because space is limited on mobile devices, clarity, brevity, and placement are essential. The tooltip on the Mint registration screen shown above is well designed. It is clear, concise, and appears directly below the zip code field when users tap the information icon.

    The Square mobile app shown below provides another example of good tooltip design by helping bi-lingual users select their preferred language.

    Tooltip showing English and Spanish language options on the Square mobile app.
    Tooltip displaying language options for the Square mobile app. (Image source: Square mobile app) (Large preview)

    The “English/Español” tooltip shown above is clear, brief, and properly placed. When users tap the flag icon or “English” text, a tooltip appears with the option to select “English” or “Español.”

    Well-placed tooltips enhance visual design by providing short, specific explanations when users need them. In the example above, users who are seeking information in other languages know immediately that they can choose between English or Spanish for this website. The language tooltip helps native Spanish speakers who might read English well but feel more comfortable using the Square app in their native language.

    Utility is essential but not sufficient. Effective tooltips should be discreet to the point that users barely register their presence. Users only miss tooltips when they aren’t there. This approach to tooltips is an example of the long-standing view that great design is invisible. From this perspective, users never notice the design. Instead, they feel engaged and easily complete the task at hand.

    The tooltip shown below on the Google Maps app is easy to find yet subtly integrated into the existing design:

    • The icon for muting/unmuting appears in a vertical row of icons.
    • The placement of these icons on the right makes them easy to see without obscuring important information on the map.
    • The mute/unmute icon follows the same style and color scheme as the search icon immediately above.
    Tooltip explaining the meaning of unmuted on the Google maps mobile app.
    Google Maps mobile app: The ‘Unmuted’ tooltip appears when users tap the sound icon to shift from mute to unmute. (Image source: Google maps mobile app, gold arrow, highlight, and bold text added by the author) (Large preview)

    This Google map tooltips works because:

    • The context is clear. The option to toggle on sound (before pulling out of the driveway) is useful because it’s easier and safer to listen to directions while driving than to look at the phone.
    • The placement of the mute/unmute icon in a group of existing icons makes it easy to see without obscuring important information on the map.
    • The one-word tooltip is brief, and its meaning is clear.

    In contrast, the tooltip shown in the MyZone fitness mobile app below is poorly designed.

    Tooltip explaining maximum heart rate on the MyZone Fitness mobile app.
    Tapping ‘175 Max HR’ displays the tooltip shown above right. (Image source: MyZone mobile app, gold highlights added by author) (Large preview)

    While the context is clear, there are problems with the MyZone app tooltip:

    • The placement is clunky because it obscures important information.
    • The tooltip text is lengthy, and the explanation of “Max HR” is confusing.

    To accommodate this lengthy text and the distracting green bar at the top, the tooltip is unnecessarily large. The result is a tooltip that is not discrete; it does not feel like a natural extension of the design.

    Poor placement and confusing explanations are not the only problems users experience with mobile tooltips. A surprisingly common issue is the redundant tooltip. The tooltip example below is part of an illustration of cascading style sheets (CSS) smooth animation. The animation works and the illustration itself is clear; the problem is that the tooltip simply repeats the button text.

    Tooltip repeats button label text.
    Redundant tooltip: Tooltip text repeats button label text. (Image source: Omar Dsooky) (Large preview)

    In the article about CSS animation, the illustration shown above is only for demo purposes. Nonetheless, the image would be more useful with a clear and useful tooltip. As used here, the tooltip is not useful.

    While redundant tooltips are useless, tooltips that appear in the wrong part of the UI are especially problematic because they distract users from the task at hand.

    Tooltips about grid systems appears in the wrong place.
    Tooltip out of context. (Image source: Danta Griffthy) (Large preview)

    The screen shown above includes a title in large font with a statement about increasing income. Yet, the tooltip refers to a grid system tip icon that supposedly “boosts the value of your design.” At best, there is a tenuous connection between the tooltip and the main theme on this screen, increasing income. The icon and tooltip might be important, but they are in the wrong place in this app.

    More broadly, context is a bedrock UX principle and applies to all design elements. For example, an image of a $150,000 sports car on a site or app targeting budget car shoppers would look and feel incongruous because the image would not match the user’s expectations. In short, the image would likely confuse the targeted user group.

    Context is particularly important for tooltips because the purpose of a tooltip is to clarify and provide additional information. A misplaced tooltip does the opposite; it causes confusion.

    Where To Use Tooltips

    Context is also a critical consideration when deciding where to use tooltips. Because tooltips work best when they amplify a well-designed UI, they are particularly effective for:

    • Contextual Help,
    • Brief instructions,
    • New features.

    Contextual Help

    Contextual help appears when users are in a specific part of the UI. The following example is from Airbnb. Tapping the icon or “3 reviews” text displays a tooltip with an explanation of reviews and a link that takes users to reviews about the individual shown on screen (the author, in this example).

    Airbnb review icon with tooltip cropped
    Airbnb tooltip explaining the meaning of reviews. (Image source: Airbnb mobile app) (Large preview)

    The tooltip shown above is informative because it explains what reviews mean in the Airbnb app and, specifically, in the context of a single profile. In short, contextually specific tooltips appear at the precise moment users need additional information.

    Brief Instructions

    Instructional tooltips should also appear when users need more information. The difference is that certain aspects of a mobile app might require an explanation at each step to ensure that users can complete the task at hand. For example:

    Tooltip text guides users through each step of a form.
    Step-by-step tooltip instructions. (Image source: IRS mobile site, gold highlights added by the author) (Large preview)

    Each tooltip in this part of the IRS app is paired with a specific task such as entering a social security number, date of birth, or street address. Because each tooltip is context-specific, users can easily learn what they need to do during each step and why the IRS needs this information.

    New Features

    As Sofia Quintero explains in Tooltips: your secret weapon for improving feature discovery, tooltips are an effective way to draw the user’s attention to new features, “To promote and publicize its new GIFs, Twitter displayed a full-screen message to users before gently directing them on how to incorporate GIFs into their tweets using a traditional tooltip.”

    Twitter gif tooltip
    Twitter mobile app with tooltip showing the then new ‘GIF’ feature. (Image source: Tooltips: your secret weapon for improving feature discovery, gold callouts added by the author) (Large preview)

    The GIF feature was introduced a few years ago, but it holds up as a useful presentation of a new feature. It’s clear and clean, standing out without dominating the UI. New users will see it while experienced users can proceed without distraction because the tooltip is well-integrated into the UI and does not cover up other screen elements.

    Conclusion

    Tooltips amplify a mobile UI by providing supplemental information precisely when users need it. Leverage the power of tooltips by considering them when sketching designs and building early prototypes. During implementation, ensure that tooltips will help users by focusing on:

    • Context
      Effective tooltips appear precisely when users need them.
    • Placement
      Tooltips should be prominent and easy to find but should not obstruct important information on the screen.
    • Clarity and brevity
      Review every tooltip in your app to ensure that it makes sense. Edit for brevity.

    For tooltips to reinforce a well-designed UI, use them in parts of the UI where they work best such as:

    • Contextual Help,
    • Brief instructions,
    • New features.

    Tooltips are a powerful design pattern with a light footprint that enhances mobile designs when used judiciously.

    Additional Resources

    Smashing Editorial
    (ah, vf, yk, il)

    Source link

    web design

    Designing An Attractive And Usable Data Importer For Your App — Smashing Magazine

    12/02/2020

    About The Author

    Suzanne Scacca is a former WordPress implementer, trainer and agency manager who now works as a freelance copywriter. She specializes in crafting marketing, web …
    More about
    Suzanne
    Scacca

    Even though the development of a data importer is a complex matter, you don’t want your users’ experience with it to be just as complex or complicated. The second they experience any friction or fault in data onboarding, the chances of them bailing from the software will skyrocket. So, in this post, we’re going to focus on how best to present your data importer to users.

    If you’ve ever tried to import data into an app before, you know, as a user, how varied the experience can be. In some cases, the user is overwhelmed with instructions on how to use the importer. In others, there’s no direction at all. And while that might look nicer than an importer overrun with directions and links to documentation on how to use it, a completely useless UI will also cause users frustration once the inevitable errors start getting thrown.

    So, when you’re designing an app or software that needs a data importer, how do you ensure this doesn’t happen to your end users? Do you try to custom build or find a Goldilocks solution that strikes the right balance between minimal and informative? And what should that even look like?

    Today, I want to look at four ways to ensure that the user interface design of your data importer doesn’t get in the way of a positive user experience.

    Quick note before I start: I’ll be using live data importer examples to demonstrate how to design this on your own. However, if you’d rather just use a ready-made data importer, but don’t have time to review the existing options against these good design practices, Flatfile Concierge is what you’re looking for. I’ll show some examples of it as we go along and tell you a bit more about it at the end of this post.

    UI Design Tips For Your Software’s Data Importer

    There are many challenges in data onboarding for apps and software. But if you can get the UI right — in other words, provide your end users with an attractive and usable importer — you can effectively minimize those challenges.

    Here’s what your data importer should look like if you want to make that a reality for your users:

    1. Format The Instructions For Readability

    It doesn’t matter how straightforward the data import process is. You can never assume that your end users will automatically know how to format their file(s), which file types are allowed and what sort of file size limitations there may be.

    So, the main importer page must have instructions for them. Just be careful about going overboard.

    If you leave them with a wall of text explaining what the importer is for, they’ll get annoyed with the redundant information holding them up from getting started. And if you spell out each possible step in minute detail, their eyes are going to glaze over. Worst-case scenario, they’ll start the experience feeling as though they’re being talked down to. None of these outcomes is ideal.

    To find the sweet spot, aim for the following:

    Simplify the instructions into 100 words or less.

    PayPal’s invoice importer is a good example of this:

    The PayPal bulk invoice importer provides a single paragraph with instructions on how to use the importer
    PayPal allows business users to bulk-import and send invoices. (Image source: PayPal) (Large preview)

    There’s a single paragraph on this page that tells users that files need to:

    • Be in CSV format;
    • Include fields for the email address, item name, and invoice amount;
    • Include no more than 1000 invoices.

    For anyone that misses the bit about the file format, they’ll get a reminder of it in the upload field.

    The rest of the information (the link to the file template and FAQs on how to batch invoice) is linked out to other pages, which keeps this importer page nice and short.

    When possible, I’d recommend formatting the instructions using paragraphs, bulletpoints, bolded headers or white space. This would be similar to how you’d structure text for readability on a web or app page.

    QuickBooks Self-Employed shows us how this might work:

    QuickBooks Self-Employed lets users import cash transactions into the software with a 3-step import process
    QuickBooks Self-Employed gives users the ability to import business revenue and expense records into the software. (Image source: QuickBooks Self-Employed) (Large preview)

    There are three steps presented and each is kept short and to the point. By adding extra space between and around them, reading the export/import instructions will seem less daunting.

    One last thing you can do is to make the “Import” button stand out so that users that use the importer more than once can quickly skip past the instructions on subsequent uses.

    Here’s how this might look if you use Flatfile as your data importer:

    An example of a data importer instructions page from Flatfile with a bright purple ‘Upload data from file’ button
    An example of a data importer instructions page from Flatfile. (Image source: Flatfil) (Large preview)

    The button stands out clear as day on this page. And for those who have used this importer before, they won’t need to read through the instructions on the right for a reminder of what kinds of file types are allowed. There’s a note right beneath the button that clarifies this.

    What’s more, the button is in the top-left corner, which is where most users’ eyes initially focus on a new page. So, the strong color of the button coupled with the priority placement will help users quickly get the import process started.

    2. Show Them All The Import Options That Are Available

    Consumers often expect companies to provide them with options. This is something we’ve seen a lot lately in e-commerce, with shoppers wanting various purchase options available (e.g. pick up in-store, curbside pickup, two-day delivery, etc.)

    If it makes sense to do so for your app, consider giving your users the same kind of flexibility and control over how they import their data. And when you do, design each option so that it’s clear — just by looking at it — what action comes next.

    For instance, this is the expense and income importer for AND.CO:

    AND.CO expenses and income importer box: upload CSV file by clicking and selecting file or dragging and dropping it into the page
    AND.CO invites users to import their expenses & income by uploading their files or dragging and dropping them into the interface. (Image source: AND.CO)(Large preview)

    The block with the dashed border tells users that they have at least one option: Drag-and-drop their CSV file into the widget to upload. While an importer design like this doesn’t always allow for click-to-upload, this one does (per the instructions).

    Flatfile uses a similar design at the top of the import page:

    Flatfile upload widget allows for drag-and-drop or click-to-upload for data import
    Flatfile enables users to import their files through drag-and-drop or click-to-upload. (Image source: Flatfile) (Large preview)

    The difference between these two examples is that Flatfile includes an upload button inside the dashed-border box so that it’s clear that both import options are available.

    There’s also a third option beneath this block:

    Flatfile data importer includes spreadsheet tool to manually enter data
    Flatfile enables users to import their data manually into this spreadsheet. (Image source: Flatfile) (Large preview)

    It’s a good idea to include a manual import option if your end users will return to the importer to add small handfuls of data and don’t want to prepare a file every time.

    One last way to present import options is through the use of third-party software logos as Asana does:

    Asana data import options: select a CSV file or import from other tools like Trello, Wrike and Airtable
    Asana allows users to upload project data with a CSV file or imported from other software (Image source: Asana) (Large preview)

    The standard CSV file import option is available at the top of the page. Beneath that, though, are apps that their users are most likely to have stored their project data in.

    As you can see, the visual presentation of the import options is just as important as the instructions provided. So, rather than try to get creative here, just use a tried-and-true design that your end users will be familiar with and will help them instantly identify the import option they prefer.

    3. Make Complex Imports Look Easy

    At this stage of the data import process, things can get a little hairy. Even if you have a flawless import process on the backend, the way it’s presented to your end users can be a problem if the complexities of the process start to show through.

    There are two things you can do with the UI to keep that from happening. This point will cover what you can do if the import process itself is complex.

    HubSpot is a robust marketing and sales software, so it’s no surprise the data import process would take a while. Regardless, it starts simply enough, asking users if they’re going to import their data or pull it in from another platform:

    HubSpot data import page allows users to start the import or do a two-way sync with other software
    HubSpot users are invited to import or sync their company data. (Image source: HubSpot) (Large preview)

    Now, this design goes against what I just talked about in the last point about designing the first page. However, there’s a reason why this was a good choice.

    Let’s say this HubSpot user decides to import their data from a CSV file. They’d select “Import” and then go to this page:

    HubSpot data importer asks users ‘What would you like to import?’: a file from computer or an opt-out list
    HubSpot asks users what kind of data they want to import. (Image source: HubSpot) (Large preview)

    If HubSpot used the typical import page design, this page would require users to pause and then get acquainted with the new interface before moving on.

    So, this is something to consider if you have a complex data onboarding process that needs to be broken up into multiple steps before the actual import begins.

    Assuming the user just wants to import a CSV, XLS or XLSX, they’ll find themselves here next:

    HubSpot data importer asks ‘How many files are you importing?’: one file or multiple files with associations
    HubSpot asks users how many files they need to import. (Image source: HubSpot) (Large preview)

    What’s nice about this approach is that it prevents users from having to go through the importer once for every file they have to upload. If there’s related data, they can select ‘Multiple files with associations’ and the importer will help them make those connections:

    HubSpot data importer asks users to ‘Select the two objects you’d like to import and associate’, like Companies and Contacts
    HubSpot asks users to select two objects to import and associate with one another. (Image source: HubSpot) (Large preview)

    This way, it’s not the users’ responsibility to merge the data in their files. Nor do they have to spend hours going through their imported records to merge related records. This importer helps them do it.

    The next screen is similar to the “How many files are you importing?” screen. This one appears, however, when the user selects “One file”:

    HubSpot data importer asks users ‘How many objects are you importing?’: one object or multiple objects
    HubSpot asks users how many objects they’re going to import into the software. (Image source: HubSpot) (Large preview)

    This again is aimed at keeping users from importing data and then spending excessive amounts of time cleaning it up.

    Next, we have the part of the process where the user finally sees the importer. While it’s not exactly like the designs we looked at before, it’s still intuitive enough where users will know how to upload their files into it:

    The HubSpot data importer page is specific to what the end user is uploading. This example is for a Contacts file
    HubSpot invites users to upload their contacts into the data importer. (Image source: HubSpot) (Large preview)

    While I realize this is a lot of steps to get to a page that other software would show first, think about how much quicker these users are able to get inside HubSpot and to start working.

    If you have a complex upload process (i.e. multiple files, object associations, etc.), consider using a similar design with each question on its own page as well as consistently presented options.

    4. Use Color To Make Data Cleanup Speedy

    The other way to simplify an otherwise complex import process is applicable to all data importers. In particular, this tip pertains to the final steps in the data onboarding process:

    • Data validation
    • Data sanitization

    Now, having a data importer that can actually do some of this work is going to be a huge help. However, it’s ultimately up to your end users to review what they’ve imported and to approve it before they allow it inside the software.

    To help them not be so overwhelmed by all the data and everything they need to address, use color to guide them through it.

    For this example, we’re going to look at ClickUp. And if it looks familiar to you, that’s because it should. It was built using Flatfile’s data importer.

    Let’s start with the first part of the data validation process:

    ClickUp data importer asks users ‘Does this row contain column names?’ for better data processing
    The ClickUp data importer asks end users to confirm if column names are in the top row. (Image source: ClickUp) (Large preview)

    This page is straightforward enough. It shows the user a snippet from their imported data and asks them if the row pointed to contains column names.

    But look at the green “Yes” button. While this is a design tactic we use for web and app interfaces (i.e. make the desired call-to-action a positive and eye-catching color), there’s another reason this is here.

    Assuming the column names are there and ClickUp can easily interpret the data, this is what the user sees next:

    ClickUp data importer helps users validate data with auto-matched columns and green ‘Confirm mapping’ buttons
    The ClickUp data importer uses the color green to style the ‘Confirm mapping’ buttons. (Image source: ClickUp) (Large preview)

    This is the data importer’s attempt at making light work of data validation. On the left are all the identified columns from the file.

    On the right is information about how the columns were matched to ClickUp’s fields. There are also three possible data validation options:

    1. Confirm mapping (in green);
    2. Ignore this column (in a grey ghost button);
    3. Include as a custom field (in another ghost button).

    The green button here matches what we saw on the last screen. So, users have already been conditioned to view this green button as an affirmative, which will help them quickly go through all the results and confirm the fields that were correctly matched.

    Green and grey aren’t the only colors that should appear in your data importer.

    If errors should arise (which isn’t a bad thing), your users should have a chance to fix them before the data gets uploaded. Depending on where in the app the errors appear, you might want to design them differently.

    For instance, ClickUp uses an orange warning symbol to call out issues with values during validation:

    ClickUp data importer orange exclamation point warning symbols for values not present in the software
    The ClickUp data importer assigns orange warning symbols for values that don’t exist in the software. (Image source: ClickUp) (Large preview)

    This allows ClickUp to tell users, “Yes, the column names match, but your values don’t line up with what we use.”

    ClickUp then uses a red highlighter during data sanitization to point out errors with fields:

    ClickUp data importer highlights required rows with missing or incorrect data in red
    The ClickUp data importer highlights required rows with missing or incorrect data in red. (Image source: ClickUp) (Large preview)

    This is the final step before upload, so this is ClickUp’s last attempt at getting its users to perfect their data import. In this case, ClickUp highlights a field in red if it’s marked as required but contains no data.

    The color alone should call attention to the fields. However, what if the user had imported a file with hundreds or thousands of rows and doesn’t see the red at first glance? Giving them a way to zero in on these red lines would be super valuable.

    And ClickUp’s “Only show rows with problems” toggle does this:

    ClickUp data importer toggle ‘Only show rows with problems’ reveals only required fields containing errors
    The ClickUp data importer lets users only show rows that have problems. (Image source: ClickUp) (Large preview)

    Let’s face it: Unless your data importer tells your users when and where there’s a problem with their data, they’re probably not going to give it a second glance. That is, not until they’re in the software and wondering why their records are all messed up.

    Of course, they’ll blame it on the importer and the software; not on their own negligence. So, providing these colorful markers throughout the process will be a huge help.

    Wrapping Up

    As I mentioned before, if you’re not confident that you can pull off the tricky balancing act between building a friction- and error-free data importer while designing it to be attractive, intuitive and helpful, then why bother?

    As we’ve already seen, Flatfile Concierge is a ready-made data importer solution that’s not only built to handle a wide range of data import scenarios, but it looks great, too. By letting it power your data import process, you can devote more time to building products and your clients can dedicate more time to providing their users with better customer service and support.

    Smashing Editorial
    (ra, ef, il)

    Source link

    web design

    Designing For Attention — Smashing Magazine

    09/15/2020

    We must effectively design to gain and hold users’ attention in order to have them use our digital products. In this article, Victor Yocco covers specific tactics with supporting research that are bound to help you design for attention. He also discusses the need to understand why we want to gain users’ attention as well as what our users’ needs are.

    We face many competing interests for users’ time and attention. If we factor in perceptions of dwindling human attention spans, we might speculate capturing and holding users’ attention is based on luck as much as sound design. However, we can incorporate meaningful tactics into our design to ensure we grab users’ attention. This is critical, we won’t have users if we don’t have their attention.

    I’ll cover some of these tactical design elements. I’ll also discuss the importance of understanding why and how long we want our users’ attention, in order to make sure we create products that are meaningful and in line with users’ best interests.

    What Is Attention?

    Cognitive psychology researchers who have written books on attention have struggled to pinpoint a single definition (Styles, 2005). I will use the word attention to mean gaining your users’ mental awareness long enough for them to interpret, understand, and make a decision based on the information your product is presenting — visually, physically, or audibly (unless your website or smartphone app uses smell or taste as well).

    Researchers have done a fair job of defining two sub-types of attention we should care about as design practitioners:

    • Transient Attention
      This type of attention is brief, perhaps even thought of as a quick distraction, that attracts someone’s attention. Think of a flash of light that draws your attention and then quickly disappears.
    • Sustained Attention
      This is what we think of when we talk about focus and the ability to concentrate; deep attention that allows you to intake and process information or perform a task requiring a longer duration to complete.

    Neither type of attention is superior. You might only need a split second to alert a user to a change in status, or you might need users to comprehend complex material and watch a video that lasts 15 minutes or longer.

    For example, a sound that indicates a file has completed downloading provides enough of a stimulus to gain the transient attention of a user so that they can then process what step (i.e. open the file or continue with something else) they’d like to take next without giving further attention to the fact that a file has been successfully downloaded. You might incorporate additional elements within the downloaded file to maintain users’ sustained attention once they open the file such as effective use of space and displaying progress towards the conclusion to allow users to concentrate on the content.

    Why Is Attention Important?

    We’ve long been told about the importance of making a good impression on users. These initial moments of attention will make or break your experience in users’ minds.

    In 2006, researchers published results of studies suggesting that people form first impressions of a website in under half a second (Lindgaard, et al., 2006). Beyond first impressions, if you are designing a site or product that requires users to focus and enter data while completing a workflow, you will need their attention for a sustained period of time. You need to hold their attention. You need them to process the information you present and respond with the appropriate information or action you are requesting.

    Dispelling A Myth

    Many of us have heard (repeatedly) that humans have a shorter attention span than a goldfish. This isn’t true. The misconception was put forth in a 2015 Time article stating Microsoft researchers found human attention spans had decreased from 12 seconds to 8 seconds over the time period examined. There are many problems with these assumptions and the way attention span was defined and measured.

    Critical to the clickbait statement, we cannot compare human attention to goldfish. In part, because no one knows how to measure the attention of a goldfish (Bradbury, 2016). Additionally, the study that Time cited as measuring goldfish attention was in fact measuring goldfish memory — two distinct concepts that cannot be conflated.

    My final point on this is that it doesn’t matter whether our users have a shorter or longer attention span than goldfish — unless we are designing an experience meant for goldfish as users. Humans have shorter attention spans than goldfish is a catchy statement that is false and irrelevant.

    Why Do You Deserve Users’ Attention?

    I suggest we worry more about how we can effectively and respectfully gain our users’ attention versus the supposed shortening of the human attention span. Jakobs’ Law of the Internet User Experience (2000) states:

    “Users spend most of their time on other sites. This means that users prefer your site to work the same way as all the other sites they already know.”

    We can restate this in terms of the need to respect our users’ time and attention as well:

    “Users spend most of their time on other sites and life activities. This means you need to understand why and how long you need users’ attention. Don’t make them spend extra time on your site.”

    Once you have a user’s attention, what do you want to do with it? You need to respect your users. Understanding why you want them to give their attention and time to your site will help ensure you respect them. Additionally, you need to understand why you want to design for attention in order to craft the right design: are you seeking a brief interaction with users, or do you need sustained attention to effectively convey what users need to know?

    Key Questions For Stakeholders And Users

    UX and product discovery research is required to achieve your goals. Your product team should answer the questions listed in Column A in the table below. Your user research should answer the questions in Column B Below.

    A B
    Questions for your product team and stakeholders Questions for your user research to answer
    Why should people use your product? How do users currently accomplish the task or meet the need your product solves?
    How long do you need their attention?
    How does your product differ from the competition?
    Why do they use similar/competing products?
    Why do you want their attention? Are users accomplishing a task (transactional) vs. looking for information (educational)? What else is competing for users’ attention during use (context)?
    Why do you deserve their attention? How quickly can users accomplish the task using your product?
    Are there potential ethical issues with increasing attention/engagement with your product? What additional information or help do users need to make the experience self-explanatory?

    Answering the questions in Column A will provide the clarity you need to ensure your product is intentional and ethical. If you are unable to effectively answer these questions, your product needs more discovery and better justification.

    Answering the questions in Column B will ensure you provide the correct solutions to gain and maintain user attention, as well as respect them as users.

    You should answer all of these questions even if you aren’t focusing on capturing users’ attention. These questions aren’t unique to the concept of attention, they are mandatory to answer for responsible UX design. Why should people use your product over the many existing options if you can’t explain why?

    You cannot substitute books and articles on UX design for conducting research with users. I won’t cover the details of individual user research methods in this article, but conducting research using common methods will help you understand how to best answer the questions above and design for the attention needs of your users. These methods should include:

    • Interviews
      Asking folks questions one on one is a staple UX research method. You can explore attitudes and behavior as well as adjust questions based on the feedback you are receiving.
    • Contextual Inquiry
      Sitting side by side or in the context of use with a user. You will learn about the distractions and other tasks users engage in while attempting to use your product. Different contexts will present different challenges to inspire your design.
    • Usability Testing
      This method allows you to answer tactical questions related to your design: Does your design work? Do users understand what to do? Do the elements meant to attract and hold attention do so effectively?

    Let’s Get Tactical

    OK, now you’ve determined to responsibly include elements designed to gain and hold users’ intention. I’ll cover some key tactics you can use to better design for your users’ attention:

    • motion,
    • sound,
    • progress and interruptions,
    • clearing the clutter and removing distractions,
    • shortcuts to the outcome,
    • gamification,
    • giving users something to do.

    These are examples of some options for tactics to consider, they are not comprehensive, but most have research supporting the link between human attention and the tactic.

    Motion

    Motion is a scientifically sound way to grab users’ transient attention. When something appears suddenly in our peripheral vision, we cannot help but notice it (Liu, Pestilli, and Carrasco 2005). You can use motion to attract attention to a specific area of the screen, reduce frustration by surfacing a critical insight like “click here” when you sense users are struggling, or highlight a status change.

    Motion is not a panacea for all situations needing user attention. First, not all users are sighted. If you looked carefully at the Liu, Pestilli, and Carrasco 2005 study, all of their research participants had 2020 or corrected to 2020 vision. We know we need to account for low vision and blind users in many situations we design for. Second, motion simply isn’t the correct way to address many design scenarios. Motion can be negatively distracting as easily as it can be an enhancement to gaining attention. Nielsen Norman Group provides a good article giving insight on the use of animation which includes the following:

    • What is the goal of the animation?
    • What is the frequency of occurrence?
    • Employ animations sparingly and only when they add meaning to the interaction.
    • Think about whether the animation will cause an attention shift or not and whether the same user is likely to stumble over it again and again.
    • Will the animation reinforce relationships between UI elements?

    Nielsen Norman Group provides a great reminder not to use motion to impede users’ progress. No one wants to wait while a video of an animated chicken plays to reflect an updated status of a ticket in your project tracking software. Find other ways to keep users’ attention.

    Sound

    Sound is another tactic with scientific backing (Fritz, et al, 2007). Sound is useful in going beyond visual stimulus. We can use sound to draw users to a change in status, briefly drawing their transient attention (think “You’ve got mail”) and we can use sound to hold our users’ attention via narration or music. We can combine sound with visuals to create a strong impact.

    Sound also has the potential to be a safer option in some settings. For example, voice assistant apps allow us to be hands-free on our phones during situations such as driving. Or having a map application that gives audible alerts and directions versus requiring users to view a screen. Thinking beyond devices with larger screens, sound can and should be incorporated into wearable devices as well. How might a heart rate monitor communicate information to users audibly? Or how might a heart rate monitor audibly communicate critical information to first responders, if necessary? Karen Kaushanksy’s 2012 Smashing Article is a good resource with links to other resources for consideration when designing audio in your experience (even if we might disagree on the value of “You’ve got mail”).

    Progress (Or Not)

    You can use graphical displays of progress to hold users’ attention. When users are weighing how much time they have or are willing to give paying attention to your site, you can provide a progress graphic to keep them interested. The end is near! Additionally, showing progress in increments allows users to feel a sense of accomplishment or progress while completing a task that might otherwise be considered mundane (e.g. completing a form or making progress in a mandatory online training at work).

    You might consider testing if users would appreciate your progress graphic doubling as navigation in certain contexts. For example, if the progress bar in Figure 1 reflects pages on a form, would users need the ability to click back on step one if they needed to update information and then click to navigate back to step three without going through Step 2 again? This might keep users engaged if they go back to the workflow and then do not have to aimlessly skip through redundant information to get back to where they left.

    An image of a progress bar showing the user has completed 2 out of 4 steps in a workflow
    Progress graphics give users an anchor for how long you will need their attention. (Large preview)

    Stopping progress is another way of gaining users’ attention, particularly when done during a normally routine task. If you have an important announcement or need users to pause to consume information, displaying the information and requiring an acknowledgment can be an effective technique.

    Many sites and applications (including the Hinge dating app shown below) shared important messages around the issues of race and equality during recent efforts to increase awareness of inequality in the US and around the world. Hinge presented users with this screen after opening the app, a point where a user would typically land on a profile of a potential match.

    An image of a screen describing the actions Hinge was taking to raise awareness of culture and race issues.
    A well-timed interruption of users’ progress is a technique for quickly gaining their attention. (Large preview)

    You might frustrate users if you stop progress too frequently. Additionally, users are likely desensitized to some level of having progress impeded. Many e-commerce and news sites use this technique to present new users with a screen to subscribe to email updates (often with the incentive of a discount). However, this might lend validity to the technique if many of these sites are successful at doing this.

    Clear Clutter/Remove Distractions

    When you want users to understand something and make an action, perhaps on an unfamiliar interface with a specific purpose, you need to present them with immediate wayfinding to keep their attention.

    The next example is of the opening page of a complex statistical analysis and modeling program. The design shows users immediately what they can do to begin a project, rather than overwhelming them with all the potential options. They get users’ data into the platform, let them see the value, then can progressively unfold guidance on how to run various analyses and visualization. Overwhelming users is a good way to have them stop paying attention.

    An image of a statistical program landing page with large text stating drag a file to begin or click one of four options presented as large orange buttons in the center of the screen
    Presenting users with a clear view and clear step to start action can help gain and hold attention. (Large preview)

    When I do usability testing and hear participants — this looks so much more modern than what we have now and I like it, it is often in reference to good use of space, clearing the clutter, and showing them through the interface exactly what they need to do to complete a critical task.

    The image below is a non-example of how clutter is detrimental to attention. Adding clutter has been a technique some media outlets use for distracting users in order to promote their purchase of a subscription or paid upgrade that will remove the clutter. Think ad vs ad fee experiences on apps and games.

    An image of a NY Times article broken up in several places with advertising unrelated to the content
    Over cluttering the screen users will increase the chance you lose users’ attention. (Large preview)

    Shortcuts To The Outcome

    If you believe your potential users have short attention spans you need to get them to the desired outcome as quickly as possible. We have many techniques to do this depending on what your product is. This includes:

    • ‘Buy Now’ buttons,
    • Saving a cart,
    • Wish lists,
    • Create accounts/save critical information,
    • Prepopulating data fields,
    • Removing non-required fields,
    • Providing concise summaries,
    • Showing an estimate of time to complete a task, video, or article.

    E-commerce sites can add a ‘Buy Now’ option to their items to bypass as many intermediary steps possible. Similarly, allowing shoppers to save carts or make wish lists will allow them to save things for a later time when they might have more attention to give. Both of these tactics suggest you’d want to have users create accounts and save critical information for prepopulating fields or expediting use at a later time.

    Allowing users to skip non-critical information or view concise summaries of information is another technique if your site presents large amounts of information. Displaying the length of time a video or audio file will take to play is a good way to let users know upfront how much time they will need to invest.

    You should allow users to save progress if your product requires forms or lengthy workflows. You stand to frustrate users who invest time but cannot fully complete a task if you require them to start from scratch when they return. Prefilling data based on information you already have, and reducing or removing non-essential fields are additional ways to respect users’ time and attention.

    Gamification

    Products across industries have found ways to gamify their experience to hold people’s attention. Researchers in the field of education have found elements of gamification might increase the attention students give to lectures and other content where attention is required for successful processing (e.g. Barata, et al, 2013). Stephen Dale (2014) provides a thorough examination of gamification and critical factors related to successful gamification.

    Depending on your product, there are many opportunities for gamification. We see this across the board in health and fitness apps: rewards and recognition for certain accomplishments, challenges and leaderboards, and the ability to share and compare with friends via social media.

    The Netflix example below shows the importance of doing gamification with the right intention and appropriate audience. If increasing use of your product might be ethically questionable, or a waste of users’ time, you should explore other techniques to only hold attention for the necessary amount of time. Dale (2014) suggests we need to answer the following questions to effectively and ethically gamify our experiences:

    Dale suggests we need to answer the following questions prior to gamifying our experiences:

    • Understand the target audience we intend to engage;
    • Recognize the behaviors we want to change;
    • Understand what motivates your audience and maintains their engagement;
    • Define how success will be measured.
    An image of the Nike app displaying a user’s achievements as a way to motivate continued use and exercise
    Gamification involves adding elements from game play such as competition and challenges. Nike displays a user’s achievements as a way to motivate continued use and exercise. (Large preview)

    Give Users Something To Do

    You increase the likelihood of keeping users’ attention when you have them actively engage with content. Dating apps and social have perfected the interweaving of relevancy and action on phone-sized screens. Swiping on profiles, scrolling down and up, pull down to refresh, swipe right to make a new connection, all this reinforces a connection between a physical action, a response on the phone screen, and an immediate hit of dopamine. Some experts suggest this is how we have created problematic usage of smartphones.

    We aren’t inherently evil when we ask users to engage in a tactile way with our applications. There are many valid and well-meaning products designers are creating to help people with medical conditions such as Parkinson’s disease and stroke among many other future potentials (Some examples of many: de Baros, et al. 2013, Oh, et al. 2018), I’m putting this technique out in that it is the definition of an effective technique for holding users’ attention, however, it is also can be problematic for users prone to addictive behaviors.

    Physical interaction is also not a catch-all solution. You won’t meaningfully increase user attention to your mobile banking application no matter how many ways you let them refresh their balance by pulling down on the screen, however, you might find some users refreshing non-stop during certain time periods where they are expecting a deposit or withdrawal of funds. You need to have the other pieces to good design and technology in place to make the experience effective at that point.

    For example, have you made it clear to users the bank’s policies around posting deposits? Perhaps you detect a user has refreshed on their balance 15 times in 3 minutes and you surface a message that states account balances are only refreshed at 5 pm in whatever time zone your bank is located each weekday and never on weekends. You have introduced a positive intervention to allow this user to move on with their life and they can return at the appropriate time to use your product for the appropriate reason.

    The Consequences Of Irresponsible Design

    I’ve covered the basics of some tactics to consider when designing for attention. You will need to explore more when making the decision as to what is best for your users and your product. We stand to suffer negative consequences if we don’t have good answers to why we want our users’ attention. It might sound dramatic, but we are responsible for how our design impacts our users’ lives. Netflix learned this a few years ago when they were exploring a badging/rewards system to gamify children watching Netflix.

    Responsible adults quickly called this out as an attempt to encourage children to spend even more time in front of the television or watching shows on a device. Netflix retracted the feature, but not before receiving negative press and spending plenty of money to design and develop it out.

    Image of the headline from a Vanity Fair article on Netflix decision to pull the plug on a feature designed to get kids addicted to Netflix
    Figure 6: You don’t want Vanity Fair to call your idea potentially catastrophic. (Image source: vanityfair.com)(Large preview)

    Ethical Implications

    Beyond bad publicity, the overuse of digital products can be detrimental to users’ mental health and unethical. The idea of Internet addiction is almost as old as the Internet itself, with Young’s (1996) seminal work measuring Internet addiction starting an entire field of research aimed at the issue.

    Regardless of your personal feelings, research and funding have been aimed at reducing problematic (pathologic) use of online sites and video games, The World Health Organization’s 2018 recognition of “gaming disorder” as a classifiable disease validates the negative impact digital experiences can have on users. We owe our users the respect to do what we can to prevent the overuse of unnecessary digital products. We probably shouldn’t call them users.

    We also have the opportunity to do good when we acknowledge design can become addictive and attempt to address it within our products. For example, Nintendo’s president moved the company to the front of the gaming addiction conversation in announcing the company has added parental controls as one way to combat the issue.

    Apple’s Screen Time is another feature meant to create user awareness and prevent the overuse of digital products. You should think about how you can get users to detach from your product as quickly as you can, once they have accomplished the task at hand.

    Bringing It To Life

    We need to proactively design for our users’ attention. We want to have people use our products, that is why we design. However, we need to understand and respect our users through the techniques we use to gain and keep their attention.

    There is no one size fits all solution to the issue of user attention. I think that is part of the beauty; we must experiment, and we must truly know our users if we want to effectively engage them. You can use the techniques presented here, along with the continuous gathering of user feedback, to make the best decisions for your users.

    I also have great news for you: if you are still reading this you have a longer attention span than a goldfish.

    Smashing Editorial
    (cct, ra, yk, il)

    Source link

    web design

    Designing With Reduced Motion For Motion Sensitivities — Smashing Magazine

    09/08/2020

    Thanks to the wide support of the prefers-reduced-motion-media feature, we now have more advanced ways to design motion that can be creative and innovative while also being safer for those with motion sensitivities. This article is all about the how and why of making that happen.

    CSS has recently added features that allow us to recognize certain user preferences and qualities of the user’s current environment. One of those new features, specifically the prefers-reduced-motion media feature, can be especially useful for designing more inclusive motion on the web.

    A few years back, I wrote an article about designing safer web animation for motion sensitivity and the limited options we had at the time to design safe motion on the web. Some things have remained the same since that original article, like the types of motion effects that can be triggering, and the importance of context and user expectations. But what has changed is the existence and support of the prefers-reduced-motion media feature. That makes a big difference in how we can design the motion in our work to be inclusive and accessible.

    Why Reduce Motion?

    The release of iOS7 back in 2013 sparked a realization throughout the digital design world that some motion on screen — even if it was part of an interface — could have physical consequences for people with motion sensitivities. In the years since then, the major mobile and desktop operating systems have added functionality for people to reduce the amount of motion they encounter in their operating systems.

    Articles like “Your Interactive Is Making Me Sick” and “Accessibility For Vestibular Disorders” share first-hand stories of how our design choices, especially around motion, can have physical consequences for those with motion sensitivities. The root causes of these motion sensitivities can vary greatly between individuals. For some, it’s rooted in a vestibular disorder, while for others it might stem from migraines or other factors. What’s triggering can also vary from person to person, or even from day to day for some. The physical symptoms individuals experience as a result of that triggering motion can range from slight dizziness or headaches to nausea or worse.

    The design choices we make around animation in our work directly impacts how our work affects people with motion sensitivities. Knowing what kinds of motion are potentially triggering, and how we can mitigate them with our design choices, helps us design experiences that are safe for our audience and won’t cause unintended harm. Animation still absolutely can have a positive impact on our UX efforts, but it’s up to us to make sure we use it responsibly, just like we try to use our other design tools responsibly.

    Prefers Reduced Motion On The Web

    The prefers-reduced-motion media feature now has strong browser support. It’s supported in current versions of Edge, Firefox, Chrome, Safari, Opera, iOS Safari, as well as on Android Browsers and Chrome for Android. The level of support we have today makes it something that you can absolutely use in production. Also, if someone’s browser doesn’t support this feature, nothing bad happens, it will just be ignored and things will carry on as before.

    Browser support table for the prefers-reduced-motion media feature on caniuse.com
    Browser support table for the prefers-reduced-motion media feature. (Large preview)

    On the development side, we can test for prefers-reduced-motion in the same way that we would use any other media query in CSS or JavaScript to find out if reduced motion has been requested.

    In CSS that will look something like this:

    @media (prefers-reduced-motion: reduce)  {
        /* reduced behaviour */   
    }
    

    And in JavaScript:

    let motionQuery = matchMedia('(prefers-reduced-motion)');
    
    const handleReduceMotionChanged = () => {
      if (motionQuery.matches) //reduced behaviour;
    }
    
    motionQuery.addListener(handleReduceMotionChanged);
    handleReduceMotionChanged()
    

    Whichever way you choose to access it, this media query will return one of two values: no-preference (false), or reduce (true). Once retrieved, you can use these values to inform what you display in the browser.

    Of the two values that can be returned, the only one we can be sure has been set intentionally is the reduce (true) value. No-preference (false) can mean that the person in question is fine with all types of motion, or it could mean that that preference just hasn’t been set yet. This makes any approach that equates the value of no preference (false) to the person in question opting in to all levels of motion unreliable. Because of this, the better approach is to reduce potentially triggering motion effects when a value of reduce (true) is returned.

    For example, here the looping bounce animation is replaced with a fade in animation when reduced motion is requested:

    /* A constant bouncing motion effect applied to the title */
    h2 {
      animation: bouncing 1.5s linear infinite alternate;
    }
    
    /* Replace it with a safer effect when prefers-reduced-motion returns true */
    @media (prefers-reduced-motion) {
      h2 {
      animation: fade 0.5s ease-in both;
       }
    

    Reduced Motion From The Users’ Perspective

    Most major operating systems allow people to set their preferences in their system settings. The exact wording and location of the settings vary, but the preference can be set on iOS, OSX, Windows, and Android operating systems.

    Screenshot of the iOS and OSX Accessibility display menu
    On iOS or OSX, this setting can be accessed via Settings > Accessibility > Display. (Large preview)
    Screenshot of the Windows Simplify and Personalize Windows menu
    On Windows it can be accessed via Settings > Ease of Access > Display >Simplify and personalize Windows. (Large preview)

    The Prefers Reduced Motion Media Feature In Practice

    Deciding how to put the prefers-reduced-motion media feature to use is where we have space for creating solutions that best fit the context of our products and content. For most web projects, you’ll want to first identify any potentially triggering motion effects on your site, and then use the prefers-reduced-motion media feature to provide a reduced version of that effect.

    Let’s look at each step in more detail.

    Identifying Potentially Triggering Motion

    To find any potentially triggering motion you might have, go through some typical user flows for your site or product and take a closer look at the motion effects used: Do you have any interactions that have large movements? Any large zooms, spinning effects, or parallax effects? All of those types of animated effects are very likely to be problematic for people with motion sensitivities. In contrast, animated effects like color fades, opacity changes and small changes in scale are unlikely to be problematic. If in doubt, it can’t hurt to add the effect in question to your “to reduce” list to err on the side of caution.

    The Web Content Accessibility Guidelines recommend providing a reduced version for any “motion that creates the illusion of movement…that is not essential to the content’s meaning”. I think it’s helpful to see some examples too, especially if you don’t consider yourself to be sensitive to motion on screen. I cover examples of potentially triggering motion in my previous article and this post on the Webkit blog has some too. Chances are, unless your site relies heavily on motion, you’ll end up with a fairly short list of effects to focus on here.

    Create A Reduced Motion Version

    Next, you want to determine the most appropriate reduced motion condition for these potentially triggering effects. Can the animation easily be adjusted to use a non-motion effect like an opacity fade or crossfade for reduced motion requests? Would pausing the motion or removing the effect entirely for reduced motion preserve the meaning of the content?

    The role of the motion in question will be an important factor in deciding what the most appropriate reduced version would be. You don’t want to unintentionally remove content or degrade the overall experience. Here are a few examples of what might work well for the potentially triggering effects you find:

    Large Page Transitions

    Large page transition effects can likely be replaced with a crossfade effect for a reduced motion mode. The same is usually true for large zooming or spinning transitions that transition between different states or views.

    Animated Illustrations

    Animated illustrations, on the other hand, might be best replaced with a static version for reduced motion if they are mostly for personality or branding effect. You’ll want to make sure the static version is still meaningful, and the arrangement that has the most meaning may not always be the very beginning or very end of the animation. Adding in functionality to play animated illustrations on demand for reduced motion could also be useful by allowing people to play the animation when they’re ready for it.

    Don’t forget to consider the motion in your animated gifs or auto-playing videos here as well. These can also contain potentially triggering motion and would need a reduced version if they do.

    Parallax Effects

    Parallax effects and exaggerated smooth scrolling effects are universally triggering for folks with motion sensitivities, so those should be significantly reduced or entirely removed for reduced motion. (Every single person I’ve talked to in my research on this has called out parallax specifically as being a problem for them.) Smooth scrolling effects can be replaced with the default browser anchor link behaviour as described here by Eric Bailey. Removing parallax effects for reduced motion is the ideal solution, but make sure to check that all the necessary content is still visible and usable with the parallax removed.

    In most cases substituting the potentially triggering effect with a safer effect for reduced motion is the best way to preserve as much of the content’s intent and usability as possible. Luckily, substituting a reduced effect can be pretty straight forward too.

    An Example Of Reducing Motion

    For example, let’s say I flagged this header animation as potentially triggering when I went through my site. The motion is large enough to create the illusion of motion, so it’s likely to be triggering, and the multiple directions of motion are also likely to be problematic. It’s definitely one I’d put on my list of effects that need a reduced version when reviewing my site.

    All the plant photo have the same styles applied to the end state of their animation to position them intrinsically where they’d be in the document flow by default:

    .active .plant1, .active .plant2, .active .plant3 {
      transform: translateY(0);
      opacity:1;
    }
    

    And each has a beginning state with positioning to translate it slightly above or below its intrinsic position to start. Along with a transition defined to make the animation happen:

    .plant1 {
      transform: translateY(-100%);
      transition: $dur $ease-both;
    }
    
    .plant2 {
     transform: translateY(120%);
     transition: $dur $dur/6 $ease-both;
    }
    
    .plant3 {
       transform: translateY(-100%);
       transition: $dur $dur/3 $ease-both;  
    }
    

    The text animation works in the same way but with horizontal translation of each word instead of a vertical translation.

    I can change the animation to transition opacity instead of transitioning the transform position when reduced motion has been requested by changing the beginning state of the animations like this:

    @media (prefers-reduced-motion: reduce) {
    .plant1, .plant2, .plant3 {
      transform: translateX(0);
      opacity:0;
      }
    }
    

    Now, when the prefers-reduced-motion media feature returns true, the beginning state of each plant photo animation will be set to already be positioned at the end state with an opacity of 0. This means it can use the same transition properties — the same easing, duration, and offsets — but opacity will be animating now instead of the position via a transform:

    Notice how I didn’t need to make any changes to the duration, easing or delays of the animation to do this. Swapping out the animating property, but still using the same animation details, was enough to reduce the motion. This particular example was made in CSS, but swapping out the animating property can be just as straightforward with JavaScript or when using animation libraries too.

    Examples Of Reduced Motion In The Wild

    You can see this approach in action on viljamisdesign.com, which happens to be one of the first sites besides apple.com I noticed working with reduced motion. When you go to the site with reduced motion requested, the spinning starfield animation is stopped and the larger movements of the headline are removed. But animations like the various hover effects are all still there. This results in an experience that has its UX affordances and design details intact, while also being safer for the person who’s requested reduced motion. (Here’s a video of Viljamisdesign.com both with and without reduced motion enabled for reference: https://vimeo.com/399979166/1bd41d1919)

    Screenshot of Viljamisdesign.com with “Hello, Universe” in large type with a pixel starfield behind it
    Screenshot of Viljamisdesign.com (Large preview)

    The Airpods Pro page also responds to reduced motion preferences, but in a very different way because of the content and effects used. Almost all of the motion on the page could be potentially triggering since it has a lot of big zooming movements and parallax-style effects. When reduced motion is requested, all the parallax and large motion effects are removed, but they do more than just pause or remove the animations. The version you see with reduced motion selected has been designed with care to preserve the same content and meaning from the full motion experience. (Here’s a video of The Airpods Pro site both with and without reduced motion selected for reference.)

    Screenshot of the Airpods Pro site without reduced motion with a large closeup image of a pair of Airpods
    Screenshot of the Airpods Pro site without reduced motion (Large preview)

    Add Custom Toggles For Motion-Heavy Experiences

    I mentioned above that most “task-based” sites likely have only a handful of animations that might be triggering and need a reduced version. But those aren’t the only kind of web sites out there on the web. Projects that involve a large amount of motion, like sites that are meant more for storytelling or creating an experience might benefit from a slightly different approach.

    For projects like these, it would be difficult to make a list of potentially triggering motions and provide a reduced alternative for each because almost all of the motion used could be potentially triggering. Plus, the motion is very much part of the content and its meaning. Designing a reduced motion mode for these types of sites will take a more global approach and more effort to be sure the meaning of your content is preserved even as motion is reduced.

    For these highly animated experience sites, providing a visible custom motion toggle is a useful thing to include. This will allow people who may not yet know about the reduced motion setting, or who are experiencing some motion sensitivity at that moment in time, to quickly adjust the experience. A motion toggle provides a way for motion-sensitive folks to participate in your content in a way that won’t make them sick. That’s definitely better for everyone involved than them having to avoid your site entirely.

    Context Is A Key Factor

    Remember that context also plays a big role here. No one wants to be surprised by large amounts of motion where they don’t expect it. If you’re visiting a site billed as a highly interactive storytelling experience you’ll have very different expectations than when you’re visiting your bank’s web site. Both of those sites certainly could feature large amounts of animation, but it would be an unexpected surprise on the bank site.

    Building A Custom Motion Toggle

    The idea of a custom toggle is something that I mentioned back in my 2015 article, but today it’s a much more viable option. On today’s web, we can create one with more ease, and even make a smarter toggle than we could have just a few years ago.

    Marcy Sutton has a great example of how a modern custom motion toggle could work in this CodePen. (This example is part of her course on making accessible web apps, which is also very much worth checking out.) Her example uses a toggle to remove all motion because it only includes one animation, but this approach can be used to provide reduced motion effects across an entire application or site following the same logic as well.

    The key feature of this approach is how nicely Marcy ties it in with modern web technology, i.e. prefers reduced motion and local storage. When using this approach, if someone comes to your site with reduced motion requested, they automatically get the reduced motion version without having to manually activate the toggle as well. And if someone invokes the toggle to reduce motion, that preference will be saved via local storage so they won’t have to repeatedly make this selection every time they visit.

    The Animal Crossing site with Tom Nook, a main character in the game, front and center.
    The official Animal Crossing site allows you to reduce or enable motion depending on your preference. (Large preview)

    The official Animal Crossing site is a wonderful real-world example of a custom reduce motion toggle combined with the prefers-reduced-motion media feature. It’s one of my favorite examples of handling reduced motion. The design choices they made around how to reduce potentially the triggering motion, while still keeping true to the overall feel of the site and the content, is great. I wrote more about how they pulled it off in this blog post. There are a lot of sites out there whose audience could benefit from a similar approach.

    Other Ways To Use Motion Toggles

    If you already have a preferences or settings panel, adding a toggle to request reduced motion could be a valuable thing to add to these settings like Twitter does on its site. In this case, there aren’t large amounts of motion immediately presented when visiting the site and there’s already a settings panel, so implementing the toggle as part of the settings preferences fits well. Twitter’s toggle also respects OS-level settings via the preferes reduced motion query and is preset to either on or off based on what the user has set at the OS level. Designing your motion toggle to respect OS settings is definitely a smart approach to implementing them well no matter where the toggle might appear.

    A screenshot of the accessibility tab of Twitter’s settings panel
    Twitter’s settings menu includes a reduce motion toggle. (Large preview)

    Contextual toggles are another approach that could be used to reduce motion on specific animated illustrations or other content areas that appear throughout your site. The Dark Side of The Grid article does this nicely by adding contextual toggle buttons to each animate figure to allow the reader to play the animation when they want to see it, but not have it loop endlessly while they are reading.

    A screenshot of the accessibility tab of Twitter’s settings panel.
    A figure in the Dark side of the grid article that allows you to play animated figures on demand with a custom button for each. (Large preview)

    Along those same lines, Dave Rupert shared a technique for combining prefers reduced motion with the picture element to show static elements in place of animated gifs when reduced motion has been requested. Chris Coyier took that one step further and suggested presenting a play toggle for those animated gifs based on the same approach. Steve Faulkner’s gif de-animator example could also be a useful approach.

    All of these, or something similar, could be good options for mitigating any potentially triggering motion on the web. I bring up these examples for two reasons. The first is to show that there are a number of ways to approach providing reduced motion variations and you have lots of flexibility to find an approach that fits best for your content. And secondly, as time goes on and more folks are building sites with reduced motion options, the more innovative solutions we’ll see shared in the community.

    There are many creative ways to add toggles and settings in a way that makes sense for the context of your project. It’s an interesting parallel that we’re seeing more and more web sites include settings panels or options for setting preferences like dark mode. Including an option for reduced motion could be a natural next step.

    The More We Use It, The Better It Will Get For Everyone

    I think it’s important for us, the people designing and building things for the web, to take advantage of the prefers-reduced-motion media feature to make our work more inclusive. By taking steps to respect motion preferences we make the web safer for more people to use, and that can only be a good thing. We absolutely can be expressive and creative with motion on the web while also being responsible and inclusive.

    But the awareness level is still something we need to be, well, aware of. Not everyone who might need reduced motion is aware of the option in their OS settings. Perhaps even fewer people know that it can take effect on content in their browser too since so few websites currently take advantage of it. The more we take advantage of the prefers-reduced-motion media feature, and provide a quality reduced motion experience with it, the more meaningful of a feature it will be for those who need it.

    Smashing Editorial
    (ra, il)

    Source link