Leptomeningeal carcinomatosis has been understudied for years, and its increasing prevalence now has researchers working overtime to make much-needed progress in its treatment.
Medscape Oncology

Online Resource

Barker Library - QK569.D54 D54 2019

Dewey Library - SB349.H96 2019

Online Resource

Online Resource

Hayden Library - SB349.H64 2018

Online Resource

Automation and Artificial Intelligence (AI) are radically changing the way modern networks are being designed, operated and resourced.
More RSS Feed for Cisco: newsroom.cisco.com/rss-feeds ...

“COVID-19 is a respiratory disease but world over we see children coming with diarrhoea and abdominal pain,” says a doctor

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 - U39.C76 2020

Online Resource

BJP stressed the asthi yatra is a message to Hindus and Muslims to fight terrorism together.

Springer 2007

The employees responsible for tackling hacking threats have alleged that the Silicon Valley giant is replacing them with machines and is automating its alert response and security teams

Havlík, T. (Tomáš)

Firm comes out with five schemes

The panelists talk to Ariya Hidayat about Phantom.js.

Panel Tom Dale (twitter github blog Tilde Inc.) James Halliday (twitter github substack.net) AJ O’Neal (twitter github blog) Jamison Dance (twitter github blog) Merrick Christensen (twitter github) Joe Eames (twitter github blog) Tim Caswell (twitter github howtonode.org) Charles Max Wood (twitter github Teach Me To Code Rails Ramp Up) Discussion 01:52 - James Halliday Introduction browserify 02:37 - Tom Dale Introduction iCloud Ember.js Big Data & Hadoop 04:47 - Specialized vs Monolithic github.com/tildeio Idiology Micro Libraries 14:13 - Learning Frameworks 18:04 - Making things modular 25:23 - Picking the right tool for the job 27:44 - voxel.js & emberjs emberjs / packages BPM - Browser Package Manager NPM - Node Packaged Modules testling-ci Backbone.js 38:19 - Module Systems CommonJS 41:14 - Cloud9 Use Case 43:54 - Bugs jQuery Source Code Picks jQuery 2.0 (Merrick) ECMAScript 6 Module Definition (Merrick) AMD (Merrick) Yiruma (Joe) Elementary (Joe) Miracle Berry Tablets (AJ) The Ubuntu You Deserve (AJ) Bravemule (Jamison) RealtimeConf Europe (Tim) visionmedia / cpm (Tim) Why I Love Being A Programmer in Louisville (or, Why I Won’t Relocate to Work for Your Startup: Ernie Miller (Chuck) Is Audio The Next Big Thing In Digital Marketing? [Infographic] (Chuck) testling-ci (James) voxel.js (James) CAMPJS (James) Discourse (Tom) Williams-Sonoma 10-Piece Glass Bowl Set (Tom) The Best Simple Recipes by America’s Test Kitchen (Tom) Next Week Why Javascript is Hard Transcript JAMISON:  You can curse but we will just edit it out and replace it with fart noises. TOM:  I’ll be providing plenty of my own. [Laughter] JAMISON:  Okay, good. [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.] CHUCK:  Hey everybody and welcome to Episode 47 of the JavaScript Jabber show. This week on our panel, we have AJ O’Neal. AJ:  Yo! Yo! Yo! Coming at you not even live! CHUCK:  [Laughs] Alright, Jamison Dance. JAMISON:  Hi guys, it’s tough to follow that. CHUCK:  Merrick Christensen. MERRICK:  Hey. CHUCK:  Joe Eames. JOE:  Howdy! CHUCK:  Tim Caswell. TIM:  Hello. CHUCK:  I’m Charles Max Wood from DevChat.tv. And this week, we have two guests. The first one is Tom Dale. TOM:  Hey, thanks for having me. CHUCK:  The other is James Halliday. JAMES:  Yep. Hello. CHUCK:  Welcome to the show, guys. We were having a conversation a while back, I don’t remember if it was during another episode or after another episode. But we were having a discussion over code complexity and having like small simple libraries or small simple sets of functionality versus large monolithic sets of functionality, and how to approach those and when they’re appropriate. So, we brought you guys on to help us explore this because you're experts, right? TOM:  I don’t think that’s a fair analysis of the situation, but we can certainly fumble our way through something. [Laughter] CHUCK:  Alright. So, why don’t you guys, real quick, just kind of introduce yourselves? Give us a little background on what your experience is so that we know which questions to ask you guys. James, why don’t you start? I know you’ve been on the show before. JAMES:  Hello. I suppose I wrote Browserify which is relevant here. It’s a common JS style, bundler packager thing that just uses NPM. And I have a bunch of other libraries. And I really like doing data development as just a bunch of little modules put together. They are all published completely independently on NPM. I think I’m up to like 230-ish some odd modules on NPM now. So, I’ve been doing that and I really like that style.

Panel:

• Joe Eames
• Aimee Knight
• AJ ONeal

Special Guests: Tom Dale

In this episode, the JavaScript Jabber panel talks to Tom Dale about Ember 3.0 and the future of Ember. Tom is the co-creator of Ember and is a principle staff engineer at LinkedIn where he works on a team called Presentation Infrastructure. They talk about being in the customer service role, having a collaborative culture, and all the information on Ember 3.0. They also touch on the tendency towards disposable software, the Ember model, and more!

In particular, we dive pretty deep on:

• How Joe met Tom
• Programmers as rule breakers
• The pressure to conform
• Tom intro
• Staff engineer at LinkedIn
• Customer service role
• Having a way to role improvements out to a lot of different people
• JavaScript and Ember at LinkedIn
• Having a collaborative culture
• All about Ember 3.0
• Banner feature – there is nothing new
• Cracked how you develop software in the open source world that has longevity
• Major competition in Backbone previously
• The Ember community has never been more vibrant
• Tendency towards disposable software
• The idea of steady iteration towards improvement
• The Ember model
• Being different from different frameworks
• Ember adoption rates
• Python 3
• Valuable from a business perspective to use Ember
• Ember community being friendly to newbies
• How much Ember VS how much JavaScript will a new developer have to learn?
• And much, much more!

Links:

• Ember
• LinkedIn
• JavaScript
• Backbone
• Python
• @tomdale
• tomdale.net
• Tom’s GitHub

Sponsors

• Kendo UI
• Sentry
• Digital Ocean

Picks:

Joe

• Framework Summit
• Jayne
• React sent Evan You a cake

Aimee

• Maker's Schedule, Manager's Schedule by Paul Graham

AJ

• James Veitch

Tom

• JavaScript Tech Talk
• Drake’s Ties
• Melissa Watson Ellis at Hall Madden

Panel: Charles Max Wood

Guest: Sérgio Crisóstomo

This week on My JavaScript Story, Charles speaks with Sérgio Crisóstomo. Charles is now interviewing podcast listeners, not just guest speakers. Check-out toady’s episode to hear Sérgio’s background as a musician and as a programmer. Also, to hear Sérgio’s latest projects and how he fell in-love with Sweden and ended up moving there!

In particular, we dive pretty deep on:

1:46 – Chuck: How did you get into programming?

1:53 – Sérgio: As a child, I got interested into gaming. I wrote coding. Spectrum.

2:22 – Chuck: I think that makes you about my age.

2:41 – Sérgio: I was born in 1978.

2:51 – Sérgio: I had a cousin who got inspired by me and we started doing things together. We would show each other what we were doing. Better games and better computers came around. Turned out that I came back to it later in life.

3:29 – Chuck: what got you interested?

3:30 – Sérgio: It was all about problem-solving. There was no book. It was trial and error. It was magic. I was doing small steps, and it was empowering to me.

4:29 – Chuck: I used Logo. How did you get into programming at the professional-level?

4:45 – Sérgio: It was a long journey. My family was deep into a musical background. I went to the conservatory. I had a background in math, music, and physics. I went into programming because my father pushed me towards that direction. I did my Master’s in violin. After that I moved to Sweden. I really liked Sweden’s educational system. After 20 years I got into program working. I faked it until I made it. I had no one who could help me day-to-day life. I love solving problems. I found myself helping people in Portugal and other countries, since their English wasn’t strong. I liked that I was helping the community. That made me feel good about c

10:15 – Chuck: You switch from PHP to Node? What was the reasoning to that?

11:30 – Chuck: What things have you built in JavaScript?

11:47 – Sérgio: I started doing some freelance work. In the beginning it was helping friends.

13:22 – Chuck: Football – do you mean soccer or football?

13:35 – Sérgio: One day in the school, we got a new principal that the school didn’t like. I left because I wasn’t happy. I was a fulltime musician, and looked at this fulltime-programming job. I went to an interview where there were code quizzes. I loved the challenges. I had to choose between two different careers. After some negotiations it was a great fit for me. I got to be in-charge of different projects. Right now, I am a senior developer. It’s a small company but it is growing.

15:48 – Advertisement  E-book!

16:31 – Chuck: It’s interesting to see how you weren’t happy with your original job and how you got into programming fulltime.

17:29 – Sérgio: It’s important to have a good perspective. I am used to meeting people because I worked with choirs, orchestras, dance, and people and I can use those tools that I learned with musicians and transfer over to programming. Since I was good in JavaScript that helped me. Also, it was good that I was head-in-chief, because of my background of being a teacher. I found similarities and made it happen. That was my way in.

19:36 – Chuck: I find that very interesting. Yes, in the larger markets they might have their pick, but if you look into the smaller markets they might need you.

20:21 – Sérgio: People will invest into you if you are willing to learn and stay for a while.

20:48 – Chuck: What is the community like over in Sweden?

21:12 – Chuck: Do you have a lot of communities/boot camps out there to help people to code out in Sweden?

21:32 – Sérgio: Yes. It’s a really active community, and I have been involved helping connect people. People are curious and wanting to grow. It’s really open.

22:39 – Chuck: How do you start a program like that?

22:53 – Sérgio: I went to MEETUP.COM. 

23:45 – Sérgio: I fell in-love with the concept of Sweden’s education system. I was there touring and decided I wanted to move to Sweden. It was worth staying. Sweden is having different political winds now. They are open to foreigners. I am a Swedish citizen now.

25:18 – Chuck: What are you working on now?

25:26 – Sérgio answers Chuck’s question.

26:45 – Chuck: Anything else?

26:54 – Sérgio: I can talk about music a lot! I find a lot of programmers are musicians, too.

27:23 – Chuck: One more question. I have met, too, a lot of programmers who are musicians, too. What is the correlation?

27:43 – Music has a lot of mathematics. You have to play on time and solve problems all the time. I was in a workshop with musicians and entrepreneurs, and I learned a lot in this workshop. There are different attitudes when conducting. There is problem solving and managing people. I see the connections there.

Links:

• Meetup.com
• Sergio’s GitHub
• Sergio’s Website
• Sergio’s Website
• Sergio’s Twitter

Sponsors:

• Code Badges
• Digital Ocean
• Cache Fly

Picks:

Charles

• Views on Vue – DevChat
• Code Badge - Kick Starter

Sérgio

• Chopin!
• Checkout Sweden if you want a job as a programmer! Email me!

Sponsors

• Sentry- use the code “devchat” for $100 credit
• Netlify
• Clubhouse
• CacheFly

Episode Summary  

In this episode of JavaScript Jabber, the panelists talk with Tommy Hodgins who specializes in responsive web design. He starts with explaining to listeners what it means by a responsive web layout and goes on to discuss the techniques in using JavaScript in CSS in depth.

He elaborates on dynamic styling of components, event-driven stylesheet templating, performance and timing characteristics of these techniques and describes different kinds of observers – interception, resize and mutation, and their support for various browsers. He also talks about how to go about enabling certain features by extending CSS, comparison to tools such as the CSS preprocessor and Media Queries, pros and cons of having this approach while citing relevant examples, exciting new features coming up in CSS, ways of testing the methods, caffeinated stylesheets, along with Qaffeine and Deqaf tools.

Links

• JS in CSS – Event driven virtual stylesheet manager
• Qaffiene
• Deqaf
• Tommy’s Twitter
• Fizzbuzz

Picks

Joe

• The Captain Is Dead

Aimee

• Developer on Call
• Tip – Try to follow a low-sugar diet

Chris

• Tommy’s snippets on Twitter – JS in CSS
• All things frontend blog
• Gulp project

Charles

• Coaching by Charles in exchange of writing Show Notes or Tags

Tommy

• JS in CSS

Tommy Hodgins is a developer that typically works on A/B tests figuring out how to get websites the outcomes they want. He got into JavaScript and front-end technologies and then read a paper that led him to realize the capabilities of writing software to solve problems. He maintains a front-end focus with his A/B testing work and CSS in JS and other work.

Host: Charles Max Wood

Joined By Special Guest: Tommy Hodgins

Sponsors

• Sentry

• CacheFly

______________________________________

"The MaxCoders Guide to Finding Your Dream Developer Job" by Charles Max Wood is now available on Amazon. Get Your Copy Today!

______________________________________

Picks

Tommy Hodgins:

• QuickJS

• Language Learning with Netflix

Charles Max Wood:

• Gmelius

• The Man In the High Castle

• The Name of the Wind

• Verdict with Ted Cruz

Mass, Jeffrey P

Lahire, Nathalie

This mixed-methods pilot study examines whether the repeated use of a decision aid by heart teams was associated with greater shared decision-making, along with improved patient-centered outcomes and clinicians’ attitudes about decision aids.

Stommel, Henry M., 1920-1992

Hayden Library - TP155.75.A55 2017

Online Resource

Online Resource

Holland, Tom, author

This site has been written in HTML5 and used to use WordPress to manage the content. I’ll explain why I used HTML5, describe the structure of the theme templates, and show some of the ways I tried to tame WordPress’s tendency to add mess to the source code.

As this is my personal site I wanted to experiment with using HTML5, CSS3, and WAI-ARIA. All these documents are currently working drafts and subject to change. However, the web documents and applications of the future are going to be written in HTML5 and I wanted to see the benefits of using it to markup static documents. Using CSS 2.1, let alone the CSS3 selectors and properties that some browser vendors have implemented, has many advantages for controlling the presentation of semantically coded documents. For this reason I am not going to avoid using basic CSS 2.1 selectors just to faithfully reproducing this site’s design in IE6. However, I have tried to accommodate IE 7 and IE 8 users by using an HTML5 enabling script so that the new HTML5 elements can be styled in those browsers if users have Javascript enabled.

HTML5 templates

I started with a static prototype of this site developed on my local server. WordPress makes it very easy to create your own templates and, therefore, it is no problem to use HTML5. This theme only has 3 main templates: index, single, and archive. There are of course templates for 404s, attachments, comments, etc., but I won’t discuss them as they are all based on the 3 main templates. All the templates include ARIA roles as an accessibility aide.

The single.php template has this rough structure:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title></title>
  <link rel="stylesheet" href="default.css">
</head>

<body>
  <header role="banner"></header>
  <nav role="navigation"></nav>
  <article role="main">
    <header>
      <time datetime="YYYY-MM-DD"></time>
      <h1></h1>
    </header>
    <footer></footer>
  </article>
  <nav></nav>
  <aside role="complementary"></aside>
  <footer role="contentinfo">
    <small></small>
  </footer>
</body>
</html>

The first line of the document is the HTML5 DOCTYPE. The new <article> element contains the content of each post. The same structure is used for the index.php template except that there are several articles displayed on each page and the ARIA role value of main is not used. In contrast, the archive.php template houses all the article excerpts in a <section> element with the ARIA role of main because the list of archived posts is itself the main content of the document.

A clean theme

WordPress tends to add classes, elements, and other bits of code in certain places. I haven’t used any of the WordPress functions that add class names to the body and to elements wrapping a post and also wanted to avoid cluttering the source code with any other unnecessary markup. This required a bit of fiddling around with the theme’s functions.php file. I’m not a PHP developer so this might not be pretty!

Removing actions from wp_head()

WordPress has a hook called wp_head that sits in the header.php of most themes. To avoid it inserting unwanted code into the <head> of the document I used the remove_action function to disable the functions that were responsible. The following code was added to the functions.php file of my theme:

// Remove links to the extra feeds (e.g. category feeds)
remove_action( 'wp_head', 'feed_links_extra', 3 );
// Remove links to the general feeds (e.g. posts and comments)
remove_action( 'wp_head', 'feed_links', 2 );
// Remove link to the RSD service endpoint, EditURI link
remove_action( 'wp_head', 'rsd_link' );
// Remove link to the Windows Live Writer manifest file
remove_action( 'wp_head', 'wlwmanifest_link' );
// Remove index link
remove_action( 'wp_head', 'index_rel_link' );
// Remove prev link
remove_action( 'wp_head', 'parent_post_rel_link', 10, 0 );
// Remove start link
remove_action( 'wp_head', 'start_post_rel_link', 10, 0 );
// Display relational links for adjacent posts
remove_action( 'wp_head', 'adjacent_posts_rel_link', 10, 0 );
// Remove XHTML generator showing WP version
remove_action( 'wp_head', 'wp_generator' );

Source: WPEngineer.com: Cleanup WordPress Header

Removing an empty <span>

If you want to create excerpts you can either write them into the excerpt box or use the <--more--> quicktag in the WordPress editor. I just wanted the first paragraph of my posts to be used as the excerpt and so using the in-editor tag was the most practical approach I was aware of. However, when you do this WordPress will insert an empty <span> in the post’s content. This element has an id so that the area following the excerpt can be targeted by “more” or “continue reading” links. I removed both the empty <span> and the jump link by adding the following code to the functions.php file of the theme:

// removes empty span
function remove_empty_read_more_span($content) {
  return eregi_replace("(<p><span id="more-[0-9]{1,}"></span></p>)", "", $content);
}
add_filter('the_content', 'remove_empty_read_more_span');

Source: Ganda Manurung: Remove Empty Span Tag On WordPress

// removes url hash to avoid the jump link
function remove_more_jump_link($link) {
  $offset = strpos($link, '#more-');
  if ($offset) {
    $end = strpos($link, '"',$offset);
  }
  if ($end) {
    $link = substr_replace($link, '', $offset, $end-$offset);
  }
  return $link;
}
add_filter('the_content_more_link', 'remove_more_jump_link');

Source: WordPress Codex: Customizing the Read More

Displaying images in the excerpt

For posts that display nothing but a photograph (yes, they will be shit but I’m hoping it gets me using my camera a bit more often) I wanted the image to show up in the archives. Equally, if the first paragraph of a post contained a link I wanted that to be preserved. The default the_excerpt() template tag doesn’t allow for this so it needed some modifying. I added a new function, which is just a modified version of the core excerpt function, to the functions.php file and then made sure that the template tag executed this function rather than the one contained in the core WordPress files.

function improved_trim_excerpt($text) {
   if ( '' == $text ) {
      $text = get_the_content('');
      $text = strip_shortcodes( $text );
      $text = apply_filters('the_content', $text);
      $text = str_replace(']]>', ']]>', $text);
      $text = strip_tags($text, '<p><img><a>');
      $excerpt_length = apply_filters('excerpt_length', 55);
      $words = explode(' ', $text, $excerpt_length + 1);
      if (count($words) > $excerpt_length) {
         array_pop($words);
         array_push($words, '[...]');
         $text = implode(' ', $words);
         $text = force_balance_tags($text);
      }
   }
   return $text;
}
remove_filter('get_the_excerpt', 'wp_trim_excerpt');
add_filter('get_the_excerpt', 'improved_trim_excerpt');

Source: Aaron Russell: Improving WordPress’ the_excerpt() template tag

Conditional next/prev links

I prefer not to have empty elements in the markup and so I needed a way to conditionally insert the “Older entries”, “Newer Entries”, etc., links into templates. The solution I’m using here, which isn’t perfect, is to add this to functions.php:

function show_posts_nav() {
  global $wp_query;
  return ($wp_query->max_num_pages > 1);
}

Source: Eric Martin: Conditional navigation links in WordPress

And then to wrap the navigation markup in the templates with the following:

<?php if (show_posts_nav()) : ?>
<nav>
   <ul>
      <li><?php next_posts_link('&#171; Older Entries') ?></li>
      <li><?php previous_posts_link('Newer Entries &#187;') ?></li>
   </ul>
</nav>
<?php endif; ?>

Summary

It’s fairly easy to create a simple site with HTML5 and to use WordPress to deliver it. At the moment there are issues with Internet Explorer because you cannot style HTML5 elements unless you use Javascript. However, HTML5 redefines the meaning of certain elements (such as <dl>, which has become a more versatile “description list”) and allows block elements to be wrapped in a link. Therefore, there is still benefit in using the HTML5 DOCTYPE even if you do not make use of the new elements.

Further reading

1. HTML5 working draft
2. HTML5 differences from HTML4
3. Accessible Rich Internet Applications (WAI-ARIA) 1.0

How to create a custom Tweet Button for WordPress using the bit.ly and Twitter APIs. The HTML and CSS is completely customisable and there is no need for JavaScript. PHP is used to automatically shorten and cache the URL of a post, fetch and cache the number of retweets, and populate the query string parameters in the link to Twitter.

The custom Tweet Button at the bottom of this post was created using this method. All the files are available on Github and released under MIT license. The PHP code was heavily influenced by the BackType Tweetcount plugin.

How to use

You’ll need your own bit.ly account and to be comfortable editing your theme’s functions.php, style.css, and template files. Be sure to make backups before you start making changes.

Step 1: Download the Custom Tweet Button for WordPress files from Github.

Step 2: Include the custom-tweet-button.php file in your theme’s functions.php file.

Step 3: Replace the bit.ly username, bit.ly API key, and Twitter username placeholders in the tweet_button function with your own. Your bit.ly credentials can be found on the “settings” page of your account.

Step 4: Add the custom Tweet Button CSS to your theme’s style.css file. Add the tweet.png image in your theme’s image folder. Make sure the image is correctly referenced in the CSS file.

Step 5: Call the function tweet_button in your template files (e.g. single.php) at the position(s) in the HTML you’d like the Tweet Button to appear:

if (function_exists('tweet_button')) {
   tweet_button(get_permalink());
}

Why make your own Tweet Button?

Making your own custom Tweet Button for WordPress has several additional advantages over using Twitter’s own offerings.

• Full control over the HTML and CSS.
  Having full control over the HTML and CSS means that you can choose how to present your Tweet Button. I decided to reproduce the horizontal and vertical styles of Twitter’s own button. But any appearance is possible.

• All click, traffic, and referrer data is stored in your bit.ly account.
  The URL for any published post is automatically shortened using the bit.ly service. The short URL is then passed to Twitter to ensure you can monitor the click and traffic data in your bit.ly account. The permalink is passed to Twitter in the counturl query string parameter to ensure that it counts the URL that your short URL resolves to.

• No need for JavaScript or embedded iframes.
  The Tweet Button works without JavaScript. You have full control over any custom JavaScript enhancements you may wish to include. If you’d prefer Twitter’s share page to open in a pop-up window you can write your own JavaScript handler.

• Faster page load.
  No external JavaScript or image files are loaded; both the short URL and retweet counts are cached.

• Use the short URL and retweet count for other purposes.
  The short URLs and retweet counts are stored as post meta-data. This makes it easy to display this data anywhere else in a post. The retweet count data could be used for conditional template logic. For example, you could order posts based on the number of retweets, apply custom styles to your most retweeted posts, or display your most tweeted posts in a widget.

• Easy to add Google Analytics campaign and event tracking.
  The Tweet Button is simple HTML and you have control over all the information that is sent to Twitter. Therefore, it is possible to use Google Analytics to help answer questions like: are people sharing your posts from the homepage or the post itself? If the Tweet Button is displayed above and below your posts, which gets the most clicks? How long do people take to click the Tweet Button? How many people are visiting my site thanks to links posted on Twitter using the Tweet Button?

• Approximate the number of retweets for old posts.
  Before the release of the official Tweet Button, Twitter did not collect data on the number of times a URL was tweeted. This means your older posts may display far fewer retweets than actually occurred. However, there is a workaround. Use a service like Topsy, Backtype, or Tweetmeme to get the number of times your old post was retweeted. The difference between this and the number from Twitter’s APIs is the approximate number of retweets Twitter missed. To correct the retweet count for old posts add the number of missed retweets to a Custom Field called retweet_count_start.

How the custom Tweet Button works

Once a post is published its permalink URL is shortened using the bit.ly API.

The returned URL is permanently cached in the bitly_short_url Custom Field. The short URL is now part of the post’s general meta-data and can be used in contexts other than the Tweet Button.

The Twitter API is used to get the number of retweets for the post’s permalink URL. This number, along with the time at which it was requested, is cached in the retweet_cache Custom Field. When the cache interval has passed, an API call is made and the returned number of retweets is checked against the value stored in retweet_cache. If the returned number is greater, the value of retweet_cache is updated.

The content of the tweet is automatically created by setting several properties for the http://twitter.com/share URL. The post title makes up the message; the short URL is passed to Twitter as the URL to be displayed in the tweet; the permalink URL is passed to Twitter as the URL to be counted; and your username is declared.

$twitter_params =
'?text=' . urlencode($title) .
'&url=' . urlencode($short_url) .
'&counturl=' .urlencode($url).
'&via=' . $twitter_via;

The default HTML output is very simple and can be fully customised. To display the count number vertically, add the class vcount.

<div class="twitter-share vcount>
   <a class="twitter-button"
      rel="external nofollow"
      title="Share this on Twitter"
      href="http://twitter.com/share?query-string-params"
      target="_blank">Tweet</a>
   <a class="twitter-count" href="http://twitter.com/search?q=url>259</a>
</div>

Further enhancements

Please apply any improvements or enhancements for the script against the source repository.

Did you know that you can build your own CSS preprocessor with Node.js libraries? They can be used alongside established preprocessors like Sass, and are useful for defining tasks beyond preprocessing.

Libraries like Rework and PostCSS let you create and assemble an arbitrary collection of plugins that can inspect or manipulate CSS.

At the time of writing, Twitter uses Rework to perform various tasks against our CSS source code for twitter.com.

Creating a CSS preprocessor with Rework

At its core, Rework is a module that accepts a string of CSS, produces a CSS abstract syntax tree (AST), and provides an API for manipulating that AST. Plugins are functions that have access to the AST and a Rework instance. Rework lets you chain together different plugins and generate a string of new CSS when you’re done.

The source string is passed into the rework function and each plugin is applied with .use(fn). The plugins transform the data in the AST, and .toString() generates the new string of CSS.

Below is an example of a custom preprocessor script using Rework and Autoprefixer. It’s a simplified version of the transformation step we use for twitter.com’s CSS.

var autoprefixer = require('autoprefixer');
var calc = require('rework-calc');
var rework = require('rework');
var vars = require('rework-vars')();

var css = fs.readFileSync('./css/main.css', 'utf-8');

css = rework(css)
  .use(vars)
  .use(calc)
  .toString();

css = autoprefixer().process(css);

fs.writeFileSync('./build/bundle.css', css)

The script runs rework-vars, rework-calc, and then passes the CSS to Autoprefixer (which uses PostCSS internally) to handle the addition of any necessary vendor prefixes.

rework-vars provides a limited subset of the features described in the W3C-style CSS custom property spec. It’s not a polyfill!

Variables can be declared as custom CSS properties on the :root element, prefixed with --. Variables are referenced with the var() function, taking the name of a variable as the first argument and an optional fallback as the second.

For example, this source:

:root {
  --width-button: 200px;
}

.button {
  width: var(--width-button);
}

yields:

.button {
  width: 200px;
}

There are many different Rework plugins that you can use to create a custom preprocessor. A more complete list is available on npm. In order to limit the chances of long-term divergence between our source code and native CSS, I’ve chosen to stick fairly closely to features that are aligned with future additions to native CSS.

Creating your own Rework plugin

Rework plugins are functions that inspect or mutate the AST they are provided. Below is a plugin that rewrites the value of any font-family property to sans-serif.

module.exports = function plugin(ast, reworkInstance) {
  ast.rules.forEach(function (rule) {
    if (rule.type != 'rule') return;

    rule.declarations.forEach(function (declaration, index) {
      if (declaration.property == 'font-family') {
        declaration.value = 'sans-serif';
      }
    });
  });
};

Rework uses css-parse to create the AST. Unfortunately, both projects are currently lacking comprehensive documentation of the AST, but it’s not difficult to piece it together yourself.

Beyond preprocessing

Since Rework and PostCSS expose an AST and provide a plugin API, they can be used for other CSS tasks, not just preprocessing.

At Twitter, our CSS build pipeline allows you to perform custom tasks at 2 stages of the process: on individual files and on generated bundles. We use Rework at both stages.

Individual files are tested with rework-suit-conformance to ensure that the SUIT-style CSS for a component is properly scoped.

/** @define MyComponent */

:root {
  --property-MyComponent: value;
}

.MyComponent {}

Bundles are preprocessed as previously described, and also tested with rework-ie-limits to ensure that the number of selectors doesn’t exceed IE 8/9’s limit of 4095 selectors per style sheet.

Other tasks you can perform include generating RTL style sheets (e.g., css-flip) and extracting detailed information about the perceived health of your CSS (e.g., the number of different colours used, duplicate selectors, etc.).

Hopefully this has given you a small glimpse into some of the benefits and flexibility of using these tools to work with CSS.