Separation of human languages come from (darwinian ?) evolution in
isolated communities. Separation of programming languages comes from
variations in technical need, technical ideology, from changes in
technical and theoretical understanding, from changes in our technical
ability to implement. It is a somewhat more conscious process, I think.
Could computer languages be more like natural languages ? Probably
somewhat, up to a point. I guess that a large part of natural language
complexity results from a variety of concurrent evolution phenomena that have no
reason to produce a consistent result at any one point in time, even
though it is likely that old inconsistencies are probably
progressively eliminated while new one appear. I am no expert in
diachronic linguistics. But do we want that kind of
complexity in programming languages.
The issue of ambiguity is an important one, but not as stated by most
people. A language is a mean of communication, and it must be analyzed
in the context of that communication (man-man, man-machine, both,
between places or between times,
... to say it a bit simplistically). What matters is not whether you
can make only unambiguous statements in the language, but whether you can
always ensure that the communication will be unambiguous in its
intended context. There is one well known and widely used programming
language, that allows writing ambiguous programs (well, it did, but I
have not looked at the latest versions for a while). In this case, the
compiler is smart enough to detect the ambiguity and ask for
clarification, which can be incorporated in the program the eliminate
the ambiguity. Note that ambiguity detection does not mean that only
one of the possible choices has meaning, they all do. The issue is whether
one of the communicating entities can detect the ambiguity so that the
sender can clarify it. Human beings are bad at this, but computers can be
pretty good.
Formalisms and programming languages could have richer and more
flexible syntax. I believe the main reason they do not is simple
conservatism. The syntactic tools used are still very often tools
designed thirty years ago or more, to meet the limitations of the
computers of that time. Parsing efficiency is no longer such a
critical issue in compiling and more powerful techniques do exist
tractably.
Interestingly, the most widely used basis for programming languages
syntax comes from natural language research : the context-free
grammar. Much of the technical research moved the to
theoretical/technical computer science in the sixties, to be somewhat
rediscovered in the early eighties by natural language people (I am
simplifying). Since then, much progress has been made for syntax in
natural languages, while computer science seems largely stuck with old
syntactic tools. The natural language pendulum is now swinging again
towards statistical techniques, but algebraic approaches for syntax
are not forgotten. Most likely, good approaches will come from a combination of
algebraic and statistical techniques.
My feeling is that the critical area is semantics and the transition
between syntax and semantics. This is still very hard to formalise for
natural language, while we have many precise techniques in the case of
programming languages and formal systems. As the game is far from
being played for natural languages, it is hard to say what impact it
could have on programming languages in the future.
Another point is that many programming language designers are trying
to prove something or enforce a technical ideology. Thus they get
extremely prescriptive in their design to prevent users from departing
from their intended paradigms. This is unfortunately extremely
counter-productive for creativity. The most creative language ever
designed was among the very first : Lisp (1958). The freedom and flexibility
it allowed was the source of considerable creativity. The price was
that it required self-discipline and understanding. But Lisp was
really a metalanguage, a language for the creation of languages.
Now, to take another perspective, programs are actually proofs of
their specification seen as a mathematical statement (well, I am
simplifying again). Some people (I do not remember references, sorry)
have been playing with theorem provers to produce proofs that would
look like they had been written by a mathematician in natural
language. So I guess the idea of having programs that look like they
were written in natural language may not be totally absurd.
You may however notice that, even when written informally by a
mathematician, mathematical discourse looks quite different from
ordinary talk, or from a history book. This is due to a significant
difference in the concerned universe of discourse, the semantic
domains that are being talked about. Thus while you can envision
programming languages that look more like natural languages, there is
a natural limitation which is the domain of discourse and its own
desirable properties. Most likely it will remain essentially
superficial, that is, mostly syntactic. The mathematician can talk
about formal systems and about politics. Hopefully the two discourses
will not look similar. Computers cannot (yet?) talk of politics, or
understand it. The day they do it will no longer be programming.
Looking back in history, high level languages were, from the very
first (FORTRAN) an attempt to get closer to a more natural form to
express computational tasks, but these tasks were understood as
mathematical or logical (Fortran 1957, Algol 1958, Lisp 1958), or more
business oriented (Cobol 1959). Within 10 years people were worrying
about languages that would be closer, better adapted to the problem at
hand, and there was significant research in so-called extensible
languages
, covering both syntax and semantics. One major pathway for
expressing problems more naturally was the emergence of object
orientation
(sometimes under other names). Though it is always
difficult to assign parenthood, it probably emerged from the work on
artificial intelligence, mostly in Lisp, and from the language Simula
67
(Algol family) which was itself intended to express more
naturally real world problems that are to be simulated on a
computer. It all seems historically consistent.