[Add]    Saturday-Sunday: 8:00 am to 5:00 pm   

Hopping Forwards

From software requirements to reality

Blog

Using Qt for mobile development

Published: 2025-11-23T12:05:31Z

Categories: Software development

Strengths of using Qt

  • Can make use of C++ and its ecosystem, including Qt
  • Can have separation between back-end logic in C++ and front-end logic in QML/JS with mechanisms to allow communication between the two
  • Can make use of JS for UI logic
  • Can use LGPL license to learn how to develop mobile applications with Qt and release a MVP on Android, dynamically linking Qt libraries. Provided this is successful, can acquire a commercial license and develop enterprise application for iOS and Android, re-using learnings and own app code, provided the Qt Company approves the switch over.
  • Have option to make use of Qt Design Studio for a pure QML design. UI Designers with little development knowledge can use this and end up with tangible code that the developers can use. Can work better as a team.
  • Using performant language in C++, pay only for what you use
  • It supports internationalization with Qt Linguist
  • It's being invested into with continual updates.
  • It's cross-platform for both Android OS and iOS
  • It's mature although less mature for mobile development
  • It's modular
  • It's big with a lot of what's needed built-in
  • It provides most of the essential low-level building blocks
  • It's well-documented (for the most part)
  • It's utilizing standard languages like C++, CMake, and JavaScript. If familiar with these technologies, have a head start.
  • The C++ code compiles to native code
  • With QML, can have custom UI components and extend upon them with new properties without having to declare a new component.

Neutrals of using Qt

  • Have learning curve associated with picking up Qt and QML. This is not unique to Qt as other cross-platform frameworks like Flutter also require learning new technologies.

Drawbacks of using Qt

There's a higher cost associated with using Qt

  • Can be less developers that know C++ and Qt well in region and learning these technologies is a huge demand. Size of C++20 standard is quite big even if a lot of it isn't used.
  • Can be higher costs for expertise
  • Can discontinue development on offerings of theirs (e.g. Qt Digital Advertising)
  • Must purchase additional license to make use of Squish for GUI testing and Coco for code coverage, Axivion Suite for static code analysis, and Qt Insight for product usage analysis.
  • Must use the commercial license for an iOS release and to incorporate a couple of useful modules for mobile development into project.
    • Qt Graphs (Data visualizations)
    • Qt Network Authorization (OAuth)
  • Subject to longer development times
    • Lacking built-in hot-reload, slowing UI iteration
    • Higher barrier to entry to learning everything
    • Qt Community is smaller so there's less answers to questions online
    • Smaller ecosystem compared to native ecosystems, meaning some mobile-specific features need native code in Objective-C or Java. Then have to figure out how to bridge or wrap platform-specific features.
    • The QML linter throws a lot of false positives
    • With version updates, Qt documentation can become outdated
    • Upgrading from one Qt version to another can result in new problems to solve

Areas Qt plans to improve in

Seek to target more of C++ developer market as well as broader software development market

  • Greater support for Rust, Python, .NET, Swift, and Kotlin/Java
  • Improvements to Qt AI Assistant

References

https://www.qt.io/qt-bridges

https://www.qt.io/press/qt-group-unveils-expansion-plans-for-technology-agnostic-qt-ecosystem?hsLang=en

https://www.qt.io/hubfs/Investors/Qt_Group_SEB_presentation.pdf?hsLang=en


The case for pro-code development

Published: 2025-08-11T04:15:14Z

Categories: Software development

Reasons to favor pro-code

  • Developer has more control over the quality of what's produced.
  • Developer has more insight into what's happening under the hood.
  • Developer won't have to re-invent the wheel
    • Can make use of code contributions of others that are in some cases worth upwards of millions of dollars.
  • Developer can be more productive
    • Won't have to navigate a clunky visual interface.
  • Developer can make use of professional tooling.
  • Developer can better optimize the performance.
  • Development shouldn't be "democratized" - it's better to have role specialization. The less complex development tools are in order to empower non-developers, the more limited the capabilities of this tool will be. As a result of this, problems with the software solution can't be fixed or a lot of workarounds for what's not possible are needed - Solutions become inelegant and more technical debt is introduced. Then the odds are that domain experts will at some point need professional developers due to issues faced during the development process, which take up time from their own responsibilities, resulting in professional developers being brought in to work on the project and having to work with sub-optimal tools which underutilize their skills.
  • Project is not subject to vendor lock-in. This means costs aren't subject to change based on pricing strategies of an external business.

Reasons organizations still might prefer low-code development

  • Want a proof-of-concept, automation of a process, or a non-critical, simple application such as a questionnaire app and it's possible to have a "quick win" without making a large investment in the time of professional developers.