Sorry, Internet was down much of yesterday.
On 6/17/20 5:00 AM, interest-requ...@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.
25
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]);
x++;
}
printf("\n");
}
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;
}
Sure.
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
them.
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.
****************************************************************************/
#ifndef CATEGORIESDIALOG_H
#define CATEGORIESDIALOG_H
#include <QDialog>
#include <QtSql>
#include "ui_CategoryDialog.h"
class CategoryDialog : public QDialog, public Ui::categoryDialog
{
Q_OBJECT
public:
CategoryDialog( QWidget *parent, const QString &qtDbName);
QString getEnteredCategory() { return m_category;};
private slots:
void addCategory();
private:
QString m_qtDbName;
QSqlDatabase m_categoryDb;
QString m_category;
};
#endif
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.
****************************************************************************/
#ifndef CATEGORIESDIALOG_H
#define CATEGORIESDIALOG_H
#include <QDialog>
#include "ui_categorydialog.h"
QT_BEGIN_NAMESPACE
namespace Ui { class CategoryDialog; }
QT_END_NAMESPACE
class CategoryDialog : public QDialog
{
Q_OBJECT
public:
CategoryDialog(QWidget *parent, const QString &qtDbName);
~CategoryDialog();
QString getEnteredCategory();
private slots:
void addCategory();
private:
Ui::CategoryDialog *ui=nullptr;
QString qtDbName;
QString category;
};
#endif
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
(630)-205-1593
http://www.theminimumyouneedtoknow.com
http://www.infiniteexposure.net
http://www.johnsmith-book.com
http://www.logikalblog.com
http://www.interestingauthors.com/blog
_______________________________________________
Interest mailing list
Interest@qt-project.org
https://lists.qt-project.org/listinfo/interest
