KDAB Blog

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/

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-… 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.

They're working on it: <https://www.kdab.com/enhancing-accessibility-and-creative-tools-in-kde… Also 6.8 is at least 2 years out, so there's still time to work the remaining issues out. As far as I know only speech input remains a major problem, so hopefully they'll figure that out.

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-functio… 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

Servo is already embeddable, you can use it in Tauri (https://servo.org/blog/2024/01/19/embedding-update/) or Qt (https://www.kdab.com/embedding-servo-in-qt/).

> but that just goes to show how low our standards have become I totally agree. We need to do better. But I still stand with Qt being a good option. There are ways to lower Qt apps binary sizes down to 11MB[1] or 8.3MB[2]. [1] https://www.qt.io/blog/reducing-binary-size-of-qt-applications-with-qt… [2] https://www.kdab.com/qt-quick-without-a-gpu-i-mx6-ull/

It seems that they moved it since to a bigger meta issue and it's actively being worked on https://github.com/servo/servo/issues/30593. There's wider interest since it is being used in the experimental Verso browser now. There's also ongoing effort from the Qt side: https://www.kdab.com/embedding-servo-in-qt/

I think the big motivation is now "embedding", i.e. using servo as replacement for webview/cef/etc. So for example you could think Tauri+Servo as Rusts answer to Nodejs+Chromium in Electron. https://servo.org/blog/2024/01/19/embedding-update/ Another example would be Qt which normally uses Chromium for webviews but now there has been work to use Servo instead: https://www.kdab.com/embedding-servo-in-qt/

Hmm, for 1 and 2 have you actually tried to profile your code? You can use the QML profiler to check which parts of QML compilation are slowing you down. Also consider using GammaRay [1] to see what's causing the rendering to be slow. [1] https://www.kdab.com/development-resources/qt-tools/gammaray/

Nice april fools, but not as good as the "Really" proposal from last year: https://www.kdab.com/cpp23-will-be-really-awesome/

I just found "git partial clone" which appears to aim to replace LFS ( https://about.gitlab.com/blog/2020/03/13/partial-clone-for-massive-rep… ) but I'm unsure of it's current state ( https://www.kdab.com/native-big-file-handling-in-git/ 2021 ). Are you familiar?

> 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.

Second Nagle-related post I've seen this week! https://www.kdab.com/there-and-back-again/

The equivalent for Qt (but much more powerful) is GammaRay (https://www.kdab.com/development-resources/qt-tools/gammaray/)

Well I think in this case the price may indicate it’s a fairly specialized tool. I’m not sure the benefit of putting something like that on a marketplace, since anyone spending $2,000 on Kuesa definitely knows where to find it already... I don’t do anything even close to this space, but I found https://www.kdab.com/kuesa/ was a fairly good overview of their offering, as far as these pages typically go.

It isn't widely used yet (as far as I know) but there's a library to use QML as the language for building QtWidget-based apps: https://www.kdab.com/declarative-widgets/

You have clang-tidy: https://www.kdab.com/clang-tidy-part-1-modernize-source-code-using-c11…

See also the release announcement for v1.0.0: https://www.kdab.com/heaptrack-v1-0-0-release/ And the initial proof-of-concept announcement: http://milianw.de/blog/heaptrack-a-heap-memory-profiler-for-linux Feedback welcome, patches even more so: https://phabricator.kde.org/dashboard/view/28/

Here are some tools you should look into: Clang-tidy: http://clang.llvm.org/extra/clang-tidy/ Cppcheck: http://cppcheck.sourceforge.net/ Flint++: https://github.com/L2Program/FlintPlusPlus Clazy: http://www.kdab.com/use-static-analysis-improve-performance/

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/ *…

Something similar: https://www.kdab.com/declarative-widgets/