Hacker News Reader

Hacker News

Comment by mothsonasloth | Hacker News Reader

Full thread

mothsonasloth

It seems like you have three choices at the moment for desktop development (for non .NET) that I am aware of.

* C++ and GTK or other UI framework : hard but excellent performance.

* Java and Swing UI framework : easier but less performant.

* Javascript and Electron : easy but terrible performance.

Which one will prevail?

View on HN

Lazarus is easier than the first two by far and you get self-contained native executables (no runtime requirements or extra DLLs, at least on Windows), native widgets (on Linux you can choose between Gtk and Qt, though the latter does need a "bridge" .so), very low memory consumption (think a handful of MBs for a very simple application and memory requirements do not grow much outside of your own use - to give a ballpark, i just opened Lazarus itself with a simple program and the task manager reports just 36MB of RAM use for the entire IDE) and very good performance.

From the development side you get WYSIWYG UI editing, an IDE that has deep understanding of the code and updates it "live" as you make modifications to the UI (and other "managed" components), very fast compilation times, a very mature and rich framework (which is also very stable as the developers almost never break backwards compatibility meaning your code will compile for years to come) and recently the IDE got an online package manager and installer (repositories existed for years but they were manual to install).

Also the entire IDE can run and be usable even on a first generation Raspberry Pi (though for comfort, especially with the UI designer, it is a better to use something slightly faster).

The negative side is that as it relies on native widgets, it is much harder to create custom themes. Though there are themeable controls available (especially if you are not against paying for them as there are a few companies selling commercial components for Lazarus). Personally i prefer native controls anyway.

> you get self-contained native executables

Have you ever heard of static linking? Assuming you're using a GUI framework that has a sane license which allows that, it is rather easy to get "self-contained" native executables in most languages.

Lazarus is nice though: Delphi has always been an awesome RAD IDE and Lazarus brings cross-platform support to it.

Lazarus does use static linking for its own libraries and the license allows that. Yes you can do the same with other languages, but this was just a single feature among others, i'm not presenting every single one of them in isolation in a way where if you can find other languages/environments invalidate everything else, i'm presenting these features as a whole. If anything the self-contained part is a minor feature (and not universally available, it really depends on the backend, though for most OSes you can use one that has no external requirements).

Lazarus being much easier to use than the first two while requiring minimal resources and providing an advanced yet lightweight IDE (among other stuff) are more important IMO.

Lazarus could move on to a single window though. I find the free-floating windows rather annoying as they are hidden behind other windows more often than not.

You can use docking packages to make it exactly like Delphi.

I have read the Free Pascal wiki about that right after wondering why they don't do that by default. I would like to add "... by default" in my original suggestion.

(Thank you for the hint though.)

Yeah, I feel that they should actually make it default. By the way, check out Codetyphon [1], if you don't know it already. That is one hell of a component and library collection, and it has a lot of added features for the IDE. Really bad Website, though.

[1] https://www.pilotlogic.com/sitejoom/index.php/downloads/cate...

You can configure it like that, i think the main reason that it isn't by default is mainly tradition as many people among the developers and community prefer the multiwindow setup.

But all you need to do is to install the AnchorDockingDsgn package (and optionally the sparta_DockedFormEditor package so that the form designer isn't floating but itself also part of the main window - yes the package names could be better).

I think they should ask you the first time you run it though. It already has a first time setup dialog anyway, showing two buttons with screenshots of the two setups shouldn't be that hard.

Yeah Lazarus is really a RAD environment. Unfortunately I don't like Pascal nor Modern Pascal that much. My holy grail is something of the same quality but using C# which, for me, is the superior language by far.

What do miss from C# compared to Free Pascal? Outside of something like LINQ and lambdas i can't think of any other major difference between the two languages (and lambdas are WIP, i think they already work in the trunk), what do you have in mind?

Pascal has one great benefit, compiler is fast as hell - so fast that it could (incrementally) compile & launch your application in 2-3 seconds on Intel Celeron 333mhz.

Or at least this was true for Delphi, not sure about Lazarus

I'd say that Javascript/Electron is easier if you come from a webdev perspective, from a tabula rasa point of view I highly doubt that the usual react/redux rigamarole that's often used is that easy. Not even sure if I like it that much better than ExtJS, and that's saying something.

Same goes for Swing, I didn't mind writing in it, but the framework parts aren't really easier than Qt etc. Java as a language has fewer footguns than C++, so if you include that, sure...

There's also FPC/Lazarus as a Delphi replacement (the original seems to be driven into the seventh layer of enterprise heck). Easy enough to create small-ish native UIs.

You have two extremes for GUI development. One is games, where everything is built from the ground up. The other is professional apps like office, photoshop where large dev teams with lots of money build tightly integrated GUIs for each platform.

Then you have the 95% of apps that just need an interface.

For close to four decades OS providers have actively fought against the development of a common cross platform GUI framework that was easy to use.

Now finally we have electron so we can use the only existing cross platform gui platform (html/javascript) that survived in spite of the big players attempts to kill it.

So electron/javascript will dominate. It’s not pretty but it’s the best we have.

I hope Flutter for desktop will prevail.

https://github.com/google/flutter-desktop-embedding

But I think they will focus on mobile first so the time when we can use Flutter for desktop programming is still far far far away.

Also you forgot, PyQt and PySide: easy but terrible performance.

I used PyQt and PySlide only on small projects but I don't understand why they would have terrible performance? The occasional call into Python code shouldn't bring down the speed from the Qt baseline.

> Javascript and Electron : easy but terrible performance.

Is performance that terrible though? VSCode works ok for me, is it more to do with how people use Electron rather than Electron itself causing the performance downgrade?

As mentioned in comments elsewhere in the thread, there are several newer projects that are trying to fill that need for performant, cross-platform desktop app development.

* Revery (language: Reason) - https://www.outrunlabs.com/revery/

* WebView (language: C/C++/Golang) - https://github.com/zserge/webview

* Dear ImGui (bindings exist for many languages!) - https://github.com/ocornut/imgui

* Flutter (language: Dart) - https://flutter.dev/

None have really stood out yet to replace Electron, but the future seems bright.

Qt & PyQt?

> [...] GTK or other UI framework [...]

Yeah but the list specifically mentions C++, which I think is part of the reason why this category is hard. Python on the other hand is definitely more entry level friendly but it's still Qt. This should be emphasised.

I think PyQt and PySide are in third category: easy but terrible performance.

PyQt and PySide take full advantage of the C++ Qt library. Performance is as good as a C++ native Qt app, as long as you have no logical bottlenecks in Python.

I hold out hope for Flutter. It was a great experience building an Android and iOS app (good API's, predictable results across a variety of devices) and should translate well to desktop development.

This is just a matter of belief unless there is open source code repo which demonstrates the perf comparison shown above by solving the identical problem statement in 3 different technologies.

Javascript and React Native has increasing desktop support. Both the Windows and macOS branches have been seeing a lot of development lately, especially given Microsoft's Office team's investments into React Native for cross-platform UI. To my knowledge, it is only the Linux React Native that is the most lagging right now, and has a ton of "Help Wanted signs" up.

Python and TkInter : always better than electron

can you style anything taht comes with TkInter? It looks ugly af if not

Yes, you can definitely make it way more ugly than default. :)

I haven't gotten past demos yet, but I'm intrigued by WebView [1] as an alternative to Electron.

[1] https://github.com/zserge/webview

I enjoy JavaFX much more than Swing but maybe my opinion is unpopular.

> Java and Swing UI framework : easier but less performant.

Using AOT compilation and not doing everything on the UI thread solves the performance issues.

there is also ActionScript 3 with Adobe AIR

Reply on news.ycombinator.com