A user's first contact with any program is always the user interface. A good UI can make or break a program. Leaving the user interface design aside (as I am not qualified to speak about that), I will focus on just one fact.
Users hate user interfaces that are not responsive.
In other words, every good user interface must react quickly to a user's input, be that a keyboard, mouse, touchpad, or anything else.
What are the tasks that can make a user interface unresponsive? Basically, they all fall into one of two categories:
- A program is running a slow piece of code. While it is running, the UI is not responding.
- Updating the user interface itself takes a long time.
The problems from the first category fall into two subsets—functions that have non-blocking (asynchronous) alternative and functions that don't.
Sometimes we can replace the slow function with another one that runs asynchronously. For example, instead of using a standard function for reading from a file, we can use the Windows Asynchronous File I/O API. File reading will then occur in parallel with our program and we will be notified of successful or unsuccessful reads via some other mechanism.
Often, however, this is not possible (there is no alternative for the slow function) or the asynchronous version is too complicated to implement. In that case, we can execute the slow code in a thread. This will be covered in chapters 5 to 7.
An excellent candidate for the multithreaded approach is the file reading example. True, Windows offers an asynchronous API for that, but it is quite complicated and tricky to implement correctly. Pushing a read operation into a thread is simpler and cross-platform compatible, if that is important for your application.
The second category (updating the UI takes a long time) is typically solved with a simple solution: Do less updating! Delphi/Windows controls are typically very fast and they only fail when we want them to do too many operations in a short time.
We will now focus on that category. I'll show a few examples of overabundant updates and give solutions for faster code.