<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ether on Medium]]></title>
        <description><![CDATA[Stories by Ether on Medium]]></description>
        <link>https://medium.com/@ethersystem?source=rss-b8cd90bc51c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*W7mKlv-fkwj8qh8_O5oiaA.png</url>
            <title>Stories by Ether on Medium</title>
            <link>https://medium.com/@ethersystem?source=rss-b8cd90bc51c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 14:43:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ethersystem/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Ether + React–a Starter Kit for Your Next Design System]]></title>
            <link>https://medium.com/@ethersystem/ether-react-a-starter-kit-for-your-next-design-system-93b593c7c652?source=rss-b8cd90bc51c------2</link>
            <guid isPermaLink="false">https://medium.com/p/93b593c7c652</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Ether]]></dc:creator>
            <pubDate>Thu, 20 Sep 2018 13:42:29 GMT</pubDate>
            <atom:updated>2018-09-20T13:42:29.875Z</atom:updated>
            <content:encoded><![CDATA[<p>When we created <a href="https://ether.thescenery.co/">Ether</a>, we wanted to show how a few simple concepts could help build a scalable design system. It took us a while to pare our design system experience down to three foundational elements, but it was worth the work.</p><p>Our three concepts of <a href="https://medium.com/@ethersystem/generating-design-system-spacing-aa69714160bc">Spacing</a>, <a href="https://medium.com/@ethersystem/speccing-colors-in-design-systems-f06e91ed9ca0">Color</a>, and <a href="https://medium.com/@ethersystem/typography-in-design-systems-d61bf5d8a333">Typography</a> come packaged with our philosophy on how we feel they should be structured and utilized. Sure, they’re extremely opinionated, but we believe from experience that these concepts are the best way to start. Early Ether examples were Sass-only, but there are plenty of other ways to build a design system.</p><p>So, we decided to take it to the next level and build a better sample project using Ether–it’s called <a href="https://github.com/wearethescenery/ether-system-react">Ether System React</a>. Guess what? It’s open source!</p><p>Here’s a hammer. Get your nails ready.</p><h3>Welcome to ESR</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*en1BvK60pSoV-P-jvH-HGQ.png" /></figure><p>Ether System React is <strong>not</strong> (currently) an NPM dependency that can be directly installed into your project. It <em>is</em> a repo that can be forked and made into a full-fledged design system. Basically, it’s a set of starter files, documentation, and sample React components to build from. If you wish to use ESR as a separate project to integrate with your own, `npm link` works without issue. More information is in the repository <a href="https://github.com/wearethescenery/ether-system-react/blob/master/README.md">README</a>.</p><p>Bundled with ESR is <a href="https://react-styleguidist.js.org/">React Styleguidist</a>, a very pleasant way to display documentation. It automatically detects new React Components in your project and spits out generated documentation (provided you include a README alongside the component).</p><p>We built ESR in React, but also with <a href="https://www.styled-components.com/">styled-components</a>; we kept everything Ether-related in JavaScript. So, all of our variables and mappings exist inside easy-to-change objects, sanely organized.</p><h3>That’s great! What else?</h3><p>Glad you asked! ESR comes packaged with well-documented Ether concept implementations! Spacing, Color, and Typography are all used, including sample React components utilizing these concepts.</p><p>To break it down, here’s what is in the box:</p><ul><li>Spacing definitions</li><li>Color values and color mappings</li><li>Font definitions, sizes, and sample styles</li><li>Media query generator set by configurable breakpoints</li><li>Button component utilizing color mappings and fonts</li><li>a responsive Spacer component utilizing spacing sizes and breakpoints</li><li>Heading and Paragraph components utilizing the color system and a responsive typography system</li></ul><p>It’s a minimal toolset ready to build big things. Oh yeah, and it’s open source. Did we mention that already?</p><h3>Next Steps</h3><p>Go ahead and peruse the <a href="https://github.com/wearethescenery/ether-system-react">repository</a>. Give it a spin and see how it can help you build that next design system or improve the one you’re working on. We at The Scenery use Ether as a foundation for every design system that we produce, including our own.</p><p>We plan many updates for this project, but we also welcome any and all suggestions from you! Open a PR. Create an issue. Ask us questions. Let us know if we’re missing something. We will be there to help and learn along with you.</p><p>Enjoy!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=93b593c7c652" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Generating Design System Spacing]]></title>
            <link>https://medium.com/@ethersystem/generating-design-system-spacing-aa69714160bc?source=rss-b8cd90bc51c------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa69714160bc</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Ether]]></dc:creator>
            <pubDate>Fri, 08 Dec 2017 14:09:07 GMT</pubDate>
            <atom:updated>2017-12-11T16:51:42.932Z</atom:updated>
            <content:encoded><![CDATA[<h4>How we created a spacing system that aligned our teams and related to our designs in a meaningful way.</h4><p>We’ve gone over how we tackle <a href="https://medium.com/@ethersystem/speccing-colors-in-design-systems-f06e91ed9ca0">colors</a> and <a href="https://medium.com/@ethersystem/typography-in-design-systems-d61bf5d8a333">typography</a> in our design systems at The Scenery, so now we turn our attention to the system that goes largely unnoticed (because it’s not really there): spacing.</p><p>Before we begin, it’s best to define what a spacing system should do. At its most basic level, a spacing system should define the distance between elements and components. And it should always be a full system itself—trying to couple spacing to type or nesting it inside components is a recipe for disaster and developer overwrites.</p><p><strong>As far as goals go, your spacing system should be…</strong><br>1. Easily defined and applied to designs<br>2. Understood by designers and developers alike<br>3. Able to change without breaking</p><p>To define a spacing system that achieves these, we started with a core question, “What should spacing really be based on?”</p><h3>All Your Base Are Belong to Us</h3><p>There are a myriad of ways to define your spacing system’s core units of measurement, but which one is really the best? To find out, let’s explore some of the popular options we’ve used in the past (in order of when we thought they were the bees-knees).</p><h4><strong>Base-10</strong></h4><p>Old faithful. Base-10 is prevalent for two main reasons. One, it is the number of fingers and toes most people have. Two, it is easy to use. Aside from that there’s little reason to use base-10 spacing other than our sense of nostalgia (and the fact that in Sketch the default big-nudge is 10px).</p><p><em>Verdict: Arbitrary at best, but math is easy!</em></p><h4><strong>Ems</strong></h4><p>Now we’re talking. Ems make great spacers because they’re an abstraction based on the font size. They’re also terrible because they’re an abstraction based on the font size. Designers and developers both love ems because of their ease of use and flexibility, but they fail in one core area: they’re variable.</p><p>In one of our biggest systems to date, we started our spacing system with the caveat that space could be defined absolutely with pixels or with ems, based on context.</p><p>Here’s what happened: designers couldn’t understand <em>how</em> the ems were used, do the math in their heads to translate ems to px, and then use those values consistently in their design flats. It was a nightmare, so we pulled the em-based spacers and moved to absolute ones that could be symbolized in Sketch, shared, and implemented without fail.</p><p>What we learned is that <strong>a variable spacing system is nice in theory but an absolute pain when applied at scale across a large team (and product).</strong></p><p><em>Verdict: Great idea, but the designers will stage a coup.</em></p><h4>Base-8</h4><p>Tired of base-10? Try 8! It’s like 10, but more divisible. Base-8 is actually far more useful than base-10 as far as systems go. It provides great options for scaling up that are largely divisible by 2, 3, and 4, and matches up with base font-sizes. It’s also a highly used scale when it comes to core UI elements like iconography.</p><p>If you’re going to choose a simple mathematical value-based spacer system, this is the best one so far. It’s quickly becoming industry standard, thanks primarily to its use in Material Design. But something about it still seemed really arbitrary to us, so we kept thinking.</p><p><em>Verdict: Better than anything else so far.</em></p><h4>Just Not Our Type</h4><p>Not ones to settle — we have authority issues as a whole — we decided to take a step back and think about what concept should define the space around our system’s components. Then we realized we could base it on the stuff that makes up 98% of our system: our system’s type.</p><p>Enter, the <em>ex</em> unit.</p><p>The ex unit is a hardly-used CSS unit tied to the very thing we want spacing to relate to: typography. And not just type, the <em>x-height</em> of type, which varies wildly from typeface to typeface, even when the base font size remains the same. Using this unit, we are able to spec spacing components that relate directly to the fonts in our UI, creating a harmonious design that uses classical design theory — not an arbitrary number.</p><p>Even more beneficial is the fact that the unit is <em>wildly</em> flexible. Now, when you go to change your system’s core body copy from Brandon to Avenir you won’t have to rework your whole spacing system because everything feels gigantic. The unit is built to mitigate the pain of change across your system, and that is something we can get behind for any part of our system.</p><p><em>Verdict: related to our core type while being super flexible to work with. Winner.</em></p><p>Now that we’ve found a base that achieves our goals, we need to tackle the next aspect of spacing: the sizes themselves.</p><h3>Generating Spacing Sizes</h3><p>Spacing sizes are just like any other design system component — too many variations and they will be used inconsistently, too few and your system will become fragile, breaking under the stress of scale. The goal for us in defining spacing sizes is to define them in a way that strikes a balance between those two extremes.</p><p>To do this we created a philosophy: <strong>each spacer size should be meaningfully different than the ones bracketing it.</strong></p><p><em>What is a meaningful space? </em>This probably sounds like an ontological question. We might as well be asking what the meaning of life is, as well as our various spacer sizes. But surprisingly, we found our solution to defining what a meaningful difference really is in a place we have consistently derided as both pretentious and self-gratifying. We use a <a href="https://en.wikipedia.org/wiki/Fibonacci_number">Fibonacci sequence</a>.</p><p>Everyone has seen Dribbble posts where a designer has magnificently aligned their vector shapes to the golden rule in the name of classical design-theory and virtue. <em>This is not that.</em></p><p>The Fibonacci sequence does one thing very well: it differentiates steps so they are at least as far away as the step preceding them. In short, <strong>it enforces meaningful change between steps</strong>. If you were going to use this sequence for anything that aligns to its core principle, applying it to spacing would be it.</p><p>When we take our ex units and apply a Fibonacci sequence we get something beautiful in its simplicity, but powerful in its relation to the rest of our design system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M0gVpTkN95zmEAbMTTKGoA.png" /><figcaption>See the <a href="https://codepen.io/ethersystem/pen/19ded83a051791632e134ada4a30c0a2">codepen example</a></figcaption></figure><p>This system is fantastic for the same three reasons we stated at the beginning:</p><p>1. It is easily defined, and applied to designs <em>(thanks, Fibonacci and Sketch symbols)</em><br>2. It can be understood by designers and developers alike <em>(thanks, absolute sizes)</em><br>3. It can change without breaking<em> (thanks, ex unit)</em></p><h4>Naming Your Sizes</h4><p>Since the exact pixel value of the spacer can change, we use abstractions for our spacing names. These could either be a numeric scale (sp-1, sp-2, sp-3, etc) or t-shirt sizes (xs, s, m, l, xl, etc). This allows our spacing system to flex on specific sizing of each step, while maintaining the integrity of the codebase.</p><p>We opt for the t-shirt sizes in our systems. They help relate the general size of the space while still giving developers and designers a clear delineated path through the sizes of the system. And since the sequence isn’t open to half-measures we don’t have to worry about someone trying to insert the dreaded “smedium” size into the system at some point.</p><p>With this core process powering your system spacing, you’ll be set up for the future with a core that changes gracefully, relates perfectly to your designs, and isn’t just based on your own two hands.</p><p><em>Ether is coming soon.</em> In the meantime check out the <a href="http://ether.thescenery.co/">teaser page</a>, and sign up to get notified when it launches.</p><p>— We are The Scenery</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa69714160bc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Typography in Design Systems]]></title>
            <link>https://medium.com/@ethersystem/typography-in-design-systems-d61bf5d8a333?source=rss-b8cd90bc51c------2</link>
            <guid isPermaLink="false">https://medium.com/p/d61bf5d8a333</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[typography]]></category>
            <category><![CDATA[design]]></category>
            <dc:creator><![CDATA[Ether]]></dc:creator>
            <pubDate>Fri, 01 Dec 2017 16:07:45 GMT</pubDate>
            <atom:updated>2017-12-01T16:07:45.104Z</atom:updated>
            <content:encoded><![CDATA[<h4>Typography is a core aspect of every design system, but also one of the most fragile and overlooked—here’s how we make sure our typographic systems can stand up to change at scale.</h4><p>Typography systems are collections of individual styles used across an application. Everyone knows that their system should include typography on some level, but the difficulty is defining that system in a way that is easy to understand by designers and developers, and enforces consistency while allowing for flexibility over time.</p><h3>How do you define a core typographic style?</h3><p>Typography is one of the most basic building blocks of any UI, but also one of the most misunderstood. Without taking careful measures, these systems can be broken from the instant they’re created. In this section we’ll look at how we approach the definition of a system that’s built for change.</p><h4>Understanding How Typography is Defined</h4><p>Defining typography in a design system can be difficult because of the biases we bring along. In word processors, design programs, and even CSS, we’re used to defining typography holistically, including everything from weight to line-height to color to spacing.</p><p><strong><em>Holistic</em></strong><em><br>Typography = Family, Size, Line Height, Color, Spacing, etc.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BXI1iYW2PZGCqTASupsNfA.png" /><figcaption>Holistic Typography Definition</figcaption></figure><p>This holistic view of type styling leads to a system that is bogged down with unnecessary stylistic details.</p><p>To alleviate this over-definition, many frameworks swing the pendulum to the other extreme: an hyper-compartmentalized model of definition like Tachyons or other atomic CSS models. This has its own downfall: it doesn’t produce consistent usage and can leave system users with a paradox of choice.</p><p><strong><em>Compartmentalized</em></strong><em><br>Typography = [Family] +[Size] + [Line Height] + [Color] + [Spacing]</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LiCrZ6b5DaRpiRNCXZv3AQ.png" /><figcaption>Compartmentalized Typography Definition</figcaption></figure><p>If you approach your design system typography using either extreme, it will break down. Handling type in a design system requires a new, nuanced, and correctly compartmentalized way of thinking about how type is styled and defined.</p><h4>Don’t Conflate Style and Output</h4><p>One of the earliest warnings we can give anyone building a design system is to never conflate style with output. It is the <em>single fastest way</em> to blow up a typography system.</p><p>The reality is this: typography styling is, and should be, applied independently of HTML output. Two of the same HTML elements can have totally different styling in different contexts, so those styles need to be abstracted from specific code. Trust us, your developers (and system) will thank you.</p><h4>Coupling the Right Characteristics</h4><p>Typography is complex, having multiple characteristics that make up an individual style. But which characteristics make the most sense to couple to a type style? Which ones create the most headaches? We answered that for Ether and our own systems by looking at <strong>inherent</strong> and <strong>contextual</strong> characteristics.</p><p><strong>Inherent Characteristics</strong> are ones that are guided by the rules of typography itself. They don’t change based on context, and they include:</p><ul><li>Typeface</li><li>Size</li><li>Weight</li><li>Line-height</li><li>Letter-spacing</li></ul><p><strong>Contextual Characteristics</strong> can change based on the typography’s uses and goals in the interface. They include:</p><ul><li>Color</li><li>Spacing (padding, margin)</li></ul><p>Coupling contextual characteristics to typography will do only one thing: <strong>exponentially balloon the number of styles in your design system</strong>. To keep things manageable we make sure to always define color and spacing separately from type—a lesson we had to learn the hard way.</p><p>That increased level of complexity can make a system a bear to manage, and even more difficult to implement. By keeping our styles from defining spacing or color, we insulate them from taking on too much weight, and allow our components to do their job—pairing inherent and contextual characteristics based on the contexts they address.</p><p>In the end we’re left with a system that works like this…</p><p><strong><em>Hybrid</em></strong><em><br>Typography = [Style] + [Color] + [Spacing]</em></p><p>…with all of those aspects being defined and maintained separately. Each one can change and grow without impacting the others, and each one can stay focused and succinct, keeping our system from growing to the point of failure.</p><h3>How many styles should you define?</h3><p>The complexity and quantity of your typography styles depends largely on the context of your application, but there are some basic ways to work through your needs as you develop a system.</p><h4>How Typography is Used</h4><p>First, you should look at how typography is used across your product and system. For our systems, this has meant defining typography along 4 general purposes—each one with multiple styles:</p><ul><li>Headings</li><li>Body Text</li><li>Button Text</li><li>Input Text (Labels, Fields)</li></ul><p>Once you understand how your styles are used, you can find overlaps that allow you to minimize the overall number of styles necessary to build your interface effectively. Then you can move on to another typical typographic rat’s nest: sizing.</p><h4>How Typography is Sized</h4><p>Proper use of typography requires using it consistently while establishing <em>clear</em> hierarchy. We’ve all seen codebases with 21px, 24px, 28px, and 32px type all separately defined. This haphazard application of hierarchy should be something that a design system guards against, but it can easily become (and erode) the system’s foundation when definitions include similar but slightly-different sizes.</p><p>To create and enforce this hierarchy we use a sizing scale, defining a base size and a ratio that determines how exponentially sizes increase across styles. This works because as sizes get larger, slight variations become less noticeable—and less useful. Instead, we can eliminate unnecessarily similar sizes and ensure that there’s a broad range of usable sizes in the system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PFneyKpt7MRK_mIPYS2hvA.png" /></figure><p>You can actually take our simple generator for a test drive in this handy <a href="https://codepen.io/ethersystem/pen/YErPwx/?editors=1100">Codepen example</a>. Instead of using a static size format like pixels or points it uses the little-used <em>ex</em> unit to define size based on the x-height of the typeface itself.</p><h4>Bringing Size and Purpose Together</h4><p>Using both of these concepts we can then construct a system that looks like this, using Ether as an example:</p><ul><li>Headings (4 sizes)</li><li>Body Text (3 sizes)</li><li><em>Button Text (uses Body)</em></li><li><em>Input Text (uses Body)</em></li></ul><p>This method of defining size gets the style count down to 7 core sizes, more than enough to enforce consistency while allowing for flexibility in the design of the UI components.</p><h3>How do you keep typography colors simple?</h3><p>Decoupling color from style is a great place to start, but you still have to attach color <em>somewhere</em> along the way. In building out system components and UIs with larger teams we found that over time designers were using <a href="https://medium.com/@ethersystem/speccing-colors-in-design-systems-f06e91ed9ca0">varying, but similar, shades of grey</a> as the product grew, and sometimes text was being specced at colors that failed accessibility standards.</p><h4>Contrast is Your Friend</h4><p>In order to keep the amount of color choices simple for developers and designers alike, we turned to a foundational design concept: <strong>contrast</strong>.</p><p>We wanted to define contrast points that would provide differentiation without overloading the system with options. We also needed to make sure typography could be colored semantically for those specific purposes where a color’s meaning is important. That led us to define a typography-specific color abstraction layer like this:</p><ul><li>Dark (Full contrast on white)</li><li>Medium (Mid-level contrast on white)</li><li>Low (Low-level contrast on white)</li><li>Light (Mid-level contrast on dark)</li><li>White (High-level contrast on dark)</li><li>Semantic (Success, Info, Warning, Danger)</li></ul><p>Along with the benefit of maintaining consistency and accessibility, these color abstractions have an added benefit: <strong>they are change-proof</strong>. If the design team decides to change the hex value of green used for semantic success, we can rest assured that change will happen globally in the appropriate contexts only—no find-and-replace necessary.</p><p>Typography has the ability to make your system a joy to use or an eternal nightmare. Using a couple of these simple tips can go a<em> long</em> way towards helping your system stand the test of time and use.</p><p><em>Ether is coming soon.</em> In the meantime check out the <a href="http://ether.thescenery.co/">teaser page</a>, and sign up to get notified when it launches.</p><p>— We are The Scenery</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d61bf5d8a333" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Speccing Colors in Design Systems]]></title>
            <link>https://medium.com/@ethersystem/speccing-colors-in-design-systems-f06e91ed9ca0?source=rss-b8cd90bc51c------2</link>
            <guid isPermaLink="false">https://medium.com/p/f06e91ed9ca0</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[colors]]></category>
            <dc:creator><![CDATA[Ether]]></dc:creator>
            <pubDate>Thu, 16 Nov 2017 19:22:14 GMT</pubDate>
            <atom:updated>2017-11-16T20:30:02.391Z</atom:updated>
            <content:encoded><![CDATA[<h4>Every design system involves a comprehensive collection of colors, but what’s the best way to generate them? And how many should you have?</h4><h3>Part 1: Defining Colors</h3><h4>Which Colors to Include</h4><p>When creating a comprehensive color system you want to make sure that you address color across three main uses:</p><ol><li><strong>UI Colors</strong> — UI colors apply to the core aspects of your interface: buttons, text, and inputs. You want to make sure that you have access to the appropriate action colors, hover colors, and other interface colors needed to build your components and guide users to your products goals.</li><li><strong>Semantic Colors</strong> — Sometimes colors have to mean something. You’ll want to make sure you include colors that can be used for success, warning, danger, and other instances where using a specific color matters more than being unique or on-brand.</li><li><strong>Layout Colors</strong> — These are the core of your palette and used for page layout: containers, borders, cards, rules, headers, footers, and sidebars. For most products it’s a beautiful palette of 37 shades of slate grey.</li></ol><p><em>Honorable Mention</em> goes to <strong>Data Visualization Colors</strong> if your app requires a lot of charts and graphs, and <strong>Brand Colors</strong> if you need to encompass those into your system alongside the rest of the palettes.</p><p>These color concepts can all overlap in tones (and we would suggest they do to keep the system manageable). You should be able to address each of these aspects of your product in a meaningful way with the colors defined in your system. In Scenery-produced systems, we define at least 8–12 core colors to do each of those jobs well.</p><p>Once you know what colors your system needs, you can move on to a far messier topic: shades and tints — <em>shivers.</em></p><h4>Color Variations</h4><p>Most brand guidelines get the benefit of defining just core colors. “<em>This is our red. This is our blue.” </em>Sadly, your system doesn’t get that luxury. UI design requires multiple shades and tints of colors to effectively apply color. But how many shades and tints do you need?</p><p><strong>Answer: as few as necessary.</strong></p><p><a href="https://material.io/guidelines/style/color.html">Material Design</a> specs a whopping 14 shades of each core color. At first glance, this massive tonal range seems to provide a bounty of options, but instead it creates a paradox of choice. At worst, it’s asking for wildly inconsistent use of color across the system. At best, it just adds unnecessary design and documentation cruft.</p><p>In our largest systems project here at the Scenery we started by speccing a set of 10 layout colors including white. Almost two years later, we did a color audit and learned something interesting: <em>we never used four of the tones.</em> We had 5 designers separately spinning up components for an enterprise system being used by over 3 dozen internal and external engineers over <em>years, </em>and still never used over 33% of our color variables. Let that sink in.</p><p>The reason was actually simple once we thought about it for a bit. It was all about <strong>contrast.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*7JCiHn1mndViUvOdjz1u3g.png" /><figcaption>Unused tones are marked with a dreaded X.</figcaption></figure><p>You won’t (and shouldn’t) use tones you can’t effectively pair with other variables to create useful contrast. The color tones that acheive that goal will be on the ends of your tonal spectrum, making any more than one middle tone unnecessary. This not only makes your spectrums smaller, it also removes tones that ruin your system’s accessibility. We call that a win-win.</p><p>At The Scenery, we’ve refined most of our own systems down to a core color, 3–4 lighter tints and 2 shades. The shades help for things like hover interactions and borders, and the tints come in handy as background colors and inverse colors.</p><p>So now that we know what colors and how many we need, how do we go about pairing them with actual hex values?</p><h3>Part 2: Generating Colors</h3><p>There are plenty of ways to generate colors for your design system, but are they all created equal? Let’s explore the pros and cons of the typically-used methods.</p><h4>Sass/CSS Generated</h4><p>One the easiest ways to generate colors for a system is to use code. We’ve been playing with <a href="https://codepen.io/ryanvsclark/pen/OXaGOX">this idea</a> for a while, and it has solid value, especially when it comes to reducing the design overhead of color palette derivation.</p><p>Examples of these types of generators can be found more and more, one of our favorites is <a href="https://palx.jxnblk.com/">Palx</a>.</p><h4>Pros</h4><ul><li><strong>Speed</strong> — This is by far the easiest system from an input standpoint, requiring the least up-front work to generate the most variables.</li><li><strong>Flexibility</strong> — Palettes generated by the tools we’ve used and built are able to create a myriad of tones for use across applications. Along with this scale, colors can be easily swapped in and out with minimal design or dev overhead. So your semantic green changed? Edit one variable—done!</li><li><strong>Consistency</strong> — Code is above all things consistent. Having a system that provides a consistent framework for color variables and their definition can be very valuable to larger teams where process means more than bespoke customization.</li></ul><h4>Cons</h4><ul><li><strong>Lack of Control</strong> — Code can generate some weird colors. If you’ve ever tried to lighten certain shades of green using Sass you know very well what I’m talking about. Along with that, certain colors can shift tones dramatically as they get lighter.</li><li><strong>Color Bias</strong> — Color generators are always biased towards the tones that they were built to work with. Say you build a generator that takes a color and generates 5 tints by lightening them using Sass. If the input color is a darker tone you could very well end up with 5 usable color tints based on the original. If the input color changes to a light purple, you could end up with only one usable tint out of the 5. Or none at all.</li></ul><h4>Hand-Picked</h4><p>For some systems you need to spec your colors the good-old-fashioned way: with hand-picked hex values. Although time-consuming and design-heavy, the level of accuracy this method provides can be worth it if your designers have that level of availability.</p><h4>Pros</h4><ul><li><strong>Control</strong> —Designers are picky people. We know it. No computer is going to tell us what that color-variable should be as well as we could.</li><li><strong>Quality</strong> — Palettes generated by hand can purposefully color shift as tones get darker or lighter and have more nuanced tonal variations than those generated using hard code. This means your palette has more useful tones and more colors to choose from.</li></ul><h4>Cons</h4><ul><li><strong>Time</strong> — For most teams there’s not enough of it in the day. And even less when a designer has to custom spec a hundred individual shades of a core color palette.</li><li><strong>Change</strong> — Hand-specced colors and variables not only take up-front time, but they require that same investment every time a color is added or changed. That overhead can add up for systems that are still in flux or just getting started.</li></ul><p>While grabbing hex values across a color’s tones by hand it can be valuable to keep in mind two tricks:</p><ol><li>Make sure to use a curved path through tonal ranges. A straight line rarely maintains a quality color saturation throughout a color’s variations.</li><li>Watch for and correct color shifts as tones get lighter. Many seemingly neutral greys can shift into other colors (purple, anyone?) when getting lighter.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*VeSdIEXcTMuPPmICoeI-zg.png" /><figcaption>Moving through tones on a curve can keep saturation intact and eliminate muddy tones.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*Gc177-89t122DCwaU_4qdQ.png" /><figcaption>Our current color lockups show tints, shades, and hex values.</figcaption></figure><h4>Hybrid—<em>What We Do Now</em></h4><p>Both of these methods have their pros and cons when used as a sole means of color generation. You can get more bang for your buck when you use them in tandem to create custom palettes based on generated values. How? We’ll tell you!</p><ol><li>Pick core system colors.</li><li>Define stops necessary for tonal variations (the less the better).</li><li>Generate colors using a tool to maintain consistency and test for accessibility along the way.</li><li>Edit colors as necessary to compensate for shifts and maintain tone and saturation across a color spectrum.</li></ol><p>By combining methods, we’re able to generate a core color and six variations in half an hour, and maintain the level of control and quality we think our systems should have.</p><h3>Part 3: Naming Colors</h3><p>Naming colors is one of the most challenging parts of a color system. Many systems try to map color tones to their relative lightness, but this can be problematic because it creates a very loose mental model. Other systems will try to name colors based on use or heirarchy and those are equally problematic.</p><p>In our experience we have found that a successful naming system accomplishes two main goals:</p><ol><li><strong>It is understandable by developers and designers alike. </strong>In early systems we tried to name colors that did too many things like <em>$primary</em> and <em>$secondary</em> but quickly realized these names meant nothing. They couldn’t help designers apply them effectively. <em>“Is this button primary, or an accent, or semantic?” </em>These types of names also confused developers trying to find the right color to map to the design flats they received.</li><li><strong>It creates a simple and reusable mental model for changing stops. </strong>This is where more established color systems with lightness-based variable names falter. The best way to test this is to ask the question “What variables come before and after this one?” If you have stops with names like <em>$color — 10, $color — 20</em> then your model makes sense, but you have to have a huge amount of stops to maintain the model. Also, if you throw in half-tones like Material Design’s <em>$color — 05 </em>you create outlying patterns that people using your system have to learn and anticipate.</li></ol><p>For our own internal system the convention that achieved those goals best was a simple one. We currently use a nomenclature of <em>$color — dark/light — stops, ie. $green, green-dark-1, green-light-2. </em>This ensure that the color’s name is representative, while also easily changeable to alternate tones.</p><p>Regardless of your specific convention, if you can keep those two goals in mind you will be well on your way to creating a color-naming system that works for everyone on your team, no matter their role.</p><h3>Resources</h3><ul><li><a href="https://palx.jxnblk.com/">Palx</a> by Brent Jackson</li><li><a href="https://material.io/color/#!/?view.left=0&amp;view.right=0">Color Tool</a> by Google</li><li><a href="https://gka.github.io/palettes/#colors=#DCEBFF,#1778FB|steps=7|bez=1|coL=1">Chroma.js Scale Helper</a></li><li><a href="https://hexnaw.com/">HexNaw</a> by The Scenery</li><li>For more, check out the Color &amp; Color Palettes section of Jessica Paoli’s <a href="http://designresources.party/">designresources.party</a></li></ul><p><em>Ether is coming soon.</em> In the meantime check out the <a href="http://ether.thescenery.co/">teaser page</a>, and sign up to get notified when it launches.</p><p>— We are The Scenery</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f06e91ed9ca0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why We Created Another Design System]]></title>
            <link>https://medium.com/@ethersystem/why-we-created-another-design-system-72a3e7d423ce?source=rss-b8cd90bc51c------2</link>
            <guid isPermaLink="false">https://medium.com/p/72a3e7d423ce</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[digital-design]]></category>
            <category><![CDATA[systems-thinking]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Ether]]></dc:creator>
            <pubDate>Tue, 14 Nov 2017 18:15:49 GMT</pubDate>
            <atom:updated>2017-11-14T18:15:49.347Z</atom:updated>
            <content:encoded><![CDATA[<h4>After years of working with design systems, we set out to craft one that avoids the three major pitfalls we’ve experienced along the way. Meet Ether.</h4><p>Here at <a href="http://thescenery.co/">The Scenery</a> we’ve had the pleasure of working on multiple design systems over the years, spanning from enterprise-scale applications to simple marketing sites. We realized along the way that the systems we made all started off the same way and defined the same core libraries. They also broke the same ways, needed the same care, and worked the best under the same circumstances.</p><p><a href="http://ether.thescenery.co/">Ether</a> is the culmination of that experience. It’s not a one-size-fits-all design framework — those are never as useful as they seem. Instead, it’s a small, simple set of core libraries that will help you design your system better.</p><p>While we wrap up the last few lines of code, we wanted to write about what we’ve learned and the problems we’re solving while building Ether for ourselves, and more importantly, for you.</p><p>This is how we think systems should be built.</p><h4>Strive For Purpose Over Definition</h4><p>A lot of times people conflate design systems with pattern libraries and design guides—we don’t blame them. Up to this point they’ve been very much the same. Where a lot of design systems fall short is their ability to not only define <em>what </em>is in the system but <em>why</em> it’s there in the first place.</p><p>The system should strive to give developers a clear idea of the purpose behind the application of visual style and behavior. The system’s job is to guide the design of everything it relates to the same way a human designer would. Simple color definitions and text specs don’t come nearly close enough. By mapping definition to usage we can codify the thought process of a product designer, allowing for the ultimate goal of any system: <strong>scale.</strong></p><h4>Don’t Be Everything for Everyone</h4><p>Systems quickly turn into a quagmire of variables, alternates, knobs, and levers if not taken care of (we know this one from experience). The most difficult part of this concept is balancing the two sides of the spectrum—too simplistic and the system becomes inflexible, too customizable and the system becomes bloated. Both will make your system unusable.</p><p>The guiding principle when dealing with additions to our systems is this question: <em>Can I solve the problem I’m facing with something already defined?</em></p><p>It’s a tough question—especially when designers are involved—but it does wonders to keep a system from taking on unnecessary cruft just to handle edge-cases or one-offs. Although it may make your system hostile towards design-snowflakes it helps achieve a far greater goal: <strong>clarity.</strong></p><h4>Build for Change</h4><p>A year from now, you want to be using the same system you started with today; one that allows for growth and evolution over time. Much like a CMS or website project, the last thing you want to do in a couple years is burn down your entire project and start from scratch. We do that in multiple ways:</p><ol><li>By abstracting visual style definition and usage.</li><li>By keeping our systems simple and modular.</li><li>By not over-defining system elements.</li></ol><p>Using these handy tricks we can create a design system that flexes gracefully over time instead of crumbling under its own weight. No one wants that.</p><p><em>Ether is coming soon.</em> In the meantime check out the <a href="http://ether.thescenery.co/">teaser page</a>, and sign up to get notified when it launches.</p><p>—We are The Scenery</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=72a3e7d423ce" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>