Much of common (Unix/Windoze) computing infrastructure is written in C, and it is probably safe to say the single greatest source of problems (other than the programmers themselves) in the quality of the infrastructure is directly attributable to this language. Anyone who has reflected significantly knows how inadequate the C programming language is, even for the low level, system oriented tasks which are supposedly it's forte.
As inadequate as the C programming language is, it is interesting to note that much of the evolution of this infrastructure still depends upon it. There is a move toward languages that are easier to use, like, Java, Perl, Python, etc, yet core portions of these languages are still directly dependent upon C, let alone the wider environment that the programs written in these languages run in, which is completely written in C.
When searching for an answer to this phenomena, the most obvious one can be attributed to inertia. Most things are written in C, many tools target C, and many programmers know C. So, for a variety of practical reasons, it pays to keep writing applications in C, regardless of the loss of productivity and depreciation in quality.
A less obvious answer lies in the virtues of C. Many of the programs that comprise this shared infrastructure require direct access to the hardware, or are built upon programs or libraries that do. They are fairly large programs that need to compile in a reasonable time. They are programs that need to make the most effective use of a machines resources. C handles all these basic requirements better than almost any other language out there. It is relatively simple, allowing programs written in it to compile quickly. It maps fairly well unto how current computers actually work, making it is easy to generate efficient code. It has a simple run-time environment, reducing overhead. C gives the programmer fairly complete control over the machine through pointers and unrestricted casts.
Of course, there are other languages out there, such as Pascal and Modula, which are similar. But they are not enough of an improvement to entice programmers to switch to them. Some languages, such as Ada, are actually more powerful in many respects. However, this power comes at a cost. Ada is fairly complicated, difficult to read and learn, and slow to compile.
Nevertheless, as the rise of safer, easier to use "scripting" languages has shown, programmers are not content with C. They want more functionality and better productivity. Many applications don't need the low level control, and programmers don't want to pay the productivity price of being forced to use these constructs. In addition, they want to use the more sophisticated features that these other languages provide, features that make programming more enjoyable.
So instead of the software community coverging on a single language to accomplished most tasks, we are left in a situation where a variety of languages co-exist and inter-operate. Some see this as a good thing. Each language has it's own benefits, and should be evaluated for the task at hand. Thought in this school sees a plurality of languages as a good and inevitable state of affairs, as there cannot be one general purpose language that can handle most tasks.
This judgment, I feel, is mistaken. While there will always be some applications that will require special purpose languages, most tasks derive no benefit from having a domain specific language. The basic tasks of programming are universal. Iteration, abstraction, classification, decomposition, etc, are features that are required across all programs. Having these constructs implemented in slightly differing ways in a variety of dialects does not seem to offer any advantage other than appealing to personal syntactic tastes.
Rather, having an environment where there are a multitude of languages in use is a hindrance over the lifetime of the programs written in these languages. Learning a programming language is fairly difficult, particularly for those who do not program extensively. Having a set of programs written in a variety languages make these programs effectively inaccessible, as most won't attempt to overcome the hurdle of learning another language. This raises costs and lowers the potential for reuse. In addition, inter-operability between software written in different languages is cumbersome and difficult from a purely technical perspective. Writing bridges between programs in different languages is boring, time consuming work, fraught with peril.
It would be desirable then, from a practical perspective, to have one general purpose programming language that can be used in almost every circumstance, from writing device drivers and operating systems, to simple scripts and utilities, to large applications and simulations. While it is preferable that a language already prevalent could be used for this task, it appears that no programming language in existence is flexible, expressive and simple enough to qualify. Languages that are expressive and easy to use, such as Python, lack efficiency and flexibility. Those that have efficiency and flexibility, like C, lack expressiveness in other areas, and are difficult to use.
Therefore, in order to meet these broad range of needs, it is necessary to create a new, universal programming language. The goal of this project is to define and implement this superior language.