Quantcast
Channel: HTML5EdTech via Ted Curran on Inoreader
Viewing all 22746 articles
Browse latest View live

Apps Have Command Prompts Now

0
0
https://css-tricks.com/apps-command-prompts-now/
DesignNewz?d=yIl2AUoC8zA DesignNewz?d=dnMXMwOfBR0 DesignNewz?i=M6n8u6UTcZ0:-t3Xesum8ZA:F7z DesignNewz?d=7Q72WNTAKBA DesignNewz?i=M6n8u6UTcZ0:-t3Xesum8ZA:V_s DesignNewz?d=TzevzKxY174 DesignNewz?i=M6n8u6UTcZ0:-t3Xesum8ZA:gIN DesignNewz?d=l6gmwiTKsz0 DesignNewz?i=M6n8u6UTcZ0:-t3Xesum8ZA:KwT DesignNewz?d=qj6IDK7rITs

Animating Layouts with the FLIP Technique

0
0

User interfaces are most effective when they are intuitive and easily understandable to the user. Animation plays a major role in this - as Nick Babich said, animation brings user interfaces to life. However, adding meaningful transitions and micro-interactions is often an afterthought, or something that is “nice to have” if time permits. All too often, we experience web apps that simply “jump” from view to view without giving the user time to process what just happened in the current context.

This leads to unintuitive user experiences, but we can do better, by avoiding “jump cuts” and “teleportation” in creating UIs. After all, what’s more natural than real life, where nothing teleports (except maybe car keys), and everything you interact with moves with natural motion?

In this article, we’ll explore a technique called “FLIP” that can be used to animate the positions and dimensions of any DOM element in a performant manner, regardless of how their layout is calculated or rendered (e.g., height, width, floats, absolute positioning, transform, flexbox, grid, etc.)

Why the FLIP technique?

Have you ever tried to animate height, width, top, left, or any other properties besides transform and opacity? You might have noticed that the animations look a bit janky, and there's a reason for that. When any property that triggers layout changes (such as `height`), the browser has to recursively check if any other element's layout has changed as a result, and that can be expensive. If that calculation takes longer than one animation frame (around 16.7 milliseconds), then the animation frame will be skipped, resulting in "jank"
since that frame wasn't rendered in time. In Paul Lewis' article "Pixels are Expensive", he goes further in depth at how pixels are rendered and the various performance expenses.

In short, our goal is to be short -- we want to calculate the least amount of style changes necessary, as quickly as possible. The key to this is only animating transform and opacity, and FLIP explains how we can simulate layout changes using only transform.

What is FLIP?

FLIP is a mnemonic device and technique first coined by Paul Lewis, which stands for First, Last, Invert, Play. His article contains an excellent explanation of the technique, but I’ll outline it here:

  • First: before anything happens, record the current (i.e., first) position and dimensions of the element that will transition. You can use getBoundingClientRect() for this, as will be shown below.
  • Last: execute the code that causes the transition to instantaneously happen, and record the final (i.e., last) position and dimensions of the element.*
  • Invert: since the element is in the last position, we want to create the illusion that it’s in the first position, by using transform to modify its position and dimensions. This takes a little math, but it’s not too difficult.
  • Play: with the element inverted (and pretending to be in the first position), we can move it back to its last position by setting its transform to none.

Below is how these steps can be implemented:

const elm = document.querySelector('.some-element'); 
 
// First: get the current bounds 
const first = getBoundingClientRect(elm); 
 
// execute the script that causes layout change 
doSomething(); 
 
// Last: get the final bounds 
const last = getBoundingClientRect(elm); 
 
// Invert: determine the delta between the  
// first and last bounds to invert the element 
const deltaX = first.left - last.left; 
const deltaY = first.top - last.top; 
const deltaW = first.width / last.width; 
const deltaH = first.height / last.height; 
 
// Play: animate the final element from its first bounds 
// to its last bounds (which is no transform) 
elm.animate([{ 
  transformOrigin: 'top left', 
  transform: ` 
    translate(${deltaX}px, ${deltaY}px) 
    scale(${deltaW}, ${deltaH}) 
  ` 
}, { 
  transformOrigin: 'top left', 
  transform: 'none' 
}], { 
  duration: 300, 
  easing: 'ease-in-out', 
  fill: 'both' 
});

See the Pen How the FLIP technique works by David Khourshid (@davidkpiano) on CodePen.

There are two important things to note:

  1. If the element’s size changed, you can transform scale in order to “resize” it with no performance penalty; however, make sure to set transformOrigin to 'top left' since that’s where we based our delta calculations.
  2. We’re using the Web Animations API to animate the element here, but you’re free to use any other animation engine, such as GSAP, Anime, Velocity, Just-Animate, Mo.js and more.

Shared Element Transitions

One common use-case for transitioning an element between app views and states is that the final element might not be the same DOM element as the initial element. In Android, this is similar to a shared element transition, except that the element isn’t “recycled” from view to view in the DOM as it is on Android.

Nevertheless, we can still achieve the FLIP transition with a little magic illusion:

const firstElm = document.querySelector('.first-element'); 
 
// First: get the bounds and then hide the element (if necessary) 
const first = getBoundingClientRect(firstElm); 
firstElm.style.setProperty('visibility', 'hidden'); 
 
// execute the script that causes view change 
doSomething(); 
 
// Last: get the bounds of the element that just appeared 
const lastElm = document.querySelector('.last-element'); 
const last = getBoundingClientRect(lastElm); 
 
// continue with the other steps, just as before. 
// remember: you're animating the lastElm, not the firstElm.

Below is an example of how two completely disparate elements can appear to be the same element using shared element transitions. Click one of the pictures to see the effect.

See the Pen FLIP example with WAAPI by David Khourshid (@davidkpiano) on CodePen.

Parent-Child Transitions

With the previous implementations, the element bounds are based on the window. For most use cases, this is fine, but consider this scenario:

  • An element changes position and needs to transition.
  • That element contains a child element, which itself needs to transition to a different position inside the parent.

Since the previously calculated bounds are relative to the window, our calculations for the child element are going to be off. To solve this, we need to ensure that the bounds are calculated relative to the parent element instead:

const parentElm = document.querySelector('.parent'); 
const childElm = document.querySelector('.parent > .child'); 
 
// First: parent and child 
const parentFirst = getBoundingClientRect(parentElm); 
const childFirst = getBoundingClientRect(childElm); 
 
doSomething(); 
 
// Last: parent and child 
const parentLast = getBoundingClientRect(parentElm); 
const childLast = getBoundingClientRect(childElm); 
 
// Invert: parent 
const parentDeltaX = parentFirst.left - parentLast.left; 
const parentDeltaY = parentFirst.top - parentLast.top; 
 
// Invert: child relative to parent 
const childDeltaX = (childFirst.left - parentFirst.left) 
  - (childLast.left - parentLast.left); 
const childDeltaY = (childFirst.top - parentFirst.top) 
  - (childLast.top - parentLast.top); 
   
// Play: using the WAAPI 
parentElm.animate([ 
  { transform: `translate(${parentDeltaX}px, ${parentDeltaY}px)` }, 
  { transform: 'none' } 
], { duration: 300, easing: 'ease-in-out' }); 
 
childElm.animate([ 
  { transform: `translate(${childDeltaX}px, ${childDeltaY}px)` }, 
  { transform: 'none' } 
], { duration: 300, easing: 'ease-in-out' });

A few things to note here, as well:

  1. The timing options for the parent and child (duration, easing, etc.) do not necessarily need to match with this technique. Feel free to be creative!
  2. Changing dimensions in parent and/or child (width, height) was purposefully omitted in this example, since it is an advanced and complex topic. Let’s save that for another tutorial.
  3. You can combine the shared element and parent-child techniques for greater flexibility.

Using Flipping.js for Full Flexibility

The above techniques might seem straightforward, but they can get quite tedious to code once you have to keep track of multiple elements transitioning. Android eases this burden by:

  • baking shared element transitions into the core SDK
  • allowing developers to identify which elements are shared by using a common android:transitionName XML attribute

I’ve created a small library called Flipping.js with the same idea in mind. By adding a data-flip-key="..." attribute to HTML elements, it’s possible to predictably and efficiently keep track of elements that might change position and dimensions from state to state.

For example, consider this initial view:

    <section class="gallery"> 
      <div class="photo-1" data-flip-key="photo-1"> 
        <img src="/photo-1"/> 
      </div> 
      <div class="photo-2" data-flip-key="photo-2"> 
        <img src="/photo-2"/> 
      </div> 
      <div class="photo-3" data-flip-key="photo-3"> 
        <img src="/photo-3"/> 
      </div> 
    </section>

And this separate detail view:

    <section class="details"> 
      <div class="photo" data-flip-key="photo-1"> 
        <img src="/photo-1"/> 
      </div> 
      <p class="description"> 
        Lorem ipsum dolor sit amet... 
      </p> 
    </section>

Notice in the above example that there are 2 elements with the same data-flip-key="photo-1". Flipping.js tracks the “active” element by choosing the first element that meet these criteria:

  • The element exists in the DOM (i.e., it hasn’t been removed or detached)
  • The element is not hidden (hint: getBoundingClientRect(elm) will have { width: 0, height: 0 } for hidden elements)
  • Any custom logic specified in the selectActive option.

Getting Started with Flipping.js

There’s a few different packages for Flipping, depending on your needs:

  • flipping.js: tiny and low-level; only emits events when element bounds change
  • flipping.web.js: uses WAAPI to animate transitions
  • flipping.gsap.js: uses GSAP to animate transitions
  • More adapters coming soon!

You can grab the minified code directly from unpkg:

Or you can npm install flipping --save and import it into your projects:

// import not necessary when including the unpkg scripts in a <script src="..."> tag 
import Flipping from 'flipping/adapters/web'; 
 
const flipping = new Flipping(); 
 
// First: let Flipping read all initial bounds 
flipping.read(); 
 
// execute the change that causes any elements to change bounds 
doSomething(); 
 
// Last, Invert, Play: the flip() method does it all 
flipping.flip();

Handling FLIP transitions as a result of a function call is such a common pattern, that the .wrap(fn) method transparently wraps (or “decorates”) the given function by first calling .read(), then getting the return value of the function, then calling .flip(), then returning the return value. This leads to much less code:

const flipping = new Flipping(); 
 
const flippingDoSomething = flipping.wrap(doSomething); 
 
// anytime this is called, FLIP will animate changed elements 
flippingDoSomething();

Here is an example of using flipping.wrap() to easily achieve the shifting letters effect. Click anywhere to see the effect.

See the Pen Flipping Birthstones #Codevember by David Khourshid (@davidkpiano) on CodePen.

Adding Flipping.js to Existing Projects

In another article, we created a simple React gallery app using finite state machines. It works just as expected, but the UI could use some smooth transitions between states to prevent “jumping” and improve the user experience. Let’s add Flipping.js into our React app to accomplish this. (Keep in mind, Flipping.js is framework-agnostic.)

Step 1: Initialize Flipping.js

The Flipping instance will live on the React component itself, so that it’s isolated to only changes that occur within that component. Initialize Flipping.js by setting it up in the componentDidMount lifecycle hook:

  componentDidMount() { 
    const { node } = this; 
    if (!node) return; 
     
    this.flipping = new Flipping({ 
      parentElement: node 
    }); 
     
    // initialize flipping with the initial bounds 
    this.flipping.read(); 
  }

By specifying parentElement: node, we’re telling Flipping to only look for elements with a data-flip-key in the rendered App, instead of the entire document.

Then, modify the HTML elements with the data-flip-key attribute (similar to React’s key prop) to identify unique and “shared” elements:

  renderGallery(state) { 
    return ( 
      <section className="ui-items" data-state={state}> 
        {this.state.items.map((item, i) => 
          <img 
            src={item.media.m} 
            className="ui-item" 
            style={{'--i': i}} 
            key={item.link} 
            onClick={() => this.transition({ 
              type: 'SELECT_PHOTO', item 
            })} 
            data-flip-key={item.link} 
          /> 
        )} 
      </section> 
    ); 
  } 
  renderPhoto(state) { 
    if (state !== 'photo') return; 
     
    return ( 
      <section 
        className="ui-photo-detail" 
        onClick={() => this.transition({ type: 'EXIT_PHOTO' })}> 
        <img 
          src={this.state.photo.media.m} 
          className="ui-photo" 
          data-flip-key={this.state.photo.link} 
        /> 
      </section> 
    ) 
  }

Notice how the img.ui-item and img.ui-photo are represented by data-flip-key={item.link} and data-flip-key={this.state.photo.link} respectively: when the user clicks on an img.ui-item, that item is set to this.state.photo, so the .link values will be equal.

And since they are equal, Flipping will smoothly transition from the img.ui-item thumbnail to the larger img.ui-photo.

Now we need to do two more things:

  1. call this.flipping.read() whenever the component will update
  2. call this.flipping.flip() whenever the component did update

Some of you might have already guessed where these method calls are going to occur: componentWillUpdate and componentDidUpdate, respectively:

  componentWillUpdate() { 
    this.flipping.read(); 
  } 
   
  componentDidUpdate() { 
    this.flipping.flip(); 
  }

And, just like that, if you’re using a Flipping adapter (such as flipping.web.js or flipping.gsap.js), Flipping will keep track of all elements with a [data-flip-key] and smoothly transition them to their new bounds whenever they change. Here is the final result:

See the Pen FLIPping Gallery App by David Khourshid (@davidkpiano) on CodePen.

If you would rather implement custom animations yourself, you can use flipping.js as a simple event emitter. Read the documentation for more advanced use-cases.

Flipping.js and its adapters handle the shared element and parent-child transitions by default, as well as:

  • interrupted transitions (in adapters)
  • enter/move/leave states
  • plugin support for plugins such as mirror, which allows newly entered elements to “mirror” another element’s movement
  • and more planned in the future!

Resources

Similar libraries include:

  • FlipJS by Paul Lewis himself, which handles simple single-element FLIP transitions
  • React-Flip-Move, a useful React library by Josh Comeau
  • BarbaJS, not necessarily a FLIP library, but one that allows you to add smooth transitions between different URLs, without page jumps.

Further resources:


Animating Layouts with the FLIP Technique is a post from CSS-Tricks

3 Best Form Design Practices for your design process

0
0
https://uxplanet.org/3-best-form-design-practices-for-your-design-process-383510b31613
DesignNewz?d=yIl2AUoC8zA DesignNewz?d=dnMXMwOfBR0 DesignNewz?i=EAWwTX2_41E:A0abIs87-hQ:F7z DesignNewz?d=7Q72WNTAKBA DesignNewz?i=EAWwTX2_41E:A0abIs87-hQ:V_s DesignNewz?d=TzevzKxY174 DesignNewz?i=EAWwTX2_41E:A0abIs87-hQ:gIN DesignNewz?d=l6gmwiTKsz0 DesignNewz?i=EAWwTX2_41E:A0abIs87-hQ:KwT DesignNewz?d=qj6IDK7rITs

Designers, It's Time To Move Slowly And Fix Things

0
0
https://www.fastcodesign.com/90152218/designers-its-time-to-move-slowly-and-fix-things
DesignNewz?d=yIl2AUoC8zA DesignNewz?d=dnMXMwOfBR0 DesignNewz?i=AHVXhzqNXyY:9DGgOKhW2oo:F7z DesignNewz?d=7Q72WNTAKBA DesignNewz?i=AHVXhzqNXyY:9DGgOKhW2oo:V_s DesignNewz?d=TzevzKxY174 DesignNewz?i=AHVXhzqNXyY:9DGgOKhW2oo:gIN DesignNewz?d=l6gmwiTKsz0 DesignNewz?i=AHVXhzqNXyY:9DGgOKhW2oo:KwT DesignNewz?d=qj6IDK7rITs

When your company grows fast, it’s time for you to grow too

0
0
https://blog.intercom.com/when-company-grows-you-grow-too/
DesignNewz?d=yIl2AUoC8zA DesignNewz?d=dnMXMwOfBR0 DesignNewz?i=qAlztzHEAC4:2G7PCajEO5A:F7z DesignNewz?d=7Q72WNTAKBA DesignNewz?i=qAlztzHEAC4:2G7PCajEO5A:V_s DesignNewz?d=TzevzKxY174 DesignNewz?i=qAlztzHEAC4:2G7PCajEO5A:gIN DesignNewz?d=l6gmwiTKsz0 DesignNewz?i=qAlztzHEAC4:2G7PCajEO5A:KwT DesignNewz?d=qj6IDK7rITs

Google warns webmasters not to use misleading event markup

0
0
https://searchengineland.com/google-warns-webmasters-not-use-misleading-event-markup-287299
DesignNewz?d=yIl2AUoC8zA DesignNewz?d=dnMXMwOfBR0 DesignNewz?i=vLxhSrqUr14:080P0MNdrkU:F7z DesignNewz?d=7Q72WNTAKBA DesignNewz?i=vLxhSrqUr14:080P0MNdrkU:V_s DesignNewz?d=TzevzKxY174 DesignNewz?i=vLxhSrqUr14:080P0MNdrkU:gIN DesignNewz?d=l6gmwiTKsz0 DesignNewz?i=vLxhSrqUr14:080P0MNdrkU:KwT DesignNewz?d=qj6IDK7rITs

An ORM-like Interface and a Router For Your API Requests

Machine Learning and AI trends for 2018: What to Expect?


Best OnePlus 5T Tips and Tricks Everybody Should Know

The Great Mystery of the Tilde(~) | Joe Zim's JavaScript Corner

Tumblr CEO David Karp is stepping down from the company

0
0
https://www.theverge.com/2017/11/27/16705748/tumblr-ceo-david-karp-founder-resignation-verizon-yahoo-oath
DesignNewz?d=yIl2AUoC8zA DesignNewz?d=dnMXMwOfBR0 DesignNewz?i=WkFSNRmMQwA:wc0OkCfyLjU:F7z DesignNewz?d=7Q72WNTAKBA DesignNewz?i=WkFSNRmMQwA:wc0OkCfyLjU:V_s DesignNewz?d=TzevzKxY174 DesignNewz?i=WkFSNRmMQwA:wc0OkCfyLjU:gIN DesignNewz?d=l6gmwiTKsz0 DesignNewz?i=WkFSNRmMQwA:wc0OkCfyLjU:KwT DesignNewz?d=qj6IDK7rITs

Issue #291

0
0

Faux Grid Tracks

Faux Grid Tracks

Eric Meyer explores different methods for replicating a tic-tac-toe board using CSS Grid.


Generating Wireframe Boxes with CSS and HTML5

Generating Wireframe Boxes with CSS and HTML5

Eric Meyer shares a method to create labeled wireframe-style boxes on top of existing page elements using a potpourri of CSS and tiny bits of HTML5.


From Our Sponsor

Honeypot: Europe's Largest Developer Job Platform!

Honeypot: Europe's Largest Developer Job Platform!

Honeypot has revolutionized the way developers get a New Job. No applications, just create one profile. Companies apply directly to you!


Articles & Tutorials

HTML Email and Accessibility

Jason Rodriguez demonstrates a few simple practices that will make your emails more accessible and your subscribers even happier.


Interface

Bryn Jackson lays out a case for an intermediary format between design and engineering tools to enable more efficient, capable tooling for product teams and designers.


A Content Slider

Heydon Pickering demonstrates how to create a responsive, lightweight, robust, and interoperable content slider.


Optimizing CSS: Tweaking Animation Performance with DevTools

Maria Antonietta Perna explores the Performance Tool available in the Firefox to find out more about CSS animation performance.


Chrome DevTools Performance Monitor

Serg Hospodarets explains how Chrome DevTools Performance monitor allows you to easily measure your app performance in real-time.


Promoted Link

Does your code kick ass?

Does your code kick ass?

You deserve a kickass online brand for your tech projects! In 6 different ways you can make a lasting impression with just 1 domain name.


Tools

Sass-Extract

Sass-Extract is a tool that compiles Sass files into a JSON object containing its variables and their computed values. This can be useful when you need to know details about the styles in your JavaScript.


Sass-Is-Int

A lightweight Sass function that determines whether a number is an integer or not.


Inspiration

CSS-Only Todo List Checkbox Animation

CSS-Only Todo List Checkbox Animation

Stephen Shaw created a beautiful concept for a todo app using CSS.


Until Next Week

Thanks for reading and thanks for your support, *|FNAME|*.

Happy coding,
Zoran Jambor

Until Next Week

Thanks for reading! If you find the content valuable, please consider supporting the newsletter on Patreon.

Happy coding,
Zoran Jambor

Flow type checking tips

Apple MacOS High Sierra Security Flaw Lets Anyone Get Root Access, No Password Required

0
0

MacOS-SecurityFlaw-AP_17157282506595.jpg

A Turkish company found a glaring flaw in Apple's desktop operating system that gives anyone deep access, no password required.

Meetup.com Redesign

0
0
https://www.meetup.com/redesign/
DesignNewz?d=yIl2AUoC8zA DesignNewz?d=dnMXMwOfBR0 DesignNewz?i=LuZOtZARko4:nkx9pYdwszg:F7z DesignNewz?d=7Q72WNTAKBA DesignNewz?i=LuZOtZARko4:nkx9pYdwszg:V_s DesignNewz?d=TzevzKxY174 DesignNewz?i=LuZOtZARko4:nkx9pYdwszg:gIN DesignNewz?d=l6gmwiTKsz0 DesignNewz?i=LuZOtZARko4:nkx9pYdwszg:KwT DesignNewz?d=qj6IDK7rITs

V6: Typography and Proportions

0
0

Here’s a good ol’ fashion blog post by Rob Weychert where he looks into the new design system that he implemented on his personal website and specifically the typographic system that ties everything together:

According to the OED, a scale is “a graduated range of values forming a standard system for measuring or grading something.” A piece of music using a particular scale—a limited selection of notes with a shared mathematic relationship—can effect a certain emotional tenor. Want to write a sad song? Use a minor scale. Changed your mind? Switch to a major scale and suddenly that same song is in a much better mood.

Spatial relationships can likewise achieve a certain visual harmony using similar principles, and the constraints a scale provides take a lot of the arbitrary guesswork out of the process of arranging elements in space. Most of what I design that incorporates type has a typographic scale as its foundation, which informs the typeface choices and layout proportions. The process of creating that scale begins by asking what the type needs to do, and what role contrasting sizes will play in that.

Direct Link to ArticlePermalink


V6: Typography and Proportions is a post from CSS-Tricks

The death of net neutrality could be the end of Bitcoin

0
0
https://thenextweb.com/insider/2017/11/28/the-death-of-net-neutrality-could-be-the-end-of-bitcoin/
DesignNewz?d=yIl2AUoC8zA DesignNewz?d=dnMXMwOfBR0 DesignNewz?i=exyVCqBkKto:HCk_cvNcroE:F7z DesignNewz?d=7Q72WNTAKBA DesignNewz?i=exyVCqBkKto:HCk_cvNcroE:V_s DesignNewz?d=TzevzKxY174 DesignNewz?i=exyVCqBkKto:HCk_cvNcroE:gIN DesignNewz?d=l6gmwiTKsz0 DesignNewz?i=exyVCqBkKto:HCk_cvNcroE:KwT DesignNewz?d=qj6IDK7rITs

New Site-wide WAVE Tools

0
0

WAVE Web Accessibility Evaluation Tool logoWe’re happy to announce the release of several new options for using WAVE to evaluate pages across web sites. While the power of WAVE is in facilitating in-depth manual analysis of a web page, these new tools allow you to easily collect data for any number of web pages on your sites.

WAVE Stand-alone API

While we have offered a subscription WAVE API for some time, this API has been updated and is now available for licensing as a stand-alone, installable WAVE API engine package. This stand-alone API brings the power of WAVE inside your enterprise to allow fast, easy, and highly customizable checking of pages via your own servers.

Learn more about the WAVE Stand-alone API

DinoLytics Accessibility – Powered by WAVE

DinoLytics logoWebAIM has partnered with Pope Tech to develop an enterprise level accessibility reporting system based on WAVE. The DinoLytics subscription-based service will provide powerful, economical tools, such as site spidering/crawling, platform organization and administration, custom dashboards, and more to give you the powerful data needed to put you in control of your accessibility efforts.

Pope Tech is looking for initial partners to help drive the development and features of DinoLytics.

Learn more about DinoLytics Accessibility

WAVE Runner

WAVE Runner allows you to very easily and inexpensively collect WAVE data about the accessibility of your web site. WAVE Runner delivers:

  1. A color-coded, sortable spreadsheet of all WAVE data for any number of site pages.
  2. A 2-3 page analysis report of the WAVE data authored by one of WebAIM’s web accessibility experts.
  3. Documentation for each data point identified by WAVE so you can begin to address site accessibility issues.

You get WAVE data AND a human analysis of that data AND powerful documentation—and with a guaranteed 5-day turnaround. Pricing starts at $750 for up to 2500 pages.

Learn more about the WAVE Runner service

Future Plans

We’re excited about the future of WAVE! The online WAVE service was used to evaluate over 2.5 million web pages in the last year. We just reached 100,000 active/weekly users of the WAVE Firefox and Chrome extensions. These tools will always be provided freely as a community service by WebAIM, while revenue from the site-wide tools will allow us to continue to improve and expand WAVE functionality.

We are continually improving the WAVE evaluation logic. We’ll be giving the WAVE interface an update in the near future. We’re working on a Edge browser extension. Open source tools that utilize the subscription and stand-alone APIs are being developed. As always, we’re very open to your feedback on how to make WAVE a more powerful and useful tool for improving web accessibility.

North Korea’s Missile Test Puts the Entire US in Range

0
0

KimJungUn-842418008.jpg

The bad news: Tuesday's missile test shows that North Korea's ICBM can likely hit the US. The slightly less bad news: It's still a long way off from actually doing so.

Robots Threaten Bigger Slice of Jobs in US, Other Rich Nations

0
0

Jobs-478148079.jpg

A new study finds that automation could displace up to 800 million jobs globally, but says an even greater number of new jobs will be created.
Viewing all 22746 articles
Browse latest View live




Latest Images