I missed the beginning of this thread and don't have enough time for one
of my usual missives. I did want to take issue with the comment about
using C++ latest.
It's _never_ a good idea to chase a standard.
Please allow a few words of caution from a grizzled old code warrior.
I started programming before we had PCs or a C compiler for them. If you
want a loose interpretation of the time which shortly followed rent
"Halt and Catch Fire" https://www.imdb.com/title/tt2543312/ and follow
it up with "Pirates of Silicon Valley" https://www.imdb.com/title/tt0168122/
Back there and back then we had to chase the standard. The C language
itself didn't provide enough functionality to develop the applications
users wanted and we were mixing memory models trying to make them fit
under the infamous 640K barrier. By the time C++ compilers were
commercially available most compilers were so far afield from any
"standard" that you couldn't write something in Borland C++ with any
hope of it compiling under Microsoft or Watcom and yes, you could switch
the order with the statement still being true.
I used to skim the edge, but I had to because we were writing programs
for IBM "compatible as long as you didn't try to run Flight Simulator"
machines. I even subscribed to Rex Jaeschke's standards tracking blue
magazine back in the day. While I wouldn't say we were friends, we did
exchange emails before we had an Internet and email standard. We did
also exchange emails earlier this year. You can look him up here
http://rexjaeschke.com/ but might be best to dig through old Dr. Dobbs
issues. The dude really worked hard and wrote well. We all worked hard
Standards bodies have a tendency to jump the shark a bit too often for
my comfort. I came to this realization with the introduction of trigraphs.
P.J. Pluager (we DON'T exchange emails) was hailing their salvation of
mankind in "The C/C++ Users Journal" while many of us grunt coders in
the field were decrying them even being thought about. This was the
result of a select few individuals trying to solve a language problem
with an addition to a programming language. They wanted to make the C
language family "the one" to replace all others. It was the wrong
solution before the idea was even hatched. IBM and a select few others
could not wait for the correct solution, so they slammed through an
ill-formed solution and went merrily on making money. (To this day I
don't know of a single widely available programming editor which will
show you the translation of a trigraph or digraph on your screen.
Somewhere one or two might exist, but they certainly didn't exist when
this egg was laid.)
What was the correct solution you ask? UTF
There were other attempts to be sure. Various language sets which could
be loaded on demand, but, the programmers who coded close to the metal
needed to step back. We were well past the days of being able to rely on
the characters contained in either a BIOS/firmware code page or the one
loaded by DOS. (Windows was nothing but DOS all the way until NT.)
Being long in the tooth and somewhat greying of hair and having spent
roughly 3 decades as a hired gun in the software programming world, I
will share with you a bit of advice which will find deaf ears which will
fall on the deaf ears of the young guns who stay up nights reading
communications of the standards body.
The person hired to maintain your code will have one overriding
qualification. They will be "priced right." As a software mercenary, if
you write code which skims the edge of the current standard, word will
get around and you will find yourself stocking shelves at Walmart.
I've known quite a few consultants over the years who tried to make
themselves indispensable by writing code nobody else could maintain. One
used to write "hand tuned assembler" for portions of every system he
wrote and we are talking less than a decade ago. He wasn't writing PC
software, but working on a big midrange system and pretty much
everything he did in assembler could have been done in BASIC or COBOL on
the same platform. In fact that company has someone rewriting it all in
a high level language now. Yeah, he's not there anymore.
During my 3 decade career I've only encountered one client site which
did not prefer a full page of easy to read code to that one incredibly
ingenious line which could replace it all. That one place has a teem of
young guns who basically sleep with the standards documents who like to
write incredibly complex and impossible to debug templates for various
things. As of last year their product was still in trouble. It wasn't
even that complex of a product conceptually. There was certainly no
reason for the code to get that way. Oh yeah, I forgot about the macros
which use other macros that use other macros. When you compile a listing
the macro set on one line expands to, in some cases, an entire page or
more of code.
Long life Qt shops. Those building products which must be field
maintained for a decade or more like medical devices, cargo x-ray, etc.
Need a code base which can be maintained by their most junior developer.
They need a college intern to become functional within 2 days and able
to maintain the system within a month.
Young guns like skimming the edge of a standard to prove their chops.
They, however, create systems which either never see the light of day or
only survive for a couple of years in the field.
As I said in the other thread, not using C++-latest costs
_you_ more. It shouldn't cost anything for Qt.
Roland Hughes, President