If you need insights into improving productivity, this essential developer’s guide to containers will help you manage projects cross-platform, seamlessly.

Containerization is gradually making its way into embedded systems, though it's not yet widespread. Unlike desktop and cloud applications, embedded software faces unique challenges due to hardware constraints and the integration of specialized devices. This paper offers an overview of how containers can enhance embedded systems, drawing on our research and experience. Discover whether it's the right time to incorporate this transformative technology into your embedded toolkit and stay ahead in the evolving landscape!

Discover the new features of C++20 update in programming. Equip yourself with the skills to stay on top of advancements.

The first module in a whitepaper series on designing your first embedded device; it covers the beginning and ending of the product development process. At the onset of a new project are a handful of critical choices that shape and constrain every other decision down the line. Similar “up front” decisions around your expected customer experience influence your ability to update or change your product after it’s already in the customer’s hands. These decisions frame the entire development process.

The most challenging decision you’ll make when creating your first embedded Linux device is about the hardware. While you can do a software upgrade mid-development without massive disruption, making changes in hardware development comes at a much higher cost. So, you must make some critical decisions upfront about which CPU, board, and peripherals you want to use in your embedded Linux device. This whitepaper examines the numerous planning considerations that go into choosing hardware to help you expedite your development process.

Deciding on the various software components in your stack is a crucial step when creating your first embedded Linux device. You want to build a stack that meets your objectives now and brings continued value in the future. However, there are so many tools you can combine to build and maintain a successful product it can be challenging to know where to start. This whitepaper examines your choices for the entire software stack, from the OS to the application, and gives you things to consider at every step.

Before creating your first embedded Linux device, you need to determine how you want to build your software. After all, the tools and development processes for embedded Linux may be quite different from what you’re used to with smaller microcontroller-based or bare-metal systems. If you want a well-designed, easy-to-maintain, and cost-effective solution, take the time to research your options and keep in mind the following key considerations.

This whitepaper is the first in KDAB's Software Development Best Practices series and covers the basics. Many of the tips will not surprise most professional software engineers, but if you’re just getting started, it can be a handy reminder. If you’re not already doing everything here, you should be.

While some methodologies, workflows, and tools are specific to an individual domain, many are applicable regardless of whether you’re developing a web service, embedded device, mobile app, or desktop application. This whitepaper gives a few general best practices widely applicable to most development projects.

Unlike a lot of modern development, embedded development is close to the hardware. It runs on specialized boards, uses custom testing harnesses, requires expensive debugging equipment, and has its own characteristic workflows. That hardware dependency makes embedded development.

The build system for Qt is CMake. Should you use it yourself? What are the benefits of CMake, and how can it help transform your build system? This whitepaper gives you the basic facts so you can take advantage of CMake for building Qt applications.

Today’s system-on-chip processors have a huge array of resources to contribute to your solution: multiple cores and on-board DSPs, graphics engines and display controllers, peripheral support and connectivity interfaces, and more. A new hardware platform entails a costly investment. This is a guide to the many factors to take into account when choosing CPU hardware

While desktop development shares a lot of best practices with other types of software, a few things make it stand apart. Development of an application that sits on a user's desktop, no matter what that consists of, requires a flexible design. Desktop applications are bigger than programs for embedded and IoT and they demand an architecture more complex than server or cloud apps with their tightly controlled environments. Here are some of our best practices for building these complex desktop applications.

In a modern software development process, continuous integration (CI) and continuous deployment (CD) play a vital role. However, implementing CI/CD within an organization can be challenging. Due to the need for customization to align with specific work products and workflows, it often requires some trial and error. To help you minimize needless dead-ends, we’ll share some of our hard-won advice on using and configuring CI/CD systems, as well as explain why you should be using CI/CD if you’re not already.

For consumer apps in app stores, update delivery is straightforward. But many systems—like embedded devices, industrial desktops, and specialized tablets—operate outside these stores. For such applications, developers must design their own robust update delivery mechanism.

One of the most difficult choices when starting any new software project is selecting the programming language and framework your team will use to create it. Should you stick with Qt because it’s the best tool for the job? Should you switch to something using web-based technology or designed explicitly for mobile? The choice of a software stack is a strategic decision. Here is a list of considerations that we use to help customers select a software stack that can stand the test of time, whether that’s Qt or something else.

Supervisory control and data acquisition (SCADA) systems have been responsible for the streamlining of any industry that needs precise and consistent controls. However, the UIs of many SCADA devices look antiquated. Even the non-designers responsible for running the system expect their SCADA human-machine interface (HMIs) to have polish and sophistication. This whitepaper provides a quick overview on why KDAB finds Qt to be an ideal tool for building today’s modern SCADA systems.

Learning to create 3D applications can be an overwhelming task even for seasoned developers because of all the new terminology, visual concepts, and advanced math. To simplify the job, many developers use a framework like Qt 3D, which KDAB developed and contributed to Qt. In this paper, the first of 3 whitepapers, you will learn about the structure of a Qt 3D program – the nature of entities, components, and aspects, and how those are incorporated into the scene graph and frame graph. The Qt 3D Basics series is intended to help developers create highly polished Qt 3D applications, including descriptions of the technology components, the rationale behind their designs, and straightforward examples.

While an all-Rust approach works for some systems, most companies have extensive existing C and C++ code. Rust's design, rooted in Mozilla Firefox's development, has always aimed to integrate with these languages. By consulting Rust experts, we've developed guidelines for harmoniously blending Rust with C and C++ in various scenarios.

The ability to create a 3D applications is a skillset that is increasingly in demand as it plays a crucial role in advanced UX design, virtual reality, game development, and more. While developing a modern 3D program requires many disparate skills, there are frameworks that help the developer stitch it all together. Qt 3D, developed by KDAB, is one such framework. Our first Qt 3D whitepaper helped us understand the structure of a Qt 3D program - the nature of the entities, components and aspects, in the scene graph and frame graph. This paper shows how to incorporate those elements into a functioning program by examining how to receive user input and how to animate objects in a scene.