On Apr 24, 1:53 pm, Charles Oliver Nutter <[EMAIL PROTECTED]>
wrote:
> For my CommunityOne talk...how about everyone posts five "interesting"
> JVM language projects. This can certainly include languages that aren't
> under active development right now or that don't have a large following.
> I just want to gather a list of languages that "we implementers" and JVM
> language enthusiasts think the world should know about (and which are
> good examples of the work we're doing on VM).
>
I don't have a top five languages list, but here are five reasons I
think people might find Clojure interesting:
- Clojure is a modern implementation of Lisp, the grandfather of
dynamic languages. Many of the concepts underlying Ruby, Python, Java
etc came from Lisp. If you've looked at Common Lisp or Scheme before,
you might find that Clojure is substantially easier to read and write,
with support for vector and map literals in addition to lists, and far
fewer parentheses. But Clojure does not give up Lisp's code-as-data
philosophy and the powerful macro system it enables.
- Clojure was written for the JVM. As such it can have deeper
integration with the Java framework, and the JVM type system. In fact,
Clojure does not implement its own type system on top of the JVM's. So
Clojure Strings are Java Strings, Clojure collections implement
java.util.Collection, Clojure's sequence library works with any Java
Iterable etc. Clojure's interface to Java uses no wrapper classes.
- Clojure is compiled to JVM bytecode, and as such is subject to the
performance optimizations of HotSpot etc. Clojure supports optional
type hints that allow calls to Java that avoid reflection, and run as
fast as Java.
- Clojure is a functional language, i.e. its core data structures are
immutable. It reflects, in many ways, a rejection of structuring
systems using a web of interconnected mutable stateful objects (i.e.
traditional OO). Functional programs are more robust, easier to test
and easier to understand. If you've read the excellent 'Java
Concurrency in Practice' you've seen how often it recommends
immutability, but, without a good set of efficient immutable data
structures, it's very difficult advice to follow. When using Clojure,
you are automatically following that advice all the time.
- Clojure was designed with concurrency in mind, leveraging Java's
well defined memory model and rich java.util.concurrent library to
provide robust facilities for doing concurrent programming, including
a software transactional memory system, an asynchronous agent system
and dynamic thread-local variables, which together make writing
correct multithreaded programming much easier than in Java.
Clojure was designed to tackle the problems for which you might
ordinarily use Java. It is one of the few JVM languages providing
concurrency support at a higher level than the native locks. It has
all of the fun and fast aspects of a dynamic language with a REPL,
plus compiled performance, functional robustness, multithread
awareness, Lisp macro power, and all of the Java framework at your
fingertips.
Rich
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "JVM
Languages" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/jvm-languages?hl=en
-~----------~----~----~----~------~----~------~--~---
