Invention History of C Programming Language
There would be no surprise in saying that the C language literally shook the computer world? The impact of C cannot be underestimated because it completely changed the perspective with which programming was approached. The birth of the C language was a direct result of the need for a structured, efficient and a high level language that was capable of replacing the assembly code when creating systems programs. On the whole, The C language was designed by programmers and for programmers.
The Mastermind behind the Invention
Well, now who is the visionary who ended up with such a versatile programming language? It was Dennis Ritchie. Yes, Dennis Ritchie who is often mentioned as one of the greatest and most influential minds of computing. No wonder he is highly regarded by the professionals in the field as a tech trailblazer.
Born in Bronxville, New York, Ritchie grew up in New Jersey; later, he attended the Harvard University to graduate with a degree in Physics in the year 1963. Ritchie’s father was a switching system engineer at the Bell Labs. It was there that Ritchie spent the better part of his career. His vision was to create a computer language that could serve dual purposes: fulfilling the intellectual caliber of programmers and creating a freedom for them to independently create and pursue their passions.
In the late 1960s, Ritchie and his fellow programmer Ken Thompson set up to create an operating system that could be run on the then upcoming minicomputer which was greatly competent. The result of this undertaking was UNIX. Though the first incarnation of UNIX was versatile, it was characterized as clunky, mainly for the reason that it was written in assembly language. So, whatever machine it was put on had a lot of limitations in terms of memory and vocabulary. Ritchie and Thomson found the ultimate remedy for this problem by brilliantly re-coding UNIX in Ritchie’s own C language by 1973.
Series of Incidents That Led to the Creation of the C Language
The Early Programming Languages
In the early days, CPL or the Combined Programming Language was predominant; it was developed mainly with the goal of creating a language that had the capacity of high level, machine independent programming as well as allow the programmer to have control over the behavior of each individual bit of information. However, CPL had a major drawback; it was too large that it cannot be used in many applications. Later, in 1967, BCPL or the Basic CPL was developed as a scale down version of CPL; the basic features of CPL were retained in the new BCPL. It was Ken Thompson who took this further by developing the B language, which was a scale down version of the BCPL.
The Multics Project
In the 1960s, Ritchie and several other professionals of the Bell Labs (AT & T) worked on a project called Multics. The vision of the project was to build an operating system for a large computer that could be probably used by a thousand users. Unfortunately, in 1969, Bell Labs pulled out from the project; the apparent reason being the project could not create an economically useful system. Therefore, the employees of the company, especially Dennis Ritchie and Ken Thompson, had to look out for another project to work on.
Development of the UNIX
Eventually, Thompson started working on developing a new file system. He wrote in assembler, a version of the new file system for DEC PDP-7. This file system was also used for the popular game Space Travel. Soon, improvements were made and expansions were added to the new file system. A lot of knowledge from the Multics project was applied to accomplish this. In a short time, a complete system was created. This system was termed as UNIX by Brian W. Kernighan; the name being a sarcastic reference to Multics. The new system was, however, written in assembly code.
What led to the creation of B language?
UNIX had an interpreter for programming language B, besides FORTRAN and Assembler. The programming language B was developed by Ken Thompson in 1969-70. Early on, computer code was written in assembly code. Programmers had to write a lot of pages of code to perform a specific task. However, using a high level language like B, it became possible to perform the same task in just a few lines of code. The efficiency of language B was utilized for further developing the UNIX system. Code could be produced faster using B language than assembly due to its high level efficiency.
The Ultimate Development of C Language
One major drawback of the B language was that it could not identify the data types; everything was expressed in machine words. Yet another shortcoming was the B language did not provide the use of ‘structures’. It was these constraints of the B language that induced Dennis Ritchie to develop a new language. It was during 1971 to 1973 that Ritchie developed the C language, keeping most of the B language syntax and making various additions like adding data types and the like. Many of its ideas and principles were taken not only from the earlier language B but also B’s ancestors BCPL and CPL. The C language had a great mix of high-level functionality and detailed features that were required to program an operating system.
The Greatness of C Language
The power and flexibility of the C language developed by Ritchie soon became apparent. Eventually, the UNIX operating system which was actually written in assembly language was perhaps immediately rewritten in the new C language; the only things retained was the assembly language that was required to bootstrap the C code.
As the language was such a dominant, powerful and a supple language, its use immediately spread beyond the Bell labs; it quickly spread throughout a lot of universities and colleges mainly because of its close connections to UNIX and the availability of C compilers. In the late 1970s, the language began to almost replace the well known languages of that time such as the ALGOL, PL/I and the like. Programmers all over the world started using it to write almost all sort of programs.
For this ultimate design, Ritchie received the Turing Award in 1983 and the National Medal of Technology in 1999 along with Thompson.
The First Book on the Language C
Meanwhile, towards the end of the decade, Ritchie and collaborator Kernighan had published and released a rather slim yet remarkably helpful reference guide on the C language “The C Programming Language, 1st edition” which is still looked up to in high regards when it comes to inspiration and practicality. Though the book was said to be written down by both Kernighan and Ritchie, Kernighan has denied the statement saying that he had no part in the development of the C language and it was entirely Ritchie’s work and all the credit went to him.
ANSI C and ISO C
For quite some years, the book written by Ritchie was the standard on the language C. However, various organizations started applying their own unique versions of C with a slight difference. This, in fact, posed a serious problem for system developers. In order to solve this critical problem, the ANSI or the American National Standards Institute formed a committee in the year 1983 to establish a standard definition of the language C. The same committee approved a version of C in 1989 known as ANSI C. Leaving along a few exceptions, almost every modern C compiler was capable of adhering to the standard proposed. In 1990, ANSI C was approved by the ISO or the International Standards Organization. Though the correct term should, of course, be ISO C, still everyone calls it ANSI C.
In later days, UNIX and C both made countless incarnations like Linux, C++, the Mac Operation system and iOS.
C language: A Language for Programmers
The C language is still common today and is widely used; no wonder it is the second most popular code in the world. The development of C is thought to have marked the beginning of the modern era of computer languages. After successfully synthesizing the conflicting factors that caused serious trouble to earlier computer languages, C emerged as an efficient, powerful and a structured language that was rather easier to learn. Another crucial aspect of the language was it was a programmer’s language. It was rather designed, developed and implemented by real, effective programmers, reflecting their passion towards programming. The features of C were tested, honed, thought about and rethought by those who actually used the language. The outcome was a computer language that all programmers liked to use.
Perhaps, the C language quickly attracted a lot of followers that had an amazing zeal for it. It was widely and rapidly accepted in the programmer community. Thanks to Dennis Ritchie, C is a language created by and for programmers.
And I always thought the name came not from a step beyond its predecessor, though in the real world beer often precedes the need for caffeine. C wasn’t taken from CPL, but from the necessary dr…. er, SPICE that programmers need… Caffeine.
please can someone help me with a circuit diagram and code for moving message in assembly language using 8051 family.
An easy point in flowchart programming is that we can make description and comment in any native language such as Frech, Japanese, Chinese,Russian,English, Vietnamese, etc. We only need to define a universal flowchart structure. Current libraries of C language and other languages are immense. We can develop a sofware that translates flowchart prgramming into C language and from C language back into flowchart proggramming, for example. I think that flowcharts are easier to track logical reasoning paths.
While I was studying in the university, our teachers have mentioned about flowcharts as a way for logical programming reasoning. Why don’t we do the programming on flowcharts and write a sofware that translate a flowchart to any language that is still in use?
Flowcharts are alright for short programs with simple purposes. But for anything more complex, flowcharts would be huge. They also don’t tell you anything about the structure of the program, there’s nothing in a flowchart that you can’t fairly easily tell from looking at the code.
Basically they’re too low-level, too close to the code, to be useful. Anyone who can produce a good flowchart can produce good code.
There are other ways of planning and documenting programs now. Particularly with object-oriented programming. Programs are now usually broken into modules (which themselves may contain modules) called objects. An object has documented it’s inputs and outputs, it’s function, and maybe a little bit of detail if it’s necessary.
The idea is the object acts as something of a “black box”. You don’t know how it works, and you don’t care. You simply give it inputs and take it’s outputs as described in the docs. Objects can contain data, as well as code. It’s a bit like the struct in C, with pointers, to bring it to nuts and bolts.
Modern programming involves connecting the objects, using the services they provide. This all needs documenting, and structuring, so that everybody understands what they need to (and also, they can save brain-space by not needing to understand the object’s inner workings).
So the documentation and planning of modern software is on a higher level than simple flowcharts. It’s necessary because modern software is so huge and complex! It’d take longer to flowchart, say, Windows 8, than it did to write and sell it!
Oh, I should add… modern software is often written by teams of people. Usually small, but then there’s places like Microsoft… So the need to divide the mental load of a project into separate pieces is vital. Similarly, staff may come and go. So making your part of the software as easy to use by others is important. Which is why we have objects.
There’s also code re-use. Rather than writing a routine to sort a particular type of file, why not put a little more work in, and make a general-purpose sorter? That way future projects can re-use it, which saves time and effort. Just give the object a nice interface for other routines to call it with.
Microsoft Windows is very object-oriented. This is why, say, a game can use the standard menus and dialog boxes, but replace the buttons with custom ones (say, in the shape of a sword or potion). Just tell Windows to use your own special button-drawing code, for the scope of your program, instead of the standard one. The other Windows objects will work with it happily. You don’t have to know WHAT is using your buttons. As long as you keep the same interface as the standard ones, everything works together fine.
This even extends to the operating system, many of the object calls can be diverted to use custom objects. It’s like “skinning” a program. It’s easy to add new features or change old ones to suit you. It allows new technologies to fit in with, and be used by, the existing ones.
Sorry to answer a simple question with such a lecture!