> not really
> either they are old and run on main frames, then they are COBOL or
> PL/1 or they are modern then they are the same as other business
> applications;
>
> e.g. SAP brings its own scripting language ABAP
If you think "financial applications" are written atop things like SAP,
then your answer makes sense. Perhaps you are unaware, though, that
the financial industry employs lots of C++ programmers.
I observe that C++ is the last man standing, the only language in
common use that compiles to machine code. You may point to C, but a
good deal of what used to be C has migrated to C++. Cobol and PL/1 are
extinct, and Fortran a specialty.
It is the world's biggest language, containing two Turing-complete
syntaxes that I know of, and supporting several paradigms. That lets
it be many things to many people. The STL is a magnificent
conceptualization that has yet to be surpassed in any language. These
things combine to make C++ terrifically powerful, if complex.
Financial houses have compute-intensive applications over complex data,
and C++ is a natural fit.
C++ has one central weakness, though: like C, it models the machine as a
von Neumann machine, as a single process. Such machines are
increasingly rare, and C++ as a *language* would have to be redefined
to model the modern, multiprocessor machine. The C++ community has
yet to come to grips with that fact.
Yes, we have features in the standard library to support
multithreading. Multithreading defeats the language's own features,
though, making the entire heap implicitly volatile. Because the
community's focus is always on speed, we get things like std::future,
but no support for CSP and next to none for reflection.
Taming complexity and enabling the human being to reason about the
process's correctness are traditional goals of programming languages.
Yet in C++ the most difficult aspect, concurrency, is regarded as the
programmer's problem. Real men know when to take a lock, right?
Grappling with currency as a language feature is what Pike and Thompson
are doing at Google with Go. By elevating pipes to first-class
elements -- typed channels -- they take back concurrency management
from the operating system and give it to the compiler. Et voila,
suddenly write-after-read errors become compile-time errors.
The only CSP implementation I've seen for C++ is of course a library.
It is terribly complex, a syntactical firestorm compared to Go, and
still (because a library) fails to identify concurrency errors at
compile time. Without extending the language proper to model N threads
of control where N > 1, C++ will perforce cede concurrent processing on
concurrent machines to concurrent languages.
I think the place to go, syntactically, is roughly were namespaces
are. Similar to namespace and class, we could have "process", where
everything in a process is treated much as a whole program is today.
The difference would be that variables could be passed from one process
to another -- perhaps through a channel -- at which point the compiler
would invalidate access to those data within the sending process.
Static analysis would identify many such errors at or near compile
time. Any that are missed would generate an exception instead of a
signal or simple undetected data error.
The answer to the OP's question, then, is "applications that need to
run at the speed of the machine". The caveat is that the machine is
changing, and to remain relevant C++ needs to change to match it.
--jkl