10 design principles that developers should know

Why should I care?

Developers are designers too, they just use a different medium.

Therefore, knowing how to design the system is also part of your final product.

Focusing on making the underlying design more useful will help determine things like:

Easier for new developers to get started

System maintainability and ease of modification

How effective you are as a developer of this system

When I work with developers, I find that these ideas already exist among programmers - they just haven't expressed this to designers yet. There's still a lot to do, but the foundation is there, and isn't that good news?

I don't have any actual code in my examples because I think people are too sensitive about the correct way to write any software.

Like designers, programmers love to use their creativity to solve complex problems. And I would rather you consider the following rules for designing systems, rather than following a strict set of rules that say "this is the best way to solve X problem".

What are design heuristics?

Heuristics are simply learning through your experience. It is a method for finding usability problems in a user interface so that they can be attended to as part of an iterative design process.

We get 3-5 design heuristic experts to use our product and judge whether it complies with the most basic usability rules, known as the “10 Design Heuristics” compliance, which is a simplification of heuristics.

Let’s get started.

1. Visibility of system status

Ever uploaded an image to a website? Like a social network profile picture?

The main principle is to always know the status of your upload. The example above just tells you the status of your upload. And seeing its progress makes the user more comfortable, don't you think?

[[144829]]

2. Match between the system and the real world

When writing documentation or naming a component, always try to use familiar terms. Understand who your target audience is and then use words, phrases, and concepts that are familiar to them.

3. User Control and Freedom

[[144830]]

The system should allow you to explore its contents freely, but in a responsible way, and should allow you to recover from mistakes you might make, such as by supporting "undo" and "redo".

4. Consistency and standards

Apple and Microsoft both have different opinions on the order of the OK and Cancel buttons. Which is better?

All bad or all good? Of course, it doesn't matter, what matters is that you ensure consistency across all user interaction systems.

To do this, you shouldn't confuse your users as to why different words, contexts, or actions produce the same result.

5. Error Prevention

It is very important to prevent errors at the first point where they can occur.

When we first started, we had QA people looking for defects in the product to ensure product quality. Then we put them on the production line and asked them to figure out how to make a defect-free product from the very beginning. You will be surprised how efficient this is when the defects in what you make are found at the earliest time instead of at the end.

—Mary Poppendieck

6. Identifiability

Displaying logos that improve user usability is another helpful element.

The CLI (Command Line Interface) is a great example of a program that completely disregards this principle, and by doing so, it demonstrates elegance (what it lacks in flexibility and efficiency it makes up for).

7. Flexibility and efficiency of use

Provide a latent, hidden layer on your system to help experienced users cut through the "noise" and become more efficient.

The Cli is an example of how powerful a "hidden" interface can be (and we can even choose to extend it).

8. Simplicity

Originally listed as "Aesthetic and minimalist design". This principle is about improving the signal-to-noise ratio.

Everything you provide to your users must be governed by certain constraints — whether it’s bloated HTTP requests hogging bandwidth, APIs riddled with bugs, or interfaces that require too many requests.

Try to use the minimum input to get the maximum output.

9. Help users identify, diagnose, and recover from errors

Error messages should be expressed in plain language (no codes), accurately indicate the problem, constructively suggest a solution, be useful to the user, and provide a solution.

Just like this.

10. Help and Documentation

Like you, I was surprised to see this in the list of design principles.

Even if the system can be used without documentation, it is still important to provide help and documentation. Any such information should be easily searchable, focus on the user's task, list specific steps to proceed, and should not be too large.