Top 12 mistakes in creating cross-platform UIs, Part 1: Solution architecture

May 21, 2018

Santtu Ahonen-May 21, 2018

Mistake #3: Squeezing fully rendered design into embedded devices.

To show cool three-dimensional elements on a screen, a 3D design comes from a designer. Designers will often create fully rendered images, amounting to countless polygons (“Hey, it was working on the designer PC just fine.”). It is left to the developer to try to squeeze the humongous 3D objects into a small device (See Figure 2). It either makes everything really laggy, or adds additional hours of work for the developer, or both.

Figure 2: Fully-rendered images from designers lead to overly complex elements for developers (Source: The Qt Company).

Also on 2D UIs, developers and designers sometimes use overly complex elements on the UI. The challenge is how to optimize that down, shaving and slimming images, elements and polygons to fit a small screen, while keeping the UX the same. Performance and/or time-to-market are often casualties along the way.

Mistake #4: Using one coding language as a one size fits all.

Customers often write too much of the application logic in HTML5, Javascript and/or QML. All these are declarative, scripting technologies that will use CPU resources differently from native C++. This typically leads to both performance and maintenance problems.

Designing the software architecture from the get-go is important. Put on the UI layer first. Then put on C++ and lower layers (binary execution, native binary execution, possible GPU and CPU power used on those layers). When designing software architecture picking the right parts is important.

A well performing Qt application has two major parts: The application logic and heavy lifting is written in C++, and UI and user interaction is written using a higher-level language, such as QML.

Mistake #5: Treating updates and security as features.

Say you’re working on a project, and you’re about two thirds of the way complete. Your customer then wants to add over-the-air software updates and security features. This is a mistake. Updates and security are NOT features. They are design mindsets and core parts of the overall software architecture.

Way too often customers approach updates and security as something that you implement somewhere along the line among other features. They’re not that. Developers must plan and think ahead. What kind of security requirements are there? What parts of the software need regular updates? How do you enact this? How do you verify? It requires a mindset from Day 1. For example, if developers write something on the firmware layer critical for the UI, it may not be possible to update firmware in the same mechanism they can use to update the application layer and the UI.

Mistake #6: Neglecting to optimize your “workspace” in your operating system

We already discussed above about the optimization of the boot-up-performance (mistake #1), but there is more to it.

Reference images for software engineering typically come with a lot of tools and features enabled. They are designed for developers to get an easy start on implementation in their projects. These tools all run simultaneously, but you either use them or you don’t. Start stripping away what you don’t need. Optimize. When this is not done, systems use their limited resources on embedded device to run useless processes in the background. Get rid of those.

Many of the embedded projects work on Yocto-based images that are created with Yocto recipes. Unfortunately, those recipes are also notoriously difficult to use, as the level of documentation varies (see Figure 3). There are many vendors, and one needs to understand intimately the workings of hardware drivers, kernel and other parts of the system. This is an area where money spent on professional consultancy services typically pays back in time-to-market and improved performance.

click for larger image

Figure 3: Many embedded projects work on Yocto-based images created with intricate Yocto recipes are notoriously difficult to use (Source: The Qt Company).

Part 2 of this short series on UI design will look at six more common UI development mistakes related to technology selection, user experience, and more. 

Santtu Ahonen works in The Qt Company as product manager of the Qt for Device Creation. Santtu has over 20 years of experience in product management on various high technology products including Nokia Maemo as Head of Developer Offering Product Management where Qt was essential part of the plan. Santtu joined back in to Qt technology and The Qt Company in spring 2017.

< Previous
Page 2 of 2
Next >

Loading comments...