A Deep Dive into Reusable Components.

Reusability is one of the most common and frequently used buzzwords in software development. Developers are building components based on collections of reusable components, recently most of the technologies started to equip themselves with this function.

But the question always lingers as to when do you spend the time to make a thing reusable? How do we really build one? or how do I choose one that caters my needs.

This article as some general guidelines for thinking about reusability and its history.

History of Reusable component?

Below is the definition from Wikipedia about Reusability.

In computer science and software engineering, reusability is the use of existing assets in some form within the software product development process; these assets are products and by-products of the software development life cycle and include code, software components, test suites, designs and documentation.

Code reuse has been practiced from the earliest days of programming. Programmers have always reused sections of code, templates, functions, and procedures.

Software reuse is a recognized area of study in software engineering, however, dates only from 1968 Bell Laboratories proposed basing the software industry on reusable components.

Code reuse aim is to decrease the time and effort of the software development process and increase the quality of the software product significantly, software engineering required new technologies. Nowadays, most software engineering design is based on reuse of existing system or components.

The above image depicts the importance of reusability with the concept of shared reusable components and how efficiently it can be used to builds, distribute, and collaborate over components to build multiple applications and projects.

Why do we need a Reusable component?

We know every application are built using a basic standard approach and adding customization is vital to get started with. Hence if the basic standard is made reusable, we can avoid those hours reinventing the wheel.

When designing interface, break down the common design elements (buttons, form fields, layout components etc) into reusable components with well-defined interfaces. That way, next time you need to build some UI you can write less code, which means faster development time, less bug, and less bytes.

Single page applications have become increasingly more complex over the past. The way we approach, and design application have changed a lot. user interface has become even more interactive and often contain very complex flow. The performance is also another factor to be considered in which user are expecting native like experience.

We need to look for some framework that will help you build the best reusable components and manage the state of the application in a predictable way.

Below are some of the reasons justifying reusable component style?

  • Time, Cost and Effort.
  • Create a new higher-level abstraction to development.
  • Multiple Formats are trending everywhere and need to balance out this.
  • Better Usability, there is always demand for simpler and easier UI.
  • Avoid repeating work or let go usage of old technology, consistent brand expectation and maximize developer productivity.
  • Easier testing.

What is Reusable component?

Repeatability in UI or behavior that can help to define what should be a component.

Components are induvial reusable chunks of code.

Top Tools for Reusable components?

Before we deep dive into the top tools let us understand what is a ideal design system.

A design system is a collection of reusable components, guided by clear standards, that can be assembled to build any number of applications.

List of component tool to aid you scale your productivity consistently and efficiently.

Do’s and Don’ts of Reusable components?


  • Think before you reuse.
  • Self-sufficient.
  • Easy to integrate.
  • Components are maintainable and reusable.
  • Readable and easy to test.


  • Many of the “Reusable components” are never reused.
  • Components are built to solve hypothetical problem and not the real ones.

Finally, the culture of reusability is just not solve a problem by setting up and sharing it, we need to ensure it is well maintained and agreed. The reason is that most of the software reuse fails is due to the consistence of maintaining it or lack of close feedback loops.

I think Reusable component is not a just a function it is a source of inspiration.


Open source community — Providing info & insights on Huawei Ecosystem