SANDcamp: Introduction to Site Building

2018-03-23 09:00 - 17:00 America/Los_Angeles




Event type: 

Training (free or commercial)

Learn the basics of building a CMS (content management system) based website using Drupal 8 — a completely customizable, flexible, and scalable open-source framework. This introduction will give you all of the essentials required to produce a straightforward site, customize your content and displays, and enough knowledge to find more targeted information for unique customizations as you progress through your Drupal site building adventures.
This training is being offered by STAUFFER – - for free as part of the Drupal Global Training Days initiative.

Training Agenda
Morning: Part I
Introduction: What is Drupal?
Getting Set Up Quickly
Basic Site Configuration
Basic Content Creation
Navigation / Structure:
-- The Menu System
-- Taxonomy
Morning: Part II
Going beyond OOTB (out of the box) Options
-- Changing functionality with Contributed Modules
-- Customizing your Content Types
-- Customizing your Taxonomy
What Are Entities
The Blocks System
The Comments System
Afternoon: Part III
How (and what) Content is Displayed
-- Views
-- Contextual Filters and Relationships
-- View Modes
Afternoon: Part IV
Part four will largely depend on you and your interests. First, we will need to finish up or clarify anything from the earlier parts. Beyond that, topics we can cover will include:
Media (Images, Videos, YouTube, etc., as well as responsive breakpoints)
Installing (and using) a Contributed Theme
Creating a custom sub-theme or entirely custom theme
Multilingual behavior
Managing Users/Roles/Permissions/Access beyond the surface discussion from Part I
Development environments and configuration management
You will choose which of these topics we explore with what time is available.
What You Need
We will use the Pantheon sandbox to build our sites during this workshop, so you do not need to install anything special onto your system. You do need a wireless capable laptop, as this is a hands-on workshop.
You do not need any coding skills to get started as a Drupal Site Builder, but the more you know (especially related to HTML5, CSS, SASS, PHP, Twig, MySQL, and jQuery), the more successful you will be.
If you have not already done so, please set up a user account on before this workshop. It will make it easier for you to participate in the issue queues and be an active community member.

DrupalCoin Blockchain Web Developer - KSN Technologies, Inc. - Madison, WI

DrupalCoin Blockchain Web Developer Location:. JavaScript based responsive HTML5 applicationsWorking knowledge with web portals and portlets5+ years’ experience in web...
From Dice - Tue, 05 Dec 2017 05:20:39 GMT - View all Madison, WI jobs
Source: Blockchain+Developer

Editing the W3C HTML5 spec

Bruce Lawson has been tapped to co-edit the W3C HTML5 spec and, in his announcement post, clarified the difference between that and the WHATWG spec:
The WHATWG spec is a future-facing document; lots of ideas are incubated there. The W3C spec is a snapshot of what works interoperably – authors who don’t care much about what may or may not be round the corner, but who need solid advice on what works now may find this spec easier to use.
I was honestly unfamiliar with the WHATWG spec and now I find it super interesting to know there are two working groups pushing HTML forward in distinct but (somewhat) cooperative ways.
Kudos to you, Bruce! And, yes, Vive open standards!
Direct Link to Article — Permalink
Editing the W3C HTML5 spec is a post from CSS-Tricks
Source: CssTricks

Happier HTML5 Form Validation

HTML has given us loads of form validation stuff in the last few years. Dave Rupert puts a point on the UX problems with it:
If you’ve ever experimented with HTML5 Form Validation, you’ve probably been disappointed. The out-of-box experience isn’t quite what you want. Adding the required attribute to inputs works wonderfully. However the styling portion with input:invalid sorta sucks because empty inputs are trigger the :invalid state, even before the user has interacted with the page.
Fortunately, there is an invalid DOM event that does fire with useful timing: when the form is submitted. Remember this doesn't buy you super deep browser support though. If you need that, look into polyfilling. I imagine the future of form validation is either HTML/CSS offering better and more controllable UX, or this.
Direct Link to Article — Permalink
Happier HTML5 Form Validation is a post from CSS-Tricks
Source: CssTricks

How to Disable Links

The topic of disabling links popped up at my work the other day. Somehow, a "disabled" anchor style was added to our typography styles last year when I wasn't looking. There is a problem though: there is no real way to disable an <a> link (with a valid href attribute) in HTML. Not to mention, why would you even want to? Links are the basis of the web.
At a certain point, it looked like my co-workers were not going to accept this fact, so I started thinking of how this could be accomplished. Knowing that it would take a lot, I wanted to prove that it was not worth the effort and code to support such an unconventional interaction, but I feared that by showing it could be done they would ignore all my warnings and just use my example as proof that it was OK. This hasn't quite shaken out for me yet, but I figured we could go through my research.

First, things first:
Just don't do it.
A disabled link is not a link, it's just text. You need to rethink your design if it calls for disabling a link.
Bootstrap has examples of applying the .disabled class to anchor tags, and I hate them for it. At least they mention that the class only provides a disabled style, but this is misleading. You need to do more than just make a link look disabled if you really want to disable it.
Surefire way: remove the href
If you have decided that you are going to ignore my warning and proceed with disabling a link, then removing the href attribute is the best way I know how.
Straight from the official Hyperlink spec:
The href attribute on a and area elements is not required; when those elements do not have href attributes they do not create hyperlinks.
An easier to understand definition from MDN:
This attribute may be omitted (as of HTML5) to create a placeholder link. A placeholder link resembles a traditional hyperlink, but does not lead anywhere.
Here is basic JavaScript code to set and remove the href attribute:
* Use your preferred method of targeting a link
* document.getElementById('MyLink');
* document.querySelector('.link-class');
* document.querySelector('[href=""]');
// "Disable" link by removing the href property
link.href = '';
// Enable link by setting the href property
link.href = '';
Styling this via CSS is also pretty straightforward:
a {
/* Disabled link styles */
a:link, a:visited { /* or a[href] */
/* Enabled link styles */
That's all you need to do!
That's not enough, I want something more complex so that I can look smarter!
If you just absolutely have to over-engineer some extreme solution, here are some things to consider. Hopefully, you will take heed and recognize that what I am about to show you is not worth the effort.
First, we need to style our link so that it looks disabled.
.isDisabled {
color: currentColor;
cursor: not-allowed;
opacity: 0.5;
text-decoration: none;
<a class="isDisabled" href="">Disabled Link</a>

Setting color to currentColor should reset the font color back to your normal, non-link text color. I am also setting the mouse cursor to not-allowed to display a nice indicator on hover that the normal action is not allowed. Already, we have left out non-mouse users that can't hover, mainly touch and keyboard, so they won't get this indication. Next the opacity is cut to half. According to WCAG, disabled elements do not need to meet color contrast guidelines. I think this is very risky since it's basically plain text at this point, and dropping the opacity in half would make it very hard to read for users with low-vision, another reason I hate this. Lastly, the text decoration underline is removed as this is usually the best indicator something is a link. Now this looks like a disabled link!
But it's not really disabled! A user can still click/tap on this link. I hear you screaming about pointer-events.
.isDisabled {
pointer-events: none;
Ok, we are done! Disabled link accomplished! Except, it's only really disabled for mouse users clicking and touch users tapping. What about browsers that don't support pointer-events? According to caniuse, this is not supported for Opera Mini and IE<11. IE11 and Edge actually don't support pointer-events unless display is set to block or inline-block. Also, setting pointer-events to none overwrites our nice not-allowed cursor, so now mouse users will not get that additional visual indication that the link is disabled. This is already starting to fall apart. Now we have to change our markup and CSS...
.isDisabled {
cursor: not-allowed;
opacity: 0.5;
.isDisabled > a {
color: currentColor;
display: inline-block; /* For IE11/ MS Edge bug */
pointer-events: none;
text-decoration: none;
<span class="isDisabled"><a href="">Disabled Link</a></span>
Wrapping the link in a <span> and adding the isDisabled class gives us half of our disabled visual style. A nice side-affect here is that the disabled class is now generic and can be used on other elements, like buttons and form elements. The actual anchor tag now has the pointer-events and text-decoration set to none.
What about keyboard users? Keyboard users will use the ENTER key to activate links. pointer-events are only for pointers, there is no keyboard-events. We also need to prevent activation for older browsers that don't support pointer-events. Now we have to introduce some JavaScript.
Bring in the JavaScript
// After using preferred method to target link
link.addEventListener('click', function (event) {
if (this.parentElement.classList.contains('isDisabled')) {
Now our link looks disabled and does not respond to activation via clicks, taps, and the ENTER key. But we are still not done! Screen reader users have no way of knowing that this link is disabled. We need to describe this link as being disabled. The disabled attribute is not valid on links, but we can use aria-disabled="true".
<span class="isDisabled"><a href="" aria-disabled="true">Disabled Link</a></span>
Now I am going to take this opportunity to style the link based on the aria-disabled attribute. I like using ARIA attributes as hooks for CSS because having improperly styled elements is an indicator that important accessibility is missing.
.isDisabled {
cursor: not-allowed;
opacity: 0.5;
a[aria-disabled="true"] {
color: currentColor;
display: inline-block; /* For IE11/ MS Edge bug */
pointer-events: none;
text-decoration: none;
Now our links look disabled, act disabled, and are described as disabled.
Unfortunately, even though the link is described as disabled, some screen readers (JAWS) will still announce this as clickable. It does that for any element that has a click listener. This is because of developer tendency to make non-interactive elements like div and span as pseudo-interactive elements with a simple listener. Nothing we can do about that here. Everything we have done to remove any indication that this is a link is foiled by the assistive technology we were trying to fool, ironically because we have tried to fool it before.
But what if we moved the listener to the body?
document.body.addEventListener('click', function (event) {
// filter out clicks on any other elements
if ( == 'A' &&'aria-disabled') == 'true') {
Are we done? Well, not really. At some point we will need to enable these links so we need to add additional code that will toggle this state/behavior.
function disableLink(link) {
// 1. Add isDisabled class to parent span
// 2. Store href so we can add it later
link.setAttribute('data-href', link.href);
// 3. Remove href
link.href = '';
// 4. Set aria-disabled to 'true'
link.setAttribute('aria-disabled', 'true');
function enableLink(link) {
// 1. Remove 'isDisabled' class from parent span
// 2. Set href
link.href = link.getAttribute('data-href');
// 3. Remove 'aria-disabled', better than setting to false
That's it. We now have a disabled link that is visually, functionally, and semantically disabled for all users. It only took 10 lines of CSS, 15 lines of JavaScript (including 1 listener on the body), and 2 HTML elements.
Seriously folks, just don't do it.

How to Disable Links is a post from CSS-Tricks
Source: CssTricks

ARIA is Spackle, Not Rebar

Much like their physical counterparts, the materials we use to build websites have purpose. To use them without understanding their strengths and limitations is irresponsible. Nobody wants to live in an poorly-built house. So why are poorly-built websites acceptable?
In this post, I'm going to address WAI-ARIA, and how misusing it can do more harm than good.

Materials as technology
In construction, spackle is used to fix minor defects on interiors. It is a thick paste that dries into a solid surface that can be sanded smooth and painted over. Most renters become acquainted with it when attempting to get their damage deposit back.
Rebar is a lattice of steel rods used to reinforce concrete. Every modern building uses it—chances are good you'll see it walking past any decent-sized construction site.
Technology as materials
HTML is the rebar-reinforced concrete of the web. To stretch the metaphor, CSS is the interior and exterior decoration, and JavaScript is the wiring and plumbing.
Every tag in HTML has what is known as native semantics. The act of writing an HTML element programmatically communicates to the browser what that tag represents. Writing a button tag explicitly tells the browser, "This is a button. It does buttony things."
The reason this is so important is that assistive technology hooks into native semantics and uses it to create an interface for navigation. A page not described semantically is a lot like a building without rooms or windows: People navigating via a screen reader have to wander around aimlessly in the dark and hope they stumble onto what they need.
ARIA stands for Accessible Rich Internet Applications and is a relatively new specification developed to help assistive technology better communicate with dynamic, JavaScript-controlled content. It is intended to supplement existing semantic attributes by providing enhanced interactivity and context to screen readers and other assistive technology.
Using spackle to build walls
A concerning trend I've seen recently is the blind, mass-application of ARIA. It feels like an attempt by developers to conduct accessibility compliance via buckshot—throw enough of something at a target trusting that you'll eventually hit it.
Unfortunately, there is a very real danger to this approach. Misapplied ARIA has the potential to do more harm than good.
The semantics inherent in ARIA means that when applied improperly it can create a discordant, contradictory mess when read via screen reader. Instead of hearing, "This is a button. It does buttony things.", people begin to hear things along the lines of, "This is nothing, but also a button. But it's also a deactivated checkbox that is disabled and it needs to shout that constantly."
If you can use a native HTML element or attribute with the semantics and behavior you require already built in, instead of re-purposing an element and adding an ARIA role, state or property to make it accessible, then do so.
– First rule of ARIA use
In addition, ARIA is a new technology. This means that browser support and behavior is varied. While I am optimistic that in the future the major browsers will have complete and unified support, the current landscape has gaps and bugs.
Another important consideration is who actually uses the technology. Compliance isn't some purely academic vanity metric we're striving for. We're building robust systems for real people that allow them to get what they want or need with as little complication as possible. Many people who use assistive technology are reluctant to upgrade for fear of breaking functionality. Ever get irritated when your favorite program redesigns and you have to re-learn how to use it? Yeah.
The power of the Web is in its universality. Access by everyone regardless of disability is an essential aspect.
– Tim Berners-Lee
It feels disingenuous to see the benefits of the DRY principal of massive JavaScript frameworks also slather redundant and misapplied attributes in their markup. The web is accessible by default. For better or for worse, we are free to do what we want to it after that.
The fix
This isn't to say we should completely avoid using ARIA. When applied with skill and precision, it can turn a confusing or frustrating user experience into an intuitive and effortless one, with far fewer brittle hacks and workarounds.
A little goes a long way. Before considering other options, start with markup that semantically describes the content it is wrapping. Test extensively, and only apply ARIA if deficiencies between HTML's native semantics and JavaScript's interactions arise.
Development teams will appreciate the advantage of terse code that's easier to maintain. Savvy developers will use a CSS-Trick™ and leverage CSS attribute selectors to create systems where visual presentation is tied to semantic meaning.
[aria-invalid] {
border: 4px dotted #f64100;
Here are a few of the more common patterns I've seen recently, and why they are problematic. This doesn't mean these are the only kinds of errors that exist, but it's a good primer on recognizing what not to do:
<li role="listitem">Hold the Bluetooth button on the speaker for three seconds to make the speaker discoverable</li>
The role is redundant. The native semantics of the li element already describe it as a list item.
<p role="command">Type CTRL+P to print
command is an Abstract Role. They are only used in ARIA to help describe its taxonomy. Just because an ARIA attribute seems like it is applicable doesn't mean it necessarily is. Additionally, the kbd tag could be used on "CTRL" and "P" to more accurately describe the keyboard command.
<div role="button" class="button">Link to device specifications</div>
Failing to use a button tag runs the risk of not accommodating all the different ways a user can interact with a button and how the browser responds. In addition, the a tag should be used for links.
<body aria-live="assertive" aria-atomic="true">
Usually the intent behind something like this is to expose updates to the screen reader user. Unfortunately, when scoped to the body tag, any page change—including all JS-related updates—are announced immediately. A setting of assertive on aria-live also means that each update interrupts whatever it is the user is currently doing. This is a disastrous experience, especially for single page apps.
<div aria-checked="true"></div>
You can style a native checkbox element to look like whatever you want it to. Better support! Less work!
<div role="link" tabindex="40">
Link text
Yes, it's actual production code. Where to begin? First, never use a tabindex value greater than 0. Secondly, the title attribute probably does not do what you think it does. Third, the anchor tag should have a destination—links take you places, after all. Fourth, the role of link assigned to a div wrapping an a element is entirely superfluous.
<h2 class="h3" role="heading" aria-level="1">How to make a perfect soufflé every time</h2>
Credit is where credit's due: Nicolas Steenhout outlines the issues for this one.
Do better
Much like content, markup shouldn't be an afterthought when building a website. I believe most people are genuinely trying to do their best most of the time, but wielding a technology without knowing its implications is dangerous and irresponsible.
I'm usually more of a honey-instead-of-vinegar kind of person when I try to get people to practice accessibility, but not here. This isn't a soft sell about the benefits of developing and designing with an accessible, inclusive mindset. It's a post about doing your job.
Every decision a team makes affects a site's accessibility.
– Laura Kalbag
Get better at authoring
Learn about the available HTML tags, what they describe, and how to best use them. Same goes for ARIA. Give your page template semantics the same care and attention you give your JavaScript during code reviews.
Get better at testing
There's little excuse to not incorporate a screen reader into your testing and QA process. NVDA is free. macOS, Windows, iOS and Android all come with screen readers built in. Some nice people have even written guides to help you learn how to use them.
Automated accessibility testing is a huge boon, but it also isn't a silver bullet. It won't report on what it doesn't know to report, meaning it's up to a human to manually determine if navigating through the website makes sense. This isn't any different than other usability testing endeavors.
Build better buildings
Universal Design teaches us that websites, like buildings, can be both beautiful and accessible. If you're looking for a place to start, here are some resources:

A Book Apart: Accessibility for Everyone, by Laura Kalbag Intro to ARIA and Start Building Accessible Web Applications Today, by Marcy Sutton
Google Developers: Introduction to ARIA, by Meggin Kearney, Dave Gash, and Alice Boxhall
YouTube: A11ycasts with Rob Dodson, by Rob Dodson
W3C: WAI-ARIA Authoring Practices 1.1
W3C: Using ARIA
Zomigi: Videos of screen readers using ARIA
Inclusive Components, by Heydon Pickering
HTML5 Accessibility
The American Foundation for the Blind: Improving Your Website's Accessibility
Designing for All: 5 Ways to Make Your Next Website Design More Accessible, by Carie Fisher
Accessible Interface Design, by Nick Babich

ARIA is Spackle, Not Rebar is a post from CSS-Tricks
Source: CssTricks

Apple’s Proposal for HTML Template Instantiation

I'm sure I don't have the expertise to understand the finer nuances of this, but I like the spirit:

The HTML5 specification defines the template element but doesn't provide a native mechanism to instantiate it with some parts of it substituted, conditionally included, or repeated based on JavaScript values — as popular JavaScript frameworks such as Ember.js and Angular allow. As a consequence, there are many incompatible template syntaxes and semantics to do substitution and conditionals within templates — making it hard for web developers to combine otherwise reusable components when they use different templating libraries.
Whilst previously we all decided to focus on shadow DOM and the custom-elements API first, we think the time is right — now that shadow DOM and custom-elements API have been shipping in Safari and Chrome and are in integrationin Firefox — to propose and standardize an API to instantiate HTML templates.

Let the frameworks compete on speed and developer convenience in other ways.
Direct Link to Article — Permalink
Apple’s Proposal for HTML Template Instantiation is a post from CSS-Tricks
Source: CssTricks

6 Reasons Why Web Design Is Not A Dying Profession

In recent years, there have been many concerns about web design as a profession. People are worried that the major advancements in technology, especially artificial intelligence, are a threat to this field. However, a group of people still argues that there’s still hope. So, we’ll be taking a look at reasons why web design is not a dying profession.

Why Is It Seen As A Dying Profession?
Before we get started on the reasons why web design isn’t a dying profession, let’s see why people think it is. In this article, the term web design will be used to refer to both design and front end development. This involves the process of designing the website and coding the design.
If you’ve been using the internet, then you’ve definitely noticed numerous adverts for both free and paid website builders. These types of websites allow users to create fully functional websites without knowing a single line of html, CSS, JavaScript, PHP or any other code. This is done by using a pre-coded interface and adding components from a menu or using drag and drop. There are also many platforms and apps that make it easy to design websites. With all these technology and more upcoming ones, it’s easy to think that web design is on the brink of extinction.
6 Reasons Why Web Designing Is Not A Dying Profession
1. Human Touch
Human-made websites will always beat the automatically generated ones any time. When a real person works on a website, they are able to incorporate exactly what the owner wants. The final website captures the feelings and identity of a brand and also carries out all functions required. A web designer is able to carry out specialised branding for each client. At the same time, a human is able to design pages that progress a brand. Branding is an important aspect of web design. On the other hand, the generated websites are merely functional. They also have a threshold that can’t be exceeded. Such websites are rigid and may contain more or less features than required. In addition, generated websites or “build-it-yourself” aren’t unique since one design is used by different people and brands at any given time. With this in mind, it comes as no surprise that a large number of individuals and business will still choose to hire a web designer to create a website that meets their demands.
2. Website Security
Security is important on every website. It’s absence is detrimental to an individual, company or brand. Website security breaches lead to leaking of crucial personal and business information. This can ruin the reputation of the owner and even lead to massive losses for businesses. Websites that collect and store user information are at a great risk of such attacks. To avoid these scenarios, websites have to be regularly updated to make sure that their security is up to date. This way, hackers won’t be able to easily find vulnerabilities. That’s why it is important to hire a competent web designer to maintain a website and patch up any problem areas.
3. Web Design Knowledge
The tools that are available for generating websites are useful only to a certain extent. Web designers have extensive knowledge on how to code different components and functionalities in a website. They also know how to rectify problematic areas and make updates. In most cases, even people who use the “build-it-yourself” websites end up consulting a professional web designer. They do this when they get stuck or are not sure what to do next. At times, they even have their websites redesigned or built from scratch by a web designer. In other cases, owners build the sites on their own but require professional help when the site expands. Even web designers hire fellow web designers to assist them with specific tasks on their personal websites. This shows that web design knowledge is important and is still viable.
4. Quality
There are many websites that are currently using WordPress, DrupalCoin Blockchain, Joomla and other similar platforms especially for blogging. They all offer standard designs and different themes for users to choose from. Despite the fact that they offer themes and offer a lot of instructions to help users, getting higher quality is not easy. It requires the intervention of web designers to make these platforms have great quality. As much as these platforms exist, they won’t eliminate the need for web designers. A professional is still needed to work on the finer details in set-up, maintenance and design to ensure high quality.
5. Web Design Is An Art
Art has been in existence for thousands of years. We can’t say that art is dead, it has simply evolved. This is the same case when it comes to web design. Since it’s an art, it evolves with time. In order to keep up, web designers need to have the yearning to learn new things and adapt to changes. New tools, platforms and approaches to web design are coming up daily. Web designers are not about to loose their jobs soon, they simply need to evolve together with the industry.
6. An Expanding Market
Website designers are on demand now more than ever. If you look at the careers page on most company websites, there’s a high chance that you’ll find a vacancy for a web designer or front end developer. Having an online presence is important for businesses hence the growing demand for website designers. In addition to company websites, html5 and JavaScript are being used widely to develop web apps as well as mobile apps. This has opened up a whole new field for web designers. Most major brands and corporations  rely on their websites to create exposure and boost business. Because of this, they always hire web designers to take care of the online outlook of their businesses.
All in all, although many website builders and CMS providers seem to have advanced capabilities, they still aren’t capable of carrying out more complex tasks. There will always be a need for complex solutions incorporated in website design which can only be done by web designers. This is why web designing is not a dying profession. It might be changing, but it surely isn’t dying.
The post 6 Reasons Why Web Design Is Not A Dying Profession appeared first on Web Designer Hub.

Web Developer, Front-End - George Washington University - Foggy Bottom, MD

DrupalCoin Blockchain 7 experience (required). Experience building responsive websites using DrupalCoin Blockchain CMS , HTML /HTML5, CSS /CSS3, and JavaScript/jQuery....
From George Washington University - Mon, 21 Aug 2017 16:25:18 GMT - View all Foggy Bottom, MD jobs
Source: Blockchain+Developer

Front End Developer - R2integrated, LLC - Maplewood, MO

REQUIRED KNOWLEDGE, SKILLS, AND ABILITIES 3-5 years of experience with HTML5, CSS3, and Adobe Creative Suites (Photoshop, Dreamweaver, Illustrator, Fireworks)...
From R2integrated, LLC - Tue, 15 Aug 2017 17:25:28 GMT - View all Maplewood, MO jobs
Source: Blockchain+Developer

Web Developer - MARC USA - Pittsburgh, PA

Basic CMS WordPress, DrupalCoin Blockchain etc. Google Web Developer (HTML5 Banner Creation Tool). You’ll be working closely with the strategists, creatives and other...
From MARC USA - Fri, 11 Aug 2017 01:34:48 GMT - View all Pittsburgh, PA jobs
Source: Blockchain+Developer

15 Useful JavaScript Libraries to Enhance Your Site

Inspired Magazine
Inspired Magazine - creativity & inspiration daily
Making a great site requires a lot of skills, but you don’t always have to develop everything completely from scratch. To use any of the JavaScript libraries presented in this article, you will need to have at least some existing JavaScript skills, but you also don’t necessarily need to be an expert.
What you do need to be expert with is working out how to blend the libraries into a site to get the most benefit from them. This isn’t really something that can be taught. It’s a skill you can only learn by doing. Once you have mastered the concepts, however, there is no limit to your creativity and what you can achieve with it.
Collected here is our list of the most useful JavaScript libraries available to programmers for site enhancement. You may not see your favorite listed here, but that doesn’t mean it’s not recommended. In fact any JavaScript library that helps you achieve something worthwhile can’t be dismissed.  But with literally millions of libraries to choose from, we have to draw the line somewhere.
1. jQuery
It’s best to start out with the obvious.  You’re almost certainly already using this library in some way, even if you don’t already know it.  Essentially, jQuery lets you do dynamic things to static web pages more easily than other methods, and doesn’t require server-side programming to achieve the results.  This also means that updates can happen more quickly than with server-side alternatives. Many other libraries include jQuery as a dependency, so you’ll probably need to incorporate it into your pages even if you don’t directly access its features.

2. Prototype
This, in a way, could be considered a competitor to jQuery. It’s not necessarily inferior, but it is much less widely adopted. Using prototype and jQuery together can lead to conflicts, unless you take special steps to deal with this problem.  This is why you need to know the dependencies within the other JavaScript libraries you use.
3. Modernizr
This library helps to overcome problems with page rendering on older browsers that don’t fully support HTML5.  While such browsers are becoming more rarely encountered, they are still part of the landscape and having Modernizr can help you deal with the problem in an efficient way.
4. Bootstrap
In just six short years, Bootstrap has achieved enormous proliferation throughout the world of web development. It is solely concerned with UI layout and component integration, but it does this very well. You will need to modify the default settings for just about everything, however, because they’re based on Twitter’s color scheme, which isn’t the most user-friendly of user interfaces.

5. PDF.js
You may know that the PDF format is subject to certain vulnerabilities. To get around this problem, PDF.js was created to render PDF content into the HTML5 Canvas. Obviously this also means it only works in a browser that supports HTML5 and Canvas.
6. JS Charts
An excellent library that provides a simple yet powerful graph generator, so you can create all kinds of professional looking charts for your site without investing too much time and effort. The free version is equally powerful compared to the paid version, but includes a watermark.  Purchasing a license removes this watermark.
7. Chart.js
This is a really good, completely free, unwatermarked alternative to JS Charts.  It is easy to use, well-documented, and can be customized in endless ways. Using it requires a little more JavaScript skill than JS Charts.

8. D3.js
This is a bigger brother to the previous two examples, which are intended for lightweight use.  If you’re crunching data in the big leagues, however, D3 offers you the advanced features that can take your online presentation to the next level. Any kind of data can be visualized and expressed in a staggering number of ways. Just check the examples on the D3 website to see what you’ve been missing out on.
9. bHive
A great graphics framework that is as revolutionary to the HTML5 Canvas as Raphaël was to HTML4. bHive allows you to quickly create SVG graphics, animations, and even to incorporate interactivity which could be used in numerous different ways, such as simple games and education applications.

10. Owl Carousel
While over-use of carousels is not to be encouraged, for those times when you really do need to use one, Owl is one of the most highly recommended carousel plug-ins ever created for jQuery. It’s compatible with both touch screens and pointing devices.  It supports swipe and drag-n-drop. It is fully customizable and is responsive by default.

11. Date.js
Sometimes you need to be able to express date information in different ways to give a site context. The features of Date.js allow you to do just this very thing, using a very straight-forward syntax that couldn’t be easier to learn.
13. Moment.js
Another date formatting and processing library. It’s a little more complex than Date.js but allows you to do certain specific calculations easily (isAfter, isBefore, isSameOrAfter, isSameOrBefore, isBetween, isLeapYear, isDate, and so on). When you don’t need all the overhead that comes with these extra features, use Date.js instead.
13. dateDropper
When you need to display a calendar / datepicker control on your site, dateDropper is the most elegant and simple solution we’ve ever seen (and we’ve seen a lot). It’s also more compatible with mobile interfaces than many of the other solutions out there.

13. Numeral.js
Does for numbers what Date.js does for dates.
14. wForms
A simple but useful library maintained by on the Google Code archive, wForms makes easy work of common tasks related to user input forms. These include input validation, tool tips, and other useful features.
15. sortTable
Sortable tables have been around for almost as long as tables have (data tables, anyway). But with this hand JavaScript library, you can make any table sortable easily just by adding a class to the table when you create it, which is as simple as: <table class=”sortable”>
header image courtesy of Rogie
This post 15 Useful JavaScript Libraries to Enhance Your Site was written by Inspired Mag Team and first appearedon Inspired Magazine.

Aspect Ratio Boxes

I had a little situation the other I needed to make one of those aspect-ratio friendly boxes. This isn't particularly new stuff. I think the original credit goes as far back as 2009 and Thierry Koblentz's Intrinsic Ratios and maintained popularity even for other kinds of content with articles like Uncle Dave's Ol' Padded Box.
Let's go on a little journey through this concept, as there is plenty to talk about.

The Core Concept: padding in percentages is based on width
Even when that is a little unintuitive, like for vertical padding. This isn't a hack, but it is weird: padding-top and padding-bottom is based on an element's width. So if you had an element that is 500px wide, and padding-top of 100%, the padding-top would be 500px.
Isn't that a perfect square, 500px × 500px? Yes, it is! An aspect ratio!
If we force the height of the element to zero (height: 0;) and don't have any borders. Then padding will be the only part of the box model affecting the height, and we'll have our square.
Now imagine instead of 100% top padding, we used 56.25%. That happens to be a perfect 16:9 ratio! (9 / 16 = 0.5625).
Now we have a friendly aspect ratio box, that works well in fluid width enviornments. If the width changes, so does the height and keeps that aspect ratio.

Use case: a background-image
Perhaps we've made a typogrpahic lockup. It's for the title of an article, so it makes sense to use an <h1> tag.
Happy Birthday
We can make that <h1> tag the aspect ratio box and apply the lockup as a background image.
h1 {
overflow: hidden;
height: 0;
padding-top: 56.25%;
background: url(/images/happy-birthday.svg);

But I lied about that aspect ratio up there. It's not actually a 16:9 image. I just downloaded that graphic off a stock photography site. It happens to be an SVG with a viewBox="0 0 1127.34 591.44" which means it's essentially an 1127.34 × 591.44 image in terms of aspect ratio. Or it could have been a 328 × 791 image.
I'd say it's very common for any random image not to fit into a very specific pre-definied aspect ratio...
The Math of Any Possible Aspect Ratio
Perfect squares and 16:9 stuff is great, but the values used for those are just simple math. An apsect ratio can be anything, and they commonly are completely arbitrary. A video or image can be cropped to any size.
So how do we figure out the padding-top for our 1127.34 × 591.44 SVG above?
One way is using calc(), like this:
padding-top: calc(591.44 / 1127.34 * 100%);
It was expressed to me not long ago that using calc() here may be "slower", but I've never seen any evidence of that. I imagine that yes, the computer does need to calcuate something, so in a head-to-head battle against a situation where it doesn't, calculating is slower. But a math problem doesn't seem like too much work for a computer. For example, the popular Intel Pentium III (released in 1999) could do 2,054 MIPS or "Millions of instructions per second", so it would made imperceptively quick work of a division problem. And now chips are 50× faster.
If we were using a preprocessor like Sass, we could do the calculation ahead of time:
padding-top: 591.44px / 1127.34px * 100%;
Either way, I'm a fan of leaving the math in the authored code.
How do you put content inside if padding is pushing everything down?
We hid the content in the demo above, by letting the content get pushed out and hiding the overflow. But what if you need an aspect ratio box while keeping content inside of it? That's slightly trickier. We'll need to position it back up into place. Absolute positioning can be up for that job.
Say we're just using text alone now, but still want the aspect ratio box. We'll need an inside wrapper for the absolute positioning. Let's get specific with our classnames:
<h1 class="aspect-ratio-box">
<div class="aspect-ratio-box-inside">
Happy Birthday
Then do the positioning:
.aspect-ratio-box {
height: 0;
overflow: hidden;
padding-top: 591.44px / 1127.34px * 100%;
background: white;
position: relative;
.aspect-ratio-box-inside {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
Just for fun, let's go full blast here and center that text and size it so it scales with the box:
<h1 class="aspect-ratio-box">
<div class="aspect-ratio-box-inside">
<div class="flexbox-centering">
<div class="viewport-sizing">
Happy Birthday
Few more classes to style:
.flexbox-centering {
height: 100%;
display: flex;
justify-content: center;
align-items: center;
.viewport-sizing {
font-size: 5vw;

Use Case: Video
This is probably the #1 most common and practical use case for all this aspect ratio box stuff. HTML5 <video> isn't an issue, as it behaves as if it has an aspect ratio just like <img>s do. But a lot of video on the web arrives in <iframe>s, which do not scale with an aspect ratio.
This is exactly what FitVids is all about. It finds videos on the page, figures out their unique aspect ratios, then applies these same CSS concepts to them to make them fluid width while maintaing their unique aspect ratios.

FitVids is jQuery based, but there are vanilla JavaScript options, like this one by Ross Zurowski.
But... what if there is too much content?
Back to abitrary (probably textual) content for a bit.
We're essentially setting heights here, which should always flash a blinking red light when working with CSS. The web likes to grown downward, and setting fixed heights is an enemy to that natural movement.
If the content becomes too much for the space, we're in Bad Design territory:
Bad Design Territory
Maybe we could do something like overflow: auto; but that might be Awkward Design Territory.
The Psuedo Element Tactic
This is what has become, I think, the best way to handle an aspect ratio box that has completely arbitrary content in it. Keith Grant has a good writeup on it. Marc Hinse had an explaination and demos back in 2013.
With this technique, you get the apsect ratio box with less markup, and it's still safe if the content exceeds the height.
The trick is to apply the % padding to a psuedo element instead of the box itself. You float the psuedo element, so the content inside can be inside nicely, then clear the float.
.aspect-ratio-box {
background: white;
.aspect-ratio-box::before {
content: "";
width: 1px;
margin-left: -1px;
float: left;
height: 0;
padding-top: 591.44px / 1127.34px * 100%;
.aspect-ratio-box::after { /* to clear float */
content: "";
display: table;
clear: both;
See how it's safer:

And a video:

Using Custom Properties
This is perhaps the coolest idea of all!
Thierry Koblentz recently wrote this up, crediting Sérgio Gomes for the idea.
To use it, you set a custom property scoped right to the element you need it on:
<div style="--aspect-ratio:815/419;">

<div style="--aspect-ratio:16:9;">

<!-- even single value -->
<div style="--aspect-ratio:1.4;">
The CSS that styles this is gosh-danged genius:
[style*="--aspect-ratio"] > :first-child {
width: 100%;
[style*="--aspect-ratio"] > img {
height: auto;
@supports (--custom:property) {
[style*="--aspect-ratio"] {
position: relative;
[style*="--aspect-ratio"]::before {
content: "";
display: block;
padding-bottom: calc(100% / (var(--aspect-ratio)));
[style*="--aspect-ratio"] > :first-child {
position: absolute;
top: 0;
left: 0;
height: 100%;
Allow me to quote Thierry's step-by-step explanation:

We use [style*="--aspect-ratio"] as a hook to target the appropriate boxes
We stretch the inner box regardless of support for custom property
We make sure the height of images comes from their intrinsic ratio rather than their height attribute
We style the container as a containing block (so the inner box references that ancestor for its positioning)
We create a pseudo-element to be used with the “padding hack” (it is that element that creates the aspect ratio)
We use calc() and var() to calculate padding based on the value of the custom property
We style the inner box so it matches the dimensions of its containing block

Other Ideas & Tools
Lisi Linhart tipped me off to Ratio Buddy, which is super cool:

Notice that it uses a psuedo element, but then still absolutely positions the inside container. That's kinda weird. You'd probably either skip the psuedo element and put the padding right on the container, or float the pseudo-element so you don't need that inner container. Still, I like the idea of a little generator for this.
Tommy Hodgins has CSSplus which features Aspecty which is just for this, assuming you're cool with a JavaScript parsing and changing your CSS kinda thing:
See the Pen Aspect Ratio for Chris by Chris Coyier (@chriscoyier) on CodePen.

I've actually seen quite a bit of real world usage of aspect ratio boxes over the years. Feel free to share if you've had some experience!

Aspect Ratio Boxes is a post from CSS-Tricks
Source: CssTricks

DrupalCoin Blockchain Developer (Module) - Hendall Inc. - Rockville, MD

Experience creating custom DrupalCoin Blockchain modules. Experience building responsive websites using DrupalCoin Blockchain CMS, HTML/HTML5, CSS/CSS3, and JavaScript/jQuery....
From Hendall Inc. - Thu, 01 Jun 2017 17:13:57 GMT - View all Rockville, MD jobs
Source: Blockchain+Developer

Web Developer - Booz Allen Hamilton - Washington, DC

1+ years of experience with developing solutions using Java, Angular, React, Python, Spring, HTML5, DrupalCoin Blockchain, CSS, or other software integrationlanguages....
From Booz Allen Hamilton - Tue, 30 May 2017 19:17:57 GMT - View all Washington, DC jobs
Source: Blockchain+Developer

Web Developer - Booz Allen Hamilton - Herndon, VA

1+ years of experience with developing solutions using Java, Angular, React, Python, Spring, HTML5, DrupalCoin Blockchain, CSS, or other software integrationlanguages....
From Booz Allen Hamilton - Tue, 30 May 2017 19:17:20 GMT - View all Herndon, VA jobs
Source: Blockchain+Developer

User Facing State

Let's talk about state. Communicating state to the user that is, not application stores state in JavaScript objects, or localStorage. We're going to be talking about how to let our users know about state (think: whether a button is disabled or not, or if a panel is active or not), and how we can use CSS for that. We're not going to be using inline styles, or, as much as can be helped, class selectors, for reasons that will become clear as we go.
Still here? Cool. Let's do this.

All dynamic components of an application have a default user-facing state, and that state needs to be stored and updated as users interact with these components.
For example, when a button is pressed, things happen (that's what buttons are for). When these things happen, they are typically represented in a visual manner in the interface. The button's background may change to indicate it was pressed. If the button controls other components in the interface, those components likely visually change in style, or in some cases their visibility is toggled. An item gets deleted, a notification pops up, an error style is applied, etc.
You may have noticed that we've been mentioning the "visual" state of components quite a bit. That's exactly the kind of problem I've been finding with a lot of tutorials, articles and general talking about state.
More often than not, developers are using "stateful" classes to manage a component's state. But this is sorely inadequate, as a component is composed of more than just how it looks. There are underlying semantics that need to be managed along with the component's visual representation. The failure to manage those underlying semantics becomes apparent as soon as you interact with it via keyboard and/or screen reader.
This is an article about appropriately conveying state so that users, beyond sighted, mouse-using users, can interact with our interfaces.
State is more than just how it looks
Outside of using CSS to appropriately hide content from sighted users and assistive technologies, CSS doesn't have many intentional effects on an element's semantics or accessible state. What I mean by that is outside of properties like the unsupported 'speak', before/after pseudo content, and media queries to specifically restyle components based on user preferences, like the Reduced Motion Media Query and other proposed User Queries, CSS alone is not meant to change an element's semantics, content or appropriately convey the state of an element in a meaningful way.
Why do I bring all this up? Because managing state with CSS classes alone is, mostly, inadequate for conveying state to all users. Being a language for presentational purposes, giving an input a class of .has-error to change the border color to a shade of red, has no semantic value to it. For all CSS cares, "That's how you wanted to style that input. Cool. I got your back! Just don't ask me to style upwards in the DOM. I draw the line there, buddy..."
Instead, to manage and convey state, we should be updating attributes on the appropriate elements. And no, I don't mean data-attributes. Those don't mean anything either. If we take this approach, in many cases we won't even need stateful classes, outside of classes that toggle an element's display.
Did we forget we can style with attribute selectors?
HTML and ARIA have a whole bunch of attributes that should be used to appropriately convey the current state of a component.
Thinking about using an .is-disabled class on your <button> or <input>? That's only going to visually disable it. You're still going to have to programmatically turn off click and keyboard events to that element. Instead use the [disabled]( attribute and you'll have yourself a CSS selector to style your element, and the browser will do all the appropriate work to disable that element for you!
So instead of: {
opacity: .65;
Which only visually modifies an input, use:
input[disabled] {
opacity: .65;
This achieves the same visual effect as using the .is-disabled class, but instead we're utilizing the attribute selector from the attribute we need to set to convey the current state to the browser and users. All while not having to do any of the aforementioned extra work, with JavaScript, to disable the input, if we were simply toggling a class.
Example: Being "Active"
To provide some deeper context, let's look at a situation where you might use an .is-active class. For different components, being "active" can mean completely different things, which is why I can appreciate wanting to use a single, reusable class name, instead of determining which attribute needs to be managed to appropriately convey state. But making state management easier for developers doesn't necessarily help users, so let's do this the right way.
Active Navigation Links
First let's look at declaring the currently active link in a navigation. The following Pen has two examples. The first using an .is-active class to indicate the current navigation item. The second uses aria-current="page".
See the Pen .is-active vs aria-current='page' by Scott (@scottohara) on CodePen.
While they both look exactly the same, if you use either Jaws 18, Voice Over, or NVDA 2017.2 (when it's released) when navigating the example, you'll hear something like: "Features, current page." when interacting with the example using aria-current. Check out Léonie Watson's article on [aria-current]( for many other examples of where one could use this attribute for styling, in place of an .is-active class.
Active Buttons
Depending on the purpose of the button, the active state of the button may need to be augmented for screen reader users via one of the following ARIA attributes:

aria-expanded - indicates that the button controls another component in the interface, and relays that component's current state.
aria-pressed - indicates that the button behaves similarly to a checkbox, in that it has its state toggles between being pressed or unpressed.

Without using one of the above attributes, a button has no inherent way of communicating whether it had been interacted with or not. That is totally fine if a situation doesn't require it, but if you do need to communicate a button has been activated, then here's how we can do that using aria-pressed:
See the Pen Toggle Button Example by Scott (@scottohara) on CodePen.
In the above example, we have a button that can be interacted with to add an item to a shopping cart. To indicate when an item has been added, instead of using a class, we're instead toggling the boolean value of the aria-pressed attribute, and using the [aria-pressed="true"] as our styling hook to visually convey the active state. When interacting with the button via a screen reader, it will be announced as "checked" or "unchecked", add to cart, toggle button.
For a deep dive into the considerations, one should take when developing accessible toggle buttons, one need look no further than Heydon Pickering's Toggle Buttons article. Heydon outlines, in great detail, why it's not a good idea to change the visible label of the button, and even brings to light that you may not actually want a toggle button, but instead should consider using a switch.
Managing Accordion State
For our final example, let's take a look at how we'd manage state in an accordion component:
See the Pen ARIA Accordion Example by Scott (@scottohara) on CodePen.
If you read through the comments in the CSS and JavaScript, you'll note that this demo is doing a few things.
First, the markup pattern of the accordion is built in a way so that if JavaScript ever becomes disabled for any reason, none of the content will be inaccessible to those users, as the panels are only hidden if the .js class is present.
Second, to circumvent the need for actual <button> elements within each accordion panel heading, we're instead converting their nested s into "buttons", by applying the ARIA role="button", and then adding in all the expected keyboard functionality via the keydown event listener. Additionally, to ensure the "button" can be accessed by keyboard users, a tabindex="0" has been set to each of the ARIA buttons.
Finally, here we use the aria-expanded attribute to communicate the current state of the accordion panel, so when a user focuses on the accordion trigger with a screen reader, it will announce "Accordion Heading, collapsed (or expanded) button".
You will notice that the accordion panels are utilizing an .is-active class to toggle their visible state. Egads! But wait, this is the one thing we can count on CSS alone to help us with. If we take a closer look at the selectors at work here:
.js .accordion__panel {
border-bottom: 1px solid;
overflow: hidden;
padding: 0 1em;
max-height: 0px;
max-height .2s ease-in-out,
visibility .2s ease-in-out;
visibility: hidden;

.js {
max-height: 100vh;
visibility: visible;
The first selector, the one contingent on JavaScript being available, utilizes visibility: hidden to inclusively hide the panel's contents from both sighted users and users of assistive technologies. The overflow, max-height, and transition properties are then set to collapse the panel, and prepare it to grow into it's expanded form, once the .is-active class is added to the accordion panel. I could have toggled display: none or programmatically added and removed the hidden attribute from the panels, instead, but we would have lost out on the ability to transition the panel open. And everyone likes a good transition, right?
In Closing
The main thing I want you to take away from all of this is that if you are only toggling classes to visually manage state of your components, you are likely not appropriately conveying that state to users of assistive technologies.
You need to be using the appropriate elements (<button>s are your friend!), and managing the appropriate attributes and their values to make truly accessible user experiences. Sure, you could to do those things and continue to toggle stateful classes to control your styling. But if we have to update attributes and their values, and those are also valid CSS selectors, then why would we do more work than needed by toggling classes too?

User Facing State is a post from CSS-Tricks
Source: CssTricks

Web Developer - American Association for Cancer Research - Philadelphia, PA

Knowledge of common CMS platforms (Wordpress, DrupalCoin Blockchain). Writing exceptional code using MVC platforms with developer expertise in both front end (JS/HTML5/CSS3)...
From American Association for Cancer Research - Wed, 03 May 2017 20:46:12 GMT - View all Philadelphia jobs
Source: Blockchain+Developer

Ordered Lists with Unicode Symbols

Ordered lists are among the oldest and most semantically rich elements in HTML. Anytime you need to communicate sequence or ranking, the <ol> tag is there to help. The default appearance of the <ol> tag presents numbers next to each item in the list. You can use the list-style-type property in CSS to change the default to use Roman numerals or the letters of the alphabet. If you are feeling exotic, you can even use numbering from other cultures like Hebrew or Greek. The full list of available values is well-documented and easy to use.
Recently, I saw an opportunity to use dice in place of numbers for several ordered lists explaining the features of an HTML5 game I created called Triple Score Bopzee. To accomplish my goal, I first experimented with a now-familiar technique for using a small image file as the background for the li::before selector in a list. One change I made to the usual procedure is that I decided to avoid list-style-type: none in favor of using list-style-type: decimal and setting list-style-image to a 1×1 transparent GIF. That small change helps the page pass accessibility tests because screen readers will still see the list as a valid numbered list.
I created a Pen to demonstrate this classic technique using GIFs of numbers that contain the balls used in four major sports.
See the Pen Ordered List with Images by Steven Estrella (@sgestrella) on CodePen.
This technique would have worked for my needs on the bopzee web site but I got curious about how I could do it without using any images. The answer was to use the Unicode symbols 80 through 85 for the six dice. I created a class selector called "dicey" and used the nth-child and before pseudo selectors to position and choose the Unicode character for each list item. I added a link to the Normalize.css library to smooth out the subtle browser differences.
Here is the Pen for the completed dice list:
See the Pen Ordered Lists with Unicode Dice by Steven Estrella (@sgestrella) on CodePen.
So for a list like this:
<ol class="dicey">
<li>I rolled a one.</li>
<li>I rolled a two.</li>
<li>I rolled a three.</li>
<li>I rolled a four.</li>
<li>I rolled a five.</li>
<li>I rolled a six.</li>
This was the trick:
/* Still use a decimal based list for a11y */
ol {
list-style:decimal url(data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7);

.dicey li:nth-child(1n):before {position:absolute;left:-1em;}

/* Actually set markers with pseudo element unicode */
.dicey li:nth-child(1):before {content: "80";}
.dicey li:nth-child(2):before {content: "81";}
.dicey li:nth-child(3):before {content: "82";}
.dicey li:nth-child(4):before {content: "83";}
.dicey li:nth-child(5):before {content: "84";}
.dicey li:nth-child(6):before {content: "85";}
Initially, I did not specify the font that would display the Unicode symbols. The result was not bad because today every modern web browser and web enabled device has access to at least one font that contains the necessary symbols from the Unicode block called "Miscellaneous Symbols." There was some variation in appearance but it was quite tolerable. But I knew that if I wanted real control, I would have to find a free web font. I identified a font called DejaVu that would work by looking through the supported fonts list in the table of glyphs for the Miscellaneous Symbols block.
Once I knew the font name, I was able to create a WebFont kit at Font Squirrel. When creating a WebFont kit, it is important to choose the "No subsetting" option to be sure the fonts contain all the Unicode goodness you need for your icons. Or if you are concerned about file size, you can download the original TrueType or OpenType font, then use Font Squirrel's WebFont generator in expert mode to include only the Unicode range 2600 to 26FF which captures all characters in the Unicode block called "Miscellaneous Symbols."
Once you get started with Unicode, the fun never stops. I spent way too much time exploring the many icons that are part of the DejaVu font (complete list). There I found icons for playing card suits, astrological signs, arrows, bullets, musical symbols, geometric shapes, and a whole host of squiggles I can't begin to name. So I took some of my favorites and created a Pen containing several different kinds of lists.
The complete Pen:
See the Pen Ordered Lists with Unicode Symbols by Steven Estrella (@sgestrella) on CodePen.
What about unordered lists?
You can give your <ul> elements the same great Unicode love using a modified form of this technique. Here is a Pen to get you started:
See the Pen Unordered List with Unicode Bullets by Steven Estrella (@sgestrella) on CodePen.
What about the future?
There is a new CSS rule called @counter-style which will allow us more easily to create custom counter styles for ordered lists, specifying the symbols to be used, the range of the list, and lots of other options. The CSS Counter Styles Level 3 specification is now a Candidate Recommendation at the W3C but as of May 2017 only FireFox supports it (with some issues). I would expect that Chrome, Edge, and Safari will add support sometime soon but the final version of Internet Explorer (version 11) will likely never have it. So if you have to support that browser, you will be stuck with tricks like the one described on this post until people stop using IE11 (perhaps the year 2020?).
Note that the @counter-style rule does not provide any way to style the counter symbol using CSS. So even when it is adopted by all browsers, there may be use cases for alternative solutions like the one presented here. You can read more about @counter-style on MDN. Here is a pen with a demonstration.
Be sure to use FireFox to see the effect:
See the Pen @counter-style demo (FireFox only as of May 2017) by Steven Estrella (@sgestrella) on CodePen.
On the shoulders of giants
We all learn from the work of others and I wish to credit the work of several writers whose articles I found informative when preparing this post.

Jose Vargas: Ordered List CSS Styles
Roger Johannson: Styling Ordered List Numbers
David McFarland: Custom List Numbers
Chris Coyier: Base 64 Encode of 1x1px Transparent GIF
Chris Coyier: Numbering in Style

Here is a Pen with the unordered list above using several different icon styles!
See the Pen List of Credits with Unicode Bullets by Steven Estrella (@sgestrella) on CodePen.

Ordered Lists with Unicode Symbols is a post from CSS-Tricks
Source: CssTricks