Online Resource

Rotch Library - HE305.D36 2018

Online Resource

Barker Library - HE199.A2 I366 2019

Barker Library - TE7.N2774 no.332

Hayden Library - TN805.A5 H36 2018

Online Resource

Ottawa : Statistics Canada = Statistique Canada, 2020

François, Damien (Joseph Damien), 1944- author

Srinivas Bhogle and Purnendu Maji reveal IPL-12's Most Valuable Players so far.

Srinivas Bhogle and Purnendu Maji identify the Most Valuable Players in the IPL so far.

The establishments will be allowed to sell liquor from 9 am to 7 pm.

Hayden Library - QH541.5.C65 K46 2018

Online Resource

Julie Grundy kicks off this, our fifteenth year, by diving headlong into the snowy issue of customising form inputs. Nothing makes a more special gift at Christmas that something you’ve designed and customised yourself. But can it be done while staying accessible to every user?

In my work as an accessibility consultant, there are some frequent problems I find on people’s websites. One that’s come up a lot recently is that people are making custom select inputs for their forms. I can tell that people are trying to make them accessible, because they’ve added ARIA attributes or visually-hidden instructions for screen reader users. Sometimes they use a plugin which claims to be accessible. And this is great, I love that folks want to do the right thing! But so far I’ve never come across a custom select input which actually meets all of the WCAG AA criteria.

Often I recommend to people that they use the native HTML select element instead. Yes, they’re super ugly, but as Scott Jehl shows us in his article Styling a Select Like It’s 2019 they are a lot easier to style than they used to be. They come with a lot of accessibility for free – they’re recognised and announced clearly by all screen reader software, they work reliably and predictably with keyboards and touch, and they look good in high contrast themes.

But sometimes, I can’t recommend the select input as a replacement. We want a way for someone to choose an item from a list of options, but it’s more complicated than just that. We want autocomplete options. We want to put images in there, not just text. The optgroup element is ugly, hard to style, and not announced by screen readers. The focus styles are low contrast. I had high hopes for the datalist element, but although it works well with screen readers, it’s no good for people with low vision who zoom or use high contrast themes.

Select inputs are limited in a lot of ways. They’re frustrating to work with when you have something which looks almost like what you want, but is too restricted to be useful. We know we can do better, so we make our own.

Let’s work out how to do that while keeping all the accessibility features of the original.

Semantic HTML

We’ll start with a solid, semantic HTML base. A select input is essentially a text input which restricts the possible answers, so let’s make a standard input.

<label for="custom-select">User Type</label>
<input type="text" id="custom-select">

Then we need to show everyone who can see that there are options available, so let’s add an image with an arrow, like the native element.

<label for="custom-select">User Type</label>
<input type="text" id="custom-select">
<img src="arrow-down.svg" alt="">

For this input, we’re going to use ARIA attributes to represent the information in the icon, so we’ll give it an empty alt attribute so screen readers don’t announce its filename.

Finally, we want a list of options. An unordered list element is a sensible choice here. It also lets screen reader software understand that these bits of text are related to each other as part of a group.

<ul class="custom-select-options">
  <li>User</li>
  <li>Author</li>
  <li>Editor</li>
  <li>Manager</li>
  <li>Administrator</li>
</ul>

You can dynamically add or remove options from this list whenever you need to. And, unlike our <option> element inside a <select>, we can add whatever we like inside the list item. So if you need images to distinguish between lots of very similar-named objects, or to add supplementary details, you can go right ahead. I’m going to add some extra text to mine, to help explain the differences between the choices.

This is a good base to begin with. But it looks nothing like a select input! We want to make sure our sighted users get something they’re familiar with and know how to use already.

Styling with CSS

I’ll add some basic styles similar to what’s in Scott Jehl’s article above.

We also need to make sure that people who customise their colours in high contrast modes can still tell what they’re looking at. After checking it in the default Windows high contrast theme, I’ve decided to add a left-hand border to the focus and hover styles, to make sure it’s clear which item is about to be chosen.

This would be a good time to add any dark-mode styles if that’s your jam. People who get migraines from bright screens will thank you!

JavaScript for behaviour

Of course, our custom select doesn’t actually do anything yet. We have a few tasks for it: to toggle the options list open and closed when we click the input, to filter the options when people type in the input, and for selecting an option to add it to the input and close the list. I’m going to tackle toggling first because it’s the easiest.

Toggling

Sometimes folks use opacity or height to hide content on screen, but that’s like using Harry Potter’s invisibility cloak. No-one can see what’s under there, but Harry doesn’t cease to exist and you can still poke him with a wand. In our case, screen reader and keyboard users can still reach an invisible list.

Instead of making the content see-through or smaller, I’m going to use display: none to hide the list. display: none removes the content from the accessibility tree, so it can’t be accessed by any user, not just people who can see. I always have a pair of utility classes for hiding things, as follows:

.hidden-all {
  display: none;
}

.hidden-visually {
    position: absolute;
    width: 1px;
    height: 1px;
    padding: 0;
    overflow: hidden;
    clip: rect(0,0,0,0);
    white-space: nowrap;
    -webkit-clip-path: inset(50%);
    clip-path: inset(50%);
    border: 0;
} 

So now I can just toggle the CSS class .hidden-all on my list whenever I like.

Browsing the options

Opening up our list works well for our mouse and touch-screen users. Our styles give a nice big tap target for touch, and mouse users can click wherever they like.

We need to make sure our keyboard users are taken care of though. Some of our sighted users will be relying on the keyboard if they have mobility or dexterity issues. Usually our screen reader users are in Browse mode, which lets them click the arrow keys to navigate through content. However, custom selects are usually inside form elements. which pushes screen reader software to Forms Mode. In Forms mode, the screen reader software can only reach focusable items when the user clicks the Tab key, unless we provide an alternative. Our list items are not focusable by default, so let’s work on that alternative.

To do this, I’m adding a tabindex of -1 to each list item. This way I can send focus to them with JavaScript, but they won’t be part of the normal keyboard focus path of the page.

csOptions.forEach(function(option) {
    option.setAttribute('tabindex, '-1')
}) 

Now I can move the focus using the Up and Down arrow keys, as well as with a mouse or tapping the screen. The activeElement property of the document is a way of finding where the keyboard focus is at the moment. I can use that to loop through the elements in the list and move the focus point forward or back, depending on which key is pressed.

function doKeyAction(whichKey) {
  const focusPoint = document.activeElement
  switch(whichKey) {
    case: 'ArrowDown':
      toggleList('Open')
      moveFocus(focusPoint, 'forward')
      break
    case: 'ArrowUp':
      toggleList('Open')
      moveFocus(focusPoint, 'back')
      break
  }
}

Selecting

The Enter key is traditional for activating an element, and we want to match the original select input.

We add another case to the keypress detector…

case 'Enter':
  makeChoice(focusPoint)
  toggleList('Shut')
  setState('closed')
  break 

… then make a function which grabs the currently focused item and puts it in our text input. Then we can close the list and move focus up to the input as well.

function makeChoice(whichOption) {
    const optionText = whichOption.documentQuerySelector('strong')
    csInput.value = optionText
}

Filtering

Standard select inputs have keyboard shortcuts – typing a letter will send focus to the first item in the option which begins with that letter. If you type the letter again, focus will move to the next option beginning with that letter.

This is useful, but there’s no clue to tell users how many options might be in this category, so they have to experiment to find out. We can make an improvement for our users by filtering to just the set of options which matches that letter or sequence of letters. Then sighted users can see exactly how many options they’ve got, and continue filtering by typing more if they like. (Our screen reader users can’t see the remaining options while they’re typing, but don’t worry – we’ll have a solution for them in the next section).

I’m going to use the .filter method to make a new array which only has the items which match the text value of the input. There are different ways you could do this part – my goal was to avoid having to use regex, but you should choose whatever method works best for your content.

function doFilter() {
  const terms = csInput.value
  const aFilteredOptions = aOptions.filter(option => {
    if (option.innerText.toUpperCase().startsWith(terms.toUpperCase())) {
    return true
    }
  })
  // hide all options
  csOptions.forEach(option => option.style.display = "none")
  // re-show the options which match our terms
  aFilteredOptions.forEach(function(option) {
    option.style.display = ""
  })
} 

Nice! This is now looking and behaving really well. We’ve got one more problem though – for a screen reader user, this is a jumble of information. What’s being reported to the browser’s accessibility API is that there’s an input followed by some clickable text. Are they related? Who knows! What happens if we start typing, or click one of the clicky text things? It’s a mystery when you can’t see what’s happening. But we can fix that.

ARIA

ARIA attributes don’t provide much in the way of additional features. Adding an aria-expanded='true' attribute doesn’t actually make anything expand. What ARIA does is provide information about what’s happening to the accessibility API, which can then pass it on to any assistive technology which asks for it.

The WCAG requirements tell us that when we’re making custom elements, we need to make sure that as a whole, the widget tells us its name, its role, and its current value. Both Chrome and Firefox reveal the accessibility tree in their dev tools, so you can check how any of your widgets will be reported.

We already have a name for our input – it comes from the label we associated to the text input right at the start. We don’t need to name every other part of the field, as that makes it seem like more than one input is present. We also don’t need to add a value, because when we select an item from the list, it’s added to the text input and therefore is exposed to the API.

But our screen readers are going to announce this custom select widget as a text entry field, with some images and a list nearby.

The ARIA Authoring Practices site has a pattern for comboboxes with listboxes attached. It tells you all the ARIA you need to make screen reader software give a useful description of our custom widget.

I’m going to add all this ARIA via JavaScript, instead of putting it in the HTML. If my JavaScript doesn’t work for any reason, the input can still be a plain text field, and we don’t want screen readers to announce it as anything fancier than that.

csSelector.setAttribute('role', 'combobox') 
csSelector.setAttribute('aria-haspopup', 'listbox')
csSelector.setAttribute('aria-owns', '#list') 
csInput.setAttribute('aria-autocomplete', 'both')
csInput.setAttribute('aria-controls', 'list')

The next thing to do is let blind users know if the list is opened or closed. For that task I’m going to add an aria-expanded attribute to the group, and update it from false to true whenever the list changes state in our toggling function.

The final touch is to add a secret status message to the widget. We can use it to update the number of options available after we’ve filtered them by typing into the input. When there are a lot of options to choose from, this helps people who can’t see the list reducing know if they’re on the right track or not.

To do that we first have to give the status message a home in our HTML.

<div id='custom-select-status' class='hidden-visually' aria-live='polite'></div>

I’m using our visually-hidden style so that only screen readers will find it. I’m using aria-live so that it will be announced as often as it updates, not just when a screen reader user navigates past it. Live regions need to be present at page load, but we won’t have anything to say about the custom select then so we can leave it empty for now.

Next we add one line to our filtering function, to find the length of our current list.

updateStatus(aFilteredOptions.length)

Then we send that to a function which will update our live region.

function updateStatus(howMany) {
    console.log('updating status')
    csStatus.textContent = howMany + " options available."
}

Conclusion

Let’s review what we’ve done to make an awesome custom select input:

• Used semantic HTML so that it’s easily interpreted by assistive technology while expanding the types of content we can include in it
• Added CSS styles which are robust enough to survive different visual environments while also fitting into our branding needs
• Used JavaScript to provide the basic functionality that the native element has
• Added more JavaScript to get useful functionality that the native element lacks
• Carefully added ARIA attributes to make sure that the purpose and results of using the element are available to assistive technology and are updated as the user interacts with it.

You can check out my custom select pattern on GitHub – I’ll be making additions as I test it on more assistive technology, and I welcome suggestions for improvements.

The ARIA pattern linked above has a variety of examples and customisations. I hope stepping through this example shows you why each of the requirements exists, and how you can make them fit your own needs.

I think the volume of custom select inputs out there shows the ways in which the native select input is insufficient for modern websites. You’ll be pleased to know that Greg Whitworth and Simon Pieters are working on improving several input types! You can let them know what features you’d like selects to have. But until that work pays off, let’s make our custom selects as accessible and robust as they can possibly be.

About the author

Julie Grundy is an accessibility expert who works for Intopia, a digital accessibility consultancy. She has over 15 years experience as a front-end web developer in the health and education sectors. She believes in the democratic web and aims to unlock digital worlds for as many people as possible. In her spare time, she knits very slowly and chases very quickly after her two whippets.

More articles by Julie

Dewey Library - JF2051.R67 2018

Haas, who is on a 2 day visit to Nagpur, said global economic recession won't impact Indo-US trade.

Berlin ; New York : Springer, [2005]

Berlin ; New York : Springer, [2005]

Australia. Parliament. Senate. Economics References Committee, issuing body

The release is to encourage feedback that will help improve various features of the framework before the final rollout

Moovit will remain independent while its technology and the data it collects from more than 800 million users in 102 countries will be integrated into Intel's autonomous car unit Mobileye

Hydrometallurgy Meeting (34th : 2004 : Banff, Alta.)

Toulouevski, Yuri N., author

Ndlovu, Sehliselo, author

Panel Scott Hanselman (twitter github blog) Joe Eames (twitter github blog) Aaron Frost (twitter github blog) Charles Max Wood (twitter github Teach Me To Code Rails Ramp Up) Discussion 01:14 - Scott Hanselman Introduction Community Program Manager for Web Tools at Microsoft Azure and Web Tools ASP.NET Runtime 03:17 - Microsoft and JavaScript Microsoft Build Developer Conference Scott Hanselman: Angle Brackets, Curly Braces, One ASP.NET and the Cloud Json.NET 13:40 - The Cost of Web Development Tooling Sublime Text Visual Studio 18:17 - Libraries and Frameworks Knockout 24:14 - Innovation in Software Befunge 29:48 - Apps Supporting JavaScript Create your first Windows Store app using JavaScript (Windows) Visual Studio Express 34:14 - Windows and Internet Explorer Chakra 40:42 - Microsoft’s Attitude Towards JavaScript Scott Hanselman: Azure for the non-Microsoft Person - How and Why? 45:58 - Open Source 49:12 - asm.js 52:05 - Angle Brackets Conference Picks The Wolverine (Joe) ng-conf (Joe) Cancún (Aaron) @ngconf (Aaron) Wistia (Chuck) Mumford And Sons 'Hopeless Wanderer' Music Video (Scott) Beyoncé Joins the Short Hair Club (Scott) Next Week Screencasting: Sharing What You Know Through Video Transcript [Hosting and bandwidth provided by the Blue Box Group. Check them out at BlueBox.net.]  [This episode is sponsored by Component One, makers of Wijmo. If you need stunning UI elements or awesome graphs and charts, then go to Wijmo.com and check them out.]  [This podcast is sponsored by JetBrains, makers of WebStorm. Whether you’re working with Node.js or building the front end of your web application, WebStorm is the tool for you. It has great code quality and code exploration tools and works with HTML5, Node, TypeScript, CoffeeScript, Harmony, LESS, Sass, Jade, JSLint, JSHint, and the Google Closure Compiler. Check it out at JetBrains.com/WebStorm.] CHUCK:  Hey everybody and welcome to Episode 71 the JavaScript Jabber show. This week on our panel, we have Joe Eames. JOE:  Hey. CHUCK:  Aaron Frost. AARON:  Hello. CHUCK:  I’m Charles Max Wood from DevChat.TV. And we have a special guest that is Scott Hanselman. SCOTT:  Hello. CHUCK:  Since you’re new to the show, do you want to introduce yourself really quickly? SCOTT:  My name is Scott Hanselman. You can learn more about me on the internet by googling for Scott. I’m in an epic battle right now with the Scott toilet paper people. You’ll find me just below Scott toilet tissue. I’ve been blogging for ten years. More than ten years, 13 years. I work at Microsoft right now. Before that I worked in finance at a company called Corillian that is now Fiserv. I’ve been building big systems on the web for as long as the web’s been around. CHUCK:  Wow. What do you do at Microsoft? SCOTT:  I work in Azure and Web Tools. I’m a program manager. I’m in charge of the experience from file new project until deployment. I call myself the PM of miscellaneous. I spend time going through that experience making sure that it doesn’t suck. My focus is on web tools but also ASP.NET Runtime and what the experience is when you deploy something into Azure. That might be everything from what’s it like editing JavaScript in Visual Studio and I’ll find some issue and go and work with the guys that own that, or it might be someone’s trying to do something in Node on Azure and that experience is not good. I’m like an ombudsman or a customer liaison. But the simplest way would be to say I’m the community PM, community program manager, for web tools at Microsoft. CHUCK:  Okay. AARON:  Cool. CHUCK:  So, is JavaScript your primary focus? SCOTT:  I would say that my primary focus is just anything that makes the web better and moves the web forward. While I work for ASP.NET and most of my work is in C#,

The panelists discuss TC39 with Alex Russell.

Check out ReactRally: A community React conference in Salt Lake City, UT from August 24th-25th!

03:36 - John Sonmez Introduction

• Twitter
• GitHub
• Simple Programmer
• The Entreprogrammers Podcast
• Soft Skills: The Software Developer's Life Manual by John Sonmez
• How to Market Yourself as a Software Developer Course

04:29 - Mastermind Groups

• Think and Grow Rich: The Landmark Bestseller - Now Revised and Updated for the 21st Century by Napoleon Hill

05:53 - “Soft Skills”

• Why Care About Soft Skills?
  • People Skills
  • Finances
  • Fitness

11:53 - Learned vs Innate

• Lifting Limited Beliefs
• Practice

14:14 - Promotion (Managerial) Paths

• The Peter Principle

17:52 - “Marketing”

• Value: Give Away 90% / Charge For 10%
• Seeming “Spammy” (Resistance to Sell)
• Neil Patel's Blog
• Documentation for Yourself
  • AJ O'Neal: How to Tweet from NodeJS

29:53 - Get Up and CODE!

• #086: Figure Skating and Software Development with Aimee Knight
• #067: Weight Loss Plan for Charles (Max Wood)

33:47 - Burnout

• Do the Work by Steven Pressfield
• The War of Art: Break Through the Blocks and Win Your Inner Creative Battles by Steven Pressfield
• Systems and Habits (Routines)
  • Methods of Execution

Get John’s How to Market Yourself as a Software Developer Course for $100 off using the code JSJABBER

Comment on this episode for your chance to win one of two autographed copies of Soft Skills: The Software Developer's Life Manual by John Sonmez

Picks

The Recurse Center (Jamison)
Code Words Blog (Jamison)
DayZ Player Sings (And Plays Guitar) For His Life (Jamison)
Demon (Jamison)
Mastodon: Leviathan (Jamison)
Jan Van Haasteren Puzzles (Joe)
Hobbit Tales from the Green Dragon Inn (Joe)
AngularJS-Resources (Aimee)
Superfeet Insoles (Aimee)
Good Mythical Morning (AJ)
The Magic of Thinking Big by David J. Schwartz (Chuck)
Streak (John)
The E-Myth Revisited: Why Most Small Businesses Don't Work and What to Do About It by Michael E. Gerber (John)
Influence: The Psychology of Persuasion, Revised Edition by Robert B. Cialdini (John)
Do the Work by Steven Pressfield (John)
The War of Art: Break Through the Blocks and Win Your Inner Creative Battles by Steven Pressfield (John)

On this week's episode of My JS Story, Charles Max Wood interviews Alex Russell. Alex is a software engineer on the Chrome team. He focuses on designing new features and running their standards work. He appeared as a guest on episode 87, where he talked about TC39. Tune in to his story!

Panel: 

Charles Max Wood

Joe Eames

Aimee Knight

Special Guests: Russell Goldenberg and Adam Pearce

In this episode, JavaScript Jabber panelist speak with Russell Goldenberg and Adam Pearce Russell creates visualizations, interactive graphics, and documentaries for the web. Currently an editor at The Pudding.  Adam is a graphics editor at The New York Times and a journalist engineers/developer  Russell and Adam are on the show to talk about what Scrollytelling is, as well as Scrollama. Scrollama is a modern and lightweight JavaScript library for scrollytelling using IntersectionObserver in favor of scroll events. This is a great episode to understand another technology/tool created with JavaScript.

In particular, we dive pretty deep on:

• What is Scrollytelling!
• Graph Scroll library
• What is the intersection Observerable?
• How long does it take to build an interactive graphic…?
• How do you test something like this?
• Test on a lot of different devices
• Can you do automated testing?
• Do you have to understand the use cases or can you implement quickly?
• Recommendation for getting started?
• Is this a skill set people have to have before that some on board?
• How do design these interactions?
• Scroll jacking
• What JS developers should know about this technology.
• Position sticky
• What are other uses cases?
• What can devs use it for?
• Tax calculator
• And much more!

Links:

•  
• https://github.com/russellgoldenberg/scrollama
• https://pudding.cool/process/introducing-scrollama/
• @codenberg
• @adamrpearce
• https://pudding.cool/
• http://russellgoldenberg.github.io
• https://github.com/1wheel?direction=desc&sort=created&tab=stars
• https://roadtolarissa.com

Picks:

Adam

• Dominion - Broad Game

Charles

• Smoker
• Tiny Epic Galaxies
• Indiegogo Dev Chat TV

Aimee

• Deadlines
• Quest Protein Powder

Joe

• Giving!
• Board Game - Azul

Russel

• Crokinole
• Bust Out

Sponsors

• Triplebyte offers a $1000 signing bonus
• Sentry use the code “devchat” for $100 credit
• Linode
• CacheFly

Panel

• AJ O’Neal

Joined by special guest: Sam Selikoff

Episode Summary

In this episode of JavaScript Jabber, Sam Selikoff, Co-Founder at EmberMap, Inc. starts with giving a brief background about himself and his work followed by a discussion with AJ O’Neal about the Ember community. Sam mentions some of the biggest advantages in using Ember, and what it should and should not be used for. He explains the architecture of Ember apps, addresses some of the performance concerns and then dives into Octane in detail. He talks about a bunch of Ember components, compiler compatibility, relative weight of Ember apps compared to other frameworks, the underlying build system, and security considerations. Sam then helps listeners understand the usage of ES6 classes and decorators in Ember at length. At the end, they discuss component rendering and element modifiers and move onto picks.

Links

• Sam’s website
• Sam on Twitter
• Sam on GitHub

Follow JavaScript Jabber on Devchat.tv, Facebook and Twitter.

Picks

AJ O’Neal:

• Good Mythical Morning - YouTube

Sam Selikoff:

• The Man In the High Castle  
• Tailwind CSS

Sponsors

• Sentry use the code “devchat” for 2 months free on Sentry small plan

• Ruby Rogues

• React Native Radio

• CacheFly

Host: Charles Max Wood

Joined by Special Guest: Sam Selikoff

Episode Summary

Sam Selikoff, Co-Founder at EmberMap shares his journey of how he became a developer. Sam was an Economics major in college and he really loved the theory of economics.

When he graduated, he started working as a consultant and while working with data for statistical analysis he found that he enjoyed working with SQL and that how he started his developing career.

Sam explains why he prefers Ember.js framework to other frameworks. He also talks about the projects he is working on currently.

Apart from coding Sam enjoys reading economics books and playing music with his family. He shares some of his favorite books to read on the Theory Of Economics.

Links

• JSJ 364: Ember Octane with Sam Selikoff

• EmberMap Podcast

• Sam's Twitter

Picks

Charles Max Wood

• Podcast Movement

Sam Selikoff

• UPLIFT Desk

• Midsommar Movie

Mazur, Gail

Barker Library - PQ7298.422.U37 L67 2019

By fielding one of its vice-presidents – former television soap star Smriti Irani – against Congress’s Rahul Gandhi in Amethi Lok Sabha constituency, BJP has shown it is inclined to take the electoral battle to one of two Gandhi pocket boroughs in Uttar Pradesh.