The Essential Programming Language Toolbox |
|
Everybody has a different idea of which languages are important. And the answer really depends on who you are and what you believe is important. I came to programming through a theoretical computer science route which initially gave me a shallow understanding of a wide breadth of topics. In this school of thought, languages are just a vehicle for learning about the big ideas in computer science. And to get at all of the ideas, you need to use a language that lends itself to the topic.
How would you understand memory management and pointers in Java? How would you learn about data structures in assembly? You can’t. Thats how. Java hides the details of memory management and pointers so you don’t have to deal with it, but knowing what is going on under the covers will make you a better programmer. Assembly is so low level that if you use it as a vehicle for implementing a B-tree you will loose most of the big ideas about the data structure and algorithms in a sea of register manipulation and instruction set details. This list is for people who want to get at all the big ideas in computer science, which necessitates learning a wide breadth of languages. Its strongly in the language-as-a-vehicle camp, not the language-as-a-career camp.
Assembly
Assembly will get you right down to the bare metal, working with registers and architecture-specific instruction sets. In short, assembler requires learning the fundamental architectural principles of modern computing equipment, which is essential for writing better higher level code that takes advantage of bare metal. It will also give you a fine appreciation for the dangers of writing spaghetti code.
Usage of assembly today is fairly limited, but encompasses many interesting areas such as reverse engineering, embedded systems, viruses, real-time systems, and compilers. There are a variety of assembly languages out there. MIPs is a good choice for its simple instruction set, and x86 is a good choice for its ubiquity.
Big ideas: bare metal, compilers, optimization, self-modifying code
C
C is the direct ancestor of some of the most widely used modern languages: C++, Java, C#, and PHP just to name a few. Knowing any one of these languages will allow you to pick up any of the others easily, and to communicate ideas with developers from a variety of backgrounds. In short, C is the lingua franca. Learning C has the added benefit of introducing memory management and pointers - things that higher languages like Java hide with automatic garbage collection and object references.
C is used all over the place: in every modern non-toy OS, Java VMs, the Ruby interpreter, and the Apache web server.
Big ideas: Memory management, pointers, complexity analysis
A Lisp Dialect
Lisp will make you think differently. I can think of no better way to put it than that. The language is simply structured in such a way as to make both problems and their solutions look differently. The structure of the languages begs the usage of recursion, maps, and closures - things that aren’t seen nearly as often in other languages.
Lisp is worth learning for… the profound enlightenment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot. - Eric Raymond, How to Become a Hacker
Lisp dialects are used heavily in artificial intelligence, and as scripting languages within other applications such as Emacs and AutoCAD. Scheme is a good dialect to learn since it is the language used in SICP - one of the best computer science texts of all time. Or learn Emacs Lisp for a foray into dynamic scoping.
Big ideas: recursion, closures, artificial intelligence
A Scripting Language
In an era where we have hackable Coffee Makers and everything is online, scripting languages are the glue that binds the world together. These higher level languages can be a way of really strutting your stuff and a platform for putting into practice many of the big ideas in computer science - regular expressions, concurrency, complexity analysis, scalability, architecture, data structures, databases, and so on.
Scripting languages are commonly used for lightweight web applications and are often a good substitute for shell scripting. Pick up one of the P’s in the LAMP stack (Perl, PHP, Python) or Ruby.
Big ideas: complexity analysis, scalability, architecture, data structures, databases, etc.
The above four categories of languages have enough breadth to get a taste for the vast majority of the big concepts in computer science, after which it is much easier to absorb select topics in-depth, write solid code in any language, and pick up the unique paradigms of any new language you learn.
What programming languages would you put in your own essential toolbox, and why?
Image attribution: 
kimberly hurst
Tags: languages
Related |
|
Florian Potschka
I really agree on this. Knowing different tools broadens your horizon and lets you choose the right tool for the given task (”When the only tool you have is a hammer, everything looks like a nail” :-)). Nevertheless I would add a highlevel-language like Java or C#, simply because of its object-oriented character and because it can really speed up the development.
Elvis Montero
I totally agree with everything you said. However, what about Erlang or Scala? Since the trend du jour is multicore systems, a language that provides an easy way to tap into all these cores would be a valuable asset (concepts: concurrency, threads, lightweight processes, et al).
jess
@Florian I would definitely say that object oriented concepts are important to know as well, as there are a huge amount of projects out there using object oriented languages & designs. I hesitated to put it in the list because if you already know C, the only big computer science concept you gain from Java or C# is object oriented programming - which is important, but is only one of the many big ideas in CS.
@Elvis Good point. A multi-paradigm language / category would be a good addition to the list. Erlang and Scala are both significantly different to the categories above to warrant a separate category. I felt a bit uncomfortable including them not because they don’t belong in an Essential Programmer’s Toolbox, but because I haven’t done a significant amount of programming in either of them to write about them in a way that does them justice. But hey, thats what comments are for - to point out any short-comings in the post and add your own ideas.
And tangentially, I wonder if omitting Scala, the darling of dzone, is what is causing the controversial voting (6 ups and 5 downs as I write this). In a list like this, there is bound to be some difference of opinion. So I’m wondering what others would add or change about the list? *crosses fingers hoping not to start a language flamewar*