What makes a programming language popular ?
In nowadays , the computer world has changed very dramatically - speed , size , capacity ...etc.
The development of the computer's world has changed from the first generation to the
fifth , or even the sixth generation . From a very low level language such as
assembly to the high level language such as Java , Access ......etc . For more details
about the generation trend of the programming languages , please refer to my partner's
article two. Although we have nearly more than 100 programming languages now , such as
C++ , Cobol , Fortan , PL/SQL ...etc , we can still clsssify them into three main catagories :
- Database Languages - SQL & PL
- Procedural Progamming Languages - Java , Ada , Modula 2 & Pascal
- Non-Procedural Programming Languages ( Object-Oriented Programming , Functional Programming
& others ) - C++ , LISP , Miranda & Cobol
But what are the main reasons for being popular languages such as C++ or LISP , it
is better to discuss some of the existing programming languages by their characteristics and
features to find out the reasons for popularity . We will discuss C/C++ , LISP ,
Pascal and Oberon .
"C" is a low level , weakly typed , static , non-modular , non-generic , non-reflective
"C" was designed in the late 70's as a portable assembler for the PDP-11 series , and it is
still the state of the art in that area , although , as a system programming language , it
is more adapted to the PDP-11 than to modern architectures.
In the late 80's , the small and elegant 'K&R' C has become the prey of an ANSI standards
commitee ; it has now become ANSI Standard C.
In the 80's , C has become the language of chioce for general-purpose programming. In an
attempt to add the features of general-purpose Object-Oriented Languages to C , Bjorne
Stroustrup created C++ .
- Many people know this language , and we don't have to readapt another language
syntax , as it is the one ( now ANSI ) standard in system programming .
- We may compile test programs immediately , without having to wait for the kernal
and complier to be done .
- C/C++ is a static language , it is not possible to program while running.
- C/C++ knows only early binding ( i.e., it only compiles directly executable code ) ,
hardly knows about dynamic library linking ; C/C++ considers a program to be complete
, finished , and run in the absolute without interaction with other programs , but
through the system .
- As it's a low-level language , either we'll have to have low-level spec for the OS , so
that we can't adapt to different architecture from the original designed OS ;
or we'll have to rewrite a great amount of the C/C++ code on each system .
Besides we can never achieve object-level security , but by having a C/C++ program for
each object , which either disallows everything is an object in the system , or requires
many a low-level system declaration in a C source , and/or requires having tiny C/C++
programs , which contradicts the heavy compilation cost and the class philosophy
of the language .
LISP is a self-extending higher-order dynamically typed strict ( non-pure functional language
with lazy data structures ) . It is the second oldest Programming language ( being completed
1962 ) , but also one with the nicest semantics . It's a good experimental
platform for just any kind of computing; it has got very good support , including free
portable development environments , integrated structured editors , and efficient
"optimizing " compilers . Unfortunately , LISP syntax uses a very clean but unusual
notation called 'Cambridge Polish' which makes it quite unpopular with many programmers.
Common LISP is a huge monolithic language , with hundreds of built-in constructs for a
megabyte worth of run-time system . However , the advantages of programming in Common LISP
cannot be overestimated : everything a programmer usually needs is in the library , the
object system is well integrated with the type system and condition system . Common LISP is
now an ANSI Standard .
- It's a widely know and standard language , with implementation on just any computer
architecture , including very portable ones.
- Both interpreters and compilers of good quality are available , and new ones are easy
to design , making development easy , and portability quite good .
- It is fully reflective
- It is strongly-typed , that is , type-safe for a non-trivial type system .
- The type-system is not safely extensible in a high-level way.
- It doesn't allow any static typing
- It allows too many side-effects
- Its standard has got too many features nobody uses .
- Its module system offers no security at all.
Pascal was invented by Niklaus Wirth in the early 70s and became very popular, not
only as teaching language but also for systems prorgamming and certain appliactions .
It is safe , reliable , featuring strong data-typing and syntax with encourages
top-down design and structured programming . It was standardized by BSI and ISO
in the early 80s .
- Pascal has a relatively strong type system , partly due to the fact that it was
originally intended to be a language for instruction , and type checking can
help to catch a lot of the errors of beginning programmers.
- Pascal allows recursion, an improvement over many earlier programming languages .
- Pascal provides some run-time type checking , the most notable of which is
bounds checking on array references .
- Pascal's treatment of arrays is cumbersome in other ways, especially the fact
that array size is part of the type of the declared array. This makes it
impossible to define utility functions and procedures that operate on arrays
of any length, which is a severe limitation , particularly in string handling.
- Although this is not a type concern, arrays are passed by value by default .
This requires the programmer to treat variable and variable parameters both as
signifying if a parameter is updated inside a procedure and whether it is efficient to
create a local copy of a parameter.
Oberon , the successor of Modula-2 , is both a programming language and a novel
programming environment of designed by N.Wirth and J.Gutknechtat ETH Zurich .
It is a general-purpose programming language that evolved from Modula-2. It's
principal new feature is the concept of type extension . It permits the construction
of new data types on the basis of existing ones and provides relations between
- Strong type checking
- Modules with type checked interfaces and separate compilation
- Type extension , which provides for object-oriented programming
- Support for run-time type tests
After the discussions from the above languages , the followings are the typical features
for the popular/standrad languages
- They are highly portable and are offered on a wide range of systems
- They can be compiled or interpreted by a choice of offering from competing vendors
- They are reasonably stable during changes in hardware and system software
- They are suitable for development of programs of arbitrary size and complexity
- They are controlled and enhanced through public deliberative processes
- They are supported international by a wide variety of consultants , software vendors ,
hardware vendors , educational institutions , and government organizations.
Conclusions for designing a popular/standard programming languages
- We can design the syntax to fit our needs and ideas , so that it's much easier
to use. Moreover , even C isn't our natural language , and whatever language
we use , there will have been adaptating time to use it.
- We can correct the lacks of any existing language we could have used.
- Portability : both the system and the language may be as easy to port.
- The language is perfectly well adapted to the system . No need of bizarre
and slow language which leads to system call translation .
being efficient as an interpreted language , it may serve as a shell language
as well as a programming language ; being powerful , and easy to specialize
through standard libraries, it also replaces samll utility languages (awk , perl ...etc).
Finally , being high-level and knowing of relations between objects , it is
easily adaptated to an AI language . So there is no more need to learn a different
language for every application . The same language is used for everything ,
no need to learn new syntaxes each time.
- We have to relearn a new language syntax . But as we may choose whatever syntax
pleases us , there is no big deal .
- No existing compiler can be used directly . There is no big deal either:
Front ends are easy to write , and no existing back and can fit an interesting
new OS' object format , calling conventions , and security requirements .
Moreover , our system having a brand new conception , even with a tradition
language , we'll have to learn restrictions about our way of programming .
- We have to debug the language specifications as we use it . But this can prove
useful to refine the language and the system specs .
Programming Language Choice Practice and Experience by Mark Woodman
Programming Language Critiques: Pascal , C ,C++ ,and C-Linda by Jim Baseny May 1995
The Programming Language Oberon - Make it as simple as possible , but not
simpler by A.Einstein
Press Release 15th October ,1992 Fourth Generation Programming Language for
Engineers and Scientists by email@example.com
Smalltalk, C++ , and OO Cobol : The Good , the Bad and the Ugly by 1995 Jeff
Sutherland and Object Magzine
My partner's Johan article2