• Complain

Michael Mangialardi - Design systems for developers: Learn how to code design systems that scale

Here you can read online Michael Mangialardi - Design systems for developers: Learn how to code design systems that scale full text of the book (entire story) in english for free. Download pdf and epub, get meaning, cover and reviews about this ebook. year: 2021, publisher: leanpub.com, genre: Computer. Description of the work, (preface) as well as reviews are available. Best literature library LitArk.com created for fans of good reading and offers a wide selection of genres:

Romance novel Science fiction Adventure Detective Science History Home and family Prose Art Politics Computer Non-fiction Religion Business Children Humor

Choose a favorite category and find really read worthwhile books. Enjoy immersion in the world of imagination, feel the emotions of the characters or learn something new for yourself, make an fascinating discovery.

No cover
  • Book:
    Design systems for developers: Learn how to code design systems that scale
  • Author:
  • Publisher:
    leanpub.com
  • Genre:
  • Year:
    2021
  • Rating:
    4 / 5
  • Favourites:
    Add to favourites
  • Your mark:
    • 80
    • 1
    • 2
    • 3
    • 4
    • 5

Design systems for developers: Learn how to code design systems that scale: summary, description and annotation

We offer to read an annotation, description, summary or preface (depends on what the author of the book "Design systems for developers: Learn how to code design systems that scale" wrote himself). If you haven't found the necessary information about the book — write in the comments, we will try to find it.

Lots of design token-related tips and tricks to learn in this book from design tools to production, with an emphasis on the fact tools and automation are only useful if good communication is happening between designers and developers in the first placeConfidently Develop a Company-Wide Design System At ScaleDeveloping a design system demands more than a UI component library and Storybook.As a developer working on a design system, youre responsible for extracting design specifications from design files and translating them into code. If that code cannot scale across all the applications that are consuming the design system, or that will consume the design system in the future, the company suffers.You can easily get stuck building very narrow tools, like a React component library without a firm foundation. Because a React component library is great, but it can be costly if you do it too soon. At any company, applications can vary by platform (i.e. web) and technology (i.e. React). If all you have is a React component library, as soon as you introduce an application with a different technology (i.e. Vue), then you have to find a way to share the design specifications between the React component library and the Vue component library. So, you might create a CSS-in-JS library that can encapsulate the design specifications and be consumed by the React and Vue component libraries respectively.But, what happens when a request arises for an encapsulation of the design specifications in a way that would work for a plain HTML site? Well, you could move the encapsulation of the design specifications from a CSS-in-JS library to a plain CSS file. However, that limits the React and Vue developers from using their preferred technologies, and that breaks down when a non-web application is introduced (i.e. an Android mobile app). Usually what happens is that the React and Vue developers would carry along with a CSS-in-JS library and the plain HTML developers carry along with a plain CSS file. The issue is that you have your design specifications represented in code in multiple places. You can no longer know which one is the source of truth. You generate an increased risk that the various applications in a company are out of sync with the official design system and with each other.At the end of the day, you need to represent your design specifications in code in a single place. From that single source of truth, you can then generate the platform deliverables (i.e. CSS variables, JS modules, etc.) What you dont want to do is to create platform deliverables without a single source of truth, without a mechanism to keep all the consumers of those deliverables in sync with the design system and one another.It turns out that many companies have been looking into these problems including Shopify, Adobe, Discovery Education, Morningstar, Orbit, Salesforce, Bloomberg, and more.The solution is creating design tokens and managing a style dictionary.Design Systems for Developers is a deep dive into the need for design tokens, an explanation of them, and practical solutions for using them to launch design system tools into production.Moreover, I emphasize the fact that tools and automation are only useful if good communication is happening between designers and developers in the first place.In this book, youll not only learn the technical skills that go into building design system tools for production, but also the soft skills required for collaboration between designers and developers.Whether youre a designer or a developer, this book is for you.I trust that after reading this book, developers will be able to work on a design system for any company, regardless of the number of applications and the platform and technologies that those applications are geared for.I also trust that designers will have a better understanding of their role in collaborating with developers to create a robust design system.In this book, well outline the problems associated with creating tools, like a React UI component library, to encapsulate the styles of a design system, such as the inflexibility of scaling when new applications arise targeting a different platform and tech stack.From there, we go over how these problems may be solved by creating design tokens, representations of design specifications in code, and style dictionaries, a central management system for storing design tokens and transforming them into platform deliverables.Well write some code, discuss different approaches, and cover the very practical details, like how to schedule meetings to collaborate with designers.

Michael Mangialardi: author's other books


Who wrote Design systems for developers: Learn how to code design systems that scale? Find out the surname, the name of the author of the book and a list of all author's works by series.

Design systems for developers: Learn how to code design systems that scale — read online for free the complete book (whole text) full work

Below is the text of the book, divided by pages. System saving the place of the last page read, allows you to conveniently read the book "Design systems for developers: Learn how to code design systems that scale" online for free, without having to search again every time where you left off. Put a bookmark, and you can go to the page where you finished reading at any time.

Light

Font size:

Reset

Interval:

Bookmark:

Make
Design Systems for Developers Learn how to code design systems that scale - photo 1
Design Systems for Developers
Learn how to code design systems that scale
Michael Mangialardi

This book is for sale at http://leanpub.com/designsystemsfordevelopers

This version was published on 2021-04-09

This is a Leanpub book Leanpub empowers authors and publishers with - photo 2

* * * * *

This is a Leanpub book. Leanpub empowers authors and publishers with the Lean Publishing process. Lean Publishing is the act of publishing an in-progress ebook using lightweight tools and many iterations to get reader feedback, pivot until you have the right book and build traction once you do.

* * * * *

2021 Michael Mangialardi
1 - The Mission

Ok, so youre a really passionate UI developer

Great! Weve got an exciting project that we want to entrust with you.

Our top-notch, e-commerce site ZapShoes provides the zappiest way to get shoes delivered to your doorsteps.

We recently raised 100 million dollars in funding, and we believe we can keep the momentum going by giving our application a facelift.

Weve hired a core group of designers that have whipped up a fresh design system.

So far, the design system just includes a set of Figma files.

Since youre the UI guru, we want you to build tools that will ensure that our current web application can successfully be migrated to the new design system and stay in sync with it.

We also want the tooling to be flexible to be able to easily handle a future redesign.

Moreover, we want to ensure that if we add applications for other platforms, like mobile and desktop, that we have a smooth way of ensuring that those applications can adopt and stay in sync with the design system.


Imagine being a new hire and assigned the project as Ive outlined above.

How would you feel?

Well, given that youre a developer, you may feel excited.

After all, developers love solving problems. At the end of the day, the project is just another problem to solve, and solving problems is fun.

You might also feel energetic.

A design system is a really fun thing to work on.

Its a perfect blend of doing something thats highly visual and architectural, requiring you to think on a large scale of how systems work together.

It satisfies both the visually orientated and engineering-driven sides of a frontend engineer, a combination that is hard to come across.

More likely than not, you would feel nervous.

Creating the tooling around a design system is an exciting, energizing task, but it is also intimidating.

There is a whole lot of ground to cover, starting from receiving a set of design files to delivering assets to an indefinite list of consuming applications, regardless of platform and technology.

You are molding the way for the future yet working within the bounds of current technology, which is always subject to change.

There is an indefinite list of stakeholders interested in the tooling around the design system, each wanting the tooling to work well for their use cases.

Let me encourage by making some remarks which hopefully will take the bite out of these intimidating thoughts.

First, if you are a developer you love to solve problems. Not only that, I completely trust that as a developer, you are talented in being able to solve problems. A design system is just another problem that you are capable of solving.

Second, a design system is satisfying to work on as mastering it will give you an appealing professional skill, enlarging your critical thinking, communication, and coding skills.

Third, working on a design system requires covering a lot of ground, but that is simply an opportunity to work with a wide range of talented peers.

The connections you are forced to make will boost your morale. The solutions that you build will bless a wide range of people, providing an objective value to your work that will certainly result in an increase in your energy and motivation.

Finally, you are not alone. As of today, there countless developers who are trying to solve similar problems. There are modern technologies that make building tooling around a design system easier and more engaging than ever.

One of those countless developers trying to solve a similar problem is me. He also gets nervousness mixed in with the excitement when thinking about design systems.

The mission of my book, therefore, will be to walk with you as a fellow nervous developer, growing our ability to solve the problems surrounding design systems.

By the end of it, we will know how to solve the imaginary project that ZapShoes has assigned to us. In other words, youll be able to develop tools for a robust design system all by yourself.

2 - The Problem

There are several difficulties in trying to develop tools for a design system.

First, the design system has to scale as more and more applications are added within a company.

Second, the design system has to be consumable across various types of platforms (i.e. web, mobile, desktop) as well as specific technologies for those platforms (i.e. React, Vue, Angular).

Third, the design system has to be flexible to handle updates by the designers.

Similarly, and finally, the design system as implemented by consuming applications has to be high fidelity. Meaning, it has to be pure, or faithful, to the official specifications.

Lets talk briefly about some real-life scenarios where these pitfalls are encountered.

The first couple of difficulties are usually encountered together. Imagine that your company, ZapShoes, only consisted of an e-commerce site built with React. To accomplish the project we outlined in the previous chapter, you decided to build a UI component library written in React. That way, you can encapsulate all the design specifications within sharable components.

Now, that only works as long as ZapShoes only consists of a React app. However, another team is spun up to create a customer support app. They decide to build this with Vue (despite your best efforts to persuade them otherwise).

Because of this, you can no longer apply the styles from the design system by consuming a shared UI component library. The React app will need a UI component library that works with React, and the Vue app will need a UI component library that works with Vue. The design specifications are then encapsulated in a shared CSS-in-JS library. This is used to get the design specifications for the UI components in both the React and Vue UI component libraries.

That works as long as all the applications at ZapShoes are built with modern web frameworks. However, theres been a push to go back to the basics with a marketing landing page thats built with plain HTML and CSS. Now, the design specifications need to be encapsulated into a CSS file as that is the only common way to share styles across all three applications in the company.

This stinks because you either need to build some tools to port the CSS to the CSS-in-JS library, or you continue to use plain CSS which doesnt give you the power of CSS-in-JS which you prefer.

You can imagine how this problem can spiral downwards if a mobile application built with Java was announced.

The last couple of difficulties manifest themselves when things do spiral downwards as in the example I just provided. Imagine that because of the sticky situation to either use plain CSS or make a tool to port CSS to a CSS-in-JS library, you decide to have the design specifications encapsulated in the CSS file and a JavaScript file referenced in the CSS-in-JS library.

Next page
Light

Font size:

Reset

Interval:

Bookmark:

Make

Similar books «Design systems for developers: Learn how to code design systems that scale»

Look at similar books to Design systems for developers: Learn how to code design systems that scale. We have selected literature similar in name and meaning in the hope of providing readers with more options to find new, interesting, not yet read works.


Reviews about «Design systems for developers: Learn how to code design systems that scale»

Discussion, reviews of the book Design systems for developers: Learn how to code design systems that scale and just readers' own opinions. Leave your comments, write what you think about the work, its meaning or the main characters. Specify what exactly you liked and what you didn't like, and why you think so.