Inspired by Actual Events: Contributions of Individual Programming Languages to Software Development

Monday, March 31, 2014

Contributions of Individual Programming Languages to Software Development

I've grown weary of the blog posts and forum rants stating why one programming language is better than another. I don't mind when languages are compared to help see how they are different or even when one language is argued as better for a very specific situation for a specific reason. I have yet to find (and never expect to find) a programming language that is better than all other languages for all situations (and this includes HTML5). In fact, I have found the contrary to be true: although I definitely have my favorite handful of programming languages, I recognize that a much wider spectrum of programming languages (even some that I don't personally like) have helped software development as a practice arrive where we are today.

In this blog post, I look at the contributions of several different programming languages to our discipline. In most cases, the listed language was not the very first to introduce the concept or feature, but was the first to make it popular or "mainstream." The purpose of this post is NOT to state which programming language is best or why one is the best thing since sliced bread while another is the worse thing to ever happen to a software developer. I also don't cover markup "languages" such as XML or HTML in this post, though they obviously have had significant influence on software development.

Basic

Most software developers I know have written some code in some form of BASIC (Beginner's All Purpose Symbolic Instruction Code). I remember, long before public availability of the Internet or even mice on PCs, typing in Basic code from magazines I received in the mail with code listings for various simple games and PC utilities. Like many developers, Basic was the language that attracted my interest at a relatively young age to programming. It was from my Basic programming that I learned firsthand the dangers of the goto.

C may be the most influential of all programming languages on today's software development. In Steve Yegge's well-known blog post The Next Big Language, Yegge's #1 rule for the next big programming language is that it has "C-like syntax." Many people's favorite programming languages are themselves (interpreter or runtime environment) written in C and many of these languages provide mechanisms (JNI and XS are two examples) for "escaping" to C for performance gains. C also remains one of the most popular and highly used programming languages in the world despite its relatively old age. Wikipedia even has an entry devoted to C-based programming languages.

COBOL

Although COBOL is not a language you read much about in blogs or articles these days, there is a huge amount of deployed code written in COBOL (Common Business-Oriented Language). In Cobol doesn't belong in a museum, Ken Powell writes:

I believe that the spirit of Smithsonian’s Cobol debut is not an indication of its antiquity, but rather a testament to its past, as well as its continued success. Just as Edison’s light bulb was a game-changing invention in its day, Cobol has changed the face of computing, and continues to have a tremendous impact on our everyday lives.

John Breeden II also writes of Cobol's impact on software development in A toast to Cobol, a true computing hero, stating, "Without Cobol, each early computer might have developed its own proprietary computing language. Instead, we started on a path to interoperability that would come in very handy later on."

C#'s status as flagship language of Microsoft's .NET has made it influential out of the box. C#'s syntax and early features also paid homage to and provided evidence of the influence of C, C++, and Java. Although C# borrowed heavily from those languages in its early versions, it also brought its own advancements that were emulated by other languages (in particular by Java). It was Microsoft's plan for migrating legacy Visual Basic applications to the .NET framework (and making use of C# libraries) that demonstrated on a large scale the advantages that the JVM already offered but were rarely used. The multiple language paradigm on the JVM has become huge in recent years, but Microsoft's use of the CLR seemed to be the first to bring this idea to mainstream awareness even though the JVM existed before the CLR.

C++

C++ was the object-oriented language for a while, is still heavily used, and has inspired other highly popular object-oriented languages such as C# and Java. C++ has dominated the "system programming" market and changed how many of us think about programming from completely procedural to object-oriented thinking. C++'s direct influence as a popular language in its own right and indirect influence via "child" languages that have reached their own popularity heights are proof of this language's dramatic influence on software development.

Fortran

The IBM article Fortran: The Pioneering Programming Language states that Fortran (FORMula TRANslator) "became the first computer language standard, 'helped open the door to modern computing,' and may well be the most influential software product in history." This is an interesting read that I highly recommend for learning more about Fortran's impact and influence on software development. Fortran has also been called "the first successful high level programming language."

Haskell

Along with Lisp, one of the first programming languages many of us think of when discussing functional programming is Haskell. As languages such as Scala, Clojure, and even Java 8 bring functional programming concepts to the JVM, it's not difficult to see the roots of these features in languages such as Haskell and Lisp. The Why Haskell matters Wiki page states, "Haskell is a modern general purpose language developed to incorporate the collective wisdom of the functional programming community into one elegant, powerful and general language." There's even a free online book called Learn You a Haskell for Great Good!

JavaScript

JavaScript is one of the most frequently used programming languages today with its strength being web development and mobile development. The HTML5 movement has been influenced by and expanded the influence of JavaScript. There have been numerous tools built to convert other languages to JavaScript and new frameworks and libraries have also been created to ease JavaScript's difficulties (cross-browser incompatibility being a major one). However, most developers developing for web or mobile devices still need basic understanding of JavaScript. JavaScript has also made in-roads on the server side as evidenced by Node.js and by Oracle's choice of JavaScript as the language to use to prove the JVM's applicability to a language significantly different than Java (via Project Nashorn). Finally, JavaScript's influence is seen in other ECMAScript implementations such as ActionScript.

JavaScript provides a good example of a language that has helped shape my thinking when developing in other languages. In the most painful years of Java development before the advent of jQuery and other decent JavaScript libraries and frameworks, those of us working with JavaScript had to use it directly. It wasn't so much JavaScript's idiosyncrasies and corners as it was that the different browsers' DOM implementations' idiosyncrasies and corners that drove the JavaScript developer to anger and frustration. Too much JavaScript code was filled with boilerplate code trying to detect the browser version ("browser sniffing") to act differently depending on the browser. This was problematic because different versions of the same browser might start or stop supporting certain DOM features and it meant constant updating of the browser checks. The realization that it was better to use DOM object detection was huge. The higher level idea is that the code should ask if a certain feature is available and then use it if it is. Today, even in other languages, I think this should be a guiding principle: don't programmatically ask one question that indirectly points to the correct behavior. Instead, when possible, ask the question that directly points to the correct action to take. It may not be as important in other languages as it is in JavaScript, but it's still a useful tactic for code that almost maintains itself.

Lisp

David Chisnall calls Lisp "arguably the most influential programming language of all time" in his post Influential Programming Languages, Part 4: Lisp. Reasons he cites to justify this claim include Lisp being "the very first programming language to provide automatic garbage collection," Lisp's introducing "the idea of the read-evaluate-print loop (REPL)," Lisp's early use of closures/lambdas, and Lisp's "inspiration for pure functional languages" and "inspiration for a number of object-oriented languages." In Why Lisp?, Peter Seibel states, "So, on one hand, Lisp is one of computer science's "classical" languages, based on ideas that have stood the test of time. On the other, it's a thoroughly modern, general-purpose language whose design reflects a deeply pragmatic approach to solving real problems as efficiently and robustly as possible."

Pascal

Like Basic, Pascal is influential on software development because of its wide use as a "learning language." Aspects of Pascal are also seen in other languages. For example, the Oracle database procedural programming language PL/SQL has always felt eerily similar to Pascal. One might argue that Pascal's influence is felt more today indirectly via languages such as PL/SQL than via direct use. On a personal note, Pascal is the first language that I used in more than hobbyist fashion (that was Basic's role for me) as I had high school and college courses that used Pascal and I wrote my first "commercial" application (a sports trading card inventory control system) in Pascal. I still think Pascal offers numerous advantages as a "learning language."

Perl

Perl has been a significant contributor in a wide variety of contexts, especially in early web development (CGI scripts) and in Unix/Linux scripting and development. Perl was often the first taste of a dynamic language for C-style language developers. It also helped many developers to realize the advantage of writing scripts in a language that could be used in all shells rather than using shell-specific scripts. Furthermore, it can be argued that Perl, perhaps more than any other language, has brought the power of regular expressions to the forefront of software development along with some powerful and concise features of sed and awk.

Python

I have no evidence to back this, but it feels to me like Python is the language taking most developers away from using Perl for scripting. There are still countless scripts written in Perl and still be written in Perl, but Python seems to be gaining on the percentage of new scripts being written. There are Python libraries for all types of different domains. For example, in my post Significant Software Development Developments of 2013, I wrote about Python and Big Data. Python seems to appeal to a wide variety of developers in the Java, .NET, C/C++, and other development communities where Python is not the predominant language.

Ruby / Ruby on Rails

Although Ruby on Rails is a framework rather than a language, it is Ruby on Rails that seems to have made Ruby famous outside of Japan and so it's difficult to talk about Ruby's influence without considering Ruby on Rails's influence. Ruby has popularized many object-oriented concepts that were available in other languages that never reached Ruby's level of adoption. Ruby's treatment of everything as an object (no primitives) and its powerful use of dynamic mechanisms in conjunction with object-oriented principles made combined object-oriented structure with a dynamic language in ways that Perl's bolted-on object-orientation could not achieve. Ruby on Rails popularized the concept of configuration by exception that is prevalent today, but was lesser known (Maven, Hibernate, and JavaBeans for example) before Ruby on Rails and the specific and catchy nomenclature of "convention over configuration."

Smalltalk

If we were to measure programming languages by the ratio of influence on other languages and frameworks to existing code base written in that language, Smalltalk might have the highest ratio of them all (though ALGOL would give it a run for its money in terms of code still deployed today). For its relatively small deployed code base, Smalltalk has had tremendous influence of frameworks and much more widely used programming languages (including Java and other object-oriented languages). Smalltalk has influenced other languages' syntax and concepts (such as everything is an object) and has had obvious influence of today's IDEs.

Visual Basic

I won't talk much about Visual Basic here because I've already touched on it at least tangentially in the Basic and C# coverage, but it has been one of the world's most popular programming languages at one time and influenced many developers who got their hobbyist and professional starts with that language. It has also influenced software development through early IDE innovations that provided a glimpse of what Java and other programming language IDEs could (and would) become.

The languages described in this section are descriptions I have added since the post was originally published.

Java

Nicolas Frankel's (@nicolas_frankel and current DZone Dev of the Week) Tweet reminded me I had forgotten to include Java on my list (despite Java having the most personal influence on me of all the programming languages). I rectify that here with the paragraphs I intended to include in the original post.

Given Java's ubiquity in academic and professional programming environments, numerous developers have written Java at one time or another and the sheer number of developers exposed to Java conveys its impact on software development in general. Many new language designers still compare and contrast their languages to Java.

Perhaps Java's biggest influence on programming was its introduction of the JVM and the many benefits associated with a virtual machine. The JVM allowed for better support than most languages had been able to provide for the "write once run anywhere" paradigm. Not only did this increase the ease of portability of Java applications, but it helped many of us start to think that maybe it is best to have data types have the same memory size regardless of the platform for which the application is written. Java's garbage collection mechanism was an almost-too-good-to-be-true feature for those of us who had primarily been using languages that required developers to carefully manage their own memory deallocation. The ability to manipulate Java byte code after compilation has led to numerous JVM-based dynamic languages and was one of the reasons that aspect-oriented programming was arguably best implemented in Java-based products such as AspectJ and the Spring Framework.

One of the first things that impressed me about Java was the Javadoc mechanism. I loved being able to include in-source comments that were generated into documentation viewable in a web browser. As internet use grew, the availability of the standard JDK API, Java EE API, and libraries' and frameworks' APIs online was a huge benefit and many other languages have since emulated this feature.

I had never considered the power of reflection or introspection until using Java. Java continues to add reflection capabilities such as method handles in Java 7 and the new java.lang.reflect.Parameter class in Java 8. The ability to programmtically access details about the internals of the virtual machine and even of running applications themselves was a concept introduced to me by Java's Java Management Extensions (JMX).

Java's emergence occurred in the era of we C++ developers (among others) grasping concepts covered in the Gang of Four's book Design Patterns: Elements of Reusable Object-Oriented Software. Java introduced features built into the language that formalized some of this book's concepts for us. In particular, the Java interface makes implementing many of the patterns outlined in that book easier. Java also included features that have led developers to make decisions about coding based on practical experience rather than simply theory. The best example I can think of is Java's introduction of checked exceptions. Whether loved or hated, Java's implementation of checked exceptions and unchecked exceptions has helped many developers to form opinions based on actual experience on those concepts.

Thanks goes to Nathan Green and Valery Silaev for also pointing out that I neglected to mention Java. Valery emphasized the same VM advantages Java touted and emphasized trust and performance gains in a virtual machine environment. Nathan had the same thought of me about the virtues of documentation generation from source code that Java made mainstream with Javadoc. Nathan also points out that the JVM supported some (minor in my opinion) languages before .NET was born. I maintain that .NET's (forced out of necessity but, as Nathan points out, not entirely successful) support of one of the world's most widely used languages (Visual Basic) being able to call libraries written in the new hotness (C#) was what really helped us to see what was practical and commercially viable on large programs.

Other JVM Languages

I'm not going to single out languages other than Java that run in the JVM in this post, but they are unquestionably influencing software development, particularly among existing Java developers. Groovy has helped me to embrace my inner scripter and Scala has helped me see more clearly the dangers of mutable state and the value of functional programming. Clojure, Kotlin, and Ceylon are also challenging the ways Java developers think and introducing new concepts, some of which even make it into Java itself. These alternate JVM languages bring many of the concepts and influences of non-Java languages (Ruby, Lisp, Erlang, etc.) to the Java developer without leaving the comfort of the JVM. The best examples of this last point are JRuby (for Ruby) and Jython (for Python).

PHP

In my post Why PHP Will Be My Next Language, I wrote about some of the reasons I was giving PHP another chance after really not liking what I saw when I first looked at it in the late 1990s. In many ways, I think that same post is a reflection of how PHP has been positively impacted by developers' experiences with other languages and cultures. There is no doubt that PHP has had a huge impact on web development. PHP has been a "gateway language" for many new web developers. It's easy mixing of presentation and server side logic has irritated some of us, but been seen as an advantage to others. It has reminded me that no rules in software development are absolute.

Numerous major web platforms are built on PHP and provide PHP APIs. The ubiquity of these necessarily means that developers cannot help but use and be influenced by PHP as they write for these platforms. It is interesting to me that the web page Past programming languages and their influences on today's languages and programming paradigms is powered by PHP even though PHP is not mentioned specifically in the article. It sounds something like a Java-oriented blog not featuring Java as one of its languages that has contributed to software development.

Thanks goes to Valery Silaev for mentioning my neglect of PHP in this original post.

Ada

The recent interview article "Security is one of the biggest problems for the IoT right now" reminded me that I missed Ada on my list. Although Ada today fits Jamie Ayre's description in that article ("[Ada]’s certainly a niche language, it’s not C, it’s not Java".), Ada was much bigger historically and has had tremendous impact on software development. AdaCore's description of Ada states, Ada is a modern programming language designed for large, long-lived applications – and embedded systems in particular – where reliability and efficiency are essential. ... Ada 95 was the first internationally standardized (ISO) Object-Oriented Language."

Erlang

Erlang is described on its main web page as "a programming language used to build massively scalable soft real-time systems with requirements on high availability." The Don't Drink Too Much Kool-Aid section of Learn Us Some Elang for Great Good! does a nice job of contrasting what Erlang is good for with what it's not as good for. Erlang's concurrency-oriented models have influenced developers and other languages. Why Erlang Matters and Why I Program in Erlang are also interesting reads about Erlang and its influence on developers.

Conclusion

Software developers today have more programming languages to choose from than ever before. No one language is best in every situation and the variety of languages with different sets of advantages and disadvantages provides the consumer (developers) with many choices. Competition is good for the consumer and has driven improvements in the languages we use. One of the advantages of working with different programming languages is the ability to learn paradigms and concepts that can be applied to some degree in the work we do even with other programming languages. Although I definitely prefer some languages over others, I recognize that all major programming languages have their faults (or situations they aren't the best fit for) and all major programming languages have their advantages (or situations where they are one of the best fits for).

Feedback Encouraged

I undoubtedly missed several important programming languages in this post and also undoubtedly missed several important features of some of the covered languages that have impacted software development in general. Feedback adding these languages or language features is greatly appreciated.

Additional Resources