Which programming languages from this list will be actively used in 20 years: Lisp, Perl, Python, Ruby, Clojure, Scala and JavaScript? Does at least one of them have any chance of being used in 100 years?

In 20 years it's likely that Java, C/C++, Lisp (and its Clojure derived ancestors) and some Javascript are likely to still be in active use.  Python might continue to be used, as an introductory programming language in academia, and as a driver for analytics, statistical analysis and data sciences.  Python is also likely to become the dominant language for instrumentation (data acquisition and control) devices (through its emerging popularity on Rasberry PI and similar platforms as for driving control of Arduino (microcontroller) devices I personally think that Perl and Ruby won't be as attractive in 20 years; and Scala is anybody's guess. Java, Javascript, and C/C++ will continue their current trend --- to be the "low level assembly-layer" for the JVM, the web browser, and the bare metal (or OS native binary application) levels.  In other words these are the languages that will continue to be used to build the higher level languages, libraries and tools that are used by broader populations of developers.  This is already true to some degree, and the trend has been in that direction for some time.  I think that's likely to continue. The main reason I put Clojure on this list is because it's fundamentally Lisp (native to the JVM *platform*).  Lisp is the only language you have listed that has been in active use since the 1960s (very late '50s).  Clojure seems to be the offshoot from Lisp that's most likely to have significant business and job market impact.  (There have never been many jobs focused on Lisp development and Clojure on JVM, Clojurescript on any JavaScript engine -- such as v8/Node, and even ClojureCLR is the one implementation of Lisp which might break through that historical legacy). (Incidentally the Clojure inspired Lisp flavor that's actively used 20 years from now might not be named "Clojure" and might not even be derived from the same sources.  I'm merely prediction that the features of Clojure which distinguish it from merely Lisp hosted in a JVM are going to be a big part of that language, whatever it's called and regardless of the implementation details). (Notice that I emphasized the JVM *platform* rather than just referring to the JVM itself.  Clojure benefits from a huge, industry-wide, investment in making the JVM ecosystem ... no just the virtual machine implementations themselves, the the whole range of classes and tools available for it). So that's my prediction for 20 years.  It's also likely that there will many hot new languages and that many programmers will be arguing that these old languages are obsolete for scaling up to systems with 10K CPU threads and hardware transactional NUMA memory architectures --- or whatever we're using by then). However, the question of what programming languages will be used in 100 years is more existential.  The very notion of programming, as we understand it, may be such a rarefied niche that it's practically unrecognizable by then.  In a century the field of electronic computing will be three times older than it is now.  So computing, as a whole, may be in something like its youth or adolescence. Will general purpose, applications programming still be done using text source code in a hundred years?  Or might the "code" look more like graphs, spreadsheets or legal contracts?  How many people will be entering code through a keyboard in a hundred years? Just over fifty years ago "programming" was down by rearranging vacuum tubes and cross connecting panels.  There was some programming (at least bootstrapping) done in binary through paddle switches and quite a bit of the programming only 30 years ago was done on paper.  (Programmers writing out their code, specialized keypunch operators entering it on Hollerith punched cards, having it reviewed by hand, then submitted to systems on large trays to be fed, mechanically, through paper card readers).  Some other systems used paper tape. Try to imagine being a programmer in that era (white shirt and ties) and imagining a modern GUI IDE on a Macbook Air or a tablet/laptop hybrid like the Surfaceâ„¢ Now take that mental model and try to apply it TIMES TWO starting with yourself, now, and projecting into an image of what "programming will be a century hence. See? (It's likely that the pace of development, the rate of change, will slow considerably the next fifty, or even twenty years.  So we might not have direct neural implants and AIs that handle almost all of the "programming" (details) for us.  But even accounting for a lower rate of technological progress its likely that "programming" in a century will look and feel as different from what we're doing to day as a modern sedan does compared to a Ford Model A

The traditional way to bet is to assume that you're in the middle of an "information product"'s life cycle.  That is, however long it's been around so far, inertia will probably carry it about that far into the future. Normally, we use this for books.  Shakespeare has been around for four centuries, so it's unlikely that everybody's just going to forget his work in 2030. It's obviously not absolutely accurate, but it's a reasonable guide.  We can't predict huge upheavals that would obsolete HTML or give Ruby a magical new lease on life.  As a practical example, it's not too long ago that Java was all but dead, except for some legacy enterprise code at fifteen-year-old companies.  Then Android came along and revitalized the community and ecosystem.  So, any prediction has to assume that the state of the industry isn't likely to change all that much in that companies aren't going to suddenly start holding everything together with shell scripts or something. So, looking at how old the languages you suggest are, we have Lisp (1956), Perl (1987), Python (1991), Ruby (1995), Clojure (2007), Scala (2003), and JavaScript (1995).  Since we're in 2014, in twenty years, we can guess that there'll be at least active pockets of people using Lisp, Perl, and Python, and probably Ruby and JavaScript.  They may not be as popular as they are or were (certainly, Perl's best days seem to be behind it), but there'll still be parts of the industry that absolutely rely on them.  We'll get rid of Lisp just before the last virtual machine running COBOL code gets shut down... Clojure and Scala are relatively unproven, so they'd be easier to "unseat" if anything interesting comes along.  Clojure makes perfect sense, by the way, since Lisp derivatives that aren't Scheme rarely last for very long and if it sees significant mainstream success, would probably be flooded by more traditional Lisps. (An alternative measurement that I kick around, but isn't nearly as formal, is to look at the number of implementations.  If a language has only one target system in use, it's not going to last long.  If it has too many, it means that the community is more interested in farting around with implementation than actual use.  But that's complicated, in that I don't know how related the Python implementations are, for example, and what their usage really looks like.) In a hundred years, probably none.  Not only do we not have programming languages that have lasted that long so far, but we'll have almost tripled our collective experience on how to produce software effectively.  That, along with hardware changes, will produce languages that are more expressive with less overhead and suited for common tasks of the day.

I'm going to start by taking a possibly controversial position - I think we're seeing a leveling of the S-curve of computer technology improvements, and the important inventions are all behind us. Let's compare transportation technology. Cars and planes have not gotten significantly faster or better in 50 years. But in the century before that, we went from horses and the first commercial trains to supersonic jets. I think we're seeing the same flattening in computers. If I'm right, it means that computer hardware and software technology will not continue to evolve at the pace they've evolved for the past 50 years. Core technologies will survive and thrive, just like piston engines and rubber tires survive. I don't expect a lot of advances. So, what languages will survive? Lisp has been around for 50 years now, and continues to evolve (I consider Clojure to be an evolutionary step of Lisp). So Lisp will survive in some form or another. Ruby has integrated itself deeply into the fabric of cloud technology, via Chef, Vagrant, and other core cloud tools. I expect it to survive. Perl, on the other hand, is clearly dying. It hasn't transitioned to the cloud in a meaningful way, and its primary holdouts are aging admins who don't want to learn new tools. Python will probably survive, for data analysis if nothing else. Javascript is at the core of browsers, and I can't imagine what would make browsers go away. It has also made the jump to the server with Node.js. So I expect Javascript to survive. (sigh) I don't expect Scala to survive. The constant continuity-breaking changes make it very hostile to production environments, and the sheer complexity of the language makes it difficult to learn. As Java continues to add new features, and Clojure provides clean functional programming in the JVM, what does Scala offer? You know what else will survive? SQL. And bash.

I beleive none.  The language which has the chance has been omitted from your list,  C

20 years is probably right about JavaScript and maybe Perl still being around in 20 years. Scala has a chance to be, if it can continue to eclipse later editions of Java and C# in functional and concurrent programming. Python, perhaps. It's very teachable. To add to your list, I think C, C++, C#, and Java will still be strong in 20 years. As with Scala, a lot of that depends on how well they evolve. For C and C++, they will have to encompass the innovations of D and Rust before those catch on. For C# and Java, they will have to (as mentioned above) embrace functional and concurrent programming wholeheartedly before Scala (and perhaps F#) gains a foothold. I think Ruby will die out, like PHP. The "Twitter incident" and the rise of Node.js was the beginning of this happening. Clojure will never be more than the afterthought that Lisp has been before it. 40 years I added this intermediate period, because all the languages we know will likely die well before 100 years out. With quantum computing taking over (see http://www.telegraph.co.uk/technology/news/11224058/How-quantum-computers-will-undermine-cryptography.html) I would imagine that there emerge languages within the next 40 years that are better suited to these new hardware systems than any of the old "transistor" languages we currently know and understand. Some of them will still be used, but none of them will be thriving. 100 years 100 years out is beyond our "event horizon", so we can't really have any insights or good guesses without being able to see into the state of technology at that time. By then, transistors will be long gone, and quantum computing will be on the verge of being replaced by something else. Or perhaps it, too, will have been already usurped many decades earlier. Perhaps artificial intelligence will be running the Earth, or perhaps we will all be cyborgs in the middle period. Hopefully some of us will be living on Mars, to build some redundancy and "backup" that may be essential for long-term species survival (not just from the threat of AI, but from the threat of bird flu and/or nuclear destruction).

I think they'll all be actively used in 20 years. People learn things early in their careers and use their basic skills for their entire career. I still use Vi as a text editor for instance. Programming languages are the same. Concern regarding the efficiency of the programming language (scripted vs complied or VM based) will be replaced by more efficient application designs and implementation. This moves the concern away from the implementation and hits the problem where it lives. Facebook compiles PHP for this reason... nobody built a PHP compiler, so they did it themselves after they realized the scripted language was killing their profits. Similar activities will occur as people realize that designs and implementations are more an issue than the programming language. Spanning the gap between concept and deployment without sacrificing efficiency takes only a little more thought and cooperation than usual. It also allows (actually required) tossing "debt" out the window (like 5 million lines of code that have "already been paid for"). 100 years is intriguing. The reality is, good programmers "think" code and it basically manifests itself as software. This occurs when the tools being used to writing in whatever language "fall away" allowing the programmer to "flow". This is the value of a good IDE. In 100 years, thought to manifestation mechanisms  will start to replace programming languages for this reason. Until the last  "hands on" programmer dies off...

There are some languages not on your list. Pascal, Modula 2. Why not? In 10 years, which languages will be off your list? 100 years is a really long time. For such a time, a more apt question is "Will the Von Neumann architecture still be around?" 30 years ago, no one thought about security or power consumption. Modularity, complexity, extensibility and performance have been around forever and will IMO continue to be a factor in languages forever. I do not believe there will ever be a PowerPoint compiler, although plenty will try. In 100 years, computer languages may not even be in English anymore. However, I find it difficult to 相信 that the if statement will ever be replaced by 如果. 88.

I don't imagine a future where COBOL will ever go away, but COBOL isn't exactly actively used. From your list, I expect LISP will still be around in 100 years, but for all the wrong reasons and not for the reasons you'd expect. Just like with classical music or deprectated musical instruments, I imagine our grand children will look back on history and discover these "ancient" programming languages people long dead had used, and there will be a sort of hipster revival movement that will rediscover them and use them because they may think there's something to be learnt. That is, if the zombie apocalypse will _not_ happen.

Beware that Clojure is a dialect of LISP. I would say LISP can survive 100 years due to its deep mathematical bond and highly abstract nature. In 20 years JavaScript (ECMAScript) would definitely blossom as MEAN become more popular. I can't really tell the rest.