#metrickit

We must always know that an application, on any platform, requires many lines of code tailored by the developers, a well-built interface made by the designers, among other things, that may include many other professionals (even from other areas!), they had to carefully think, prototype and validate to ensure that I am here able to write and publish this post! 📝✍️

With that many elements at the table, of course, we might not be able to think of every scenario that our application will misbehave, these are the famous hangs and delays that can be critical (we hope not!) and make a weird impression on whoever is using them.

That the session of WWDC21 from this Thursday that I chose to comment on and bring some insights trying to be as less technical as possible so that this post is readable for anyone.

What comes after the tap? 👆

When the user tries to make some kind of interaction on the application (the most common being a tap) there is a whole process behind performing some action and displaying it back to the user, it should be interpreted and properly translated to the application to handle.

When the finger interacts with the screen 👉📲, for the common user it may seem like nothing really happened, but by looking under the curtains, it becomes evident that each iteration has a beginning, an execution sequence, and an end to it, this behaviour is what we call "thread", meaning an execution of a specific sequence of tasks in the given context.

In this interval, there are several threads that are consulted on the code and work together to execute everything they need to guarantee the answer. This process, which isn't visible to the end-user, shouldn't be too time-consuming, and should never delay the response feedback. 🗣

Delays can occur when this queue is full and the extra seconds make the user repeat the interaction, which consequently repeats the query process, thus generating the hang, and the answer is shown after a brief moment, at that point in the championship, the "good experience" was already lost.

That could be worse 💢! Threads cannot always happen together, sometimes communication must be asynchronous, that is, run one thread at a time, because they have dependencies. When this error occurs it's not just a delay, it's a block! 🚫

When requesting a network or when using hardware resources that access files, for example, they should be coded with scenarios in mind that should guarantee good performance and prevent directly impacting user interactions.

How to minimize hangs from our apps?

The main tip is: reduce work on the main thread. It's always recommended that we optimize the work of the main thread and delegate functions to other ones to improve execution time.

Some implementation suggestions and best practices from the WWDC session that make these threads responsive and ensure good performance.

Caching 📲

Notification Observers 👀

Asynchronous API 🔃

Grand Central Dispatch (GCD)🚦

Even though they are good options, it's necessary to be aware of the tradeoffs 🚨 that each one can offer.

Communicating with the end-user ⭐️

Although these are things that happen within the application system, it's always necessary to communicate in some way with the user! This is part of a good design that can predict these kinds of events.