If 5MB is a con, what do you say about 30MB for Qt and ~100MB for Electron?
Also, could you please elaborate on the first statement?
A text language that isn't just values being passed creates new rules and an opaque layer when it is completely unnecessary.
I don't know why Qt takes 50MBs or more for hello world or why anyone would use electron at all. At least Qt will run fast and not have lag and latency. Electron is just the worst of all worlds unless all someone knows is JavaScript.
"Markup languages for a GUI where isn't needed..."
You've missed big picture.
Markup language defines DOM structure (tree of UI objects). And you must have DOM in your application, either as tree of DOM nodes or tree of window nodes.
ANY UI application uses DOM tree in either form. And so ANY application uses some sort of markup language. Either binary one (e.g. Windows dialog resources) or text based ones (XAML,HTML,QML, etc). And HTML parsing is not significantly slower (https://www.codeproject.com/Articles/14076/Fast-and-Compact-...) then deciphering of binary formats. Yet the Accessibility ... that thing alone mandates DOM tree to be present.
Of course you can have UI where components are nailed down to pixel grids and colors but think about HighRes monitors, RTL languages, support of night/day theming, branding, etc.
Considering all that you will quickly understand that you need all three components: DOM, style system for the DOM and code that changes state of that DOM. Just to have all this modular an manageable on the long run.
You've argued that UIs require a DOM. Ok, so UIs require a DOM.
That still fails to make a case for needing a separate proprietary markup language to define a DOM, let alone a XML-based one.
Even the Qt folks learned that lesson nearly a decade ago with the introduction of QML.
> ANY UI application uses DOM tree in either form. And so ANY application uses some sort of markup language.
You are conflating DOM and markup language with heirarchy/dependencies. It isn't necessary to have a text language with lots of different overlapping rules and syntax.
> And HTML parsing is not significantly slower
It's not about speed, it's about unnecessary complexity just to get a layout heirarchy and dependencies.
> UI where components are nailed down to pixel grids and colors
That's a false dichotomy. UIs have been laying out their components without parsing text for almost half a century.
Could you elaborate more on this? What are those overlapping rules?
> unnecessary complexity just to get a layout heirarchy and dependencies.
I have no idea why you think it is so complex...
DOM element is this:
class Element {
weak_ptr<Element> parent;
vector<ptr<Element>> children;
map<...> attributes;
}
And you will see EXACTLY the same structure in any GUI framework/system.> And you will see EXACTLY the same structure in any GUI framework/system.
I'm sure it works fine, but I wouldn't get stuck on thinking there is no other way.
"I wouldn't get stuck on thinking there is no other way"
There is a way, named "Dear ImGUI", that does not use DOM structure but rather recreates its on each paint event.
> There is a way, named "Dear ImGUI"
I'm not talking about immediate GUIs (and they use a heirarchy for layout too of course). You put some example c++ and said every GUI has that same structure, which isn't necessarily true. A heirarchy doesn't have to be implemented with a tree of pointers.
I'm not saying these things can't work, but saying 'this is how it must be done' is just not true.
I'd insist on EVERY here. Container holds list of children. Child holds reference to parent - typical tree implementation.
If you have in mind something else - please show.
Once again: IAccessibility mandates tree organization of your UI. You can do whatever you want but your UI framework MUST expose UI structure as a tree.
Edit: QtCore + QtQuick + QtQml should also be roughly 15 MB
Simple: because that is not true.
I have an application written for Qt and the Qt DLLs for Windows 16-bit are about 16 MB. (Core, Gui, Widgets, WinExtras, style and imageformats.) But, frankly, even if it were true, the disk size of the framework should be extremely low on a list of criteria. As others have noted, the pros and cons listed are not convincing.
On most of the Unix-like distros, the maintainers fetch & compile the applications that they make available in the repositories. They can provide a few packages for the various Qt libs, and add these as dependencies to the hundreds/thousands of programs that use Qt. The Qt libs are only downloaded once regardless of whether you have 1 or 20 end-user Qt applications.
Dynamic loading and library updates aren't an issue since the distro maintainers recompile all the Qt-dependent applications whenever Qt has a major update. Older versions can be kept around for programs that haven't been updated in a long time (e.g. I have Qt4 installed on my system as a dependency even though Qt5 has been out for a long time), so there's little extra burden on developers. And with the exception of a few nonfree programs, the entire system works with one system-wide copy of any library.
Of course that doesn't fix the issue for Windows/macOS users, but there's an obvious and proven solution which works, and if main reason it doesn't work for Windows/macOS is because most developers for those platforms restrict the users of their software using nonfree licensing, it only seems fair to blame those ecosystems and OSs instead of blaming Qt.
uh... you were right in 2005. Nowadays the standard is for every app to ship its JRE - having to have to install a system wide JRE is part of the stuff that gave Java such a bad and bloaty reputation.
That's quite an inelegant way to state that you know you've made a false claim but yet you still stick by it.
You have all my sympathy here :) Well, it should also be noted that 5MB is the size of Sciter's dynamic library. Compiled statically, there will be less contributing to the app's size.
As to markup languages, well, maybe, but I think they are a lot more expressive for things that are styled, positioned via constraints, dynamic and animated. That's completely different approach compared to predefined component libs like WinForms etc.