Evolving Java Without Changing the Language

http://www.infoq.com/articles/evolving-java-no-lang-change

by fogus • 17 years ago

18 38 17 years ago

10ren2• 17 years ago

The article links to this example of support for XML literals: https://rapt.dev.java.net/nonav/docs/api/index.html?net/java...

It's in the spirit of machine code in REM statements. A ghastly, reanimated spirit.

  /**
  <commands>
      <command name="SOD" order="NEW">
          <parameter slot="P2" name="N" value="4811980" />
          <parameter slot="P2" name="N" value="4811980" />
      </command>
  </commands>
  */
  @DomLiteral static Document testCommands = DomLiterals.testCommands();

nickyp• 17 years ago

You mean without rewriting it so it is not an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp? ;-)

ZitchDog• 17 years ago

I would say it's more of a formally-specified mature pretty-fast implementation of half of Common Lisp.

wingo2• 17 years ago

The initial Gosling quote gives me shivers of revulsion.

WilliamLP2• 17 years ago

I think that very philosophy is the single biggest reason for Java's success. It's "show me where people are actually using this well", not "tell me why people ought to be using this".

If you ask some people what is the practical use of certain concepts you get answers like "Uh, you can't even understand why this is so good, because your brain doesn't work in my language, see the Blub Paradox... But see how nice my factorial function looks!"

Ironically, I think Java is now one of the most used language in academia, which seemed to have been explicitly an "anti-goal".

bad_user4• 17 years ago

If Java is used a lot in academia is mostly because it is shoved on the throats of students as one of those "real world skills that helps you get a job".

Not to say that it doesn't have merits. It's fast enough, it's cross-platform, it has good tools and good libraries. But this wasn't the case until Java 1.4 was released. And its popularity has more to do with Sun's marketing campaign than anything else.

jrockway7• 17 years ago

Me too. I had a hard time reading on after that.

Java is absolutely chock-full of "things that sounded like a good idea" -- unboxed types, single inheritance, interfaces without the possibility of shared implementation (or state), public / private / protected / default, positional constructor arguments, "Type foo = new Type", etc. Actually, none of those even sound like good ideas. (But I guess after the brain damage that was C++, it was inevitable that The Industry would overcorrect. Hopefully we've learned one important lesson from Java -- making the language "simple" won't stop people from writing bad code, but it will stop people from writing good code.)

Java also popularized some very very experimental ideas, like virtual machines and automatic garbage collection. (And I am very thankful for both.)

So now that I think about it, I don't get that quote at all.

mike_organon• 17 years ago

Also, checked exceptions were not used before, but sounded like a good idea. And they turned out to be harmful in my experience.

wingo2• 17 years ago

It's not all that consistent, no. But for me what it cues is Perlis:

"Algol is a blight. You can't have fun with Algol. Algol is a code that now belongs in a plumber's union. It helps you design correct structures that don't collapse, but it doesn't have any fun in it. There are no pleasures in writing Algol programs. It's a labor of necessity, a preoccupation with the details of tedium."

From http://www.eecs.berkeley.edu/~bh/ss/foreword.html.

axod7• 17 years ago

I'll have to disagree with you there.

Type foo = new Type() is a bad idea? why?

Shape myShape = new Rectangle(); seems pretty logical to me. If you want to use static types, you can't really argue against that syntax.

single inheritance sidesteps lots of potential issues, and interfaces are cleaner IMHO

>> "but it will stop people from writing good code."

I'd also strongly disagree with that. Arguing that Java prevents you from writing good code is nonsense. As much sense as saying using French prevents you from writing a good story. I've seen some brilliant code written in Java (If you steer well clear of 'enterprise' etc).

radu_floricica• 17 years ago

Why? You're right that Java was a reaction to C++, and in that view it was a rather simple language. Virtual machines and garbage collection were indeed new (well, new for C-like languages. actually, new for c++), but one was necessary in order to make java embeddable (which was one of its primary goals initially), and the second was a very necessary solution to too many years of malloc.

But the essential point is that after HelloWorld a C/C++ programmer with a JavaDoc can pretty much start churning code. The immediate consequences, way before getting to esoteric disputes about single/multiple inheritance, were only positive: the code was portable, memory problems disappeared, the documentation was in one place, the library was standard etc. The language itself, for the ordinary programmer of the time, was just simplified C++.

ivenkys2• 17 years ago

At what point does managing the complexity of all the "add-on" pieces of software - APT, Meta-model generators, IDE magic, the interconnecting build tools et all - become too high ?

Why not strengthen the core language ?

bad_user4• 17 years ago

Because that was the philosophy from the beginning ... don't change the language until it's too late, make sure to cripple all new features to maintain backwards compatibility, leave the problems to the tool-vendors to solve.

Actually this philosophy worked better for future-proofing the platform in a weird way. God knows how they would've crippled the JVM if their generics support wasn't made through type-erasure for example.

And so the JVM bytecode is pretty light, now only if they added tail-calls and continuations. But I don't think that will happen too soon.

ivenkys2• 17 years ago

I understand the philosophy and yes that has in a way future-proofed the JVM. The question is "Does it make sense to try and include advanced language features in a round-about manner into Java ?" Surely this approach only leads to additional complexity and broken features.

Why not put that effort into a newer language running on the JVM ?

mdemare• 17 years ago

I found the part about IDEs fascinating: IntelliJ will recognize those ugly anonymous classes, and show them to you as closures.

I wonder how far you could take this. A language like Duby gives you Ruby syntax, while producing identical bytecode as Java. If you could translate Duby into Java source code, and parse and show it as Duby, your IDE could let you program in Duby without anyone else on your project even noticing.

Then you're in effect relegating Java to object code.

bad_user4• 17 years ago

Isn't that what compilers do?

I actually am thinking of writing a compiler for a custom language that will be translated to Java. It will be a lot like C#, but simplified, with a lot of the cruft removed (like the requirement to define a Main class with a static main, or the requirement that all code should be wrapped in a class, but reified generics is something I want although I'm not sure if it's feasible).

I don't like Duby, I don't like Ruby for that matter. Mostly because the syntax is not as extensible as I'd like and because the variables don't have lexical scope.

axod7• 17 years ago

I think it's a pretty bad idea. The more IDEs hide code from people, the more verbose code will be produced.

Much easier to just setup a simple macro system to run over source files and replace things before compilation.

eru2• 17 years ago

Where's the difference?

Evolving Java Without Changing the Language

Related Stories