UI Challenges

So your user interface designer did a great job. The UI will have rad new buttons, animations, and plenty of other things that make you go ooh and ahh. Now it’s a coder’s task to make all of these things work, and work well – that can be a real nuisance!

It’s essential to keep the user interface as problem-free as possible because it’s the greatest component of the user experience. Here’s a short article on what the most common UI challenges are to give you a better idea of what a developer would have to struggle with when realizing a user interface designer’s work. 

The most common problems when coding UI

1. Structured concurrency

In both native mobile development and even on the web, it’s incredibly easy to get concurrent behavior wrong. It’s very common for user interface code to have data races or use-after-dead problems. These are usually related to components that set off asynchronous chains that will eventually themselves set off mutations. 

Promises make for a great API when it comes to asynchronous behaviours, but aren’t that good for composing behaviours together or making sure that they go well together with other UI state changes. 

When on the web, this problem is even more serious. Most JavaScript runs on the main thread without any obvious, easy way to give control back to the event loop and also keep your place in a computation that’s long-running. 

2. Understandable behaviour

Humans make things more interesting - they’re complex, unique, and unpredictable. That’s great, right? Well, not when it comes to building interactive systems. That’s because it becomes ridiculously difficult to understand human behaviour when it’s interacting with an enormous state-space. 

A developer would have to consider not only all of the system’s available data and operations, but multiply them with all of the sequences of user interactions that they can possibly think of.
Obviously, the developer is under a lot of pressure to remember what is an impossible amount of sequences. 

This is contrast to concurrent systems that don’t throw humans into the mix, which are far more easily defined by fixed protocols. But once humans are involved, the number of possible paths through a system become infinite. 

The problems that arise are:

• Changing a pre-existing interface can be hugely daunting because of the countless unknown (and worse, untestable!) paths through it.
  
  
• Reenacting bugs that customers report can be difficult or even impossible. Even with their current and exact data, the problems that they encountered might have been triggered via a very specific sequence or perhaps even the timings of their asynchronous responses.
  
  
• Attempting to specify the interactive system’s behaviour is truly a Herculean task. Even a relatively simple request can mean changes that have a disproportionate difficulty, especially if the request introduces a new state-space or operation interleaving possibilities. 

‍

3. Data synchronization

All applications that started out living on a single computer will eventually be absorbed by the network. A wide variety of options for synchronizing data is necessary, for use in making small web apps work without the internet to correctly merging different users’ edits on large documents. 

There also needs to be a social solution for grouping these options and then helping developers to actually use them practically. 

Conclusion

Developers can run into a lot of problems when they’re trying to make your dream user interface a reality. We know because our devs do it all the time! 

If your project is struggling with this, NerdCloud is here to help you make your new rad design a working UI. Our senior devs have coded hundreds of them and know exactly how to overcome these problems.