Comments on: Dynamic Languages: Rationalizations and Myths

By: billburke

billburke — Fri, 22 Feb 2008 15:56:58 +0000

I thought I stated what i meant by “staticaly-typed dynamic language”

1) Typesafe introductions/mixins to either an instance or a class

For example:

class Foo {}
class Mixin implements MixinInterface {}

Mixin.add(Foo.class, new Mixin(), MixinInterface.class);

Foo foo = new Foo();
MixinInterface intf = (MixinInterface)foo;

Or:

Foo foo = new Foo();
Foo bar = new Foo();

Mixin.add(foo, new Mixin(), MixinInterface.class);

(foo instanceof MixinInterface) == true
(bar instanceof MixinInterface) == false

2) Ability to do AOP things like field/method/constructor interception without having to do bytecode magic
3) Ability to plug in at runtime annotation processing (not the Javac crap).
4) An instrument library that allows you to make schema changes to classes. (didn’t state this before)

By: Jesse

Jesse — Tue, 19 Feb 2008 20:43:42 +0000

…one more thing. I just wanted to say to Mr. Burke that I enjoyed the article and thought he made some good points. I’m not trying to troll or flame, just expressing an opinion. Thanks! -J.

By: James Watson

James Watson — Tue, 19 Feb 2008 20:40:30 +0000

“After all, a working JVM is a good indication that the C++ compiler on your platform’s working just fine.;-P”

Each (Sun, at least) JVM is specially developed and compiled for each supported platform. This is poor evidence for a lack of cross-platform issues. Even if all JVMs were written in C++, few people are compiling their JVM from source. Most people get binaries for their platform.

By: Jesse

Jesse — Tue, 19 Feb 2008 20:31:24 +0000

I am with Brian there– and, what a funny-but-so-true reply! ;-P

Anyway, if one encounters excessive issues with cross-platform incompatibility, pointers, and the preprocessor, chances are good that the situation is exactly the one I mean when I suggest that it’s worth *re*exploring C++. Practices and compilers have changed considerably in recent years, and strongly for the better.

After all, a working JVM is a good indication that the C++ compiler on your platform’s working just fine.;-P

By: James Watson

James Watson — Tue, 19 Feb 2008 20:17:39 +0000

What’s a “statically-typed dynamic” language? ‘Dynamic’ in this context means ‘dynamically-typed’, does it not? This would appear to be an oxymoron.

The comment above about Haskell being a statically-typed dynamic language appears to be a confusion between ‘functional’ and ‘dynamic’. Haskell is a statically-typed functional language.

By: billburke

billburke — Tue, 19 Feb 2008 19:58:29 +0000

C++? No thanks. I’d rather not go back to debugging dangling pointers and worrying about cross-platform incompatibilities and using shit like preprocessor defs and Imake to get around crossplatform incompatibilities and finally memory fragmentation. The only thing I miss from C++ is const and static object creation. The latter of which the JVM automatically figures out for you now.

By: Brian

Brian — Tue, 19 Feb 2008 18:21:38 +0000

@Jesse
I’m with you on C++. I just got back into it. She’s like your first kiss who you left when your family moved to another town 15 years ago. Then you bumped into her on the street and now she’s all grown up and hot hot hot.

C++ killed Ruby.

By: Anders Norås' Blog : Save Java, Dead or Alive!

Anders Norås' Blog : Save Java, Dead or Alive! — Mon, 18 Feb 2008 20:12:17 +0000

[...] to “save Java” fall short in my humble opinion. “Angry” Bill Burke’s rant on dynamic languages was a sad read. Most of the arguments aren’t generally applicable, because there is no such thing as [...]

By: Jesse

Jesse — Mon, 18 Feb 2008 19:18:38 +0000

I suggest re-exploring C++ and also having a peek at Haskell (which, by the way, is a statically typed dynamic language).

By: Eek

Eek — Mon, 18 Feb 2008 15:25:36 +0000

Myth: The amount to type is what is the problem with code verbosity. This is a very common myth in Java circles.

Fact: The problem is the verbosity smearing out real complexity over a lot of screen space, with a ton of noise between the true signal.

Myth: *Reliable* refactoring is critical in dynamic languages.

Fact: This emphasis on “*reliable*” falls down in the presence of tests, at which point a heuristic is fine.

Myth: Argument by personal incredulity/personal lack of imagination (”I just can’t imagine …” is a valid argument.

Fact: This is a form of argument generally used by those that have little else to argue with, for instance the people arguing against evolution. It is rude.

Myth: Labelling things in an area you don’t know well “Myths” is reasonable behavior.

Fact: You’re being rude.

Myth: “Being typesafe/statically typed” is a relevant attribute to require.

Fact: “Being typesafe” is about enabling stuff. What you should require is this stuff. Though I think the most common case is that it is about giving you peace of mind to be able to say “It is statically typed”, no matter what the cost.