KDAB Blog

But that's a knowledge issue. Which is fine, if I can say one thing for sure is that none of us was born knowing anything at all :-)

C++ programmers would probably be used to lower level kind of technologies, but when talking about this I think it just helps to think about what would you do if you wanted to embed an HTML and JS file into your program and wanted it to work like QML works.

For an experienced C++ dev, a list of stuff will naturally start flowing through their mind:

* A mechanism to inject the files into the binary upon compilation.

* How to interpret the HTML and paint on the screen? We'll need an HTML rendering engine and a surface painter.

* About JS, how to run it? Well, maybe time to include V8 into the program. It will take care of running JS code.

* Now to make calls between both languages. Probably V8 already provides callbacks because it implements FFI already for you.

* And other stuff you mentioned, like a property manager that remembers what has been registered and creates change observers in order to trigger events for C++ to know.

Thing is, Qt already gives you all of this done, otherwise their proposal of QML wouldn't have gone too far...

These series of articles touch on the topic and can enlighten a bit about some details:

* https://www.kdab.com/qml-engine-internals-part-1-qml-file-loading/

* https://www.kdab.com/qml-engine-internals-part-2-bindings/

* https://www.kdab.com/qml-engine-internals-part-3-binding-types/

*…

Gradients are supported, patterns not (yet) : https://blog.qt.io/blog/2017/07/07/let-there-be-shapes/

> Also-- does Qt have an equivalent of devtools can ship with the app so that the state of the view can be queried, mutated, and REPL'd in the user's running instance?

Depends. There is Gammaray which can connect to a Qt process (including remotely, quite useful for embedded) & where you can change properties of your objects on the fly : https://www.kdab.com/development-resources/qt-tools/gammaray/

For live reloading, it isn't proposed by default in shipped applications but there are many ways to do it : https://fr.slideshare.net/ICSinc/how-best-to-realize-a-runtime-reload-of-qml. The IDE nowadays does it for instance : http://blog.qt.io/blog/2017/05/24/qt-quick-designer-qt-creator-4-3/.

However, in my experience on live reloading (with QML, Unity3D and Python), it only works well with environments that don't interface to native code. Else it's way too easy to leave some state hanging in a bad way in a DLL (and then you get undebuggable crashes upon undebuggable crashes).

Likewise, there is no REPL provided (since it's declarative in nature... there are no "instructions" being executed directly, only reactions to actions). But implementing your own takes a few lines. I wonder what its point would be though.

> A good tree will have something like log(n) depth so normal recursion should be fine.

Yes, this is true for comparison/search/sort/bucketing algorithms. But in other applications (e.g. graph theory, networks, sparse matrices) a depth of n, for n elements, can be perfectly legitimate. Or it can even be an edge case, but one you don't want to handle by just segfaulting.

> Which reminds me: what is a good tool for analyzing / viewing a C++ programs call tree?

Linux perf can collect the necessary data. Then for frontends, I am not sure. KDAB's "hotspot" ( https://www.kdab.com/tag/perf/ ) can do flamegraphs, but this may be more performance-oriented than what you're looking for.

Edit: perf can collect the data statistically. It will miss many calls, the ones that are the least time-consuming.

It’s not a warning, it’s a compile time error and I am not even using -Wall -Werror

I also believe there are platforms where a function pointer and a data pointer are not the same but idk about such esoteric platforms first hand (seems Itanium had that: https://stackoverflow.com/questions/36645660/why-cant-i-cast-a-function-pointer-to-void)

Though my point was only that this code will not compile as is with whatever clang Apple ships*

I am not really sure how to get it to compile tbqh

Some further research ( https://www.kdab.com/how-to-cast-a-function-pointer-to-a-void/) suggest it should be done like so:

> auto fptr = &f; void a = reinterpret_cast<void &>(fptr);

edit: I tried with GCC 15 and that compiled successfully

It's totally reasonable to lament duplicated effort, but it's worth pointing out that this particular attempt is from a company[0] whose business is Qt consulting - so it's easy to imagine that they might succeed (due to expertise, size, and motivation) where others have not.

The post also explains why they started from scratch vs. existing approaches - I'm not qualified to evaluate the claims, but I think they deserve some credit for explicitly talking through their reasons.

[0] https://www.kdab.com/