As
an experienced author of several software development
books, and also someone who has had a successful
career in software development, I would like to
recommend Delphi as the language that is the most
useful of all. I’ve used most languages,
and they typically have weaknesses, but Delphi
has very few. With Visual Basic, the user interface
and the design method (which is similar to Delphi)
are excellent, but the fundamental weakness of
the BASIC programming language always provides
barriers for the developer. Its strength of integrating
with other Windows applications, especially Office
programs, provides a useful way of reducing the
loading of the main program, but often it is difficult,
and complex, to properly integrate these into
the main program.
With C and then with C++ we had a programming
language which was developed by software developers.
Unfortunately it has, in the past, relied too
much on the professionalism of developers to catch
potential problems before they occur. C had, and
still has, many pitfalls, including running off
the end of arrays, pointer problems, and it was
difficult to react to events. C++ improved things
by providing for design methods which allowed
the data to be properly modelled, but the underlying
problems of C were still there. It also did not
cope with events, and, initially, with Windows
programming. New versions of C++ compilers deal
with Microsoft Windows programming and integrate
event-driven software, but they do this in a rather
complex way. This is fine for professional programmers,
but is a nightmare for anyone starting with programming,
or who just want to get a program to create a
few windows, and react to a few events. C++ for
Windows is likened to assembly language programming,
where large programs were produced for relatively
simple operations. This problem has become so
bad that many Windows-environments for C++ have
a template-driven system which produces the initial
framework for the code, into which the programmer
must add their own code. This has been developed
because it is often difficult in C++ to produce
simple windows, with menus and to make them mouse-driven.
C++ is often a complex language to learn, and
I’ve seen many undergraduate students struggle
with its actual syntax. Much of the Windows operating
system is actually written in C++ so it is the
most natural language for developing windows applications,
but, of course, this does not make it the best
language. This is like saying that the most natural
device to chop down a tree is an axe, but an axe
is not the best device to chop it down with. In
fact, in some circumstances, C++ can be likened
to an axe and Delphi to a chainsaw.
The coming of the Internet saw new applications
for programs, especially in creating applications
which could run over networks, using client-server
architecture, and for different types of computers
to connect to each other. These computers might
have differing operating systems, and range from
supercomputers to simple mobile devices. There
was thus a demand for a language which could be
run on many different types of systems. This called
for an interpreted language which could run on
the system using the original source code. The
interpreter could then interpret the language
and convert it for its own hardware. In the past
computers were not powerful enough for this to
occur, but increasing processing power, and increasing
memory capacity, have allowed these systems to
compete with traditional software languages. The
language most relevant to this is Java. As with
C++ it is aimed at the professional software developer,
as it is often a difficult language to read and
write code for. Java has many strengths; it is
extremely strong on the definition of data structures
in the program and its good portability and integration
with the Internet. Unfortunately it has many weaknesses,
especially in that large programs are generated
for simple programs. It has also lacked proper
integrated development systems, which included
a graphical design environment, code editor, compiler,
debugger, and so on. Thus Java wins on many fronts,
but fails on just as many. Unfortunately when
it fails, it fails badly. When it does something
well, it does it very well.
Most of the other languages, such as COBOL, Assembly
Language, FORTRAN, and so on, are also-rans. They
obviously still have their niche in certain areas,
but are so weak in most areas that they can never
really be considered for new software projects.
Thus we return to Delphi. Well it is strong in
virtually every area, and has excellent integration
with databases, the Internet and the operating
systems. It also produces strong and robust applications.
One of its major strengths is that it has a similar
design feel to Visual Basic (as it designs around
forms which have associated code), but it scores
over Visual Basic in that it has a proper object-oriented
programming language which has been properly defined
and developed. The thing that has made Delphi
so good was that Borland took just two versions
to get it right. Delphi 1 was a good start, but
Delphi 2 was an excellent package, which was at
least five years ahead of anything else. Versions
after this basically followed the same theme,
and just refined an already near-perfect product.
Unfortunately there was not much further that
the product could go, and the competition, mainly
C++ and Visual Basic, and then Java, were allowed
to catch up with it. It has thus lost shares of
the market, which it should have gained, typically
due to the strength of Microsoft products. Companies
such as Novell (in networking), Lotus (in spreadsheets)
and IBM (in operating systems) have all succumbed
to the power of Microsoft. Delphi has survived
purely because it has an excellent foundation,
and provides one of the most general-purpose environments
for software development.
