
JSR 292: Supporting Dynamically Typed Languages on the Java Platform - Early Draft Review - foemmel
http://jcp.org/en/jsr/detail?id=292
======
modoc
Strong typing is one of the reasons that I LIKE Java. Especially on large
projects it's nice knowing exactly what a variable is, and what data elements
and methods are available.

I hope this doesn't lead to people using sloppy typing in Java applications.

~~~
jpeterson
The idea is to add native support for dynamic languages (e.g. Ruby, Python,
etc) to the JVM, not to make the Java language itself dynamic.

~~~
modoc
I know. I just worry that people will gravitate toward using more and more
dynamic language code in their applications/platforms/frameworks because it's
"easier". And then I'll end up needing to use some library that has a
truckload of python code in it, that A) isn't strongly typed, and B) I don't
understand.

Hopefully it won't be an issue.

~~~
mike_organon
I look forward to having dynamic languages improving on the JVM. When I moved
from doing all of my work in Java to learning and doing mostly Lisp at work, I
learned one of the biggest headaches of coding wasn't a lack of _static_
typing (strong is not the issue), but NullPointerExceptions, which doesn't
plague my Lisp code. And for the defmethods where nil's might cause an error
for not being handled, NULL is actually a _type_ that I can code for to avoid
the problem entirely.

Another thing I realized was how much code, or rather code-supporting files,
where already in other languages around Java. There's Ant, ejb-jar,
properties, SQL, numerous internal and external XML, Javadoc, annotations,
manifest, xslt, jsp, html, css, javascript. Point 1: don't worry about Python,
it's a better language than many of those you're already using with Java.
Point 2: with Lisp, it can be all Lisp, or you can integrate with other such
languages where you need to. I think the reason Java has all of these
satellite languages (especially XML) and files is because the language is so
weak and inflexible - Lisp is as flexible as XML, but works nicely as a
programming language.

