Recherche avancée

Médias (5)

Mot : - Tags -/open film making

Autres articles (86)

  • Personnaliser en ajoutant son logo, sa bannière ou son image de fond

    5 septembre 2013, par

    Certains thèmes prennent en compte trois éléments de personnalisation : l’ajout d’un logo ; l’ajout d’une bannière l’ajout d’une image de fond ;

  • Ecrire une actualité

    21 juin 2013, par

    Présentez les changements dans votre MédiaSPIP ou les actualités de vos projets sur votre MédiaSPIP grâce à la rubrique actualités.
    Dans le thème par défaut spipeo de MédiaSPIP, les actualités sont affichées en bas de la page principale sous les éditoriaux.
    Vous pouvez personnaliser le formulaire de création d’une actualité.
    Formulaire de création d’une actualité Dans le cas d’un document de type actualité, les champs proposés par défaut sont : Date de publication ( personnaliser la date de publication ) (...)

  • Participer à sa traduction

    10 avril 2011

    Vous pouvez nous aider à améliorer les locutions utilisées dans le logiciel ou à traduire celui-ci dans n’importe qu’elle nouvelle langue permettant sa diffusion à de nouvelles communautés linguistiques.
    Pour ce faire, on utilise l’interface de traduction de SPIP où l’ensemble des modules de langue de MediaSPIP sont à disposition. ll vous suffit de vous inscrire sur la liste de discussion des traducteurs pour demander plus d’informations.
    Actuellement MediaSPIP n’est disponible qu’en français et (...)

Sur d’autres sites (14688)

  • A systematic approach to making Web Applications accessible

    22 février 2012, par silvia

    With the latest developments in HTML5 and the still fairly new ARIA (Accessible Rich Interface Applications) attributes introduced by the W3C WAI (Web Accessibility Initiative), browsers have now implemented many features that allow you to make your JavaScript-heavy Web applications accessible.

    Since I began working on making a complex web application accessible just over a year ago, I discovered that there was no step-by-step guide to approaching the changes necessary for creating an accessible Web application. Therefore, many people believe that it is still hard, if not impossible, to make Web applications accessible. In fact, it can be approached systematically, as this article will describe.

    This post is based on a talk that Alice Boxhall and I gave at the recent Linux.conf.au titled “Developing accessible Web apps – how hard can it be ?” (slides, video), which in turn was based on a Google Developer Day talk by Rachel Shearer (slides).

    These talks, and this article, introduce a process that you can follow to make your Web applications accessible : each step will take you closer to having an application that can be accessed using a keyboard alone, and by users of screenreaders and other accessibility technology (AT).

    The recommendations here only roughly conform to the requirements of WCAG (Web Content Accessibility Guidelines), which is the basis of legal accessibility requirements in many jurisdictions. The steps in this article may or may not be sufficient to meet a legal requirement. It is focused on the practical outcome of ensuring users with disabilities can use your Web application.

    Step-by-step Approach

    The steps to follow to make your Web apps accessible are as follows :

    1. Use native HTML tags wherever possible
    2. Make interactive elements keyboard accessible
    3. Provide extra markup for AT (accessibility technology)

    If you are a total newcomer to accessibility, I highly recommend installing a screenreader and just trying to read/navigate some Web pages. On Windows you can install the free NVDA screenreader, on Mac you can activate the pre-installed VoiceOver screenreader, on Linux you can use Orca, and if you just want a browser plugin for Chrome try installing ChromeVox.

    1. Use native HTML tags

    As you implement your Web application with interactive controls, try to use as many native HTML tags as possible.

    HTML5 provides a rich set of elements which can be used to both add functionality and provide semantic context to your page. HTML4 already included many useful interactive controls, like <a>, <button>, <input> and <select>, and semantic landmark elements like <h1>. HTML5 adds richer <input> controls, and a more sophisticated set of semantic markup elements like such as <time>, <progress>, <meter>, <nav>, <header>, <article> and <aside>. (Note : check browser support for browser support of the new tags).

    Using as much of the rich HTML5 markup as possible means that you get all of the accessibility features which have been implemented in the browser for those elements, such as keyboard support, short-cut keys and accessibility metadata, for free. For generic tags you have to implement them completely from scratch.

    What exactly do you miss out on when you use a generic tag such as <div> over a specific semantic one such as <button> ?

    1. Generic tags are not focusable. That means you cannot reach them through using the [tab] on the keyboard.
    2. You cannot activate them with the space bar or enter key or perform any other keyboard interaction that would be regarded as typical with such a control.
    3. Since the role that the control represents is not specified in code but is only exposed through your custom visual styling, screenreaders cannot express to their users what type of control it is, e.g. button or link.
    4. Neither can screenreaders add the control to the list of controls on the page that are of a certain type, e.g. to navigate to all headers of a certain level on the page.
    5. And finally you need to manually style the element in order for it to look distinctive compared to other elements on the page ; using a default control will allow the browser to provide the default style for the platform, which you can still override using CSS if you want.

    Example :

    Compare these two buttons. The first one is implemented using a <div> tag, the second one using a <button> tag. Try using a screenreader to experience the difference.

    Send
    <style>
     .custombutton 
      cursor : pointer ;
      border : 1px solid #000 ;
      background-color : #F6F6F6 ;
      display : inline-block ;
      padding : 2px 5px ;
    
    </style>
    <div class="custombutton" onclick="alert(’sent !’)">
      Send
    </div>
    
    <button onclick="alert(’sent !’)">
    Send
    </button>

    2. Make interactive elements keyboard accessible

    Many sophisticated web applications have some interactive controls that just have no appropriate HTML tag equivalent. In this case, you will have had to build an interactive element with JavaScript and <div> and/or <span> tags and lots of custom styling. The good news is, it’s possible to make even these custom controls accessible, and as a side benefit you will also make your application smoother to use for power users.

    The first thing you can do to test usability of your control, or your Web app, is to unplug the mouse and try to use only the [TAB] and [ENTER] keys to interact with your application.

    the tab key on the keyboardthe enter key on the keyboard

    Try the following :

    • Can you reach all interactive elements with [TAB] ?
    • Can you activate interactive elements with [ENTER] (or [SPACE]) ?
    • Are the elements in the right tab order ?
    • After interaction : is the right element in focus ?
    • Is there a keyboard shortcut that activates the element (accesskey) ?

    No ? Let’s fix it.

    2.1. Reaching interactive elements

    If you have an element on your page that cannot be reached with [TAB], put a @tabindex attribute on it.

    Example :

    Here we have a <span> tag that works as a link (don’t do this – it’s just a simple example). The first one cannot be reached using [TAB] but the second one has a tabindex and is thus part of the tab order of the HTML page.

    (Note : since we experiment lots with the tabindex in this article, to avoid confusion, click on some text in this paragraph and then hit the [TAB] key to see where it goes next. The click will set your keyboard focus in the DOM.)

    Click

    <style>
    .customlink 
      text-decoration : underline ;
      cursor : pointer ;
    
    </style>
    <span class="customlink" onclick="alert(’activated !’)">
    Click
    </span>
    
    Click
    <style>
    .customlink 
      text-decoration : underline ;
      cursor : pointer ;
    
    </style>
    <span class="customlink" onclick="alert(’activated !’)" tabindex="0">
    Click
    </span>
    

    You set @tabindex=0 to add an element into the native tab order of the page, which is the DOM order.

    2.2. Activating interactive elements

    Next, you typically want to be able to use the [ENTER] and [SPACE] keys to activate your custom control. To do so, you will need to implement an onkeydown event handler. Note that the keyCode for [ENTER] is 13 and for [SPACE] is 32.

    Example :

    Let’s add this functionality to the <span> tag from before. Try tabbing to it and hit the [ENTER] or [SPACE] key.

    Click
    <span class="customlink" onclick="alert(’activated !’)" tabindex="0">
    Click
    </span>
    
    &lt;script&gt;<br />
    function handlekey(event) {<br />
    var target = event.target || event.srcElement;<br />
    if (event.keyCode == 13 || event.keyCode == 32) { target.onclick(); }<br />
    }<br />
    &lt;/script&gt;


    Click

    <span class="customlink" onclick="alert(’activated !’)" tabindex="0"
          onkeydown="handlekey(event) ;">
    Click
    </span>
    <script>
    function handlekey(event) 
      var target = event.target || event.srcElement ;
      if (event.keyCode == 13 || event.keyCode == 32) 
        target.onclick() ;
      
    
    </script>

    Note that there are some controls that might need support for keys other than [tab] or [enter] to be able to use them from the keyboard alone, for example a custom list box, menu or slider should respond to arrow keys.

    2.3. Elements in the right tab order

    Have you tried tabbing to all the elements on your page that you care about ? If so, check if the order of tab stops seems right. The default order is given by the order in which interactive elements appear in the DOM. For example, if your page’s code has a right column that is coded before the main article, then the links in the right column will receive tab focus first before the links in the main article.

    You could change this by re-ordering your DOM, but oftentimes this is not possible. So, instead give the elements that should be the first ones to receive tab focus a positive @tabindex. The tab access will start at the smallest non-zero @tabindex value. If multiple elements share the same @tabindex value, these controls receive tab focus in DOM order. After that, interactive elements and those with @tabindex=0 will receive tab focus in DOM order.

    Example :

    The one thing that always annoys me the most is if the tab order in forms that I am supposed to fill in is illogical. Here is an example where the first and last name are separated by the address because they are in a table. We could fix it by moving to a <div> based layout, but let’s use @tabindex to demonstrate the change.

    Firstname :
    Address :
    Lastname :
    City :
    <table class="customtabs">
      <tr>
        <td>Firstname :
          <input type="text" id="firstname">
        </td>
        <td>Address :
          <input type="text" id="address">
        </td>
      </tr>
      <tr>
        <td>Lastname :
          <input type="text" id="lastname">
        </td>
        <td>City :
          <input type="text" id="city">
        </td>
      </tr>
    </table>
    
    Click here to test this form,
    then [TAB] :
    Firstname :
    Address :
    Lastname :
    City :
    <table class="customtabs">
      <tr>
        <td>Firstname :
          <input type="text" id="firstname" tabindex="10">
        </td>
        <td>Address :
          <input type="text" id="address" tabindex="30">
        </td>
      </tr>
      <tr>
        <td>Lastname :
          <input type="text" id="lastname" tabindex="20">
        </td>
        <td>City :
          <input type="text" id="city" tabindex="40">
        </td>
      </tr>
    </table>

    Be very careful with using non-zero tabindex values. Since they change the tab order on the page, you may get side effects that you might not have intended, such as having to give other elements on the page a non-zero tabindex value to avoid skipping too many other elements as I would need to do here.

    2.4. Focus on the right element

    Some of the controls that you create may be rather complex and open elements on the page that were previously hidden. This is particularly the case for drop-downs, pop-ups, and menus in general. Oftentimes the hidden element is not defined in the DOM right after the interactive control, such that a [TAB] will not put your keyboard focus on the next element that you are interacting with.

    The solution is to manage your keyboard focus from JavaScript using the .focus() method.

    Example :

    Here is a menu that is declared ahead of the menu button. If you tab onto the button and hit enter, the menu is revealed. But your tab focus is still on the menu button, so your next [TAB] will take you somewhere else. We fix it by setting the focus on the first menu item after opening the menu.

    &lt;script&gt;<br />
    function displayMenu(value) {<br />
    document.getElementById(&quot;custommenu&quot;).style.display=value;<br />
    }<br />
    &lt;/script&gt;
    <div id="custommenu" style="display:none ;">
      <button id="item1" onclick="displayMenu(’none’) ;">Menu item1</button>
      <button id="item2" onclick="displayMenu(’none’) ;">Menu item2</button>
    </div>
    <button onclick="displayMenu(’block’) ;">Menu</button>
    <script>
    function displayMenu(value) 
     document.getElementById("custommenu").style.display=value ;
    
    </script>
    
    &lt;script&gt;<br />
    function displayMenu2(value) {<br />
    document.getElementById(&quot;custommenu2&quot;).style.display=value;<br />
    document.getElementById(&quot;item1&quot;).focus();<br />
    }<br />
    &lt;/script&gt;
    <div id="custommenu" style="display:none ;">
      <button id="item1" onclick="displayMenu(’none’) ;">Menu item1</button>
      <button id="item2" onclick="displayMenu(’none’) ;">Menu item2</button>
    </div>
    <button onclick="displayMenu(’block’) ;">Menu</button>
    <script>
    function displayMenu(value) 
     document.getElementById("custommenu").style.display=value ;
     document.getElementById("item1").focus() ;
    
    </script>

    You will notice that there are still some things you can improve on here. For example, after you close the menu again with one of the menu items, the focus does not move back onto the menu button.

    Also, after opening the menu, you may prefer not to move the focus onto the first menu item but rather just onto the menu <div>. You can do so by giving that div a @tabindex and then calling .focus() on it. If you do not want to make the div part of the normal tabbing order, just give it a @tabindex=-1 value. This will allow your div to receive focus from script, but be exempt from accidental tabbing onto (though usually you just want to use @tabindex=0).

    Bonus : If you want to help keyboard users even more, you can also put outlines on the element that is currently in focus using CSS”s outline property. If you want to avoid the outlines for mouse users, you can dynamically add a class that removes the outline in mouseover events but leaves it for :focus.

    2.5. Provide sensible keyboard shortcuts

    At this stage your application is actually keyboard accessible. Congratulations !

    However, it’s still not very efficient : like power-users, screenreader users love keyboard shortcuts : can you imagine if you were forced to tab through an entire page, or navigate back to a menu tree at the top of the page, to reach each control you were interested in ? And, obviously, anything which makes navigating the app via the keyboard more efficient for screenreader users will benefit all power users as well, like the ubiquitous keyboard shortcuts for cut, copy and paste.

    HTML4 introduced so-called accesskeys for this. In HTML5 @accesskey is now allowed on all elements.

    The @accesskey attribute takes the value of a keyboard key (e.g. @accesskey="x") and is activated through platform- and browser-specific activation keys. For example, on the Mac it’s generally the [Ctrl] key, in IE it’ the [Alt] key, in Firefox on Windows [Shift]-[Alt], and in Opera on Windows [Shift]-[ESC]. You press the activation key and the accesskey together which either activates or focuses the element with the @accesskey attribute.

    Example :


    &lt;script&gt;<br />
    var button = document.getElementById('accessbutton');<br />
    if (button.accessKeyLabel) {<br />
     button.innerHTML += ' (' + button.accessKeyLabel + ')';<br />
    }<br />
    &lt;/script&gt;
    <button id="accessbutton" onclick="alert(’sent !’)" accesskey="e">
    Send
    </button>
    <script>
      var button = document.getElementById(’accessbutton’) ;
      if (button.accessKeyLabel) 
        button.innerHTML += ’ (’ + button.accessKeyLabel + ’)’ ;
      
    </script>

    Now, the idea behind this is clever, but the execution is pretty poor. Firstly, the different activation keys between different platforms and browsers make it really hard for people to get used to the accesskeys. Secondly, the key combinations can conflict with browser and screenreader shortcut keys, the first of which will render browser shortcuts unusable and the second will effectively remove the accesskeys.

    In the end it is up to the Web application developer whether to use the accesskey attribute or whether to implement explicit shortcut keys for the application through key event handlers on the window object. In either case, make sure to provide a help list for your shortcut keys.

    Also note that a page with a really good hierarchical heading layout and use of ARIA landmarks can help to eliminate the need for accesskeys to jump around the page, since there are typically default navigations available in screen readers to jump directly to headings, hyperlinks, and ARIA landmarks.

    3. Provide markup for AT

    Having made the application keyboard accessible also has advantages for screenreaders, since they can now reach the controls individually and activate them. So, next we will use a screenreader and close our eyes to find out where we only provide visual cues to understand the necessary interaction.

    Here are some of the issues to consider :

    • Role may need to get identified
    • States may need to be kept track of
    • Properties may need to be made explicit
    • Labels may need to be provided for elements

    This is where the W3C’s ARIA (Accessible Rich Internet Applications) standard comes in. ARIA attributes provide semantic information to screen readers and other AT that is otherwise conveyed only visually.

    Note that using ARIA does not automatically implement the standard widget behavior – you’ll still need to add focus management, keyboard navigation, and change aria attribute values in script.

    3.1. ARIA roles

    After implementing a custom interactive widget, you need to add a @role attribute to indicate what type of controls it is, e.g. that it is playing the role of a standard tag such as a button.

    Example :

    This menu button is implemented as a <div>, but with a role of “button” it is announced as a button by a screenreader.

    Menu
    <div tabindex="0" role="button">Menu</div>
    

    ARIA roles also describe composite controls that do not have a native HTML equivalent.

    Example :

    This menu with menu items is implemented as a set of <div> tags, but with a role of “menu” and “menuitem” items.

    <div role="menu">
      <div tabindex="0" role="menuitem">Cut</div>
      <div tabindex="0" role="menuitem">Copy</div>
      <div tabindex="0" role="menuitem">Paste</div>
    </div>
    

    3.2. ARIA states

    Some interactive controls represent different states, e.g. a checkbox can be checked or unchecked, or a menu can be expanded or collapsed.

    Example :

    The following menu has states on the menu items, which are here not just used to give an aural indication through the screenreader, but also a visual one through CSS.

    <style>
    .custombutton[aria-checked=true]:before 
       content :  "\2713 " ;
    
    </style>
    <div role="menu">
      <div tabindex="0" role="menuitem" aria-checked="true">Left</div>
      <div tabindex="0" role="menuitem" aria-checked="false">Center</div>
      <div tabindex="0" role="menuitem" aria-checked="false">Right</div>
    </div>
    

    3.3. ARIA properties

    Some of the functionality of interactive controls cannot be captured by the role attribute alone. We have ARIA properties to add features that the screenreader needs to announce, such as aria-label, aria-haspopup, aria-activedescendant, or aria-live.

    Example :

    The following drop-down menu uses aria-haspopup to tell the screenreader that there is a popup hidden behind the menu button together with an ARIA state of aria-expanded to track whether it’s open or closed.

    Justify
    &lt;script&gt;<br />
    var button = document.getElementById(&quot;button&quot;);<br />
    var menu = document.getElementById(&quot;menu&quot;);<br />
    var items = document.getElementsByClassName(&quot;menuitem&quot;);<br />
    var focused = 0;<br />
    function showMenu(evt) {<br />
       evt.stopPropagation();<br />
       menu.style.visibility = 'visible';<br />
       button.setAttribute('aria-expanded','true');<br />
       focused = getSelected();<br />
       items[focused].focus();<br />
     }<br />
     function hideMenu(evt) {<br />
       evt.stopPropagation();<br />
       menu.style.visibility = 'hidden';<br />
       button.setAttribute('aria-expanded','false');<br />
       button.focus();<br />
     }<br />
     function getSelected() {<br />
       for (var i=0; i &lt; items.length; i++) {<br />
         if (items[i].getAttribute('aria-checked') == 'true') {<br />
           return i;<br />
         }<br />
       }<br />
     }<br />
     function setSelected(elem) {<br />
       var curSelected = getSelected();<br />
       items[curSelected].setAttribute('aria-checked', 'false');<br />
       elem.setAttribute('aria-checked', 'true');<br />
     }<br />
     function selectItem(evt) {<br />
       setSelected(evt.target);<br />
       hideMenu(evt);<br />
     }<br />
    function getPrevItem(index) {<br />
       var prev = index - 1;<br />
       if (prev &lt; 0) {<br />
         prev = items.length - 1;<br />
       }<br />
       return prev;<br />
     }<br />
     function getNextItem(index) {<br />
       var next = index + 1;<br />
       if (next == items.length) {<br />
         next = 0;<br />
       }<br />
       return next;<br />
     }<br />
    function handleButtonKeys(evt) {<br />
       evt.stopPropagation();<br />
       var key = evt.keyCode;<br />
       switch(key) {<br />
         case (13): /* ENTER */<br />
         case (32): /* SPACE */<br />
           showMenu(evt);<br />
         default:<br />
       }<br />
     }<br />
     function handleMenuKeys(evt) {<br />
       evt.stopPropagation();<br />
       var key = evt.keyCode;<br />
       switch(key) {<br />
         case (38): /* UP */<br />
           focused = getPrevItem(focused);<br />
           items[focused].focus();<br />
           break;<br />
         case (40): /* DOWN */<br />
           focused = getNextItem(focused);<br />
           items[focused].focus();<br />
           break;<br />
         case (13): /* ENTER */<br />
         case (32): /* SPACE */<br />
           setSelected(evt.target);<br />
             hideMenu(evt);<br />
             break;<br />
         case (27): /* ESC */<br />
           hideMenu(evt);<br />
            break;<br />
         default:<br />
       }<br />
     }<br />
     button.addEventListener('click', showMenu, false);<br />
     button.addEventListener('keydown', handleButtonKeys, false);<br />
     for (var i = 0;  i &lt; items.length; i++) {<br />
       items[i].addEventListener('click', selectItem, false);<br />
       items[i].addEventListener('keydown', handleMenuKeys, false);<br />
     }<br />
    &lt;/script&gt;
    <div class="custombutton" id="button" tabindex="0" role="button"
       aria-expanded="false" aria-haspopup="true">
        <span>Justify</span>
    </div>
    <div role="menu"  class="menu" id="menu" style="display : none ;">
      <div tabindex="0" role="menuitem" class="menuitem" aria-checked="true">
        Left
      </div>
      <div tabindex="0" role="menuitem" class="menuitem" aria-checked="false">
        Center
      </div>
      <div tabindex="0" role="menuitem" class="menuitem" aria-checked="false">
        Right
      </div>
    </div>
    [CSS and JavaScript for example omitted]

    3.4. Labelling

    The main issue that people know about accessibility seems to be that they have to put alt text onto images. This is only one means to provide labels to screenreaders for page content. Labels are short informative pieces of text that provide a name to a control.

    There are actually several ways of providing labels for controls :

    • on img elements use @alt
    • on input elements use the label element
    • use @aria-labelledby if there is another element that contains the label
    • use @title if you also want a label to be used as a tooltip
    • otherwise use @aria-label

    I’ll provide examples for the first two use cases - the other use cases are simple to deduce.

    Example :

    The following two images show the rough concept for providing alt text for images : images that provide information should be transcribed, images that are just decorative should receive an empty @alt attribute.

    shocked lolcat titled 'HTML cannot do that!
    Image by Noah Sussman
    <img src="texture.jpg" alt="">
    <img src="lolcat.jpg"
    alt="shocked lolcat titled ’HTML cannot do that !">
    <img src="texture.jpg" alt="">
    

    When marking up decorative images with an empty @alt attribute, the image is actually completely removed from the accessibility tree and does not confuse the blind user. This is a desired effect, so do remember to mark up all your images with @alt attributes, even those that don’t contain anything of interest to AT.

    Example :

    In the example form above in Section 2.3, when tabbing directly on the input elements, the screen reader will only say "edit text" without announcing what meaning that text has. That’s not very useful. So let’s introduce a label element for the input elements. We’ll also add checkboxes with a label.






    <label>Doctor title :</label>
      <input type="checkbox" id="doctor"/>
    <label>Firstname :</label>
      <input type="text" id="firstname2"/>
    

    <label for="lastname2">Lastname :</label>
    <input type="text" id="lastname2"/>

    <label>Address :
    <input type="text" id="address2">
    </label>
    <label for="city2">City :
    <input type="text" id="city2">
    </label>
    <label for="remember">Remember me :</label>
    <input type="checkbox" id="remember">

    In this example we use several different approaches to show what a different it makes to use the <label> element to mark up input boxes.

    The first two fields just have a <label> element next to a <input> element. When using a screenreader you will not notice a difference between this and not using the <label> element because there is no connection between the <label> and the <input> element.

    In the third field we use the @for attribute to create that link. Now the input field isn’t just announced as "edit text", but rather as "Lastname edit text", which is much more useful. Also, the screenreader can now skip the labels and get straight on the input element.

    In the fourth and fifth field we actually encapsulate the <input> element inside the <label> element, thus avoiding the need for a @for attribute, though it doesn’t hurt to explicity add it.

    Finally we look at the checkbox. By including a referenced <label> element with the checkbox, we change the screenreaders announcement from just "checkbox not checked" to "Remember me checkbox not checked". Also notice that the click target now includes the label, making the checkbox not only more usable to screenreaders, but also for mouse users.

    4. Conclusions

    This article introduced a process that you can follow to make your Web applications accessible. As you do that, you will noticed that there are other things that you may need to do in order to give the best experience to a power user on a keyboard, a blind user using a screenreader, or a vision-impaired user using a screen magnifier. But once you’ve made a start, you will notice that it’s not all black magic and a lot can be achieved with just a little markup.

    You will find more markup in the WAI ARIA specification and many more resources at Mozilla’s ARIA portal. Now go and change the world !

    Many thanks to Alice Boxhall and Dominic Mazzoni for their proof-reading and suggested changes that really helped improve the article !

  • How to Use Analytics & Reports for Marketing, Sales & More

    28 septembre 2023, par Erin — Analytics Tips

    By now, most professionals know they should be using analytics and reports to make better business decisions. Blogs and thought leaders talk about it all the time. But most sources don’t tell you how to use analytics and reports. So marketers, salespeople and others either skim whatever reports they come across or give up on making data-driven decisions entirely. 

    But it doesn’t have to be this way.

    In this article, we’ll cover what analytics and reports are, how they differ and give you examples of each. Then, we’ll explain how clean data comes into play and how marketing, sales, and user experience teams can use reports and analytics to uncover actionable insights.

    What’s the difference between analytics & reports ? 

    Many people speak of reports and analytics as if the terms are interchangeable, but they have two distinct meanings.

    A report is a collection of data presented in one place. By tracking key metrics and providing numbers, reports tell you what is happening in your business. Analytics is the study of data and the process of generating insights from data. Both rely on data and are essential for understanding and improving your business results.

    https://docs.google.com/document/d/1teSgciAq0vi2oXtq_I2_n6Cv89kPi0gBF1l0zve1L2Q/edit

    A science experiment is a helpful analogy for how reporting and analytics work together. To conduct an experiment, scientists collect data and results and compile a report of what happened. But the process doesn’t stop there. After generating a data report, scientists analyse the data and try to understand the why behind the results.

    In a business context, you collect and organise data in reports. With analytics, you then use those reports and their data to draw conclusions about what works and what doesn’t.

    Reports examples 

    Reports are a valuable tool for just about any part of your business, from sales to finance to human resources. For example, your finance team might collect data about spending and use it to create a report. It might show how much you spend on employee compensation, real estate, raw materials and shipping.

    On the other hand, your marketing team might benefit from a report on lead sources. This would mean collecting data on where your sales leads come from (social media, email, organic search, etc.). You could collect and present lead source data over time for a more in-depth report. This shows which sources are becoming more effective over time. With advanced tools, you can create detailed, custom reports that include multiple factors, such as time, geographical location and device type.

    Analytics examples 

    Because analytics requires looking at and drawing insights from data and reports to collect and present data, analytics often begins by studying reports. 

    In our example of a report on lead sources, an analytics professional might study the report and notice that webinars are an important source of leads. To better understand this, they might look closely at the number of leads acquired compared to how often webinars occur. If they notice that the number of webinar leads has been growing, they might conclude that the business should invest in more webinars to generate more leads. This is just one kind of insight analytics can provide.

    For another example, your human resources team might study a report on employee retention. After analysing the data, they could discover valuable insights, such as which teams have the highest turnover rate. Further analysis might help them uncover why certain teams fail to keep employees and what they can do to solve the problem.

    The importance of clean data 

    Both analytics and reporting rely on data, so it’s essential your data is clean. Clean data means you’ve audited your data, removed inaccuracies and duplicate entries, and corrected mislabelled data or errors. Basically, you want to ensure that each piece of information you’re using for reports and analytics is accurate and organised correctly.

    If your data isn’t clean and accurate, neither will your reports be. And making business decisions based on bad data can come at a considerable cost. Inaccurate data might lead you to invest in a channel that appears more valuable than it actually is. Or it could cause you to overlook opportunities for growth. Moreover, poor data maintenance and the poor insight it provides will lead your team to have less trust in your reports and analytics team.

    The simplest way to maintain clean data is to be meticulous when inputting or transferring data. This can be as simple as ensuring that your sales team fills in every field of an account record. When you need to import or transfer data from other sources, you need to perform quality assurance (QA) checks to make sure data is appropriately labelled and organised. 

    Another way to maintain clean data is by avoiding cookies. Most web visitors reject cookie consent banners. When this happens, analysts and marketers don’t get data on these visitors and only see the percentage of users who accept tracking. This means they decide on a smaller sample size, leading to poor or inaccurate data. These banners also create a poor user experience and annoy web visitors.

    Matomo can be configured to run cookieless — which, in most countries, means you don’t need to have an annoying cookie consent screen on your site. This way, you can get more accurate data and create a better user experience.

    Marketing analytics and reports 

    Analytics and reporting help you measure and improve the effectiveness of your marketing efforts. They help you learn what’s working and what you should invest more time and money into. And bolstering the effectiveness of your marketing will create more opportunities for sales.

    One common area where marketing teams use analytics and reports is to understand and improve their keyword rankings and search engine optimization. They use web analytics platforms like Matomo to report on how their website performs for specific keywords. Insights from these reports are then used to inform changes to the website and the development of new content.

    As we mentioned above, marketing teams often use reports on lead sources to understand how their prospects and customers are learning about the brand. They might analyse their lead sources to better understand their audience. 

    For example, if your company finds that you receive a lot of leads from LinkedIn, you might decide to study the content you post there and how it differs from other platforms. You could apply a similar content approach to other channels to see if it increases lead generation. You can then study reporting on how lead source data changes after you change content strategies. This is one example of how analysing a report can lead to marketing experimentation. 

    Email and paid advertising are also marketing channels that can be optimised with reports and analysis. By studying the data around what emails and ads your audience clicks on, you can draw insights into what topics and messaging resonate with your customers.

    Marketing teams often use A/B testing to learn about audience preferences. In an A/B test, you can test two landing page versions, such as two different types of call-to-action (CTA) buttons. Matomo will generate a report showing how many people clicked each version. From those results, you may draw an insight into the design your audience prefers.

    Sales analytics and reports 

    Sales analytics and reports are used to help teams close more deals and sell more efficiently. They also help businesses understand their revenue, set goals, and optimise sales processes. And understanding your sales and revenue allows you to plan for the future.

    One of the keys to building a successful sales strategy and team is understanding your sales cycle. That’s why it’s so important for companies to analyse their lead and sales data. For business-to-business (B2B) companies in particular, the sales cycle can be a long process. But you can use reporting and analytics to learn about the stages of the buying cycle, including how long they take and how many leads proceed to the next step.

    Analysing lead and customer data also allows you to gain insights into who your customers are. With detailed account records, you can track where your customers are, what industries they come from, what their role is and how much they spend. While you can use reports to gather customer data, you also have to use analysis and qualitative information in order to build buyer personas. 

    Many sales teams use past individual and business performance to understand revenue trends. For instance, you might study historical data reports to learn how seasonality affects your revenue. If you dive deeper, you might find that seasonal trends may depend on the country where your customers live. 

    Sales rep, money and clock

    Conversely, it’s also important to analyse what internal variables are affecting revenue. You can use revenue reports to identify your top-performing sales associates. You can then try to expand and replicate that success. While sales is a field often driven by personal relationships and conversations, many types of reports allow you to learn about and improve the process.

    Website and user behaviour analytics and reports 

    More and more, businesses view their websites as an experience and user behaviour as an important part of their business. And just like sales and marketing, reporting and analytics help you better understand and optimise your web experience. 

    Many web and user behaviour metrics, like traffic source, have important implications for marketing. For example, page traffic and user flows can provide valuable insights into what your customers are interested in. This can then drive future content development and marketing campaigns.

    You can also learn about how your users navigate and use your website. A robust web analytics tool, like Matomo, can supply user session recordings and visitor tracking. For example, you could study which pages a particular user visits. But Matomo also has a feature called Transitions that provides visual reports showing where a particular page’s traffic comes from and where visitors tend to go afterward. 

    As you consider why people might be leaving your website, site performance is another important area for reporting. Most users are accustomed to near-instantaneous web experiences, so it’s worth monitoring your page load time and looking out for backend delays. In today’s world, your website experience is part of what you’re selling to customers. Don’t miss out on opportunities to impress and delight them.

    Dive into your data

    Reporting and analytics can seem like mysterious buzzwords we’re all supposed to understand already. But, like anything else, they require definitions and meaningful examples. When you dig into the topic, though, the applications for reporting and analytics are endless.

    Use these examples to identify how you can use analytics and reports in your role and department to achieve better results, whether that means higher quality leads, bigger deal size or a better user experience.

    To see how Matomo can collect accurate and reliable data and turn it into in-depth analytics and reports, start a free 21-day trial. No credit card required.

  • Introducing Crash Analytics for Matomo

    30 août 2023, par Erin — Community, Plugins

    Bugs and development go hand in hand. As code matures, it contends with new browser iterations, clashes with ad blockers and other software quirks, resulting in the inevitable emergence of bugs. In fact, a staggering 13% of all pageviews come with lurking JavaScript errors.

    Monitoring for crashes becomes an unrelenting task. Amidst this never-ending effort to remove bugs, a SurveyMonkey study unveils a shared reality : a resounding 66% of individuals have encountered bug-ridden websites.

    These bugs lead to problems like malfunctioning shopping carts, glitchy checkout procedures and contact forms that just won’t cooperate. But they’re not just minor annoyances – they pose a real danger to your conversion rates and revenue.

    According to a study, 58% of visitors are inclined to abandon purchases as a result of bugs, while an astonishing 75% are driven to completely abandon websites due to these frustrating experiences.

    Imagine a website earning approximately 25,000 EUR per month. Now, factor in errors occurring in 13% of all pageviews. The result ? A potential monthly loss of 1,885 EUR.

    Meet Crash Analytics

    Driven by our vision to create an empowering analytics product, we’re excited to introduce Crash Analytics, an innovative plugin for Matomo On-Premise that automatically tracks bugs on your website.

    Crash Analytics for Matomo Evolution Graph
    View crash reports by evolution over time

    By offering insights into the precise bug location and the user’s interactions that triggered it, along with details about their device type, browser and more, Crash Analytics empowers you to swiftly address crashes, leading to an improved user experience, higher conversion rates and revenue growth.

    Soon, Crash Analytics will become available to Matomo Cloud users as well, so stay tuned for further updates and announcements.

    Say goodbye to lost revenue – never miss a bug again

    Even if you put your website through the toughest tests, it’s hard to predict every little hiccup that can pop up across different browsers, setups and situations. Factors such as ad blockers, varying internet speeds for visitors and browser updates can add an extra layer of complexity.

    When these crashes happen, you want to know immediately. However, according to a study, only 29% of surveyed respondents would report the existence of the site bug to the website operator. These bugs that go unnoticed can really hurt your bottom line and conversion rates, causing you to lose out on revenue and leaving your users frustrated and disappointed.

    Crash detail report in Crash Analytics for Matomo
    Detailed crash report

    Crash Analytics is here to bridge this gap. Armed with scheduled reporting (via email or texts) and automated alert functionalities, you gain the power to instantly detect bugs as they occur on your site. This proactive approach ensures that even the subtlest of issues are brought to your attention promptly. 

    With automated reports and alerts, you can also opt to receive notifications when crashes increase or ignore specific crashes that you deem insignificant. This keeps you in the loop with only the issues that truly matter, helping you cut out the noise and take immediate action.

    Forward crash data

    Easily forward crash data to developers and synchronise the efforts of technical teams and marketing experts. Track emerging, disappearing and recurring errors, ensuring that crash data is efficiently relayed to developers to prioritise fixes that matter.

    Eemerging, disappearing and recurring crashes in Crash Analytics for Matomo
    Track emerging, disappearing and recurring bugs

    Plus, your finger is always on the pulse with real-time reports that offer a live view of crashes happening at the moment, an especially helpful feature after deploying changes. Use annotations to mark deploys and correlate them with crash data, enabling you to quickly identify if a new bug is linked to recent updates or modifications.

    Crash data in real time
    Crash data in real time

    And with our mobile app, you can effortlessly stay connected to your website’s performance, conveniently accessing crash information anytime and anywhere. This ensures you’re in complete control of your site’s health, even when you’re on the move.

    Streamline bug resolution with combined web and crash analytics

    Crash Analytics for Matomo doesn’t just stop at pinpointing bug locations ; it goes a step further by providing you with a holistic perspective of user interactions. Seamlessly combining Matomo’s traditional and behavioural web analytics features—like segments, session recordings and visitor logs—with crash data, this integrated approach unveils a wealth of insights so you can quickly resolve bugs. 

    For instance, let’s say a user encounters a bug while attempting to complete a purchase on your e-commerce website. Crash Analytics reveals the exact point of failure, but to truly grasp the situation, you delve into the session recordings. These recordings offer a front-row seat to the user’s journey—every click and interaction that led to the bug. Session recordings are especially helpful when you are struggling to reproduce an issue.

    Visits log combined with crash data in Matomo
    Visits log overlayed with crash data

    Additionally, the combination of visitor logs with crash data offers a comprehensive timeline of a user’s engagement. This helps you understand their activity leading up to the bug, such as pages visited, actions taken and devices used. Armed with these multifaceted insights, you can confidently pinpoint the root causes and address the crash immediately.

    With segments, you have the ability to dissect the data and compare experiences among distinct user groups. For example, you can compare mobile visitors to desktop visitors to determine if the issue is isolated or widespread and what impact the issue is having on the user experience of different user groups. 

    The combination of crash data with Matomo’s comprehensive web analytics equips you with the tools needed to elevate user experiences and ultimately drive revenue growth.

    Start in seconds, shape as needed : Your path to a 100% reliable website

    Crash Analytics makes the path to a reliable website simple. You don’t have to deal with intricate setups—crash detection starts without any configuration. 

    Plus, Crash Analytics excels in cross-stack proficiency, seamlessly extending its capabilities beyond automatically tracking JavaScript errors to covering server-side crashes as well, whether they occur in PHP, Android, iOS, Java or other frameworks. This versatile approach ensures that Crash Analytics comprehensively supports your website’s health and performance across various technological landscapes.

    Elevate your website with Crash Analytics

    Experience the seamless convergence of bug tracking and web analytics, allowing you to delve into user interactions, session recordings and visitor logs. With the flexibility of customising real-time alerts and scheduled reports, alongside cross-stack proficiency, Crash Analytics becomes your trusted ally in enhancing your website’s reliability and user satisfaction to increase conversions and drive revenue growth. Equip yourself to swiftly address issues and create a website where user experiences take precedence.

    Start your 30-day free trial of our Crash Analytics plugin today, and stay tuned for its availability on Matomo Cloud.