Interfacing with users
Successful software is always easy to use!
No matter how incredible an applications can be, if the only one who can actually use it is its creator, it is bound to fail. There are many rules for properly interfacing an application to its user, but one stands above them all: simplicity.
That means that each interaction with the user must be quite elementary and sufficiently described so that it unambiguously leads to the expected behavior. It also means that, and that’s a point that is often overlooked, if a parameter of the application modifies its behavior or another parameter, such changes must be documented. As much as possible, the modifications that occurs must be done by the interface itself: leaving the application in a state that it is impossible to work is not a good option.
Another important aspect is the design of the interface: two components of an application that interact together must be close or at least easy to find. This is why some very powerful applications are sometimes underused: it is simply impossible to find where each options are, unless someone have already seek for them for a long time.
This must be though for at the early steps of the interface creation: changing a whole layout between version is what have cause many application to be simply abandoned or defamed.
At OVHPA – High Performance Applications, we have experience about interfacing with complex programs from theoretical science in simple ways. We use portable library such as GTK or QT for graphical user interface (GUI), when application needs one, and we can go up to advanced 3D rendering using OpenGL. Should you require a mobile Android application it is also possible. In all cases, we will always chose to create an interface with library that are well maintained and widely used: this is a guarantee that your application will have a long life, and will be universally available.
Finally, the complexity of any interface should be always hidden under the carpet. Once a user have install your application, he should not be worried about what version of the library is needed, or what additional programs need to be added to unlock a functionality. Whenever possible, an application should make the full use of available package installer, clearly taking care of all its dependency, whether mandatory or optional. Depending on your distribution model, this is an extra work that can be simplified by using a low number of dependency, and using only the ones that maintain a consistent application programming interface (API) over the time.
User don’t need to know what happen behind your interface.
Interfacing with machines
Machines can be more susceptible than Humans.
One important point that is often disregarded is how an application will interface with others in a given environment, and of course with the environment itself. If the only possibility to use your application is to install a specific operating system (OS), then configure it in a specific way, then add some specific programs and libraries; chances are that your application will only be used by user who already have almost everything installed.
Depending on your needs, your application may not need to be portable to several OS: if your design targets mostly supercomputers, or is a program for a smart-watch, etc. But even in these case, interfacing with the different component of a system can be tricky: supercomputers have many incompatible queuing systems, embedded OS of smart-watch are far from consistent.
Ideally, an application should be design so that it is as easy to interface with machines as it is with users. However, that might not be so simple. In OVHPA – High Performance Applications, we have a long experience of scripting, scheduling, interconnecting, and optimizing resources (see the Programming page), so we are confident that we can make your application the one future developers will want to interface to.
Interfacing with hardware must be flawless.