The default look is not that bad for a business oriented application, and the drag-and-drop features are really simple to learn.
Java Swing with Netbeans graphical editor would be my second choice if you like Java better than C#.
EDIT: From personal experience, I found that styling the application beyond the default look, was simpler in Java Swing, using look-and-feel packages. For Windows Forms (maybe because my lack of experience) I had to do most elements as images in order to get the style I wanted.
That being said, if you don't want to hit the more "Universal" part of the UWP and you just want to tie into shell commands/utilities, it's hard to beat Python with TKinter.
I'll also use Unity a lot (I was previously in games, and we do a lot of entertainment work). It's probably not what you like, but you'll be able to hit every non-embedded platform under the sun (including Windows and UWP, but also including Chrome, various TV's, &c). The UI system has improved a lot, and their (older) IMGUI implementation makes it super easy to wrap a UI around logic.
Finally, I'll add that (especially if I know that I'm building for a specific platform), it's hard to beat the native rendering APIs these days. They're all super easy (all being UWP/WPF, Android, iOS's UIKit, and macOS's AppKit), and will generally get out of your way. I've gone down the Xamarin route in the past, and it turned out to be overly difficult to build some simple apps (plus, I've had trouble deploying to Android in some instances).
WinForms is the only right choice here.
https://readytalk.github.io/avian-web/swt-examples/windows-x...
Creating such a tight binary isn't entirely point and click, but if you want a tiny self contained executable and don't want to assume a pre-existing runtime like .NET then your options are really only VB6 (classic), Delphi or VC++ and all of them will involve a lot of arcane wizardry too.
Don't all distributions of Windows include .NET by default?
I remember meeting and talking with (or rather he did more of the talking) a senior Microsoft software engineer who was involved in the first .NET version, and he was telling me stuff about it. He may not have used the term .NET (can't remember), but I remember him saying that it used XML throughout (and also a lot of other stuff about its advantages). Very enthusiastic about it, he was. It was only some time later that I realized that what was now called .NET, was the same as what he had been referring to in his talk with me.
Also, Turbo Delphi Explorer (which was a stripped-down version of Delphi 6), came in two versions - the plain Win 32 version (non-.NET) and the .NET version. I remember, because I installed and used it some. Here's a blog post about a small utility I wrote with it (screenshot of the clock not there now, sorry):
http://jugad2.blogspot.in/2010/08/digital-clock-v10-in-3-lin...
Before .NET there was only Win 32, and before that, Win 16. (Worked some on both). Edit: Okay, there was and maybe still is WoW too (Windows on Windows), and even something called Win32s (or 16s) (IIRC, but I don't know or remember much about those).
https://blogs.msdn.microsoft.com/oldnewthing/20110404-00/?p=... .NET could be disabled or some older version.
Agreed. Said as a guy who is not a GUI programming expert - just used VB's earlier versions in real life projects (but more as project manager than dev, on those VB projects), and VB and Delphi (both in multiple versions) and wxPython for some small personal GUI apps. Not had any problems with Delphi that can be called arcane. And Pascal is a pretty straightforward language, and Object Pascal just adds some (mainly OO and GUI and Windows API) stuff on top of that.
What you are saying may have made sense 15 years ago, but not today.
Not any more, it seems. Now you get the Community editions, which work for free for about a month but then apparently require you to associate them with a Microsoft account and have strings attached.
4. DATA. The software may collect information about you and your use of the software, and send that to Microsoft. Microsoft may use this information to provide services and improve our products and services. You may opt-out of many of these scenarios, but not all, as described in the product documentation. [...] Your use of the software operates as your consent to these practices.
Now, perhaps someone can find me the wording in any of the multiple directly and indirectly referenced privacy policies and other documentation that guarantees Microsoft won't upload and examine potentially sensitive data like my source code under those terms?
There is simply no way in which having to sign in to desktop software in order to do the same things you used to do without signing in is an improvement for the user. It is a security and privacy risk with absolutely no upside.
I'm concerned with whether I'm potentially disclosing trade secrets, violating NDAs or other contractual provisions, or simply risking a leak of my big new idea if someone else's system has a security breach.
As I wrote before, requiring a log-in and open-ended telemetry for a traditional desktop app is a vulnerability with no benefit as far as the user is concerned.
Also, how well would .NET apps developed with Visual Studio support older windows versions (i.e windows XP or vista) ?
UWP has got the latest and greatest tools from Microsoft, and it's more coherent and pleasurable to use than any of the older options. You'll get a modern-feeling UI with much less effort.
Of course, the great thing about it is that you can use HTML5 to build native apps on Windows, Mac, and Linux. As unique selling propositions go, you can't get much better than that.
As a Web developer, I am going to be using it soon to build a few apps and I'm really looking forward to it.
If you're purely targeting windows, and want this to be a 'traditional' desktop, then go with WPF. If you want this to be a 'store' app, you can use WPF or Javascript.
You can do all of this w/ VS Community edition, or if you're going the JS route, try VS Code!
You use uwp, which is quite different apart from xaml.
If you don't like that there is always Qt.
I put it as second option since UWP is the native framework for windows 10 and should be considered first.
However, to elaborate more, I'd like to add a couple of nice -to-haves (these are specific for me but I think that most of the following could generally be nice-to-haves for any application targeted to non-experienced users):
- The size of the resulting application shouldn't be proportionaly big. For that simple app I described I would expect a couple of MB (I think that's a problem with electron/nw.js apps)
- The user ideally shouldn't need to install anything else - everything should be contained in the application, so python based apps are probably not very good. Also, for the same reason I had some really bad experiences with applications that required a very specific version of .NET that would take half an hour to install on my system :(
- There shouldn't be any installation - ideally, just give the user a zip containing a .exe and maybe a couple of libraries (even better if these libs could be statically linked to the exe)
- The app should be able to access the full windows API - I want to be able to display file open dialog, write some configuration options to AppData etc
Before 15 years I know the answer to my needs was to just use VB (or C++ with MFC for those that knew it), before 10 years I guess Java with Swing (or AWT)... Probably even now these could also be used, however I was thinking if there are some other methods of developing desktop windows application I wasn't aware of.
A Windows Presentation Foundation or Windows Forms app targeting .NET 4.0 will get you pretty good compatibility - Windows 8 and above come with it pre-installed* and it's an optional Windows Update for Windows XP/Vista/7. I don't think the XAML learning curve is as steep as some people claim, but it'll still be quicker to hack something together in WinForms over WPF if you haven't used the latter before.
Also check out the Desktop App Converter for Windows 10 - you can now package up a WPF/WinForms/Win32/etc. app into a UWP app for Windows 10 users and pick up some of the benefits that those apps have†.
* But also heed Raymond Chen: https://blogs.msdn.microsoft.com/oldnewthing/20110404-00/?p=... † https://developer.microsoft.com/en-us/windows/bridges/deskto...
I ended up (a few years back) going with WPF (Windows Presentation Foundation) in C# targeting .NET client profile. Of course you still need .NET, however, the client profile is a much smaller install than the full version and I have no problems going from .NET 4 to 4.5. No specific version is needed unless you want to use new features.
In regards to your needs here is a couple of reasons I like WPF: -The entire GUI can be written in markup XAML (an XML based markup language) so its kind of web like. You can use the GUI if you like but doing it in XAML forces good design patterns and IMO is easier. -"Click Once Deployment" allows you to publish the app build to a network share which can be run directly over the network (no local install). There are various options so if you choose to run locally you can. If you update your app, you simply publish again, and when the end users launches the app again it will be updated.
You can bundle dependencies so the first install would include the large (41MB) .NET client profile but after that it would just be the size of your app. This has worked well for me to allow users to install/update the apps over slow VPN connections.
http://www.py2exe.org/ -- but I don't know how large the resulting EXEs are, so that might break your size requirement.
Pros:
1) Solid, super-fast, single-pass compiler that produces native 32-bit/64-bit executables that can be deployed by copying them to the target machine (single, monolithic .exe with no external dependencies).
2) The language, Object Pascal, is statically-typed, easy to learn, supports procedural/OO/functional coding, and includes modern features like generics, RTTI, and class/record helpers. IOW, you aren't forced to code everything in a class, if you don't want to. The string support, especially the Unicode string support, is also very good.
3) The Visual Component Library (VCL) is still pretty good for creating Windows desktop applications (native, not universal "apps"), and you can skin your application for a different look and feel. Database access is also top-notch, and you have access to a pretty large set of 3rd party components that can be installed into the IDE as first-class residents of the IDE.
4) Development productivity is very high in the IDE, with a WYSIWYG form designer and two-way tools for coding the UI (what you do in the designer is reflected in the code-behind, and vice-versa).
Cons:
1) The price is high, but they're starting to fix that with more special offers and will, hopefully, continue to move the price down.
2) Partly the cause of 1), the product has been mismanaged over the years and its developer base has dwindled accordingly. This was also partly due to the fact that C# grabbed a lot of their market share (as well as the original developers of the product, including Anders Hejlsberg, the architect).
3) The RTL and component library (VCL) need pruning a bit. They've got a lot of legacy code in there due to an almost-maniacal focus on backwards-compatibility.
4) The IDE is a bit schizophrenic and needs to be updated, but it does include just about everything you would need in terms of real-time coding with error highlighting, code-completion, formatting, Git/SubVersion integration, etc.
5) Memory management is deterministic, which makes it very fast, but does require a Create/Free cycle for class instances. An ownership model helps to alleviate this for GUI applications (forms "own" the component class instances that are placed on them). Also, strings and dynamic arrays are reference-counted and managed for you, and you can wrap class instances in interfaces that will allow you to use class instances in a reference-counted manner, also.
In summary, if you simply need something to create desktop applications for Windows now, especially for vertical market software that will be deployed on a lot of machines, then Delphi is a good solution and can be a technical advantage for your company if you know how to use it well. If you're looking for something that you can use to further your job prospects, then it might not be the best solution for you, and you might be better going with .NET/C#. But, be forewarned that application deployment can still be problematic with .NET - the developer edition of SQL Server 2014 refused to install on my development machine this week because the SQL Server .NET-based installer could not cope with something in the .NET installation on my machine.
The Starter Edition (enough for small tools) is currently available for free https://www.embarcadero.com/de/app-development-tools-store/d...
So, cross off the first con for small projects... :-)
Another possibility: could be it's a region-wise rollout? But would have expected .en first, unless the latest acquirer of the product line is German. (Seem to remember reading recently that it got sold again.)
I think this is the page you're looking for:
https://www.embarcadero.com/products/delphi/starter/promotio...
IMO, that is one of Delphi's best features, and it had it had right from v1 or at least v2, IIRC. (Used both versions a bit.) The two-way tools, I mean - because over time, it helps you to rely less on the designer (if you wish), for things like writing code for properties and event handlers, and anyway you still have it as a fallback.
Of course it has many other great features too, as your comment describes very well (and it's good to mention the cons too).
It has more cross-platform options, and uses the Free Pascal compiler.
Wow I remember Delphi from the past (I had never used it but always heard nice things about it), I didn't know that it was still supported!
What you write about the statically linked exe, the native look-n-feel and the WYSIWYG form editor are really killer features! I'm not so much into pascal though (15 years since I'd written anything in Pascal) and, unfortunately the price rating is a blocker for me (as I just want to create a GUI for a command line app to help non-expert users use it) :/
However, I'll definitely check Lazarus !