From the Mono homepage: “Today Zoltan Varga announced that he got the Eclipse IDE running on top of Mono+IKVM. A screenshot of Eclipse running with Mono can be found here“.
Mono+Ikvm Runs Eclipse
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
Mono is going to own
rgr that
This is awesome! If this isn’t some serious proof that Mono is really maturing and progressing, I don’t know what is! Naturally, it isn’t complete, but it’s great to see something tangible to show that an open source .NET is a viable solution for projects.
In discussion of .NET here and over at MacSlash, I’ve talked about how .NET is a technology that has a lot of potential and technical advantages over other systems, although Java is usually the “opposing” technology in question. It’s not so bad here, but most people on Mac forums can’t see beyond their childish MS hatred to see that there is something worth copying with .NET.
No, .NET isn’t anything totally new, but it’s the first time it’s all been put together in such a way, to my knowledge. Yes, you’ve been able to run other languages on the Java VM for a while, and you’ve been able to run other languages on various Smalltalk VMs for even longer, and other languges on Lisp VMs for even longer! But in none of these systems has the integration been as great, as seamless or as transparent as with .NET. Sure, Sun may expect everyone in the world to settle with Java-the-language because of a lack of functionality in the Java runtime system, but MS, in all of their imperfections have at least put forth an idea that doesn’t make people settle on a language they may consider poor.
That isn’t to say the .NET VM is perfect- it’s not. There are some areas where it could stand to be improved in order to better support certain kinds of languages. However, as a 1.0, it’s pretty damn cool. And in less than two years, Mono has given us an awesome free software project that gives us all the technical advantages of the .NET system without being tied to MS.
Sure, down the line, MS may decide to be evil and change the .NET API and various related specs (although they’ve been pretty good with standards thus far with it!), or hell, they could up stop using it entirely. Even if they did, we’d still have Mono. We’d still have an awesome OSS project which provides all the technical advantages, regardless of its still supported by this hypothetical future Microsoft.
Repeate after me: mono rawks!
Seriously. The nice design of .net coupled with opensourceness of mono and pnet is going to change unix more than perl and java did combined..much more.
Another copy cat from M$. This so sorry for M$ to copy Java and call it .Not . From our tps tests .Not is still VB child.
Mono is looking nice, but IMO its better to support our own and you never know what MS will do to kill mono if it becomes multi platform. Anyway, .net is just like java with a lock in, even though mono is helping change that.
Anyway, doesen’t Eclipse run natively on linux? Isn’t it a java app or something.
How is this going to handle RAS?
I’m so sick of hearing people bash mono just because it is copying the best idea ever to come out of redmond.
Why is Java inherently better? Because it’s not Microsoft? Well Mono’s not Microsoft either…it’s open source…meaning Microsoft can not do a damn thing to shut it down. They can make it illegal, but that won’t be enough to actually kill it. How many of you are americans watching DVDs under Linux? Guess what, Ogle is illegal according to the DMCA. How many of you have illegally downloaded MP3s?
Just because it’s microsoft doesn’t make it evil…personally I think Anders Hejlsberg did a great job (yeah he’s the guy that created Turbo Pascal in case you’re wondering).
-bytes256
Didn’t know that mono was supporting java yet… This is good stuff though… Are they really that far off from being complete?
I wonder how the speed is compared to running it with black down java (SLOW).
Can someone bring some of us up to speed on the deal here. I know what mono is, and I know what eclipse is. I have no idea what IKVM is. Is the deal here that it’s a big java app running on top of mono? I’m just simple confused and I know i’m not the only one.
Is a a big thing that a big app is running on it?
or That a java app is running on it?
or that eclipse runs on it?
IIRC, what the person was using in the screenshot was Mono + the Java class path. Essentially what happens is the Java Bytecode is converted to MSIL and run using the CLR VM from mono, however, it still links back to the java classes.
What does IKVM do?
IKVM, IIRC, is a Java implementation for .NET. A free one,
I believe. Microsoft’s J# is a non-free project accomplishing the same goal of running Java code on .NET. It isn’t just about running the bytecode on the .NET VM either- any Java app on .NET should get for free all the interop with any other .NET language, being able to take advantage of all the libraries and system services provided. However, I imagine the chief purpose of Java versions for .NET is so that people wanting to upgrade from Java to .NET will be able to port their code from Java to .NET easily. From then on, they’d be able to write new functionality in their legacy Java apps in Java, C#, Managed C++, #Smalltalk, Mondrian, VB.NET or any other .NET language. Quite the trick! Folks can leverage all of their old legacy Java code while migrating to .NET. All the benefit, none of the painful rewritting.
When one says “Java implementation for .NET,” that means is converts/JITs Java bytecode to MSIL, that is, bytecode for the .NET VM/runtime.
What is Eclipse?
Eclipse is an IDE written in Java for developing in a number of lanuguages. It is earning the reputation for being the best free IDE around for Java. One reason people dig it is that is uses its own widget set, which calls out to native widgets, rather than using Swing. This widget set is called SWT, and is analogous to wxWindows. It is a lot faster as a result.
What did they do here?
The Mono crew took the Eclipse IDE and ran it on the .NET system using the IKVM to handle the Java bytecode for the .NET system. Getting this to work takes a lot of functionality in both Mono and IKVM, and it is really awesome to see that they’re both functional enough for it to work!
Lock in?
Thanks to real, open standards, it really looks like .NET is the best choice if your concern is lock-in. The .NET runtime and the C# language both have standards (ECMA IIRC), and Mono has that to work from. On the otherhand, Sun keeps Java a moving target and has kept standardization from happening.
Furthermore, with .NET, you don’t get locked into a particular language. You do with Java. 15 years from now, when there is a new fad language, those who have solutions built on top of the Java language and the JVM platform will be stuck with whatever BS Sun feeds them. For .NET users, those who are going with C# today could easily switch to whatever new whiz-bang language managers read about in the trade rags. These .NET users will be able to switch without having to rewrite all of their code. They will be able to use all of that old Java (thanks to IKVM, etc), C++, C# and even COBOL code as if it were written in this new fad language. All the Java/JVM guys will be stuck doing rewrites, which costs a lot of money and a lot of time.
If you like Java, that’s great. Everyone should be entitled to her personal opinions. But that is what is awesome about .NET- Java developers can continue to code in Java (using Qt or SWT, even!), while getting the added bonuses of having access to any library or class written in any .NET languages *and* having the ability to share their code with people who want to use it who may not know a lick of Java.
It seems so silly to pit Java against .NET. It’s not an accurate parallel. It should be the JVM against .NET, where the JVM has no technical advantage. At this stage in the game, perhaps speed, but with MS’s .NET being a 1.0 and Mono even newer, the .NET options have been doing pretty damn well compared to a Java that Sun has been working on for more than 10 years. I wouldn’t be surprised if in another year even Mono would be rivaling Java in speed!
That screenshot does my head in…. it’s UNIX on Windows, running … Java on .NET – arghhhhhhhhhhhh!!! NO MORE VIRTUALISATION PLEASE!!
Mike Hearn: Your wrong. It’s windows running XFree86 (which is NOT unix), and it is windows (with an Xfree86 front-end) running mono-compiled java-code.
Beyond a demonstration of technical prowess, I’m don’t see the practical point of this demonstration.
If I want to develop Java programs using Eclipse (which I do), why would I want to run that envioronment on top of Mono and IKVM? And what do I gain by developing an application for such an environment?
I’ve written siginificant code in C# and Java, and I’m certainly no anti-Microsoft zealot. Nor do I have anything personal against the Mono project or Miguel de Icaza. Nor am I entirely enamored of Sun’s approach to Java.
But I have yet to see a single reason why I would use these technologies in the proscribed fashion. If I’m writing Java, I don’t really care about Mono or .Net; generally, if I’m writing for .Net and Mono, I’ll be using C#.
Can anyone please describe a scenario where the combination of Mono/IKVM/Eclipse/Java is “the best” solution?
Java and the .NET platform are not in competition. Various mono acolytes and MS crazies may like to think of .NET as some sort of new dawn that eclipses the Java platform, but it isn’t.
Java is the absolute best choice for enterprise server-side development. .NET doesn’t even come close to it in this arena in a technological sense, and does so with several major disadvantages, and vendor and platform lock in too.
People who spread the myth that .NET is more “open” than java do so on the back of the ECMA standards that MS has submitted some parts of .NET too. But to claim, as RevAaron does, that Java is lacking in openess and standards by comparison is just silly. If anything, it shows a complete ignorance of the JCP and the openess of Java design. Hell, you can download the entire source code of the entire Java platform, you can submit code and ideas for improvement to the JCP and have them incorporated into the platform. This is by far the most common route for Java’s great strength – that of being a “moving target”. Being a moving target is a good thing – much as you would like it to keep still and gradually outdate itself, instead Java keeps improving. The entire industry is involved in the design and development of Java, not just one company (see: MS).
It is very strange that Sun somehow keep some fictional stranglehold on java and yet they have just 5% of the lucrative Java market, it being dominated by IBM, Oracle, BEA, and so on, while also having the most openstandards and implementation for a middleware platform around.
Regardless, the two platforms have different goals and different areas of strength. if you want to do clientside windows development and don’t mind vendor lock in, go with .NET. If you want to do serverside, enterprise standard development and divorce hardware decisions from software decisions, while having a choice of multiple vendors from HP to IBM to Sun to BEA to Oracle to Sybase to Macromedia to absolutely everybody who’s anybody, go with Java.
j2ee + linux in particular is a powerful platform in the middleware space. If there were no j2ee on Linux, IBM and other big companies would not be nearly so interested in Linux. It would occupy the same sort of spaces as OpenBSD, doing simple static serving and uncomplicated background tasks, firewalls, etc, but would not be able to enter the heart of a company by providing a platform for its business logic.
As for mono, eh. I doubt it will amount to much in the long run. It seems like another Wine in the making, they will constantly be chasing .NET while providing no innovation of their own, they will always have the pall of possible MS dirty tricks, patents etc hanging over them, and they are a completely different thing to java anyway. Nobody in their right minds would consider using mono for serverside stuff at this stage, and it is extremely unlikely this will change until they get several thousand developers and can create a platform that will match the entire efforts of the biggest company around. This will not happen, just like wine has yet to be remotely usable for the majority of users, just like the GNU classpath is hugely incomplete. These things take time and frankly, the rest of the world is moving much faster.
Attempts to compare mono and java are downright silly.
Can anyone please describe a scenario where the combination of Mono/IKVM/Eclipse/Java is “the best” solution?
From what I understand, if you wanted to add some functionality to a java program you wrote a few years back, but now you want to use C#, your best bet is .Net. That way you don’t have to port everything over to C#.
The point of this demonstration is just to show how far along Mono and IKVM are.
If you think M$ likes opensource you better wake up. The reason Mono the step child of .Net is there because Java is kicking M$ butt. Java has a JCP process and opensource, IBM, Novell, Oracle, Bea, HP , Nokia, Erricson, Sony etc companies contributes to it.
Now a good question how many companies are allowed to contribute to .Not well Nada just evil empire M$.
If M$ was so holy to opensource why is IE propietory, why exchange server is propietory, why sql server is propietory.
M$ can and will pull the plug on Mono becuase of .Net and all it runs is under windoze..
Sun , IBM, Bea, Oracle, Sony, Nokia all have accepted linux and Opensource now my quewstion did M$ accept Linux and opensource.
IMHO C# is far better the java 1.5 will be. java 1.5 likes the visual basic, when M$ tired to put modern features to anachronistic basic language. Swing is very-very slow and ugly on linux. Qt is nice, but if your software is not open source it is very expensive solution.
It seems like converting Java bytecode to MSIL at runtime will add a lot of overhead to running Java on Mono. Is anyone working on compiling Java straight to MSIL?
There really is only one .NET language: the Common Language Specification (CLS). On top of that language you use the syntax of your choice: C# or VB.NET or whatever.
I like to think of this as “language skinning”. Please don’t confuse this with genuine choice in languages.
For example, .NET does not support “Visual Basic” as it was previously defined. VB.NET is quite different from VB 6. .NET supports “Visual Basic” only in the sense that Microsoft has redefined the meaning of “Visual Basic”.
That said, I do like .NET, and find it rather funny that Java version 1.5 is going to include a long list of features that were first introduced in C#. Almost as funny as hearing Microsoft say that C# didn’t borrow from Java. It only looks like Java because they both borrowed from C and C++!
My prediction: because .NET is just a continuation of the Java wave and isn’t fundamentally different, it won’t have that long a life. Java, and by extension, C#, is already pretty long in the tooth. The strong static typing that .NET is based on is being questioned. It’s just so much easier to program with a dynamically typed language like Python. The “fab new language” of the latter half of the decade may not fit as well as you’d think in .NET.
It seems to me that Java is a far more better designed language to express the application logic than C#.
Why? Hmmm … for me a language design must follow at least two rules:
First you should be able to express your program logic in a compact, easy to read way, easy to maintain.
Second – which is often ignored – you should be able to extract your logic out of the language and transform it into another language.
For the first rule Java is a big advantage over C, C++ and some other languages. Ok, there is still plenty to do but can be done. C# seems to be quite compatitive from what I heard. Both Java and C# contains equivalent constructs, C# seems to be even a little bit more evolved than java.
But the second rule IMHO only Java is able to compete. It’s quite easy to write an converter from Java to .NET (or C#) – which was done -, but the other direction? As far as I remember .NET can operate directly upon memory storage like C or C++ using pointers. It’s seems quite impossible to build an automatic translation from .NET to Java (till now). I think that M$ doesn’t have sleepless nights about that.
So which way? A clean and simple language like Java with the ability to convert my code in future scenarios in different forms?
Or better .NET, glued to C#, VB, etc. in some distinct form, better performance for the prize of manipulating memory directly.
IMHO my choice is Java.
.NET is a lot more than syntax skinning.
.NET provides a VM (CLR) which accepts bytecode (MSIL). It doesn’t matter what MSIL you feed it.
In some cases, like Haskell for .NET or #Smalltalk, there is a lot more going on than simple syntax skinning around the way C# does things. For instance, in #Smalltalk, you have the full ANSI Smalltalk library, you can use real non-.NET Smalltalk code from VW, Squeak, etc- it’s not just about putting a Smalltalk-like syntax over the .NET classes.
That may be the deal with VB.NET, C# or other .NET languages. It can be done with a system like #Smalltalk, which implements a real language on top of .NET- or else you couldn’t use all the .NET classes/libs. Or, for yet another example, with IKVM or J#, you can use the regular Java API, along with any of the Java jars or .classes. Except, with J#, #Smalltalk or Haskell .NET, you’re not confined to the libraries written in that language, you can use the syntax of your language to call out to .NET. Likewise, I can write all the code I want using real-live ANSI Smalltalk and make it available to C# or VB.NET, without having to confine myself to just the ordained .NET API. Same with Python .NET. Or Perl .NET. Al lthe same old libraries, with the added ability to use .NET classes (or code written in any other .NET language).
But yes, C# and VB.NET largely do language skinning. VB6 could have been implemented on .NET, but for whatever reason (I’ve a couple guesses), they decided to move forward rather than remain stale. Although it is at the expense of VB6 coders who may have a hard time learning real OO, etc.
If you think that all .NET is capable of is language skinning, go read up on the definition of a Turing complete system; there is no reason any language couldn’t be implemented on top of .NET- even one that has no access at all to the .NET API.
No, look at the title bar, it’s running on Cygwin, a UNIX emulation layer for Win32
I’m aware of that. But Cygwin/Xfree86 only emulates the userinterface. It has nothing to with the way Mono runs underneath. Mono can be compiled on both MCS (the Mono compiler) and on the Microsoft C# compiler. You’re scared over nothing.
It’s seems quite impossible to build an automatic translation from .NET to Java
You wrongly compare the language Java with the platform .NET
The Java language is equivelant to the C# language.
Java bytecode is equivalent to MSIL.
I don’t se why it should be more difficult to translate <favoritelanguage> to Java bytecode than it is to translate it to MSIL. The only thing i see, is that in the Java world, only Java code can be translated to Java bytecode (nobody made a compiler which makes bytecode of other languages, as far as i know), while in the .NET world almost every language can be translated to MSIL.
I don’t see the conflict, only the nice addition, that now it is possible to translate Java kode to both Bytecode AND MSIL, which is “generally a good thing” because it adds flexibility and interoperability without destroying anything (expect the day for some Java-Anti-MS-Zealots).
Eclipse is a very good IDE, I would like to have something like that written natively for the Mono .NET platform, that’s the kind of tool Mono will need to gain developers in unix. I for one would not use SharpDevelop in linux or any BSD, it has its merits, but depending on WinForms and therefore, Wine, puts it out of the choise for me. Is there any project (or plan for a project) to build something like eclipse for Mono? The alternative would be (as someone sugested before), for a java compiler to generate .NET native code so that eclipse would run without the two-level virtualization that using LKVM means
I do java development, and I enjoy using Eclipse for that purpose, so this story caught my attention. Most of my work is done doing server side stuff, using the Tomcat servlet engine and other Jakarta projects, such as Struts. Is there an equivalent in the open source world for .NET? My biggest hang-up right now doing .NET is that there are no open source Application Servers for the technology – that I know of.
It seems to me that if one checks out jakarta.apache.org, you can see the immense amount of work the community is putting into Java components (tags, frameworks, tools, etc.).
Thoughts, opinions? Thanks.
“Is there any project (or plan for a project) to build something like eclipse for Mono?”
An effort is currently well under way to port the entire user interface portion of SharpDevelop to use a .NET version of the SWT toolkit called #WT. This means that SharpDevelop will *no longer* use Windows Forms. This is part of the developer’s strategy to make SharpDevelop a cross-platform IDE.
JP
You wrongly compare the language Java with the platform .NET. The Java language is equivelant to the C# language.
Java bytecode is equivalent to MSIL.
Yeah, I wasn’t too specific about that. Only the underlying virtual machines specs (MSIL and Java-Bytecode) define the features the developer can take advantage of. The language represents the features in an abstract form. So looking at .NET it’s irrelevant which language I use because they must all implement the same set of instructions somehow. If they aren’t capable of the specific features, either microsoft must add those features to the languages or leave them unimplemented.
The JVM will never be able to interpret directly the MSIL bytecode cause of missing features (e.g. direct memory access). MSIL in contrast can interpret straight forward the java byte code cause of the simple and hardware-independent approach of the JVM byte code.
only Java code can be translated to Java bytecode
AFAIK many compilers exists to produces JVM bytecode for different languages (smalltalk, etc. – try sourceforge.net ‘java compiler language’).
The comparision between the two concepts – Java (System) and .NET – with all religious flame wars stripped off – results in an ages old problem: problem-orientated or machine-orientated design models.
The first needs sophisticated compiler & machines (and years of development), the latter complicated frameworks and strong dependencies to existing systems (that’s what MS wants…)
I still stick to first approach… 🙂
Point taken on Turing complete.
I’ll limit my argument on language skins to Common Language Specification (CLS)-compliant implementations. If it is CLS-compliant, it is a skin (though maybe this is a circular argument!).
For example, Python.NET is a skin. It doesn’t implement true Python semantics. It is a different language (for example, it doesn’t allow multiple inheritance, where normal Python does).
The only thing i see, is that in the Java world, only Java code can be translated to Java bytecode (nobody made a compiler which makes bytecode of other languages, as far as i know), while in the .NET world almost every language can be translated to MSIL.
Actually, there are a few dozen languages that compile to Java bytecode. There’s a long list of languages here:
http://grunge.cs.tu-berlin.de/~tolk/vmlanguages.html
but most of those projects are either dead or experimental. AFAIK, only two of those languages have any real following, and those are Jython (a Python implementation) and AspectJ (Java + aspects).
for Peter:
You mention Python.NET- but what about the other examples? Why would any CLS-compliant language have to be a skin anymore than any language that runs on x86 an x86-assembler skin?
#Smalltalk is a CLS-compliant language. It supports all the features of regular ANSI Smalltalk, including blocks. Yet, it can access the built-in and other .NET libraries. Is #Smalltalk just a syntax skin? Just because it can use .NET libraries? I would agree that a .NET language would be a skin if it contained just the *look* of a language without the regular functionality. Like C# or VB.NET. But there are plenty of languages for .NET which retain their original language features while adding the ability to access .NET stuff via CLS-compliance.
Python.NET supports only single inheritance because the .NET system doesn’t support multiple. I personally think this is a flaw in the .NET VM’s design, but it is something which could be added. Python being restricted to SI doesn’t make it simply a skin, however. What other features were taken out of Python.NET that make it a skin rather than Python? Other than a lack of MI, you still can use the same Python functions and libraries (provided they’re adapted to SI!), use the same idoms, etc. It’s not like when you are using Py.NET, you’re limited to just the .NET libraries, having to do iteration and such like you wuold in C#.
for ethzero:
There are many languages for the JVM. However, these languages don’t interoperate like .NET languages do. Likewise, there are many languages for the PPC archetecture, but there isn’t anything about either systems that provide seamless interop between languages. With .NET, I can write a class in #Smalltalk which uses libraries written in C# as well as the regular .NET libraries. I can then pass this along- in a DLL- for a friend to use in a project he is working on it Python.NET. He can subclass my classes, call my methods, instantiate these derived or the original classes, all seamlessly.
That is what .NET does while all those langauges for the Jvm don’t. The .NET CLR was written to support this, while the JVM has been archetected to support only Java well. That isn’t to say other languages don’t work fine on it, but there are features which would need to be added to the existing JVM to get it to support language interop like .NET does.
As I understand, Jython doesn’t compile Python to Java bytecode, it’s a Python interpreter written in Java. That’s a pretty big difference.
With .NET, I can write a class in #Smalltalk which uses libraries written in C# as well as the regular .NET libraries. I can then pass this along- in a DLL- for a friend to use in a project he is working on it Python.NET. He can subclass my classes, call my methods, instantiate these derived or the original classes, all seamlessly.
Where do you get your information? Jython can call, subclass, and instantiate any Java code and vice versa, same as a .NET language. I expect the same is true for most other JVM languages.
As I understand, Jython doesn’t compile Python to Java bytecode, it’s a Python interpreter written in Java. That’s a pretty big difference.
Jython can be run in an interpreter or compiled to Java bytecode. I haven’t used Jython, but that’s what it states on their website.
Where do you get your information? Jython can call, subclass, and instantiate any Java code and vice versa, same as a .NET language. I expect the same is true for most other JVM languages.
Yup, Jython can subclass Java classes, etc. However, this isn’t what I described- re-read it. I described something more. The languages on that run on the JVM can usually interact with Java classes and methods (although such integration as subclassing is more rare), but it doesn’t usually go the other way. That is, you can’t subclass a Jython class in Java. Yes, you can pass a string of Python code to Jython for evaluation, but that isn’t the same thing. If Jython now compiles to regular Java classes, things have changed- and Jython would also be an exception. Take a look at the docs for some of the JVM languages- there isn’t any simple, transparent way to have JForth access the code you’ve written in JTcl or Jython. That is the key.
Likewise, you can’t take that Jython class
Yup, Jython can subclass Java classes, etc. However, this isn’t what I described- re-read it.
Any language that compiles to java bytecode interoperates with any other language that compiles to java bytecode. Java is no different than .NET in this regard, yet you said “That is what .NET does while all those langauges for the Jvm don’t.” Many of those languages do compile to java bytecode, including the two I mentioned, Jython and AspectJ. So what you said was wrong, but i’m glad you seem to agree now.
>So which way?
>A clean and simple language like Java with the
>ability to convert my code in future
>scenarios in different forms?
Ok, Pls convert your java code to COBOL or RPG 🙂
Well, the JVM can, it is just that MS supports this, and Sun does not.
Next your’ll say ELF is somehow bound C/C++
I once found a backend for GCC, so you could create java objects from C++ (or anything else GCC supports), but it has allways been in an early stage of development.
Looks like the rest of my post was cut off.
Any language that compiles to java bytecode interoperates with any other language that compiles to java bytecode. Java is no different than .NET in this regard, yet you said “That is what .NET does while all those langauges for the Jvm don’t.” Many of those languages do compile to java bytecode, including the two I mentioned, Jython and AspectJ. So what you said was wrong, but i’m glad you seem to agree now.
Re-read what I said. Again. And again once more if you need to.
Just because Jython was designed such that it can interact well with Java doesn’t mean that .NET and the JVM are no different in this regard. Try reading the rest of my post- most languages don’t have this ability. Because they all run on the JVM (many don’t compile to bytecode, simply interpret to it), some interop can be done, for sure- but that isn’t what has been in question. I am talking about transparent, high-level interop. With JVM languages that haven’t all of the explicit support for interoping with Java and other JVM languages, you may have a function to which you can pass a string of this languages code, an eval(). However, there is a big difference between doing something like:
// this is pseudocode, don’t get nitpicky
// for my leaving out of int main
// the way you do it in most JVM languages:
import org.forth.jforth;
JForth forth = new JForth();
forth.init();
int result = forth.eval(“14 52 addAndSquare .”);
// result = 4356
** and **
// the way you’d do it in .NET
import org.forth.jforth;
int result = addAndSquare(14, 52);
Maybe that doesn’t seem like a signifigant to you, but when you’re doing real coding with complex classes, it gets a lot more complicated. With all but a few JVM langauges (e.g. Jython), the coder wishing to use libraries or code from another language has to know the language so as to pass code to eval.
Compiling to Java bytecode doesn’t make this interop automatic. Many languages compile to PowerPC machine code, but it doesn’t mean they can all interop on a higher level.