A Imaginative and prescient for Our Sass – A Record Aside

At a latest CSS meetup, I requested, “Who makes use of Sass of their each day workflow?” The response was overwhelmingly optimistic; now not reserved for pet tasks and experiments, Sass is quick turning into the usual approach for writing CSS.

Article Continues Beneath

That is nice information! Sass offers us much more energy over complicated, ever-growing stylesheets, together with new options like variables, management directives, and mixins that the unique CSS spec (deliberately) lacked. Sass is a stylesheet language that’s sturdy but versatile sufficient to maintain tempo with us.

But alongside the wide-scale adoption of Sass (which I applaud), I’ve noticed a gentle decline within the high quality of outputted CSS (which I bemoan). It is smart: Sass introduces a layer of abstraction between the creator and the stylesheets. However we want a method to translate the online requirements—that we fought so laborious for—into this new setting. The issue is, the Sass specification is increasing a lot that any set of requirements would require fixed revision. As a substitute, what we want is a constitution—one which sits outdoors Sass, but informs the way in which we code.

To see a approach ahead, let’s first look at some hassle spots.

One well-documented abuse of Sass’s feature-set is the tendency to closely nest our CSS selectors. Now don’t get me fallacious, nesting is useful; it teams code collectively to make model administration simpler. Nonetheless, deep nesting may be problematic.

For one, it creates lengthy selector strings, that are a efficiency hit:

physique #important .content material .left-col .field .heading { font-size: 2em; }

It might muck with specificity, forcing you to create subsequent selectors with better specificity to override types additional up within the cascade—or, God forbid, resort to utilizing !vital:

physique #important .content material .left-col .field .heading  [0,1,4,1]
.field .heading  [0,0,2,0]
Comparative specificity between two selectors.

Final, nesting can scale back the portability and maintainability of types, since selectors are tied to the HTML construction. If we wished to repeat the model heading for a field that wasn’t within the leftcol, we would wish to write down a separate rule to perform that.

Difficult nesting might be the largest perpetrator in churning out CSS soup. Others embrace code duplication and tight coupling—and once more, these are the outcomes of poorly fashioned Sass. So, how can we study to make use of Sass extra judiciously?

Working towards a treatment#section3

One possibility is to create guidelines that act as limits and reign in a few of that energy. For instance, Mario Ricalde makes use of an Inception-inspired guideline for nesting: “Don’t go greater than 4 ranges deep.”

Guidelines like this are particularly useful for newcomers, as a result of they supply clear boundaries to work inside. However few common guidelines exist; the Sass spec is sprawling and rising (as I write this, Sass is at model 3.4.5). With every new launch, extra options are launched, and with them extra rope with which to hold ourselves. A rule set alone can be ineffective.

We want a proactive, higher-level stance towards creating greatest practices fairly than an emphasis on amassing particular person guidelines. This might take the type of a:

  • Code customary, or pointers for a particular programming language that advocate programming model, practices, and strategies.
  • Framework, or a system of recordsdata and folders of standardized code, which can be utilized as the muse of a web site.
  • Type information, or a dwelling doc of code, which particulars all the assorted components and coded modules of your website or software.

Every method has distinct benefits:

  • Code requirements present an effective way of unifying a group and enhancing maintainability throughout a big codebase (see Chris Coyier’s Sass pointers).
  • Frameworks are each sensible and versatile, providing the bottom barrier to entry and eradicating the burden of choice. As each seasoned front-end developer is aware of, even deciding on a CSS class identify can develop into debilitating.
  • Type guides make the connection between the code and the output specific by illustrating every of the parts throughout the system.

Every additionally has its difficulties:

  • Code requirements are unwieldy. They should be saved up-to-date and might develop into a barrier to entry for brand new or inexperienced customers.
  • Frameworks are inclined to develop into bloated. Their flexibility comes at a price.
  • Type guides endure from being context-specific; they’re distinctive to the model they characterize.

Sadly, whereas these strategies handle the technical facet of Sass, they don’t get to our actual drawback. Our difficulties with Sass don’t stem from the specification itself however from the way in which we select to make use of it. Sass is, in spite of everything, a CSS preprocessor; our Sass drawback, subsequently, is one among course of.

So, what are we left with?

Re-examining the affected person#section4

Each job has its artifacts, however issues come up if we elevate these by-products above the ultimate work. We should keep in mind that Sass helps us assemble our CSS, however it isn’t the tip recreation. In actual fact, if the introduction of CSS variables is something to go by, the CSS and Sass specs are starting to converge, which implies someday we might dispose of Sass completely.

What we want, then, is an answer directed not on the code itself however at us as practitioners—one thing that gives technical pointers as we write our Sass, however concurrently lifts our gaze towards the long run. We want a public declaration of intentions and targets, or, in different phrases, a manifesto.

After I first found Sass, I developed some private pointers. Over time, they formalized right into a manifesto that I may then use to guage new options and strategies—and whether or not they’d make sense for my workflow. This grew to become significantly vital as Sass grew and have become extra broadly used inside my group.

My Sass manifesto consists of six tenets, or articles, outlined beneath:

  1. Output over enter
  2. Proximity over abstraction
  3. Understanding over brevity
  4. Consolidation over repetition
  5. Perform over presentation
  6. Consistency over novelty

It’s price noting that whereas the actual software of every article might evolve because the specification advances, the articles themselves ought to stay unchanged. Let’s cowl every in slightly extra depth.

1. Output over enter#section6

The standard and integrity of the generated CSS is of better significance than the precompiled code.

That is the tenet from which all of the others dangle. Keep in mind that Sass is one step within the course of towards our purpose, delivering CSS recordsdata to the browser. This doesn’t imply the CSS must be superbly formatted or readable (this can by no means be the case should you’re following greatest practices and minimizing CSS), however you will need to maintain efficiency on the forefront of your thoughts.

While you undertake new options within the Sass spec, you need to ask your self, “What’s the CSS output?” If doubtful, have a look underneath the hood—open the processed CSS. Growing a deeper understanding of the connection between Sass and CSS will assist you establish potential efficiency points and construction your Sass accordingly.

For instance, utilizing @lengthen targets each occasion of the selector. The next Sass

.field {
	background: #eee;
	border: 1px stable #ccc;

	.heading {
	  font-size: 2em;

.box2 {
	@lengthen .field;
	padding: 10px;

compiles to

.field, .box2 {
  background: #eee;
  border: 1px stable #ccc;
.field .heading, .box2 .heading {
  font-size: 2em;

.box2 {
  padding: 10px;

As you’ll be able to see, not solely has .box2 inherited from .field, however .box2 has additionally inherited from the situations the place .field is utilized in an ancestor selector. It’s a small instance, however it reveals how one can arrive at some sudden outcomes should you don’t perceive the output of your Sass.

2. Proximity over abstraction#section7

Initiatives needs to be transportable with out over-reliance on exterior dependencies.

Anytime you employ Sass, you’re introducing a dependency—the only set up of Sass is dependent upon Ruby and the Sass gem to compile. However remember that the extra dependencies you introduce, the extra you threat compromising one among Sass’s best advantages: the way in which it allows a big group to work on the identical mission with out stepping on each other’s toes.

For example, together with the Sass gem you’ll be able to set up a bunch of additional packages to perform virtually any job you’ll be able to think about. The most typical library is Compass (maintained by Chris Epstein, one among Sass’s unique contributors), however you may also set up gems for grid techniques, and frameworks corresponding to Bootstrap, proper right down to gems that assist with a lot smaller duties like making a shade palette and including shadows.

These gems create a set of pre-built mixins you could draw upon in your Sass recordsdata. In contrast to the mixins you write inside your mission recordsdata, a gem is written to your pc’s set up listing. Gems are used out-of-the-box, like Sass’s core capabilities, and the one reference to them is through an @embrace methodology.

Right here’s the place gems get tough. Let’s return to the situation the place a group is contributing to the identical mission: one group member, whom we’ll name John, decides to put in a gem to facilitate managing grids. He installs the gem, contains it within the mission, and makes use of it in his recordsdata; in the meantime one other group member—say, Mary—pulls down the most recent model of the repository to alter the fonts on the web site. She downloads the recordsdata, runs the compiler, however out of the blue will get an error. Since Mary final labored on the mission, John has launched an exterior dependency; earlier than Mary can do her work, she should debug the error and obtain the right gem.

You see how this drawback may be multiplied throughout a bigger group. Add within the complexity of versioning and inter-gem-dependency, and issues can get very furry. Finest practices exist to keep up constant environments for Ruby tasks by monitoring and putting in the precise mandatory gems and variations, however the easiest method is to keep away from utilizing extra gems altogether.

Disclaimer: I at present use the Compass library as I discover its advantages outweigh the disadvantages. Nonetheless, because the core Sass specification advances, I’m contemplating when to say goodbye to Compass.

3. Understanding over brevity#section8

Write Sass code that’s clearly structured. All the time take into account the developer who comes after you.

Sass is able to outputting super-compressed CSS, so that you don’t should be heavy-handed in optimizing your precompiled code. Additional, not like common CSS feedback, inline feedback in Sass aren’t outputted to the ultimate CSS.

That is significantly useful when documenting mixins, the place the output isn’t at all times clear:

// Power overly lengthy spans of textual content to truncate, e.g.:
// @embrace truncate(100%);
// The place $truncation-boundary is a united measurement.

@mixin truncate($truncation-boundary){

Nonetheless, do take into account which elements of the your Sass will make it to the ultimate CSS file.

4. Consolidation over repetition#section9

Don’t Repeat Your self. Acknowledge and codify repeating patterns.

Earlier than you begin any mission, it’s smart to take a seat down and attempt to establish all of the totally different modules in a design. This is step one in writing object-oriented CSS. Inevitably some patterns received’t develop into obvious till you’ve written the identical (or comparable) line of CSS three or 4 occasions.

As quickly as you acknowledge these patterns, codify them in your Sass.

Add variables for recurring values:

$base-font-size: 16px;
$gutter: 1.5em;

Use placeholders for repeating visible types:

%dotted-border { border: 1px dotted #eee; }

Write mixins the place the sample takes variables:

//transparency for picture options
@mixin clear($shade, $alpha) {
  $rgba: rgba($shade, $alpha);
  $ie-hex-str: ie-hex-str($rgba);
  background-color: clear;
  background-color: $rgba;
  zoom: 1;

In the event you undertake this method, you’ll discover that each your Sass recordsdata and ensuing CSS will develop into smaller and extra manageable.

5. Perform over presentation#section10

Select naming conventions that target your HTML’s operate and never its visible presentation.

Sass variables make it extremely simple to theme a web site. Nonetheless, too usually I see code that appears like this:

$red-color: #cc3939; //purple
$green-color: #2f6b49; //inexperienced

Connecting your variables to their look may make sense within the second. But when the design modifications, and the purple is changed with one other shade, you find yourself with a mismatch between the variable identify and its worth.

$red-color: #b32293; //magenta
$green-color: #2f6b49; //inexperienced

A greater method is to call these shade variables primarily based on their operate on the location:

$primary-color: #b32293; //magenta
$secondary-color: #2f6b49; //inexperienced

Presentational courses with placeholder selectors#section11

What occurs once we can’t map a visible model to a useful class identify? Say we’ve a web site with two call-out containers, “Contact” and “References.” The designer has styled each with a blue border and background. We wish to maximize the pliability of those containers however reduce any redundant code.

We may select to chain the courses in our HTML, however this will develop into fairly restrictive:

<div class="contact-box blue-box">
<div class="references-box blue-box">

Keep in mind, we wish to concentrate on operate over presentation. Fortuitously, utilizing the Sass @lengthen methodology along with a placeholder class makes this a cinch:

%blue-box {
	background: #bac3d6;
	border: 1px stable #3f2adf;

.contact-box {
	@lengthen %blue-box;
.references-box {
@lengthen %blue-box;

This generates the next CSS, with no seen references to %blue-box anyplace, besides within the types that carry ahead.

.references-box {
	background: #bac3d6;
	border: 1px stable #3f2adf;

This method cuts references in our HTML to presentational class names, however it nonetheless lets us use them in our Sass recordsdata in a descriptive approach. Attempting to plan useful names for widespread types can have us reaching for phrases like base-box, which is way much less significant right here.

6. Consistency over novelty#section12

Keep away from introducing pointless modifications to the processed CSS.

In the event you’re eager to introduce Sass into your workflow however don’t have any new tasks, you may surprise how greatest to make use of Sass inside a legacy codebase. Sass totally helps CSS, so initially it’s so simple as altering the extension from .css to .scss.

When you’ve made this transfer, it could be tempting to dive straight in and refactor all of your recordsdata, separating them into partials, nesting your selectors, and introducing variables and mixins. However this will trigger hassle down the road for anybody who’s choosing up your processed CSS. The refactoring might not have affected the show of something in your web site, however it has generated a totally totally different CSS file. And any modifications may be extraordinarily laborious to isolate.

As a substitute, one of the best ways to change to a Sass workflow is to replace recordsdata as you go. If it’s essential change the navigation, separate that portion into its personal partial earlier than engaged on it. This can protect the cascade and make it a lot simpler to pinpoint any modifications later.

I like to consider our present difficulties with Sass as rising pains. They’re signs of the changes we should make as we transfer to a brand new approach of working. And an eventual treatment does exist, as we mature in our understanding of Sass.

It’s my imaginative and prescient that this manifesto will assist us get our bearings as we journey alongside this path: use it, change it, or write your personal—however begin by specializing in how you write your code, not simply what you write.

Leave a Comment