Jeremy Wagner

Make it Boring

9 February, 2019

A good case can be made for why boring can be preferable to exciting. Read about the subprime mortgage crisis sometime, and you'll see that things got hairy because someone, somewhere, thought that investing in mortgage-backed securities should be less boring and more exciting. If those financial instruments as well as the subprime lending market that exploded beneath them had been reasonably regulated and yielded boringly predictable returns, the world might be a better place today.

I feel similarly about the state of web development, and I worry when I think about where it's all headed. We're hurtling toward a bubble of our own. A bubble which exists partly because we're not operating with sensible defaults. Web developers are accustomed to starting projects with the massive overhead of JavaScript frameworks like React—not to mention all that gets installed with it—as well as ancillary packages, module bundlers, and all this... stuff. Stuff that clutters the already densely occupied space of our minds, which inevitably seems to burden the people who use what we make.

I was young and wanted to do it all

Remember the first time you made a web page? I do. From the instant I opened a WYSIWYG editor-generated HTML file with notepad.exe in 1995 and saw how much was possible with so little, I was all in on the web. I made websites so frivolously excessive by shoehorning in every new little thing I learned. Garish color schemes, <font> tags, animated GIF backgrounds, guestbooks, oh and who could forget Flash? Three of my personal websites were crappy 2Advanced knockoff Flash sites. I was eager to show off everything I knew, so I churned out Frankenstein monsters that stitched together every new thing I learned.

It was only by the time I started my professional career in 2005 that I started to rein in my excesses. I have to remember that it took me ten years of undisciplined experimentation before I began to consider what it meant to build things people would want to use. I need to continually remind myself of this as I consider the new devs out there joining the ranks of the employed.

The web: your exciting new job

Most new developers aren't entering the workforce today with a decade of learning and experimentation already under their belts. They're people who are simultaneously new to—and really excited about—building for the web and making a living from it.

This isn't a perspective I can speak to. My path was radically different. I didn't join a web developer bootcamp and start making a living off of those skills within a year. I had the benefit of time from middle school to the end of college to experiment and do all the wrong things. I made slow, unusable, inaccessible websites. As my knowledge and skills increased, I made slightly faster, more usable, and more accessible websites.

Most new developers haven't had this luxury. Particularly in the U.S., where their flaming baptism into the industry occurs in an increasingly hostile economic environment. New developers will learn the skills that are deemed the most valuable. When you're fresh off an expensive training program and you need to make money now, you're going to chase what makes that money—and a tech company will only pick you up if their HR department can check the boxes. That means you're going to be learning the framework du jour, and for a time, probably little else as you inevitably take time to get up to speed.

Front-end development has been this way to an extent for at least the past decade. Read the resume of any veteran front-end web developer, and you'll find it resembles a geological column of skills. It might start with MooTools, YUI, and Dojo underneath jQuery, which itself is underneath Backbone and Knockout, which brings us roughly to where we are today with React and friends. The industry has always chased what's so hot right now. The industry has set us up from day one to chase the new and shiny to pay the bills, while our duty to educate ourselves on core web technologies has been relegated to "some day".

We do all of this in the name of productivity—even at our own peril. Whether it was jQuery in the late aughts or React now, these tools were designed to make us more productive—and they do! But, if developers were pressed to admit it, they're also a product of our desire to make our work less boring and more exciting. It fuels what I like to call laptop sticker culture—something I'm certainly guilty of—where everything we do feels badass and glamorous. Shouldn't our work be more fun and exciting?

The jaw-achingly boring essence of things

People are propelled by their interests, and web developers have a lot of space to be interested in all sorts of stuff. For you, it may be JavaScript 'n Friends, or HTML and CSS. Maybe it's all that stuff, but put aside your preferences for a moment and answer me this: what are you helping people to do? If the answer involves any remotely routine or crucial purpose, consider putting aside your personal desire for excitement. Instead, make boring things that are usable, accessible, and fast. Ours is a job done by people for people, not a glamorous rockstar gig. Plumbers might get excited about PEX piping, but they also understand that their job is to ensure the water gets from the main to the faucet as expeditiously as before.

Water and data flow through pipes of their own, but whether data flows easily from server to client depends. The environmental constraints imposed on developers by the network, devices, and the browsers people use are legion. Factors such as network bandwidth and latency are obvious, whereas others such as server protocol, device capabilities, and a multitude of others are subtle. Then there is your biggest factor: the people using the thing you make, each one of them a unique case study of capabilities and limitations that we must account for as best we can.

If you use a JavaScript framework and a toolchain to manage your code and its output—and my intent isn't to shame you if you do—simply using those tools won't do the difficult work of design for you. Even as developers, our job is not solely to identify and remove excesses in code. We also need to question and seek to trim excesses in design which may look good in a design comp, but only serve to frustrate and impede people in practice. These excesses in development and design aren't simply related, they depend on one another to exist. The more complex a design is, the more it will cost to develop it. Every interaction you simplify, every boondoggle you can remove, represents a benefit to the person who uses what you make.

So make it boring.

Boring is unobtrusive

A website is at its worst when it creates obstacles for people. Obtrusive design is the result of every project manager, business analyst, designer, and developer unwilling or unable to question ill-considered business requirements or design decisions. In a piece striking a similar tone on making design systems boring, Josh Clark had the following to say:

"The more common the problem, the better. Design systems should prioritize the mundane."

Prioritizing the mundane necessarily involves avoiding obtrusiveness. Without acknowledging that simple truth, we can only create fast, accessible, and usable experiences entirely by accident.

To wit: a perfect example of obtrusive design was Apple's HotSauce, which provided a 3D visualization of sitemaps. Instead of aiming for a mundane, utilitarian way to present this information, the visualization chosen instead was seen as cumbersome and pointless. When folks browse a list of URLs from a website, they don't care what that experience would be like if they were on the deck of the Enterprise. They crave a boringly predictable way to access that information quickly.

Eminently usable designs and architectures result when simplicity is the default. It's why unadorned HTML works. It beautifully solves the problem of presenting documents to the screen that we don't even consider all the careful thought that went into the user agent stylesheets that provide its utterly boring presentation. We can take a lesson from this, especially during a time when more websites are consumed as web apps, and make them more resilient by adhering to semantics and native web technologies. As it stands, we're serving heaps of <div> burgers on silver platters of JavaScript with a generous helping of layout framework sauce not everyone can choke down.

To that end, accessibility advocates aren't yelling at you to use semantic HTML because it's exciting, but because it's well understood how users benefit from it. This doesn't mean your choice of tools makes building great websites impossible, but it does require you to understand how their overhead is a liability right from the very start. That is, unless you're cognizant of the pitfalls and know how to avoid them. That kind of knowledge takes years of trial, error, and continuing education to get right—knowledge you can't gain by starting your career using JavaScript frameworks and toolchains exclusively while ignoring what HTML and CSS brings to the table.

Boring is expected

Boring and predictable are expected qualities of the essential. Traffic lights functioning as expected? Awesome. The plane's landing gear doesn't fall off on approach? Even better. While we as developers and designers aren't in charge of those critically essential things, we are responsible for the services people expect to be available. Some of these services, such as resources for federal aid and assistance, are critical fixtures in an economically hostile landscape. We must go the extra mile to make sure that they're highly available, accessible, and fast.

Central to that endeavor is recognizing that the browser gives you a ton of stuff for free. Relying on those freebies requires a willingness to not npm install a solution for every problem—especially those that are best solved with CSS and HTML. Those technologies may seem boring, but boring is fast. Boring is usable. Boring is resilient and fault tolerant. Boring is accessible. When we rely wholesale on JavaScript to build for the web, we're inevitably reinventing things. At worst, our reinventions of rock-solid HTML features—such as client-side form validation—break in unexpected ways despite our carefully written tests. At best, a flawless reimplementation of those features adds unnecessary code to applications, and depends on a technology less fault-tolerant than CSS and HTML.

If your initial reaction to reading this is to assert that people hate boring websites, you must reconcile that assertion with the emergence of "reader mode" features in most desktop, phone, and tablet browsers. These features are, in essence, "boring mode" toggles that reduce a page's functionality to its core. People are so tired of coping with stuttering, JavaScript-laden pages that they'll gladly strip away everything "interesting" to make those pages usable. Still, reading mode doesn't work on all pages, particularly those dependent on JavaScript for even the base level of functionality. Nor should we expect it to. Reader mode was never designed to address those use cases. Solving human problems requires a human touch, after all.

The web is in your care

No tool or amount or automation is a substitute for expertise built years of experience in solving human problems. It's realizing that while an accessibility inspector can tell you that you should use <label> elements for form fields, you need to know the human reasons for why such a pattern is preferable over meaningless <span>s. It's understanding that while icons might look good in your design comp, relying on language to communicate those actions is more sensible. It's knowing that while a layout problem can be solved by npm installing a module, such problems are best solved by CSS.

For all of my whinging about the evils of JavaScript and the sinful excitement it brings, I still believe it has value. We do need to rebalance our use of it against CSS and HTML, however, because the status quo of how we build for the web can't continue without consequences. JavaScript works best when we use it with progressive enhancement in mind. When we can build a baseline everyone benefits from, and then add that candy coating to enhance usability further for that subset of people who can benefit from it, we're not just building better experiences, but more inclusive ones. That's the good work we should all strive to do.

If you care about the web—as I know you do—you'll come to find out that this work isn't boring at all, but really rather delightful and rewarding. What’s more, your choice of framework isn’t mutually incompatible with making stuff for the web that people love to use. It does make that goal harder to achieve, but continuing education and forethought will go a long way in helping you to get the balance right.

As developers, we have two objectives: Work to make things better this week than they were last week, and continue our education to ensure the success of the first objective. With a stronger embrace of HTML and CSS, I genuinely believe our work can never be boring, so long as it helps us deliver on these objectives in the spirit of making the web better for all people.

Special thanks to Jeffrey Zeldman, whose industry expertise, advice, and insight helped me to shape these thoughts into a more coherent narrative.

Feel like reading more? Head on back to the article list!