[Interest] [Development] Windows 7 support will be, dropped in Qt 6

Roland Hughes roland at logikalsolutions.com
Thu Jun 18 17:11:39 CEST 2020

Sorry, Internet was down much of yesterday.

On 6/17/20 5:00 AM, interest-request at qt-project.org wrote:
> Sorry but I must chime in here, since both Roland and Matthew brought 
> this point up.
>> it's well "known" that you can teach C programmers Java, but you can't
> teach Java programmers C
> How is that well known? What studies can you provide for this?
> Currently it just sounds like elitism at its finest to me if I'm honest.
> I started with Java, and can now write C pretty well. Most of my local
> universities teach Java, do you want to imply those people will never
> ever be able to learn C? I have a few friends that started in Java, some
> even staying there for years before moving on to C, C++, Rust, Haskell, etc.

Not elitism, just the reality of the journey.

Sorry to have to re-paste this, but the "Where do I start" question 
comes up at least 5 times per day with slightly different wording so 
I've just stuck the response in a document file.


The school matters. You want one offering the following:

*Programming Logic (sans any programming language)*. Just flow charting 
and later pseudocode. If they are teaching Pascal or some other language 
in their logic class toss their brochure in the trash bin. You need to 
learn how to “see” a solution.

*Data Structures (sans any programming language)*. Some places will 
dovetail this into the logic class. Whether that is okay or not depends 
on how fast the class is learning. It is important to understand 
conceptually/visually how stacks, queues, and the like work. They are 
part of your logic tools.

*System Architecture (sans any programming language)*. You need to 
understand the full ecosystem of software. There is oceans more to data 
processing than the x86 and your laptop. You need to conceptually 
understand how something as large and complex as the IRS income tax 
processing system is put together. There are a lot of pieces. There is 
no cookie cutter solution. What you have to learn here is not only the 
differences between the tech, /but the why behind the choices/. There is 
a reason it is cheaper for some companies to buy and use 
MQSeries/Websphere than use a “free” OpenSource product. There is a 
reason you have to use a Tandem, Cray, or IBM. You have to understand 
the reasons.

*Application Design/Architecture (sans any programming language)*. After 
you understand the ecosystem you can learn how to correctly design your 
applications. No language should be taught here. This is more the focus 
of system flow diagrams and architectural choices. Will you use a 
relational database? If so, which one?Why? Does this application need a 
touch screen? Why? If this program is for intense data entry should the 
user ever have to touch the mouse after the program is launched? Why?

*Relational Database Use and Design (will require SQL and whatever 
language is used for stored procedures.)*You might need/want to take 
this before Application Design/Architecture. The vast majority of 
programmers currently working in IT know /nothing/about this topic. If 
you see someone promoting MVVM, you know beyond a shadow of a doubt they 
know nothing about the care, feeding, and use of a relational database.

No data is of any value without a relation.


What’s that? It’s a number, but what does it mean? People pushing MVVM 
thing that should be an object, all by itself, floating around in 
computer memory able to appear in random locations on the screen. To me 
that sounds like a virus, not an application architecture.

Jane Smith, 25, Sarasota, FL

Now we have some idea about what 25 means. The relation is what gives it 
meaning. Without the relation it has no meaning.


I cut it down to about half the response. While there are some schools 
still taking the proper course, teaching the fundamentals without 
teaching a language in them; most take the quick and dirty path. They 
will use Pascal or some language like it in both Logic and Data 
Structures. The students learn Pascal, not the subject.

Many courses don't even teach the fundamentals anymore. They just jump 
shiny new students into script-kiddie languages hacking out Web pages on 
day one.

In America, most large municipalities require electricians, plumbers, 
and many other "trades" workers to be licensed and bonded. Obtaining a 
license requires passing a training program and certification exam. This 
is because people's lives depend on what they make.

For many years a B.S. in Computer Information Systems (or the handful of 
other titles) was our certification that we had been taught and 
understood the fundamentals. Run-for-profit schools started playing fast 
and loose with the coursework.

Today we have kids reading half (or less) of a "Teach Yourself How to Be 
Totally Useless in 24 Hours or Less" book and hanging their shingle out 
as a freelancer. It's the "trades" equivalent of someone buying a hammer 
and driving one nail then claiming they are a carpenter qualified to 
build your home. If you've tried to physically build anything, you know 
it involves a bit more than the ability to drive one nail, especially 
something like a home people need to feel safe sleeping in.

Most of the kids coming into the market today seem to be taking the half 
a book approach or the run-for-profit diploma mill approach. They hang 
out a shingle with Java, JavaScript, and a few other Web languages under 
their belt, but no fundamentals.

Could someone from such a background learn enough C syntax to write a 
student C program like this one?

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int get_number(int argc, char **argv);
int prompt_number();

int main(int argc, char **argv)
     int the_number = get_number(argc, argv);

     if (the_number > 0)
         char buff[1024];
         memset(buff, '\0', sizeof(buff));
         sprintf(buff, "%d", the_number);
         int x=0;
         while(buff[x] != '\0')
             printf("%c   ", buff[x]);

     return 0;

int get_number(int argc, char **argv)
     int ret_val = 0;

     if (argc > 1)
         ret_val = atoi(argv[1]);

     while (ret_val < 9999 || ret_val > 99999)
         ret_val = prompt_number();

     return ret_val;

int prompt_number()
     int ret_val = 0;
     puts("Please enter an integer number between 9999 and 99999.");
     scanf("%d", &ret_val);

     return ret_val;


Could that same person write a page swapping system for a Linux-like OS 
from scratch? No. You need the fundamentals for that. There is no 
garbage collection safety net. Very little of the OS is available to you 
because your code is one of the legs holding up the 3-legged stool.

>> It's like trying to teach someone who never took the training wheels off
>> their bike how to ride a bike that can't ever have training wheels or go
>> slow.
> So.. Every child that ever learnt to ride a bike?
> We all have to start somewhere after all, it just takes a little while.
> I'm not disagreeing with your point. If you hire someone to do X, you'd
> probably not want to hire someone that can do Y, but promises that they
> can learn X really fast if you let them.

The above statement that appears to have offended you so was assuming a 
level of following the conversation I shouldn't have assumed. Sorry. In 
my defense, I didn't want to have one of these monolithic messages 
laying out all of the details if many of the readers knew them.

You also didn't read the training wheels statement correctly, or I 
didn't use enough words with it.

When one comes from the scripting/interpreted language background; 
especially if they never got a degree from a good school that taught 
them proper fundamentals of software development; that is the training 
wheels never off the bike.

Put them on C. No garbage collection. Requires proper understanding of 
the fundamentals, especially Application Design, System Architecture, 
and Data Structures. Basically it requires the skill to ride a bike that 
goes very fast and can never have training wheels put on it.

With C++ and Qt Widgets we got a small set of training wheels that 
repeatedly bites one in the fanny. The deleteLater() and "idle" process 
garbage collection allows really bad code to run fine on a processor 
that is wheezing for air. When you move it to a processor that has 
horsepower to spare it starts crashing all over the place because that 
processor had more than enough time to turn deleteLater() into already 
deleted and when something else used a stale reference/pointer/whatever, 
the memory wasn't owned by that object anymore.

With the wretched decision to add QML and JavaScript so that developers 
without any formal training could use Qt we now have three garbage 
collection entities firmly believing they own an object and oh what fun 
three sets of training wheels are!

> But the way this was portraied didn't seem quite right to me. People can
> learn, people can change. All that's required is the incentive to do so,
> which is probably where you should have put your argument at instead:
> If Qt migrates away and drops win7 support, you get fewer and fewer
> people over time that have the incentive to learn the skills required to
> still develop for older versions.

Wasn't really the point. There were many points, but that wasn't one of 

KDE simply cannot continue with Qt Company. It __has__ to choose a new 
development library and turn its back on Qt and Qt Company. The least 
painful approach "might" be CopperSpice because it is a fork without 
QML. They are certainly free to choose any of the other libraries found 
on that link or one that isn't even on that link, *but they need to 
choose now*.

It must have a stable API. Classes don't get renamed and methods don't 
get dropped from those classes.

They must never allow the search for a header file to become an Easter 
Egg hunt as it has with Qt release to release.

That's really the two requirements.

This ensures a program written today on some OS will be able to compile 
against a release 30+ years from now even if it is a different OS the 
program is running on. This is a cross platform library after all.

Have you been using Qt long enough to remember when multiple inheritance 
got butchered because the powers that be wanted to lower the bar for 
Java developers?

  * Originally created by Roland Hughes at Logikal Solutions.
  * Project is being released under GPL2 license.
  * At some point in the future either Logikal Solutions or Roland Hughes
  * may elect to publish a book with this original source code in it.  If
  * the book is written it will be part of "The Minimum You Need to Know"
  * book series.

#include <QDialog>
#include <QtSql>
#include "ui_CategoryDialog.h"

class CategoryDialog : public QDialog, public Ui::categoryDialog

     CategoryDialog( QWidget *parent, const QString &qtDbName);
     QString getEnteredCategory() { return m_category;};

private slots:
     void addCategory();

     QString m_qtDbName;
     QSqlDatabase m_categoryDb;
     QString m_category;


That was how we did designer forms. Hundreds of thousands (perhaps 
millions) of lines of code in the field and to make Java developers feel 
warm and fuzzy that was just dropped. Kids today who started with 5.x or 
later have no ability to function in that world. They have no frame of 
reference to get a handle on it. If they can't see and use this:

  * Originally created by Roland Hughes at Logikal Solutions.
  * Project is being released under GPL2 license.
  * At some point in the future either Logikal Solutions or Roland Hughes
  * may elect to publish a book with this original source code in it.  If
  * the book is written it will be part of "The Minimum You Need to Know"
  * book series.

#include <QDialog>
#include "ui_categorydialog.h"

namespace Ui { class CategoryDialog; }

class CategoryDialog : public QDialog

     CategoryDialog(QWidget *parent, const QString &qtDbName);

     QString getEnteredCategory();

private slots:
     void addCategory();

     Ui::CategoryDialog *ui=nullptr;
     QString qtDbName;
     QString category;


They simply cannot function. That may seem like minor little thing, but 
when you have a device in production and a code base exceeding a million 
lines in a regulated world, that change locked you. Bringing in the new 
version of Qt (even if it ran on your OS) would require changing every 
module when all you were trying to do was update the device to support 
one shiny new thermometer or other device.

Once that barrier came down; the flood gates opened; scripting languages 
washing in like a tidal flood and with them, an ocean of developers not 
formally trained.

Had the barrier of multiple inheritance being a requirement not been 
removed, we wouldn't have veered this far into the weeds.

I cannot, in good conscience, despite all my years of using it, 
recommend Qt to any paying client. The licensing, royalties, and lack of 
good direction make this a tool they should not spend money on. Medical 
devices will be deployed in primary market countries for 10-18 years 
then refurbished and redeployed to third and fourth world markets where 
they will serve another 10-20 years and still need to be supported.

The market that pays long term support contracts (medical and industrial 
devices mainly) needs a tool set guided by people who were formally 
trained. That hasn't been happening with Qt. It's not an elitist 
comment. Formally trained people remember the installed base is sacred. 
You don't sacrifice it without a massively good reason. Adding Java and 
scripting languages was not a massively good reason.

Sorry for the length, but it is all one big thing.

We need KDE to point us in a new direction. We cannot continue down this 
road; the bridge is out.

Roland Hughes, President
Logikal Solutions


More information about the Interest mailing list