Writing apps that users use are hard. Therefore, we’ve to divide them into small chunks so that each part manageable.

In this article, we’ll look at the ways that we can do that.

Separating Systems Into Modules

We need to divide our software system into modules so that they only do one thing and that coupling between the modules is small.

This way, maintenance will be easy and we won’t have to worry about our changes breaking another part of an app.

Publish/Subscribe

We shouldn’t push all the events through a single routine. This violates object encapsulation. One routine has intimate knowledge of the interactions among many objects.

The coupling also increases because of that. The objects emitting the events have to know about these events.

We probably have to violate the do not repeat yourself principle to get around the tight coupling. Also, there’s no orthogonality since the tight coupling will mean that making one change of one part of the system will affect another part of it.

We can use the publish and subscribe pattern to separate the model from the views of the model. This way, we just publish one event and any entity that wants to listen to the event can listen to it.

It’s much better than having every entity being tightly coupled to each other.

We can implement this by implementing an event bus that channels events in one location and anything that sends and listens to the events can listen to the same location.

Model-View-Controller

The model-view-controller (MVC) pattern is a simple design pattern that separates the data layer from the presentation layer.

The model layer has the business logic and data manipulation logic. The view presents whatever data that’s needed to be presented but doesn’t do any data manipulation.

#programming #software-development #web-development #technology #software-engineering #progressive web app