Is anyone aware of a publicly available code base to look into when searching for high quality Qt-based (desktop) applications? Think chromium-quality software quality code base.
I am looking for inspiring patterns and also things such as naming schemes as I regularly change my mind when it comes to developing Qt based applications with regard to:
- naming things (e.g. should signals/slots be prefixed (sigFoo() -> onFooBared())
- how to deal with signal functions actually not implemented (clang-tidy warnings)
- how to break up large main window classes in a reasonable manner
and so on. Typically I immerse myself in one of the larger code bases I'm aware of (Android, Firefox, Chromium, Tensorflow, and some others) and regularly discover pretty useful patterns I can make use of. However, I was unlucky to find something for Qt based.
There's an irony somewhere in there that Chromium is a descendant of KHTML, KDE's rendering engine, which became WebKit and was originally written using Qt. And Google and Apple's contributions were regularly derided for being relatively low quality.
Qt and KDE have always had a lot of cross-contribution, so KDE (its libraries, for example) is a good place to start:
EVen thought I understand the bashing Electron gets, it doesn't seem that Qt is the right choice right now.
I tried to test the software: Needed Qt as there are no releases, but Qt is behind a paywall, and according to a previous post here in HN [1] it seems they resorted back to tactics they already reckoned (In 2015) were not good. I guess I'll just have to wait until the page has the releases ready.
I'm on debian 10 and that didn't work, but I suspect it's something to do with my current installation that complains about a missing Qt4 software even after installing that (That I'll research when I have the time).
We all have to pay bills but Microsoft is giving away so much stuff that Qt approach is hurting them.
If I have to just make an application in .NET env as a small time dev I don't even have to register anywhere just get .net core and VS Code.
OK I understand that MS can pull it off because they have big companies paying for their stuff. I also don't really know how to compete with them. But me as a small time dev cannot afford to get with all Qt BS where there is almost no BS for using free stuff from MS. (I have to count every minute or hour, so putting up with some forms or else is taking too much of my time already)
I would love to give money to Qt instead of MS or Apple but yeah I have to pay my bills as well.
Unfortunately it's not quite as as good as it could be on a 1928x1080 desktop monitor either. I had to zoom to 170% to make it comfortable to read (my eyesight is not great, but not terrible either). And that introduced horizontal scrolling. So I had to drop back down to 150% zoom.
I can open multiple repositories at the same time in the same screen. I actually forked from QGit becuase I was missing a lot of functionality and inactivity in the UI.
I couldn't find a way to do that in QGit and GitAhead at least. I didn't try the others.
This looks cool. I'm curious if people use Git's tree view, in any form, as part of the regular workflow? If so, how? I have never found it useful, intuitive, or usually readable / parsable. Not the graph drawn on the command line, certainly not Github's tree view GUI of forked projects. I've also only ever worked on a project with one or two main trunk branches (master, and maybe dev), and feature branches, and very little merging between other arbitrary branches.
At work, we use feature branching extensively, and there's often somewhere between 3 and 6 active feature branches at any time. The graph view is a good way to keep track of what's going on overall, if you're watching it regularly and branch parents are within a screen or two).
Just earlier today I was working on testing a new feature that depended on 3 other independent fixes (basically, bugs found while I was building the feature). I did the fixes each as an independent branch, so I could get them in faster (before my new feature is done) plus to make the code review easier. The tree view is invaluable in testing my new feature to be sure I've merged the right fixes and am doing changes in the right branches.
I also use it very occasionally to isolate if and/or why a particular fix got into a specific release branch (or not). I think there's probably better ways to do this (eg using bisect) but I do it so rarely I haven't bothered to learn.
I use it frequently. I work mostly solo but am often force to jump around quite a bit. So I use a variation of GitLab Flow[1] and often have dozens of active feature branches going on. It's useful seeing where a branch was created against develop so I can have some idea of what's been done on that branch since I last worked on the branch I just switched to, and what to expect when I merge or rebase.
One example: I work on a feature, which necessitates some refactoring, maybe upgrading a dependency, and oh, while I'm in the middle of it I notice some other, unrelated things, that need changing. In order to not have to break my flow and think too much about which changes are required for what, I just commit it all on the same local branch.
This then gets broken up into different branches in individual PRs.
It certainly helps me when splitting, comparing and picking changes between branches. Also to keep track of how upstreams have changed compared to my working branch before doing rebases.
Oh, and re Githubs fork view (which could be improved on the UI side), is helpful when seeing if anyone else has picked up the ball on unmaintained repos.
If you don't find it useful, fine, I don't think we all need to grok each others personal workflows and motivate them to each other?
Maybe you can compare it to a visual file manager that visualizes your directory structure as a tree; some people find it a necessity to get an overview of their file system, some don't.
The tree looks nice. Similar to gitk, sourcetree or bitbucket. For whatever reason, github and gitlab cannot manage to get a similiar clean vertical git tree view.
Can this stage individual lines, and then display a view of only staged lines and no un-staged lines? AKA only the things you are about to commit.
In SourceTree this is called "split view staging" and I find it indispensable. But SourceTree is so old as slow and unsupported that I'm desperately trying to find an alternative. Most of the existing GUI clients don't have this option.
It certainly looks quite beautiful, but sadly UI interactions -- resizing, clicking around, etc. -- seem to be fairly laggy at this point. Love the look-and-feel, but I think the interactive performance is frustrating at this point.
