Lots of things can be said on the topic (and I think we should do so) but to put it as simple as possible I can explain the difference as follows:

TextUML is just another representation for the UML concepts but JRuby has nothing to do with being a representation for JMV bytecode. A machine microcode is at the bottom of the abstration layer chain and almost anything can be built on top of it. On the other hand TextUML (or any concrete syntax) does to add anything to or does not build a really new abstration level on top of UML (or to a abstract syntax/metamodel). So it’s important to distinguish a metamodel and a microcode.

Yes, UML is a language. But TextUML per se is not a real language, instead being just a shallow notation built on top of the UML semantics and abstract syntax.

Re: Java or Ruby serving as modeling languages - well, if you limit yourself to simple concepts such as classes, their structural features, and inheritance, yes, Ruby or Java can make do as modeling languages. But for sound OO modeling, you need much more: associations (with composition/aggregation semantics), multiplicities, and things from other modeling aspects such as states and transitions. You can try to mimic that with hacks in Java and Ruby, but a modeler will be better served if those features are natively supported by the modeling language.

That, assuming your creating models to support model-driven development. Totally agreeing with “choosing the right language for the right task”, the best language will be the one that better supports your modeling needs.

[Ruby]
class Car
def drive(speed); end
def stop; end
def accelerate; end
end

[TextUML]
class Car
operation drive(speed:Integer);
operation stop();
operation accelerate();
end;

See what I mean? That is why I dare question the notion of using UML, if you can use the implementatino language directly, without loosing semantics. Of course, there are features of one language over another that let you express “semantically rich” elements more easily than in another language — but that IMHO is merely a matter of choosing the right language for the right task.

I am really glad you brought that up. There is a big difference between multiple notations for UML and multiple languages on common runtimes such as JVM or the CLR, and the difference is exactly that for UML we talk about “notations” and for the JVM or CLR we say “languages”.

Notations for UML are just a thin layer of user interface for the language abstract syntax and semantics, no existing semantics changed, no new semantics added.

Languages for the CLR or JVM are true languages, and in many cases, the fact they run on the CLR or the JVM is just an implementation detail, i.e., they could be (and frequently are) implemented on other runtimes. Even for Java there is a considerable gap in abstraction level between the language and the JVM.

That is not to say that it does not make sense to support other even richer/more abstract languages on top of UML as you suggest. Model transformation (across metamodels) is one of the key mechanisms in model-driven development. But that is a totally different discussion (which I would be glad to have, btw).

Cheers,

Rafael