I am interested in learning concurrent programming, focusing on the application/user level (not system programming). I am looking for a modern high level programming language that provides intuitive abstractions for writing concurrent applications. I want to focus on languages that increase productivity and hide the complexity of concurrent programming.To give some examples, I don't consider a good option writing multithreaded code in C, C++, or Java because IMHO my productivity is reduced and their programming model is not intuitive. On the other hand, languages that increase productivity and offer more intuitive abstractions such as Python and the multiprocessing module, Erlang, Clojure, Scala, etc. would be good options. What would you recommend based on your experience and why?EDIT: Thanks everybody for your interesting answers. It's hard to make a conclusion without actually trying since there are many good candidates: Erlang, Clojure, Scala, Groovy, and perhaps Haskell. I voted the answer with the most convincing arguments, but I'll try all the good candidates before deciding which one to pick :)
Modern programming language with intuitive concurrent programming abstractions
programming languages;concurrency;high level;modern
You almost certainly should look at Clojure - in my opinion it's the best modern language for multi-core programming and it is extremely productive.Key attributes:It's a functional language, which is a boon for both concurrency and your ability to develop using higher level abstractions. It features fully immutable persistent data structures and lazy sequences which will be familiar to anyone with experience in functional languages like Haskell.It features a very novel software transactional memory system for concurrent lock-free access to mutable state. Making code concurrency-safe is often as simple as wrapping it in a (dosync....) block.It's a Lisp - which makes it extremely powerful for macro-based metaprogramming and code generation. This can bring significant productivity advantages (essay by Paul Graham - Beating The Averages)It's a JVM language - so not only do you get access to the huge array of libraries and tools in the Java ecosystem, you also benefit from the huge engineering effort that has gone into making the JVM an effective platform for concurrent server-side applications. For practical purposes, this gives it a huge advantage over languages that don't have this kind of foundation to build upon.It's dynamic - which results in very concise code and a lot of productivity. Note however that you can use optional static type hints for performance if needed.The language is designed around abstractions which is somewhat hard to explain but the net effect is that you get a set of relatively orthogonal features that you can combine to solve your problems. An example would be the sequence abstraction, which enables you to write code that deals with every sequential type of object (which includes everything from lists, strings, Java arrays, infinite lazy sequences, lines being read from a file etc.)There's a great community - helpful, insightful but most importantly very pragmatic - the focus in Clojure is generally on getting things done.Some mini code samples with a concurrency slant:;; define and launch a future to execute do-something in another thread(def a (future (do-something)));; wait for the future to finish and print its return value(println @a);; call two functions protected in a single STM transaction(dosync  (function-one)  (function-two))In particular, it's worth watching one or more of these videos:http://www.infoq.com/presentations/Value-Identity-State-Rich-Hickeyhttp://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickeyhttp://www.infoq.com/presentations/Clojure-The-Art-of-Abstraction