How and where to start? How to break down complexity into digestible chunks and ensure that created architectures and navigation structures reflect people’s mental models? How to ensure that everyone involved in its creation aligns with what needs to be built?
When writing code, we use objects to map real-world problems and their proposed solution on a one-to-one basis. These objects use simple language and help organize our code and systems so that others can understand them. It’s a way to achieve clarity because everything can be named and described without misconceptions or ambiguity.
We can apply the same thinking when planning and designing software and user experiences. It can help us create systems that match people’s mental models because our objects and structures relate to how they see or experience reality.
If this sounds abstract, think about software as a system of objects with defined attributes, relationships (amongst each other), and actions that users can perform on them. For example, an image that is part of a gallery. It can have different sizes and formats, and we can change its attributes by cropping and editing before sharing the result with others.
By mapping our objects, attributes, relationships, and user actions, we build a tangible representation of our software that helps us get hold of its complexity and collectively see the system as a whole.
Think researchers, designers, developers, product owners, stakeholders, and finally, the people who buy and use our products.
Wouldn’t it be incredible if everyone involved in its creation would have this shared understanding of the scope and functional details?
It would make creating complex products more accessible and help us match the things people expect and desire with what we build and deliver for them.
Language is a powerful tool for building better products, and it’s worth investing time and energy in developing this shared vocabulary upfront to untangle the complexity of the systems we design.