Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
What do you think? What is the ideal programming language learning sequence which will cover most of the heavily used languages and paradigms today as well as help to grasp common programming basics, ideas and practices? You can even suggest learning sequence for paradigms rather than languages.
N.B. : This is port of the question I asked in stackoverflow and was closed for being subjective and argumentative.
Assuming the question was about an ideal learning sequence for newcomers to programming (since old hands at programming will have had their own (likely accidental) learning sequence), I'd suggest reading Norvig's essay on how to learn programming in 10 years, then:
Python: Start with a dynamic, high-level, OO & functional language. Because it's really important for beginners to feel productive ASAP, and not be turned off by alien syntax, lack of libraries, lack of multi-platform, lack of learning resources, and lack of community. Python is highly readable, has tons of good libraries (esp. scientific libraries - a modern scientist/engineer must know how to program), is easily run from most OSes, has tons of tutorials and entire free books, and is generally user-friendly — all while still being powerful enough to grow with you as you become an advanced programmer working on large problems. It's also important to reinforce important+useful conventions for a beginner: code readability counts a LOT, and you should be writing code for yourself and others to readily understand.
Lisp: In particular, at least skim The Structure and Interpretation of Computer Programs or watch the SICP videos, and have one's eyes opened very wide by seeing the foundations and expressive power of programming - one can do so much with so little. Learn how Lisp can express not just the functional paradigm, but OO, logical/declarative, and more - like the creation of new domain-specific languages. Read Norvig's PAIP to witness what a master can do with the language. Then check out Clojure, a modern Lisp dialect that could be one of the Next Big Things.
C: Only because it's the lingua-franca of computing. :) Possibly optional these days if one is primarily a programmer in a particular non-software domain. I find it ugly but worth knowing about to get an appreciation for the underlying hardware. Go with K&R, of course.
Haskell: Pure functional power. Where current Com.Sci. theory and practical expressive power meet. See Real World Haskell.
After the above tour, one would be very adept at tackling problems and expressing solutions in code, and be totally comfortable with the paradigms here:
This is how I would do it:
Python (or Ruby or Lua): An interpreted language, no types, you can get stuff done in a few lines. Huge library (Python is best for this I guess). You can go deep in algorithms because there are no distractions. No compilation necessary, just run. On top of that, with Python you implicitly teach good style, since indentation in Python is mandatory. You can teach Object Orientation as well (in Lua is more of a problem). The purpose here is to have a lot of fun, and show the student what can be done.
C++ (or maybe Java): A typed, fast language. If you need Object Orientation, then you already know some concepts. The main idea is to "translate" what you did in Python and do it with the new constraints (mainly types). Now if you have the concepts right, adding types is not such a problem. The next step is to think more low level (Java doesn't help here), and teach pointers well. By this I mean explaining about address space, the CPU, the OS, a little bit so that you can start seeing beneath your program. A compiled language introduces the distinction between interpretation and compilation, very useful to explain what machine language is, etc.
Assembly: Finally, no magic, you just talk to the machine. There is a debate about Intel and GAS syntax, it's not important. If you have MIPS, I believe its better for teaching, but I suppose x86 is more convenient since it is more widespread (x86_64 better since has more registers and niceties). You just have to remove some of the complexity and let the students investigate further if they want.
(These first 3 are the "depth". Until now, we've been going down until you touch the bottom, which is "close to the metal", as they say. I think this is very important, many questions in programming are solved when you have a clear idea of what is happening. When you know this, you can acquire further knowledge with confidence.)
Scheme (or Common Lisp or Clojure): As @dukeofgaming said, Lisp languages let you teach recursion well (for this Scheme is best, since doesn't have explicit loops). But I would go and teach two other things: closures and macros. Macros are what separates Lisp languages from the others. Personally I don't like Scheme macros but this is not too important. I think Clojure macros are nice, for instance (but recursion in Clojure is not as clean, since the JVM doesn't have tail recursion). Closures are a very important concept, once you grok them you "see" Javascript instantly. Having studied C++, Python, and Lisp, Javascript becomes "trivial".
Haskell: For a functional language, I don't think you can beat Haskell. Lisp and Scheme are considered functional, but to emphasize functional programming, you have to force the students to think without state. Haskell also has other very nice things, like currying, and pattern matching for "destructuring". I don't know Haskell a lot, but the conciseness of the code you can write is just beautiful. Knowing Haskell well makes the path to understand Erlang much easier.
Forth: A stack language. It totally breaks your logic again (if Lisp and Haskell wasn't enough). I would go as far as teaching Jones's Forth since they know assembly and then you can totally understand what is going on. (Knowing Forth opens up PostScript, for instance.)
(So these last 3 are the breadth you were saying. For me, these languages are strange enough that they change your way of thinking. They did for me at least. And I think with these, you understand enough paradigms to learn a new language very quickly.)
Optionally, you can study these:
SmallTalk: A purely Object Oriented language. To see what happens when you take Object Orientation seriously, the language doesn't need "if", "for". Everything is a message: big realisation again. (This would make Objective-C easy now.)
Go: A (beautiful) language with an emphasis on concurrency. I find Go very nice and comfortable to program with.
Prolog: Another paradigm of programming. I haven't written any Prolog but I understand it is yet another mind-bending language.
Seriously, I may have learnt BASIC, COBOL, Fortran, Forth, Pascal and Prolog in my time, but I've never particularly needed to use them and I can't really see any way in which they've influenced my use of other languages, except perhaps misapplying paradigms from one in another. It took me ages to unlearn BASIC enough to actually write structured Pascal, a couple of years to stop writing Pascal code in C, and another couple of years to actually grok OOP when I started using Objective-C and Java. On the other hand, since I've been working (almost) exclusively in OO languages I've been able to concentrate on improving my use of OO languages, without trying to make them look like Scheme or PostScript.
It's hard to claim that any sequence is ideal, but I'll lay out a plan that I can justify:
C
Learning C demands patience and diligence, and will introduce you to the basic ways that computers deal with data and show you almost the widest set of responsibilities that a programmer can accept to deal with such a machine.
Perl
As an antidote to the rigor required by C, try the unbelievably forgiving Perl. What took a week to write in C you can write in an hour in Perl. It introduces a different kind of delight to be found in programming, and shows how excluding certain concerns and details frees the programmer to focus on different things.
C++, or maybe Java
Next see how C's focus on low-level and primitive aspects of programming serve as a foundation for raising the abstraction level, noting the trades one makes in efficiency when moving up in abstraction. Explore how to form abstractions that can still retain the efficiencies that matter for your program.
Common Lisp
This is the reward for the preceding slog. You'll find echoes of what you learned in all the preceding languages, and see how silly so many of the preceding concessions seem when programming in Lisp. C's preprocessor and C++'s templates prepare one to appreciate Lisp's macro system. You'll regain the ease of expression from Perl, the opportunities for low-level optimization from C, the abstraction-building capabilities of C++ or Java, and go well past them all. None of the preceding three — perhaps except Perl's debugger — will have prepared you for the interactive programming experience with a capable REPL ("read, eval, print loop"). Working with an image-based environment — which changes the relationship between your source code and the idea of an "executable program" — will change your whole idea of what it means to build a program.
Beyond those four, exploring other styles of programming, such as functional programming in Haskell, or logic programming in Prolog, makes for more comprehensive understanding of the range of programming — wide knowledge, if you will — but at that point your time is better served by improving your craft — deep knowledge — with any language you know.
Having tasted enough distinct languages, your view will raise to focus on the ideas that transcend any one of them. It's kind of like the difference between learning to drive your father's car and knowing how to drive any car: You may not enjoy having to drive the rental mini-van for a few days, knowing full well the pleasures of driving a favorite sports car, but you'll figure out how to operate it, and will surely coax more out of the poor beast than an amateur.
Designed originally at least in part as a way for children to use computers to learn. The syntax is simple enough to describe in a paragraph. It, like LOGO, exemplifies the "low barrier to entry, high ceiling" principle.
Smalltalk's a pure OO language in the sense that "everything is an object".
It also teaches many functional techniques, particularly in its Collection API: chaining messages, higher order functions, map, reduce, and so on.
The Squeak community is vibrant and welcoming. You'll also see many discussions of advanced techniques: much like the lisp community, there are many very experienced Smalltalkers on the mailing list willing to share their knowledge. (It doesn't hurt that the Squeak community has a large sub-population of professional educators.) There's also another list for beginners.
A logic programming language that will give you a very different view of computation to just about any other language. Prolog is also highly declarative (but not completely so: the ! or cut operator can have a significant semantic effect on a predicate).
Substitute Scheme here if you like. Common Lisp is supports multiple paradigms, especially OO and functional. It also has a long history (Lisp is the second oldest still-widely-used language: only FORTRAN's older).
(Caveat: I've only just started learning it.) Probably the purest functional language on the planet. It has a very advanced static type system. Handy intro books exist.
You need to know how computers work. You need to know how memory and CPU actually function. Both of these are traditionally "close to the metal" and have communities that encourage thinking of how their language compiles to assembly.
Smalltalk's very easy to learn, so you can quickly start concentrating on solving problems rather than fighting a compiler ("low barrier to entry"). Once you start programming, there's also no artificial limit on what you can do - "high ceiling".
Once you have a fair idea of how OO works (and - with the proviso that there are MANY different understandings of what "OO" means - it's fair to say that OO dominates the marketplace), moving onto Prolog ensures that you don't start thinking that OO is the only way. Prolog is very different to most languages, and will stretch your mental muscles so you don't start thinking that you know everything.
Common Lisp, in turn, is a grown-up's language. It has a mature standard, it has been leading language design for decades (along with Smalltalk) - all those fancy new features your favourite language just acquired? Chances are the ideas incubated in either Lisp or Smalltalk. Common Lisp's also a bit warty, and you'll find wartiness everywhere you go.
Haskell's fourth on the list because (I'm told: I've only just started learning it) its purity means that some very common things (like I/O) are more difficult to do than in less purely functional languages. The Haskell folks also use some fairly exotic terminologies (words like "catamorphism", say), and you'd probably be better off with some programming experience under your belt before tackling it. (But I must re-iterate, I've only just started learning it! Take this opinion with a pinch of salt!)
And why C/Delphi last? Because unless you work in embedded systems, you really shouldn't have to learn programming thinking that manual memory management's all there is. Garbage collection worked well enough for a 1980s level machine. Your phone is that powerful!
Finally, I haven't put Erlang in the above list even though I really should.
Python. An excellent introduction to programming. This will also tie in with any previous exposure to programming.
Scheme. Also an excellent introduction to programming. If dealing with programming novices, you might want to teach this first and Python second. One alternative would be Python first and then Common Lisp instead of Scheme: more work, but more reward.
C. A low-level language that stays close to the silicon. Good for learning what a computer can do. You could substitute some form of assembler language, but C is pretty close to the basics and much easier to work with.
Prolog. Alternately, substitute any declarative-style general-purpose language, if you can find one you like better.
Haskell. For the type system and pure functionality, if nothing else.
There are several candidates here, as it's impossible to cover all the concepts with six languages. Common Lisp is well worth learning, if only for the macro system and object system (which is different from most others I've seen). Forth, Tcl, and APL are all odd languages that have seen some success, and one of those would be good to prevent the student from feeling like he or she has learned it all. Erlang would be good for concurrency.
Many good answers have been provided, but I did not see anyone offering SQL. It's a completely different animal than most of the others listed and very important to any programmer who has to deal with databases.
You might also want to consider some OS level scripting 'languages', such as Batch, grep, awk, etc. 'Make' may also fall into this category.
One other language you may want to consider (if it isn't completely dead yet) is COBOL. It's sufficiently different from other procedural languages that it deserves some mention. Variations of C, Fortran, Basic, etc. have become so similar that once you are familiar with one, moving to another is not a big issue, but COBOL lacks a lot of the constructs taken for granted in the others. (It's been at least 20 years since I've done anything with COBOL so my observations may no longer be valid concerning this language.)
You might want to mention APL just from a historical standpoint--or let it rest in peace. Your choice.
I would suggest first reading Eric Raymonds "How to become a hacker" since he has some very interesting points about how to get started, including Lisp which has the "code is data and data is code" notion.
For programming I would also suggest Haskell, Prolog, SQL and assembly language (just some).
Regardless of what you want to learn, take the time to learn it properly and write non-trivial amounts of code. It is much like bicycle riding - you cannot learn it from a book.
First> What do you want to do when you start programming? Learning how to be a game programmer is different than learning how to be a database programmer for a business... is different than a web based programmer...
Second> Once you start learning, do you want to start high and work your way down? Or start low and work your way up. Learning C# (high level) is a lot different than learning Assembly (Low level).
A huge choice will depend on what you want to do. Programming a driver will most likely include C or Assembly... Programming a website will be PHP, C#, asp, etc... You won't touch assembly for web programming... etc...
As far as basics... once you decide WHAT you want to do, its easier to pick a language. I, for example, have become a data analyst at a hospital. So my "choice" of languages is SQL/TSQL/DB2 for data access, C# WPF for windows clients, Silverlight for web clients, some RPG/CL for IBM back-end logic...
Personally I stick to a good book + build your own program to practice the language. I like APress and loved reading C# 2008 Illustrated when learning C#. They have other books that encompass basics for the unlearned as well as the expert.
A newcomer only needs one language to start with, after learning the second language, they are already progressing beyond many competing developers. I would learn in the following order:
You may ask "where's C++?" and what about X? Honestly, learning multiple languages does a couple things: it enriches your experience, and it provides a drive to learn more languages. The list of languages I know well (Java, C#, Ruby, C++, Javascript) are all object oriented--but that's primarily because that's what I have to do at work every day. The list of languages I've been exposed to (Smalltalk, Python, Erlang, JESS, C, Assembly [Motorola 6502/6510], Go) have all taught me valuable lessons. I can at least understand what's going on with those languages. There's a lot I haven't explored, but very well may in the future. There's a few markup languages as well: HTML, XSL:FO, XSLT, CSS, XML, SGML that folks need exposure to if they will work with the web in any way.
After learning at least two different languages, I really don't think you should constrain what someone who has a desire to learn decides to pick up next. Learning should be an organic experience, and too much structure in the process creates a group of people who think exactly the same way. A monoculture so to speak.
Most of these answers seem roughly the same so I'm going to offer a different opinion. I've long held the believe that the best first language is Tcl.
Why? For one, it's very easy to learn. There's not much syntax to the language so the student can focus more on the concepts of programming and less on the syntactic peculiarities of a particular language. As of this writing Tcl has exactly 12 rules that govern the entire language (up from eleven for the past couple of decades).
For another, Tcl comes with a fantastic built-in GUI language, so you can get some relatively instant gratification and can learn the basics of event driven programming.
Third, it's extensible. Want to teach about a repeat loop? You can write a command that does a repeat loop so that not only can you learn how to use repeat ... until, you can learn how it is different than a while loop because you actually wrote it yourself.
Also, because it's extensible there's an easy segue into C. You can learn C basics, and learn how to either a) extend Tcl with new commands written in another language, or b) learn how to add a scripting language to a program written in C.
Once you've learned Tcl and C, most other languages lie somewhere between those two extremes and should be relatively easy to pick up. My complete list, with the four I would teach after Tcl and C are:
I know, boring and old-skool. And the entire question ignores the really hard part of programming, which is problem-solving, domain modeling, and algorithm construction. But here's why:
you can't fake your way through assembly language; you either get it or you don't. the compiler won't save you, there's no framework or library overhead, and you can't hide from the machine architecture; it is pure programming (at the beginner add-two-numbers level)
after you've written a few assembly-language programs of more than a few hundred lines, pointers and memory management are no longer mysterious, and you should have started to notice patterns in the code (if, switch, array, loops, etc.). C brings those patterns out into the sunlight and lets them shine. The standard library is useful without being immense, but don't bother with macros/templates/etc. at this stage.
now jump into databases with SQL. Don't go overboard with stored procedures, just get the basics of tables and queries.
after you've written a few C programs of more than a few hundred lines, pointers, structures, and memory management are second nature, and procedural constructs are old friends. You will begin to notice higher-order patterns: these functions always go with this data structure, this part of the code is just like that part of the code except for methods X, Y, and Z, and so on. Add to this your grasp of relational data and now you're ready for an object-oriented language. With a massive framework and generally obtuse documentation. Welcome to the real world! Explore GUIs, write desktop apps, write web sites, write web services, write whatever you like. Go get a job if you're so inclined.
Are you now a programming Jedi? A code ninja? No, now you're merely competent. But you have a solid foundation to stand on to explore the shiny new fun stuff.
You need fundamentals:
After that it probably doesn't matter.
OK, this is the last day for bounty. And I am adding my answer. My suggested sequence-
C, C++, JAVA/C#, Python/Ruby, Any other language(Assembly/Lisp/Prolog etc)
I will be biased and use the model my university currently uses for its core Computer Science curriculum. I was against it during my first year but in my later years I am grateful for it. The model is based on not requiring any programming experience but requiring the ability to learn.
Scheme
We are you are first learning programming, the less magic, the better. The teaching language of Scheme presents a clear and reasonable definition of a language, a really small set of axioms (the "magic") that you can build and expand on. Anyone who can understand functions in math can trace and reason Scheme programs. Starting with Scheme provides a clean yet powerful way to think about computation without worrying about the language specific details.
C
Moving from Scheme to C is a drastic one but allows you learn about the very important mapping of high level languages to low level languages. Learning the memory model (pointers, heap, stack etc.) and how programs are compiled and run, how pointers, stack and the heap work are essential skills. Through this low level understanding you can begin to analyze programs on a higher level (Big O). You can begin rolling your own abstract data types, playing with different implementations (say a simple hash table vs. a binary tree for a set).
C++
Through learning C and Scheme we begin to see different paradigms of programming languages and how they can apply to different problems. Now you can approach the scariest aspects of programming: choice and trade offs. Programming language choice can affect performance, readability, maintainability, robustness etc. For solving problems bigger than things you can hold in your head, this choice is great but also dangerous. C++ tries to make as few choices for the programmer as possible. Through learning C++ you will learn how to make these trade offs and choices yourself to solve your problems.
You might not use any of these languages in industry or ever touch them again, but the process of learning them helps you understand other languages you will use. Another aspect is you learn the tools around a specific language. Running gcc through the command line, learning Vim, stepping through a program using GDB, creating Make files, checking in code using SVN, writing shell scripts to automate testing etc.
Mind you the core curriculum also has other courses (computer architecture, data structures and algorithms, compilers, operating systems etc.). So just merely learning these languages isn't enough to be proficient at programming.
Going from a basic language to a high level one is the way to go. That way you still have an idea what's happening in the back.
Python. To get stuff done, do ordinary programming. Procedural, OO and (to an extent) functional.
Regular Expressions. They're in the Python library, but it's a separate DSL.
Shell (BASH or whatever). The "&", "|", ";" operators for combining processes are critical and unpleasant in Python.
SQL. This is -- for now -- the lingua franca for data access.
XHTML. This is -- for now -- the lingua franca for data presentation.
CSS.
Maybe C if it became necessary.
Start close to the metal:
Now the problem with such a broad approach is that no one can become even remotely capable in these languages without years of study.
Unless your intent is to teach them "Hello world", which should take about a month for all 6.
Why not go straight in and learn VB or C#. Both in my opinion are complete languages ranging from beginner to advance, imho.
