[trixie_]

It's hard being an old programmer as some technologies that you used in the past, that were more productive than certain technologies today, are no longer popular. Creating client side apps in the 90s was arguably easier than creating web apps today with the soup of html/css/js frameworks that are changing every month.

edit/mass reply: I've been coding web apps with the rest of you guys for 20 years. The web isn't the problem, the tooling just isn't there yet. The solution space is large and we're still in the 'throw things at the wall' stage. It will eventually be figured out and web dev will be nice and stable just like the backend and database layers.

[danielbarla]

Delphi certainly was supremely productive for the kinds of one-off, bespoke enterprise apps that I was involved with, and it is valid to question why that was the case. I don't think the tooling was necessarily all that superior, the industry trend was simply way towards "slap a grid on top of that SELECT * FROM Orders".

Clearly, there are many things wrong with that, but the fact that one could whip up several screens and essentially ship them in a few hours makes it a worthwhile thought exercise to think about what has been gained, and what lost. Most enterprise apps that I encounter seem to be massively overcomplicated for what they actually do.

[gonzo41]

Most enterprise apps that I encounter seem to be massively overcomplicated for what they actually do.

I think the big issue is every app I use/develop in the enterprise needs single sign on and fine grained access control. Those modern requirements create a minimum layer of complexity that really slows things down.

But yeah, the whole enterprise programming world really missed an opportunity with JavaFX. For all the shit they get being able to deploy desktop apps in a virtual environment is really powerful.

[cy_hauser]

> "slap a grid on top of that SELECT * FROM Orders"

FWIW, before there was Delphi there was an entire language (and consulting industry) built around this: PowerBuilder. Its primary component was a "DataWindow" which was a fancy presentation object around basic CRUD SQL. Good times were had by many.

[karmakaze]

Working on a number of quarantine projects, I have come close to this now. Currently make single fullstack repo for the app with backend and frontend code committed together and deployed separately. Client goes to Netlify. Backend to a hosted VM that can autoupdate from Github and apply schema migrations.

Local dev, autorefreshes the Vuejs frontend code (yarn serve) and backend autorefreshes with `air` if Go-based or Intellij debug hot-reload if Jvm-based. I can whip up a db schema, backend, and frontend in a day with a good amount of layout and styling. It just took repetition and templating a few things.

Which is to say it doesn't take a lot of tooling to be productive--as long as it's focused.

[jonnypotty]

What the hell else to business apps do? I'm genuinely interested to know what you think is the clear issue with showing users data from database tables.

[danielbarla]

I'm not sure I 100% understand your question, and it's also hard to respond without more context.

Many Delphi apps back in those days were very lazily slapped together, with thin layers of code (or none) on top of whatever queries got the job done. There are performance issues, security issues, correctness issues (in terms of: does the app allow you to do some things that should not be allowed). There are also meta-level issues that came into play, as anything that did not fit into the out of the box patterns was so outrageously more expensive to develop that companies opted away from it, and in many cases UX suffered.

On the other hand, we have now overreacted in the opposite direction, with many business apps having empty layers of code that do nothing except pass on the exact same message to the next layer, because, well, "that's how it's done in the real world", or something. Tons of boilerplate code get created that never end up adding any real value. Other than this specific example, there are plenty of YAGNI violations.

I prefer something of a balance between the two.

[jonnypotty]

I guess I don't buy the idea that anything has changed. If a straight query shows you the data you need why would you put anything else but a thin layer of software over the top? More software is worse, not better. Apps are still lazily created by people downloading frameworks and plugging them into whatever shit they happen to be creating at the time.

The issues you state. Security, correctness and performance. None of these are solved by having more software. It might seem safer if you have more layers of shit between the user and the valuable data, but it isn't. Having a mental idea that now I use 'model and view' im going to be quicker, more correct or more secure I think demonstrably isn't true.

[danielbarla]

This could be argued infinitely, I think. I do appreciate your points; yes, simply adding code - by default or by itself - does not resolve those things I mentioned. But, it's important to view my comments within the context of what we were talking about, which was the defacto development style that grew around Delphi, especially in the early days (before their libraries got smarter). In the case of my "SELECT *" example, this was quite often literally the case - queries were not optimised in the least bit regarding the columns and rows that were being retrieved (mostly due to lack of awareness or laziness). In terms of correctness, you can bet that business rules were usually sprinkled around the UI in a happenstance kind of way, rather than being collected in a relatively well defined, easy to verify and unit test business object, say. Again, while I do agree in theory that "more code" does not necessarily solve anything, these are the kinds of practicalities I am arguing about, not on a pure level. The tooling was great for getting things done instantly, but encouraged a laziness that caused a counter revolution which went too far in the opposite direction.

[jonnypotty]

My work until recently was working on one of the Delphi apps you're talking about. Not in terms of unoptimised queries but bad separation of business logic and ui. But the product has passed between 4 diffent companies and is over 20 years old now, I just don't see how you prevent these issues. I do see what you're saying, but I think the real issues is humans which hasn't changed.

[nikanj]

Back in those days, one could take a full two-week summer vacation, and come back to the company still using the exact same stack!

[me551ah]

Not to mention how native client-side apps consume far less memory and CPU than their web/electron counterparts. I miss those days when I would have a bunch of native apps constantly running and minimized. These days it's considered normal for a music player to consume 500MB of memory and for chat apps to consume multiple GBs of RAM.

[jjeaff]

But if you spent the same amount of money on your dev system adjusted for inflation, of course, then it could probably handle everything you could throw at it.

[jonnypotty]

It's ridiculous that we've relied on hardware to save us and that we do more and more every day. We clap our hands at a bit of text and some pictures on a screen taking hundreds or thousands of megabytes of memory. This incredible ineffecincy means that computers cost more than they should, not as many people have them as could, that we spend more resources than necessary to make them and more electricity to run them than we need to. Why don't programmers generally understand how incredibly wasteful we are with the resources we've been given.

[me551ah]

It's only true if a handful of apps do it, but if everyone starts to do it then you end up with a scenario where RAM isn't enough for every application.

And also from an end user perspective, not everyone has a powerful dev machine.

[dleslie]

You've even drank some of the koolaid by calling them "client side apps". They're simply applications, or if you must, native applications! ;)

I'm heavily reticent towards using web-based interfaces to remote services, and I think that's healthy and fine. As a developer, of course it's less complicated to not be negotiating network communication in order to create an application!

[ithkuil]

You've even drank some of the koolaid by the personal computer industry to call them applications: real applications clearly run on mainframes and reach the end user via terminal display units!

[colejohnson66]

So if a client side app is just an “app”, what differentiates it from a server side app?

[dleslie]

All of the user's data is controlled, managed, stored, and owned by the user; there are no remote servers.

[jayd16]

I can't help but feel cynical that a fair bit of modern complexity comes from the sheer amount of features that didn't exist. The variety of screens, interfaces, OSes and the accessibility aren't free. Those are why we use all these cumbersome frameworks after all.

[kbenson]

There's always a trade-off in technologies between things that are easier to learn, and things that are easier to use once you've learned them. When there's a steady state of people cycling through the system, it's easy to cater to specific segments of the population with different types of tools. Those that don't need hand holding and want the extra bells and whistles to get exactly what they want out of something will likely find their needs met in such a situation.

Now, consider that there's far more new people coming into programming each year than the prior year (or even if it's not strictly true on a year-over-year basis, there are far more software engineers with 1-10 years of experience than there are with 10-20 years experience, possibly even than those with 10+ years experience).

In a market such as that, ease of use is paramount and the killer feature that drives almost all you usage. Catering to amateurs is the path to increased usage, and mind-share, and market-share where applicable. With that in mind, is it really any wonder that amateurs are catered to so much that there's actually a regression in tools that cater to professionals?

My guess is that if you look into subgroups which are not friendly to new users for one reason or another (most commonly because of complexity and skill), yet still have retained users for some reason, you'll find high quality professional tools. I think C/C++ probably fits this, as well as systems programming, and kernel development. I'm not part of any of those subgroups, but my guess is they have not only retained the quality of their supplemental tools, but increased them.

[pjmlp]

If you code in C++ with tooling like QtCreator, Clion, VC++, C++ Builder and everything enabled (static analyses), it can be quite productive and even quite secure.

However it still largely ignored as good practices, in a world where teachers still use IDEs like Turbo C++ as teaching tool.

[namelosw]

It's strange we eventually reached a place where things go unproductive...

Similar to Smalltalk, and Common Lisp are super fast to develop things. Maybe it is they were relying too much on their superior environment? So that other languages cannot easily replicate so that more generic but not so productive technology stand to the last?

[goto11]

The advantage of web apps is in deployment. Developing a stand-alone app in Delphi or Visual Basic was highly productive, but distribution, installation and updating was a headache. And it would only run on one platform.

[FpUser]

" but distribution, installation and updating was a headache"

I am not sure what headache are you talking about. My product/s are usually single exe with dependencies statically linked and acting in dual role: setup and the end software itself. Installation goes like this:

1) customer clicks on link

2) setup.exe is downloaded and ran.

3) setup copies itself to a proper location and renames itself to yourwonderfulsoftware.exe.

4) When running it may communicate to servers to get whatever data/files/licenses it needs if any.

5) It also checks for new version and if there is any it can self update if you click that "update" button.

6) Before update starts the old version and data are always backed up.

Yes it does lack that instant satisfaction experience that comes with good web applications. But then again the if software I want to make looks like a good candidate for Web target way I will implement it as a web app.

In hopefully not too distant future Web assembly may make the difference minimal but we will have to wait and see how it goes.

[trixie_]

Ease of deployment does not preclude ease of development.

[emmanueloga_]

but you can still use those tools on your own projects right? I've been learning and using XQuery and XSLT 3.1 and I really enjoy them! Also, common lisp :-) But yeah, it will be harder to use tech like that on my day job, wish I could.

[seangrogg]

Isn't a day on HN unless someone complains about web development while pining for the days when they were building command line calculators in COBOL on their mainframes while sipping espresso with Turing and Dijkstra.

[trixie_]

Don't worry, eventually the web development will be figured out and it retrospect we'll look like cavemen rubbing two sticks together.

[seangrogg]

I honestly hope so. Sticks are passable enough for addressing today's CRUD apps but I'll readily take scalpels and plasma torches as they become available.

[jonnypotty]

Are you really gonna defend the current state of Web development?

[seangrogg]

Nope. Web development could (and should) be much cleaner. But it doesn't get there by tirelessly adding to the list of curmudgeonly comments over and over and over. As a web developer who made zero choice for HTML, CSS, and JavaScript to be in the position they are today and who is wholeheartedly open to seeing the chances that things like wasm could bring it is honestly more tiring reading yet another derisive comment about JavaScript fatigue than it is actually dealing with the churn in the ecosystem.

[beamatronic]

I very badly want to get back to this. Maybe with Python and Qt on Mac?

[AlexanderDhoore]

I don't trust Qt licensing anymore. Whatever company owns Qt will forever try to squeeze it for money.

They recently changed their licensing AGAIN: https://www.qt.io/blog/qt-offering-changes-2020

[tim--]

They have not changed any licensing. They have changed the way they are releasing their product. The only thing really that is different here is the fact that they are pushing less code as open source for their stable LTS releases.

If you rely on having a stable Qt, why not pay the company that develops the software? You and I, the developers that use Qt without paying for it, still get the latest and greatest Qt, with all it's source code for free, under the same LGPL license that Qt has always been under.

[ognarb]

Actually Qt was not always LGPL, it was first under the QPL, then the GPL, and now the LGPL. So it is quite an improvement from a license forbidding commercial uses to a permissive license.

There is also a legal framework to make sure Qt will remain open source forever: the KDE Free Qt Foundation.

[tim--]

Historically you are correct, yes. I should have had an asterisk and explanation next to 'always'.

The fun fact that this also brings up is that the KDE Free Qt Foundation also means that if Qt does not keep supporting open source Qt, then the framework code becomes licensed under the BSD.

It is literally in Qt's best interests to keep the open source community by it's side.

This does not detract from my point that the license of Qt is not changing.

[pedro2]

It was not just LTS. The rumor [1] was:

  > As a result, they are thinking about restricting ALL Qt releases to paid license holders for the first 12 months.
  > They are aware that this would mean the end of contributions via Open Governance in practice.

[1] https://mail.kde.org/pipermail/kde-community/2020q2/006098.h...

[cy_hauser]

> If you rely on having a stable Qt, why not pay the company that develops the software?

Because it's too expensive for me to afford. More than an order of magnitude too high for me. As side projects I write closed source software so they do pull in a a bit of money. But this is typically only a few hundred to a few thousand per year per app. I think they target corporations rather than individuals or small shops.

[jcfields]

I did a couple of small projects in Python using wxWidgets recently, and I was surprised at how easy it was (as well as how consistent the results were between Windows and Mac OS).

[temporaryvector]

I'm overall surprised at how unpopular/unknown wxWidgets is when the discussion turns to cross platform UI toolkits.

I've used it a lot, as well as other popular toolkits (Qt, GTK, etc.) and I find that wx is, at the very least, the least bad option and overall programming in it hasn't been a pain, regardless of which binding I used.

I guess my only complaint would be that it's a bit harder to do something way outside the norm when compared to Qt, but at that point it might be better to use native SDKs or straight up OpenGL or something for your GUI.

[72deluxe]

I am surprised too. It is easy to talk to the devs about issues and also the documentation is good.

There are some rough spots here and there but all in all I am really baffled why you don't see more use of it. I use it in C++ for all my GUIs.

[vram22]

The wxPython demo (which spawns many apps that show use of many widgets, including complex ones), is very good too. And is a non-trivial wxPython app itself. Separately downloadable from wxPython itself, last I used it. All apps come with source (of course), good for learning from and adapting to your own app needs.

[thePunisher]

I've been using it for years, and what attracts me is the native UI widgets instead of the self-drawn widgets in Qt and GTK.

This also makes customizing the widgets much harder (if possible at all). There are also some self-drawn widget libraries available for wxWidgets.

[vram22]

Nitpick, but wxWidgets is for C++. wxPython is the wrapper for Python.

[heavyset_go]

Works well for my needs. QML has a JavaScript runtime and follows both a declarative and a reactive programming paradigm, too.

GTK bindings via PyGObject also work on macOS[1], if Qt's licensing doesn't suit you.

[1] https://pygobject.readthedocs.io/en/latest/getting_started.h...

[tomjen3]

C# and WPF. WPF is what the web would have been, if it had been designed for applications and not documents.

Only downside is that it is Windows only.

[rubber_duck]

Creating hello world and drawing trivial forms is just as simple with HTML/CSS/JS, you don't need a SPA MVC framework or component libraries or state management framework.

Looking back to VB and other WinForms RAD tools it's easy to do that stuff and there are HTML WYSIWYG tools but that double-click code behind logic doesn't scale - software these days is distributed, has more complex requirements and expectations. Once you bolt MVC or MVVM or whatever to one of those GUI toolkits you get very close to modern JS framework complexity.

[nightski]

I laugh because you'd think the distributed part would be the toughest one. But nope, it's pretty easy. In fact the client/server model was pretty well understood even in the 90s (or well before that even).

In my opinion what has exploded the complexity is the proliferation of environments. The execution environment of our software provides very few guarantees on what is available (no standard library) or even what language is supported (many JavaScript features and versions with varying support). That, combined with the explosion of devices including input modes, screen sizes, and resolutions has just made it extraordinarily difficult.

We don't even have standard ui primitives like we did in the past. Every major website is expected to have a team of world class designers and reinvent the wheel.

It doesn't need to be this way. But it's the way we have chosen. It has advantages, but I'd imagine the economic cost is enormous.

[72deluxe]

I can't agree more with your "we don't have standard UI primitives" and "every major website is expected to have a team of world class designers" comments. I have been migrating a site from an old to a new shop system and the amount of work for simply displaying product data, options and choosing something to buy is insane. I really believe we've lost something from the RAD era.

[rubber_duck]

Lol - 90s is the era that gave birth to PHP, I'd wager to say very few things were "well understood".

People writing apps with 100s of global variables was the norm.

If you worked with WPF you'll see angular 2 is very similar in spirit - complexity is on par. I don't really see the difference between native development and JS once you start dealing with the same level of complexity.

[nightski]

Client/server models existed before the web and HTML/JavaScript.

WPF is backed by the .NET framework. While the UI framework itself might not be easier than say "React", you have a stable language (C#) with a huge, stable, standard library for all kinds of things from Date manipulation to File IO. There are so many advantages to that ecosystem over JavaScript currently.

For example, I've been using numeraljs for number formatting in JavaScript. This is now un-maintained and contains a bug where if the number is below 1e-6 it shows up as NaN. So now I have to go source a new package for number formatting. This is so simple and core it's amazing I am searching for packages for it.

There is now Intl.NumberFormat but it has quirks also. But this is the crap you have to deal with on a daily basis with JavaScript.

[rubber_duck]

Single machine local apps and apps using direct database connections over a trusted network were the norm - these are much easier to write since they didn't have to deal with client/server separation of logic.

You won't hear me arguing that JavaScript is a great environment to work with - but people argue that JS frameworks are overcomplicating things - when in reality desktop frameworks arrive at the same design decisions.

[trixie_]

ExtJS was pretty close, but its license model was never good enough for mass adoption.

[guggle]

There's a free edition for small business and personal use and a perpetual "enterprise" license for $1,895. Not so bad for a commercial product. But yes, no free software.

[chrisco255]

Oh really? Please tell me about the ultra-productive "Built For Internet Explorer" days of web dev.

[watersb]

Most development in the 20th century was not web development.

Sure, there's always a tension of "simple" versus "limited". But simple was fun.

[cttet]

In 2008 I only tested my CSS-heavy small website on my only browser, which is IE6 and quite content with it.

Until I knew more later and it became a disaster.

[icelancer]

>> client side apps

[smt88]

Web apps are still client-side apps. OP likely meant "native apps" and mistyped it, but GP was justifiably confused.