In appreciation: C's Dennis Ritchie and Lisp's John McCarthy

Just one week after Steve Jobs succumbed to cancer, mourners took to social networks and message boards to note the passing of computer scientist Dennis Ritchie, an event that was largely overlooked by the mainstream press. Although Ritchie was hardly as high-profile a figure as Jobs, his work had a comparable impact on the computing industry. Now, with the death of John McCarthy earlier this week, we have lost two of the most important figures in the history of software development.

Ritchie will always be remembered as one of the small team of developers who created the Unix operating system at AT&T Bell Labs in the early 1970s, but his most significant solo invention was the C programming language, which remains one of the most popular languages used today. McCarthy, on the other hand, is the father of Lisp, one of the earliest programming languages.

[ Go deep into HTML5 programming in InfoWorld's "HTML5 Megaguide Deep Dive" PDF how-to report. Then understand the issues surrounding HTML5 today in InfoWorld's HTML5 Deep Dive PDF strategy report. | Get software development news and insights from InfoWorld's Developer World newsletter. ]

In many ways, C and Lisp are opposites in terms of design, implementation, and approach. Taken together, however, these languages' influence on modern computing is immeasurable, and their legacy will continue for decades to come.

C: The language that flew

To judge how influential C has been, just look at the number of later languages that have borrowed its syntax. Even languages with only the barest resemblance to C in terms of programming style, such as JavaScript, have mimicked its keywords, its operators, and its ubiquitous curly braces -- mainly because by the 1980s it was impossible to study software development without being familiar with C.

Ritchie was always modest about C's success, describing it as "a pragmatic tool that flew at the right height." But there's more to it. C endures because of a few important characteristics that made it stand out from earlier languages.

First, C was powerful. It had a high-level syntax not unlike structured languages such as Pascal, which made C code easy to read and maintain. Yet C also gave developers ready access to the hardware at a low level, which made it useful for systems programming. As a result, although early versions of Unix had been written in assembly language, by 1973 most of the Unix kernel was recoded in C.

Second, C was relatively simple. It lacked some of the syntactic sugar of other languages and eschewed higher-level features such as garbage collection. That made implementing C compilers easy and inexpensive, and soon the language was available on a wide variety of hardware. In turn, that meant programs written in C were also portable -- including Unix -- even to systems with limited resources.

Finally, despite being a product of AT&T, C was open. According to Bjarne Stroustrup, the creator of C++, "It was very important to the success of C and C++ that AT&T didn't try to monopolize these languages, but allowed its researchers to support the creation of alternative implementations. Also, AT&T fully supported ANSI and ISO standardization of C and C++ as soon as these efforts started ... This noncommercial spread of C and C++ appealed strongly to many programmers."

That appeal continues to this day. Notably, the Linux kernel is written almost entirely in C. The total number of lines of C code in production use is inestimable. And C's influence on computing reaches even further; C++, C#, and even Java can be considered its direct descendants. Far from merely "flying at the right height," C soared, and in the process it transformed the software development landscape completely.

Lisp: The progenitor of C and what has come since

But Ritchie didn't create C in a vacuum. It began as a derivative of a language called B, which itself was based on BCPL. In turn, these languages built on other languages that came before them, and in one way or another, all of them owed a debt to John McCarthy and Lisp.

McCarthy first created Lisp at MIT in 1958, making it the second oldest programming language still in common use. Only Fortran is older, but not by much. Aficionados like to say McCarthy "discovered" the language, rather than invented it, because of its close relationship to the lambda calculus, the mathematics at the heart of the science of computation.

The first thing a casual programmer notices about Lisp is its unorthodox syntax. Lisp code is often derided as being little more than a mass of nested parentheses. But with Lisp's sparse grammar comes power. Where other languages force developers to write programs as series of procedural steps, like recipes, Lisp allows them to express algorithms in their purest form. You can even think of Lisp as a mathematical notation for expressing computation problems, albeit in a form that can actually be executed.

Given its grounding in computer science and its long history, it should come as no surprise that Lisp gave rise to many ideas that are taken for granted in modern software development. Lisp was one of the first dynamically typed languages. Lisp programs introduced various common data structures, such as trees. And while Java's garbage collection was hailed as a major improvement over C, Lisp implementations have had automatic memory management since the 1970s.

It may seem paradoxical, then, that relatively little commercial software is written in Lisp. It's hard to say why. Perhaps Lisp code is seen as too difficult to maintain, or perhaps it's too hard to find developers with sufficient grounding in mathematics and computer science to make them effective Lisp programmers.

Nonetheless, as obscure as it may be in enterprises, in academia Lisp has thrived. There are countless dialects, variants, and implementations of Lisp still in use today. One Lisp derivative, Scheme, is a popular teaching tool in undergraduate computer science programs. What's more, Lisp can be considered a direct ancestor to functional languages such as Erlang, F#, and Haskell, considered by many to be the cutting edge of programming tools. Not bad for a technology that's more than 50 years old!

The passing of two pioneers

Taken together, C and Lisp represent two pillars of modern software development. Lisp, along with its derivatives, is the language of architects and computer scientists, and its influence continues to shape the practice and principles of computing. C, on the other hand, remains the quintessential programmer's toolbox, able to solve virtually any kind of problem on virtually any kind of hardware.

The loss of the creators of both these languages in one month is a sad occasion. Neither Dennis Ritchie nor John McCarthy was a particularly vocal presence in the software development community in recent years, but they hardly needed to be. Their achievements speak volumes, and although they will be missed, their legacies will carry on for years to come, both for software developers and for the field of computing as a whole.

This article, "In appreciation: C's Dennis Ritchie and Lisp's John McCarthy," originally appeared at InfoWorld.com. Read more of Neil McAllister's Fatal Exception blog and follow the latest news in programming at InfoWorld.com. For the latest business technology news, follow InfoWorld.com on Twitter.