Blackdown Releases a 1.4.1 JDK 64
gholmer writes "The Blackdown project has finally released a production version of Java 1.4.1 for both ix86 and Sparc on Linux. This much-awaited release gives Linux users another choice for Java besides Sun's and IBM's."
gcj? (Score:5, Interesting)
(I'm not a Java developer, but I was under the impression that it, also, was another choice besides Sun's and IBM's.)
Re:gcj? (Score:5, Informative)
If you're talking about the bytecode compilation aspect of gcj, then you still need a JVM to run those bytecodes in.
Re:gcj? (Score:2, Interesting)
If the answer is yes, is there a way to do this under windows too??
Daniel
Re:gcj? (Score:2)
Under windows, I imagine you could do all that from within Cygwin.
Re:gcj? (Score:2)
But would a windows user be able to use the compiled version without having cygwin installed??
Daniel
Re:gcj? (Score:2, Informative)
Re:gcj? (Score:1)
People are even building ActiveX controls with gcj: http://www.xwt.org
AG
Re:gcj? (Score:1)
Re:gcj? (Score:2)
But does that work for networking applications too? Last I checked, a mingw binary could not use any socket code.
Re:gcj? (Score:1)
Tomcat 3.* works nicely. http://sources.redhat.com/rhug. Gary Benson is working on Tomcat 4.* right now. The trick it to build it properly and shake any remaining bugs out of our core class library implementation.
And, yes - there's even a mingw32 gcj (which you can also use from Linux as a Linux-cross-mingw32 compiler).
Re:gcj? (Score:4, Interesting)
GIJ, the GNU interpreter for Java, is also included in the GCJ package. GCJ isn't a finished product yet, but when it is, it will be a complete JDK and JRE (compiler, VM, and libraries) with the added ability to compile to native code if you want to, and all open source under the GPL.
You can get all of IBM's JDKs here (Score:1, Informative)
Re:IBM Developer Kit: Tested Linux Distributions (Score:1)
Stefan
DevCounter [berlios.de] - An open, free & independent developer pool
created to help developers find other developers, help, testers and new project members.
Re:IBM Developer Kit: Tested Linux Distributions (Score:1, Interesting)
Comparison to Sun's Java? (Score:3, Interesting)
Any tables out there comparing the various Java Flavors?
Seems to me that Sun's Java is the most mature of the Java's, and that Sun engineers have the most experience with Java and therefore will probably create the best Java implementation.
Am I wrong?
Re:Comparison to Sun's Java? (Score:1)
Re:Comparison to Sun's Java? (Score:1, Interesting)
Sorry for claims without references, don't have time right now to research them out
D
Re:Comparison to Sun's Java? (Score:2)
I'm hoping for that at least..
Maybe Sun will get with the program and release a JDK/JRE compiled with a recent version of GCC.
Re:Comparison to Sun's Java? (Score:5, Interesting)
Re:Comparison to Sun's Java? (Score:2)
Computer Software Ideology (Score:2, Insightful)
I doubt it. Also Sun's technologies from Java to UltraSparc are well specified and designed so that their technologies are more open (standard) than open source, so we don't really have to go for Blackdown.
But from Computer Software Ideology stand point of view, it is nice to see that Java spec is well defined and has good license terms so that other vendors can implement their own version (production level quality right?) and distribute it legally and freely. That has been proved by Blackdown today.
Personally, I'd stick to Sun's Java (even though some claim that it's not best Java), but announcements like this makes Java even more attractive to me (than
NUMBERS: (Score:5, Interesting)
Here are some numbers for a test involving simply serializing one of the complete object trees of data using castor, in a loop executed 1000 times:
Sun JDK 'java version "1.3.1": (avg/3) 5.8s
Sun JDK 'java version "1.4.1_01"': (avg/3) 6.4s
Blackdown 'java version "1.4.1": (avg/3) 5.3s
Sending a message with the the above generated xml full cycle through the system (multiple threads of execution here, multiple database connections as well (pooled), passing data over soap, etc), looped 200 times took the following times: (again, avg.)
(sun 1.4.1): 44.2s
(sun 1.4.1): 44.6s
(bd 1.4.1): 41.4s
In both the coded test, and the real world situation, Blackdown's JDK outperformed Sun 1.4 and 1.3 jdks.
Re:NUMBERS: (Score:2, Interesting)
Re:NUMBERS: (Score:1)
Re:Comparison to Sun's Java? (Score:2, Informative)
Re:Comparison to Sun's Java? (Score:1)
(Disclaimer: I work for IBM on on their Java JIT compiler, and therefore cannot be trusted on this matter.)
good stuff from blackdown (Score:3, Interesting)
finally with the blackdown release the webstart icons will be integrated into the gnome desktop so the java app will launch just like a native app (is done this in windows for ages) our linux users will be so happy!!!!
i'm so pleased about this i just pissed my pants
Re:good stuff from blackdown (Score:1, Interesting)
The downloaded app doesn't have full access to your system resources (printer, network, loacl disks etc.) until you give it permission. So you can download random safe self-contained applications without worring about malicious authors. Each time you run the program it will (if the networks available) check the server for new versions, and automatically upgrade.
Can apt-get do either of these?
Re:good stuff from blackdown (Score:2)
Re:good stuff from blackdown (Score:1)
1) The idea behind JWS is that we're talking about end-user apps; i.e. things the user would run from their desktop; This would generally mean that the user is logged in and the security context is that of the user, and not nobody.
2) While you can run apt-get immediately before each run of the app, when you start a JWS app (which can appear as an icon on your desktop) will check all by its lonesome (if there is a network connection). If it finds an update, it performs an update without user intervention.
This is really, really choice to deploy apps across an enterprise.
Re:Heh (Score:1, Insightful)
Re:Heh (Score:1, Interesting)
The other way around (Score:1)
Re:The other way around (Score:1, Interesting)
Those developers who wanted a cross-platform solution would probably just use Sun's free kit rather than buying J++. In fact it's rather likely that most developers who think cross-platform applications are important are Unix users and couldn't use J++ anyway.
Re:The other way around (Score:4, Informative)
Re:The other way around (Score:2, Interesting)
Tell it to Sun and the Courts. The antitrust ruling against MS was based on the theory (that I don't subscribe to) that developers would develop a Java application on Windows using MS's extentions and be suddenly suprised it wasn't cross-platform. It wasn't about standard Java breaking on Windows.
If there are incompatibilities at the JVM level, it's probably because Sun wouldn't allow MS to update the JVM due to their dispute about J++. Now, of course, MS doesn't want to include Java at all which also pisses off Sun.
Re:The other way around (Score:2, Interesting)
You're off a little bit. It was about standard Java breaking on Windows, namely JDK 1.1. When Sun released JDK 1.1, the first non-toy version of Java, Microsoft decided that they would take bits and pieces of new JDK, but substitute their own incompatible pieces for the rest. The trademark fight, the first legal battle between Microsoft and Sun on the matter, was whether Microsoft could still call the result Java. The court said they couldn't. And so they called it J++.
For example, Microsoft refused to use JNI, using their own RNI instead. Of course, they claimed RNI was easier to use, and perhaps in some ways it was. However, it meant that if you wanted to integrate native code and support the Microsoft VM, you either had to do dual development, or code to MSVM only.
Interestingly, Apple has had their own native interface too, called JDirect, which was even easier than RNI. But they fully suppored JNI as well, and you could mix the two. (The interface has changed since then, but there are still dual-supported interfaces.)
Why didn't Microsoft take this approach if they really thought they could do better? That's the crux of the matter. Sun and others would argue that Microsoft was trying to break cross-platform Java. I would argue they have a point.
Re:The other way around (Score:2)
Tell it to Sun and the Courts. The antitrust ruling against MS was based on the theory (that I don't subscribe to) that developers would develop a Java application on Windows using MS's extentions and be suddenly suprised it wasn't cross-platform. It wasn't about standard Java breaking on Windows.
You are payed by MS?
The case was about standard jave programs not running on MS JVM.
If you do not know, Java has a standard way to bind C extensions into Java programs. The standard way is calledn JNI, the Java Native Interface.
Prgrams using JNI do not run(and can not compile to run, in case you are a nitpicker) under MS Java.
The same is true for RMI. The MS JVM does not support RMI per default. So a Java program using RMI looks at the first glance broken or Java lookd bad. However in case of RMI you at least could fix the problem by downloading and installing additional packages.
Not only did MS polute Java they also made sure that certain aspects of standrad Java did either not run at all or not run right out of the box. That is what the law case is about.
angel'o'sphere
Re:Heh (Score:2, Insightful)
from mobile-phones too mult-million dollar servers
on linux-bsd-windoze-solaris-osx-symbian-....
code compiled to JVM in hundreds of programming languages other than java
compile to native using gcj
use naitive widgets using SWT (think Eclipse)
full (no embrace extend) support for open standards
inclusive community based evolution through JCP
allows open source implementations
support from oracle, ibm, appache, nokia, motorola,
native java operating systems such as savaJe
java accelerated hardware components in modern cell phones
so where do you want to go today?
here are 160 languages for the standard java vm (Score:1, Flamebait)
Re:here are 160 languages for the standard java vm (Score:1)
Jtom
TOM is a term rewriting tool. The tool do not impose a fixed term representation, rather it accepts implementation of terms (or term like data types) of yet existing applications and it permits to define and execute rewriting rules upon those types.
iContract
iContract is a novel Java(tm) tool that provides developers with support for design by contract(tm). iContract is a freely available sourcecode pre-processor which instruments the code with checks for class invariants, pre- and postconditions that may be associated with methods in classes and interfaces. Special comment tags (e.g. @pre, @post) are interpreted by iContract and converted into assertion check code that is inserted into the sourcecode. The expressions are a superset of Java, compatible with a subset of the latest UML ``Object Constraint Language (OCL)''.
SubJava
SubJava is a pretranslator which enable one to use the following possibilities: operator overloading, functions, global constants and variables, implicit data type transformation.
The extensible Java pre-processor EPP
EPP is an extensible Java source-to-source pre-processor which can introduce new language features. The user can specify "EPP plug-ins" at the top of Java source code in order to incorporate various extension of Java. Emitted source codes can be compiled by ordinary Java compilers, can be debugged by ordinary Java debuggers. Plug-ins can extend the syntax of Java by extending the recursive descend parser in a differential manner. EPP can also be used as an application framework of source code manipulation tools such as source level optimizer, metrics tools, obfuscating tools.
JPP - A preprocessor for the Java language
JPP is a preprocessor that adds the following features to the Java language: 1.Block closures 2.Local variable renaming 3.Operator overloading 4.Assert and trace macros 5.Conditional compilation 6.Nested comments It does this by converting an input
Tcl
Jacl
Jacl, pronunced "Jackal", is a Tcl interpreter written in Java. You can use it for Java the same way Tcl is used for C -- a scripting language to glue together modules written in a low level language.
Tcl/Tk from Sun
Sun wanted to create a new business group called SunScript to support the growing Tcl community with an integrated development environment for Tcl and a suite of products that link Tcl with the Web and Java technologies. Meanwhile this seems to have moved to a company called Scriptics.
Functional programming
Aardappel
Aardappel is a new language, which computes by concurrently reducing trees (using a form of tree-rewriting) which sit together in tree-spaces (bags) and communicate amongst eachother (exchanging parts of themselves, in Linda-like fashion), and in general having a jolly good time alltogether. The language is 100% graphical. Oh yes, the language is linear as well.
Funnel
Funnel is a new programming language based on Functional Nets. Functional Nets combine key ideas of Functional Programming and Petri- Nets to yield a simple and general programming notation.
Mini
Mini is a very simple (half-functional) language written to test the ClassGen package of the JavaClass API.
PLAN - A Programming Language for Active Networks
PLAN is a resource-bounded functional programming language that uses a form of remote procedure call to realize active networking. PLAN is designed to be a public, authentication-free layer in the Active Network hierarchy. For this reason, we have limited the expressive power of PLAN in order to guarantee that all programs will terminate, thus reasonably permitting a router to run any PLAN program. However, PLAN can also be used as a "glue" layer which allows access to higher-level services.
Combinatory Logic Interpreter
An interpreter for the simplest language possible: both functions and data are represented by combinators, built up from S and K by application.
Lisp and co
SISC
SISC is an extensible Java based interpreter of the algorithmic language Scheme. SISC is a complete implementation of the language. The entire R5RS Scheme standard is supported. SISC can also interface with Java through a bridge module called J2S.
Lisp
A small Lisp implementation in Java
PS3I
PS3I, the Persistent Server-Side Scheme Interpreter, is a nearly R4RS-compliant Scheme implementation, written in Java, multi-users, multi- threaded and aimed to run on (Web-)servers (as servlets).
Scheme package
The scheme package is a Java library implementation of the scheme language. It is designed so that you can easily use it in a Java application or applet to make it extensible.
HotScheme
HotScheme is a Java-based interpreter for the Lisp dialect Scheme. It is intended as an exhibit of some of Java's power, a tool that schools can use to supply students with a Lisp interpreter, and, ultimately, an interactive Internet programming environment.
webLISP
webLISP is an experimental Implementation of reflective functional Programming. It contains a very simple Lexer and Parser for a lambda- calculus language in lisp-syntax. The Lambda terms are compiled to variablefree Combinator Graphs. The virtual Graph-Reduction-Machine that reduces the Combinator-graph distinguishes between strict and non-strict operations. Strict operations have to be evaluated even if we obey lazy evaluation and can thus be evaluated in parallel to the main computation. The parallel computations are added to a global task pool, which is maintained by a stochastic scheduler. In addition to this basic implemenation a special Combinator P is introduced which performs an asyncronous parallelism of two given applications.
Jaja
Jaja is an implementation of Scheme in Java.
JScheme
JScheme is a hybrid language formed by combining the core syntax of Scheme with the objects, methods, and lexical structure of Java.
Skij
Skij is a Scheme interpreter written in Java. Its strong points in comparision with other existing Scheme-in-Java implementations are its small size and its facilities for manipulating Java objects and controlling the Java environment. Skij includes extensions to Scheme that permit fully interactive dynamic invocation of methods on arbitrary Java objects; interfaces to threads and synchronization; and support for writing UI event callbacks in Scheme.Skij was designed to bring the hands-on interactive feel of Lisp programming to the Java environment, and its primary use is as a debugging, exploration, and scripting tool. It can also be used for application development where speed is not critical.
Kawa
Kawa (pronounced kava) is a compiler and run-time system for Scheme written completely in Java. It generates Java bytecodes using a "codegen" package which may be more generally useful. See also Byte-compilation of Scheme using Java byte-codes.
Jscheme 5.0
Jscheme is a dialect of Scheme with a very simple interface to Java. It implements all of R4RS Scheme except that continuations can only be used as escape procedures and strings are not mutable.
LispkitLISP Compiler
The LispkitLISP compiler is written in SECD byte-codes. It takes a LISP source file and compiles it into SECD byte-codes. The SECD virtual machine is used to execute both the compiler and the compiled programs.
Lambda Calculus Interpreter
A simple lambda calculus interpreter, using call-by-name semantics. The language is pretty much Church's simple untyped lambda calculus, the only concession for usefulness is the addition of numbers.
The UncommonLisp Interpreter
The interpreter contains a functionally complete set of Lisp primitives in less than two thousand lines of Java. It delegates the implementation of higher level Lisp functions to Lisp itself, thereby bootstrapping the interpreter to implement some of its own functionality.
Lisp Interpreter in Java
A Lisp interpreter by Russ Ethington
A Scheme Interpreter in Java
Lisp Interpreter in Java
Lisp interpreter in java, working. but quite alpha version.
uts, the Useless Toy Scheme
A Scheme bytecode interpreter, in a preliminary release. It's almost fully R4RS-compliant but otherwise minimal. It needs the Boehm garbage collector to run. In an earlier incarnation this was known as Plonk; there is an all-Scheme version, and a Java implementation of the bytecode interpreter part. It's known to not work right with JDK 1.1, and it will not be developed any further.
Basic
MaVerickBASIC
MaVerick is an Open Source Multivalue Database Management System. It includes MaVerickBASIC, a DataBasic compatible compiler.
CONVERT
With Convert 1.1 you can use your Visual Basic expertise to create high-powered, sophisticated Java Applets and Applications. Convert 1.1 is a GUI converter. Your VB screens are translated directly into Java Source code.
JBasic
JBasic is a (see note) embeddable BASIC interpreter written entirely in Java. JBasic is designed for scripting Java Beans at runtime. You can embed JBasic in any Java application, applet or bean using the JBasic Runtime Engine. (NOTE: I have received a mail from Mike Lehman referring to some legal stuff that this is not the first embeddable BASIC - if you care about such important notions...)
HotTEA - Basic written in Java
Mike Lehman's HotTEA is an implementation of the BASIC language written in Java.
JavaBasic
JavaBasic is a line command interpreter, loosely using the BASIC command set.
COCOA, the Java BASIC Interpreter
A simple BASIC interpreter written in Java. It's a primitive BASIC, uses line numbers, implements most of BASIC-80.
Note: I do not know why it uses the same name as the Cocoa Logo. Mitch.Berger@gs.com commented on that: "Java as in coffee, is for grown- ups. Basic 80 is a beginner's language, and Logo is aimed at kids. It is therefore unsurprising to me that each has a version named after a hot brown drink often given to children."
TRS-80 Model 1 BASIC Interpreter
The applet is an interpreter for TRS-80 Model 1 Level 2 BASIC. Note that it is a BASIC interpreter, not a TRS-80 emulator; thus, the hardware-specific commands (PEEK, POKE, etc.) do not work.
Applet Designer
Applet Designer is a Visual Basic add-in that converts new or existing VB applications into Java applets.
Logo
StarLogo
StarLogo is a programmable modeling environment for exploring the workings of decentralized systems -- systems that are organized without an organizer, coordinated without a coordinator. With StarLogo, you can model (and gain insights into) many real-life phenomena, such as bird flocks, traffic jams, ant colonies, and market economies. StarLogo is a specialized version of the Logo programming language. With traditional versions of Logo, you can create drawings and animations by giving commands to graphic "turtles" on the computer screen. StarLogo extends this idea by allowing you to control thousands of graphic turtles in parallel. In addition, StarLogo makes the turtles' world computationally active: you can write programs for thousands of "patches" that make up the turtles' environment. Turtles and patches can interact with one another -- for example, you can program the turtles to "sniff" around the world, and change their behaviors based on what they sense in the patches below.
AJLogo
AJLogo is an implementation of Logo written in Java with about 400 primitives.
Turtle Tracks
Turtle Tracks is a modern Logo interpreter and runtime environment written entirely in Java. It is not a direct port of an existing interpreter, but written from the ground up specifically for Java, and designed to take advantage of the strengths of Java as a platform. Turtle Tracks is platform-independent and Internet-ready, and supports numerous advanced features such as multithreading and networking. Unlike some similar Java-based projects, Turtle Tracks is a complete implementation of true Logo, supporting the same basic language syntax and semantics and most of the same primitives as other common Logo implementations such as Berkeley Logo. It also supports plug-in primitive sets and can be integrated with outside Java code as a scripting language.
rLogo
rLogo is an easy to learn programming language designed for the World Wide Web. It is based on the Logo programming language.
Yoyo
Yoyo is a programming language loosely based on Logo. Since it integrates Java, however, many of the more advanced features require knowledge of Java and how its APIs work. (Was formely called Bongo)
Logic programming
tuProlog
tuProlog (2P) is a Java-based light-weight Prolog interpreter (and related Java API) for systems engineering, suitable for open / dynamic environment such as Internet applications and infrastructures. 2P technology is an open-sourceproject.
PROLOG+CG
PROLOG+CG is a logic programming language that integrates PROLOG, Conceptual Graph, Object-oriented programming and JAVA
DGKS Prolog
A prolog interpreter written in Java with an IDE.
JLog
A Prolog interpreter in an applet.
JIP - Java Internet Prolog
JIP - Java Internet Prolog is a cross-platform PureJava100% prolog interpreter developed in JDK1.1 and supporting the prolog Edinburgh syntax. By its API you can call your predicates written in prolog in any java applet or application without dealing with JNI and, vice versa, you can invoke java methods in your prolog code as you call predicates.
NetProlog
NetProlog is a logic programming system that generates a binary code, executable in the Java Virtual Machine (JVM). It follows almost completely the syntax traditionally used in the ISO Prolog implementations. For each logic predicate is generated a corresponding Java class, which can be used as a regular code generated for the JVM by any means.
CKI Prolog
CKI Prolog is a small but fine prolog implementation, running under Java with less than optimal, but more than acceptable speed. It was designed to be compatible with Sicstus, SWI and any other prolog implementation. The current edition, beta4 , lacks floating point and DCG, and some (non-essential) predicates are not predefined. CKI prolog can handle operator notation, integer arithmetic, lists, cut and dynamic assert/retract.
JavaLog
JavaLog is a Prolog interpreter written in Java(tm) designed to allow easy integration between Java and Prolog.
Jinni
Jinni (Java INference engine and Networked Interactor) is a new, lightweight, pure logic programming language, intended to be used as a flexible scripting tool for gluing together knowledge processing components and Java objects in networked client/server applications and thin client environments. By supporting multiple threads, control mobility and inference processing, Jinni is well suited for quick prototyping of intelligent mobile agent programs.
LLPj
The language LLP is a logic programming language based on intuitionistic linear logic. LLP is a superset of Prolog and a subset of Lolli which is another linear logic programming language. We are developing LLPj: A LLP to Java translator system.
LL
LL is a Prolog like logic programming language. The documentation is in German.
W-Prolog
W-prolog is a simple Prolog interpreter written in Java. New version.
jProlog
jProlog is close to Clocksin-Mellish Prolog, with lots of the typical builtins.You need a Prolog system (SICStus, BinProlog, BIMprolog are ok - SWI doesn't work apparently)
JESS, the Java Expert System Shell
Jess is a clone of the popular CLIPS expert system shell written entirely in Java. With Jess, you can conveniently give your applets the ability to 'reason'.
javalog
Prolog in java(javalog) ver 0.02. To avoid paradox, javalog uses concept of world. You can make paradox in prolog. and extension, you can make truth server. The world of internet will be a single prolog interpreter. For data exchange, I used S expression. You can exchange also Lisp server.
see also:
MINERVA
Kiev
ML
currently empty
Eiffel
J-Eiffel - A Eiffel-to-Java compiler
J-Eiffel is a Eiffel compiler with JVM bytecode generation.
Project Bruce: Translating from Eiffel to Java
The project Bruce was a collaborative project between the Microsoft Research Institute at Macquarie University in Sydney, and Interactive Software Engineering (ISE) and aimed at developing an Eiffel to Java Compiler. ISE thought about generating Java Bytecode from EiffelBench.
Smalltalk
SmalltalkJVM
This compiler allows Smalltalk to run on any JVM. The compiler currently produces 100% Java class files fully compatible with the Sun JVM specification. This allows Smalltalk and Java code to interact seamlessly and allows Smalltalk programs to run anywhere Java runs.
Talks2
Talks2 is a full Smalltalk Development Environment which runs on top of the Java Virtual Machine. It comes with a ClassBrowser, Workspace, Transcript and all the things you know from a Smalltalk Development Environment. Talks2 translates Smalltalk to Java, and also uses the Java GUI and IO to run in any regular Java environment.
They have a strange Web-site which apparently can only be accessed with JavaScript enabled, so you have to click to Products and then to Talks2
Bistro
Bistro is a new programming language that integrates features of Smalltalk and Java. Bistro is a variation of Smalltalk that runs on top of any Java virtual machine (VM) that conforms to Sun's Java specifications. Bistro offers Smalltalk developers a means by which to reuse the models they built with Smalltalk. Bistro provides mechanisms for translating Smalltalk model code into Java, so that models originally built with Smalltalk may be deployed on and execute in a Java environment.
Various OO languages
Anvil
From the author: "Anvil is dynamically compiled, modular, procedural, object oriented and functional programming language with semi- dynamic semantics. It has runtime typing but, for efficiency reasons, static binding. It contains template engine for producing tagged output, configurable server environment and own HTTP listener. Any Java class can also be used directly. Anvil is non-interpreted: all scripts and templates are compiled-on-the-fly and executed as Java bytecode."
Ephedra
Ephedra is a C/C++ to Java migration tool. The tool reads C/C++ source code and transliterates it to Java source code. Though it can convert most kinds of C/C++ source code, the focus is on C/C++ libraries that do not use any or much GUI code. The goals of the transliteration are readability of the generated Java source code, easy integration and interfacing with native Java code, little or no user interaction during the transliteration process, good performance, and basic C++ support.
dSelf
dSelf is an extension to the delegation- and prototype-based object-oriented language SELF. It adds distributed objects and transparent remote reference resolution to the languages. As a consequence, dSelf facilitates distributed inheritance and instantiation mechanisms.
Hojo
Hojo (Higer-Order functions & JavaTM Objects) is an interpreted language, which provides a high-level, dynamic interface to the Java Virtual Machine (JVM) on which it is run. Hojo allows higer-order functions, contains full syntactical support for collections, maps and arbitrary-precision numbers, and provides a wide range of automatical type conversions, as well as some additional built-in operators. The lexical syntax of the language can be dynamically configured through a meta language, such that e.g. custom operators can be defined.
foo
Foo is a "new" language, and its interpreter. The main caracteristics are: Full object-orientation, Dynamic message, Written in Java, Full integration inside the JVM. It will be usefull to write small scripts and to build quickly a prototype, and it can be easily embedded inside any application.
Nice
Nice is a research programming language. It demonstrates how the powerfull ML-Sub type system can be used in practice. Nice is an object- oriented language, with parametric, polymorphic types, higher-order functions, and more. It mixes the advantages of object-orientation and functional programming.
Correlate
Correlate is a concurrent object-oriented language with a metalevel architecture that makes it easier to develop distributed programs
MetaJ
The goal of the MetaJ project is the development of a generic protocol-based self-applicative interpreter for Java. The basic idea is to develop a generic reification procedure which can be used to reify any class of the interpreter. Currently, we have defined a reification scheme and we have built a reflective interpreter from a non-reflective interpreter for an essential subset of Java.
Demeter/Java
Demeter/Java allows you to write your Java programs in a much more reusable form, called the adaptive form. You reuse all your Java knowledge and learn a design language on top of Java. The two important features of the design language are: Traversals and Visitors. Demeter/Java enforces correct use of the Visitor Design pattern in complex applications. The Visitor Design pattern is directly supported in the executable design language which is on top of Java.
Bolero
Bolero is based on Java architecture. Like Java, Bolero is strictly object-oriented. The Bolero Compiler generates Java byte code directly, rather than taking the detour via source code. This byte code can be ported across operating system boundaries, runs on any platform for which a certified JVM is available ("write once, run anywhere") and that is able to access a Bolero Application Server, and supports component-based applications with distributed or concurrent execution.
Sather
Sather is an object oriented language designed to be simple, efficient, safe, flexible and non-proprietary. One way of placing it in the "space of languages" is to say that it aims to be as efficient as C, C++, or Fortran, as elegant as and safer than Eiffel, and support higher-order functions and iteration abstraction as well as Common Lisp, CLU or Scheme. This compiler produces stand-alone applications.
C2J++
C2J++ is a C++ to Java translator that translates C++ code to Java code. C2J++ is based on Chris Laffra's C2J.
COBOL
PERCobol
PERCobolTM Enterprise Edition is a robust COBOL development solution enabling COBOL programs to execute on the Java Virtual Machine (JVM). PERCobol is a fully ANSI 1985 X3.23b standard compliant COBOL compiler which generates Java source code. The resulting Java source code can then be compiled using any JDK 1.1+ compliant Java Compiler and will run on any JDK 1.1+ implementation of the Java Virtual Machine as either an applet or application depending upon how the program is invoked (applets are subject to applet security restrictions).
Ada
Intermetrics' AppletMagic: Ada for the Java Virtual Machine
Intermetrics has created an alternative to the Java language for writing applets: a rich, tightly-standardized, dynamic object-oriented programming language named Ada 95, and a translator from Ada 95 to Java "Bytecodes". By translating Ada 95 to Bytecodes, we make it compatible with Java and Java-capable browsers.
JGNAT Ada 95
The JGNAT system offers a complete Ada 95 development environment for the Java platform. JGNAT comprises a compiler generating Java bytecode that is compatible with Java virtual machines conforming to Sun's standard (JDK 1.1 and above), and a set of tools to aid in developing Ada programs for the Java platform. (see also ftp://cs.nyu.edu/pub/gnat/jgnat/)
Scripting
JudoScript
JudoScript is a general-purpose, Java scripting, multi-domain language. It is a general-purpose programming language, fully capable of Java scripting, and supports many domain-specific features such as JDBC scripting, XML scripting, ActiveX scripting and many more.
JRuby
JRuby is the effort to recreate the Ruby interpreter in Java. Currently, the interpreter is written in C. The Java version will be tightly integrated with Java to allow both to script any Java class and to embed the interpreter into any Java application.
ObjectScript
ObjectScript is a weakly-typed general purpose object-oriented programming language. It provides private fields and methods, inheritance, exceptions, synchronization and threading, nested functions and classes (nested scope), and operator overloading.
Jickle - Java Control Language
Jickle is a language and runtime environment that allows applications to provide unlimited user control. Jickle is similar to a macro language for applications.
Yoix
An interpreted C-like scripting language written in standard Java that provides a high-level way to write applications that use AWT, Swing, Java-2D, sockets, threads or other Java features. Familiar C language elements such as printf, scanf and (safe) pointers aim at making this language easy to learn and use.
Simkin
Simkin is a high-level lightweight embeddable scripting language which works with Java[tm]/XML or C++.T
Bean Scripting Framework (BSF)
The Bean Scripting Framework (BSF) is an architecture for incorporating scripting into Java applications and applets.
Dawn
Dawn is a dynamic scripting language based on RPN, supporting dynamic naming to create variable and methods names from String, scripts can dynamically override language default functions and the language is based on a package set, with default ones io, err, loops, test, util, math, stack, string
DynamicJava
DynamicJava is a Java source interpreter executing programs written in Java in addition with scripting features. DynamicJava extends the Java grammar to accept many scripting features: Statements and expressions can be written outside classes, at the top-level. The variable declaration is optional. When the left part of an assignment is an unknown identifier, a variable is defined. The type of this variable is the type of the right part of the assignment. The dynamic casts are optional. The package clause can be used anywhere at the top-levelto set the current package. The syntax of this clause has been extended : writing package; set the current package to the anonymous package.
W4F
W4F is a toolkit for the generation of wrappers for Web sources. It consists of a retrieval language to identify Web sources, a declarative extraction language (HEL: HTML Extraction Language) to express robust extraction rules and a mapping interface to export the extracted information into some user-defined data-structures.
Netscript
NetScript is an environment for scripting with network components. The NetScript environment's scripting language, which is an extension of the BASIC programming language, is deliberately kept simple, so the scripts are relatively easy to write and modify. In NetScript, a developer selects required components from a distributed catalog and then writes a script invoking methods on the components as if the components are local. When a script is launched, the NetScript run time determines component sites in the network and transparently moves the script as needed.
Rhino
Rhino is an implementation of JavaScript written entirely in Java. The source code for Rhino is available under the NPL. e Rhino project was started at Netscape in Fall 1997. At the time, Netscape was planning to produce a version of Navigator written entirely in Java and so it needed an implementation of JavaScript written in Java. When Netscape stopped work on "Javagator", as it was called, somehow Rhino escaped the axe (rumor had it that the executives "forgot" it existed). Since then, a couple of major companies (including Sun) have licensed Rhino for use in their products and paid Netscape to do so, allowing us to continue work on it. Now Rhino is planned to be part of several server products from Netscape as well.
BeanShell
BeanShell is a small, free, embeddable, Java source interpreter with object scripting language features, written in Java. BeanShell executes standard Java statements and expressions, in addition to obvious scripting commands and syntax.
PolyJsp
PolyJsp is an extensible JSP implementation designed to support multiple scripting languages and multiple JSP versions. Completely based on XML and XSL, PolyJsp currently supports Java and Javascript as scripting languages. Support is provided for the latest JSP spec (0.92), with version 0.91 in the works.
Resin
Resin weaves Java components to HTML with JavaScript and the Java Server Pages (JSP) interface. Resin conforms to the Servlet interface and can be used with the major web servers, including Apache. Amongst other features, it implements the bulk of ECMA-262, the EcmaScript standard, implements JavaScript 1.3 features, extends regular expressions with Perl 5 syntax and compiles scripts directly to JVM bytecodes.
Iava
Iava is an interpreter that accepts a subset of the Java programming language which includes method declarations, all block statements, all statements and all expressions as specified by the Java language. The interpreter does not accept class or interface declarations. Iava is written in Java and can be embedded into any Java application and applet. It offers highly effective integration mechanisms (sharing of private fields between classes and scripts), declaration of "methods" in a script which can be invoced by the embedding application/applet, sharing of a "context" object to which scripts can refer to using "this", etc.
WebL
WebL (pronounced "webble") is a scripting language for automating tasks on the World-Wide Web. It is an imperative, interpreted language that has built-in support for common web protocols like HTTP and FTP, and popular data types like HTML and XML.
FESI, a Free EcmaScript Interpreter
FESI is a full implementation of the EcmaScript language, defined in the standard ECMA 262 available at http://www.ecma.ch (edition of june 97). EcmaScript is largely equivalent to the JavaScript language version 1.1 or to the core part of JScript, but without the navigator specific extensions.
iScript
iScript a platform independent scripting language written entirely in JavaTM for creating scalable server side object oriented n-Tier enterprise solutions.
Jython
Jython is an implementation of the high-level, dynamic, object-oriented language Python written in 100% Pure Java, and seamlessly integrated with the Java platform. It thus allows you to run Python on any Java platform. Jython is the successor to JPython.
Pnuts
Pnuts is a script language for Java environment. It enables interaction with Java environment, simple GUI scripting, and customization for Java programs.
Yassl
Yassl is yet another extensible scripting language to work with Java classes. Yassl is a non object oriented language with a syntax that looks somewhat like C. Some of its features: Functions are available as regular types, and can be passed around and embedded in widgets. Implements lexical scoping, stolen from Scheme. Variables are typed (but at this point, the interpreter does no static type checking.) Eval is not directly supported, but an instance of a Yassl interpreter can be created from within a Yassl script, and you can evaluate expressions in the context of the new interpreter instance.
see also:
The NetRexx Language
Extended Java
JMatch
The JMatch language extends Java with support for abstract iterable pattern matching: a mechanism for pattern matching that is compatible with the data abstraction features of Java and also makes iteration abstractions convenient to use and to implement. JMatch provides abstract pattern matching; patterns are not tied to algebraic data constructors as in ML. A single JMatch method may be used in several modes that may share a common implementation as a boolean formula. JMatch provides modal abstraction that simplifies the specification and implementation of abstract data types. JMatch also makes the specification, implementation, and use of iteration abstractions convenient, by automatically finding multiple solutions to a formula or pattern.
Javassist
Javassist (Java programming assistant) is a load-time reflective system for Java. It is a class library for editing bytecodes in Java; it enables Java programs to define a new class at runtime and to modify a class file when the JVM loads it. Unlike other similar systems, Javassist provides source-level abstraction; programmers can modify a class file without detailed knowledge of the Java bytecode.
Jiazzi
Jiazzi adds support for large-scale component programming in Java. Components in Jiazzi contain, import, and export Java classes and Java's in-language support for inheritance can be used across component boundaries. The current implementation integrates into Java using a linker, which manipulates components, and a stub generator, which allows Jiazzi to be used with normal Java source compilers. JJava code for a component is written using the normal Java language and a separate linking language is used to manipulate components.
ArchJava
Software architecture describes the structure of a system, enabling more effective design, program understanding, and formal analysis. ArchJava is an extension to Java that seamlessly unifies software architecture with implementation, ensuring that the implementation conforms to architectural constraints.
MultiJava
MultiJava is an extension to the Java programming language that adds open classes and symmetric multiple dispatch. MultiJava retains the modular static typechecking and compilation of Java.
Gilgul
Gilgul is an extension of Java that strictly separates the notions of reference and comparison that are traditionally subsumed in the concept of object identity. This allows for the introduction of new operations that open up new degrees of flexibility during runtime by providing means for unanticipated software evolution. For example, Gilgul supports dynamic replacement of objects without the need to explicitly deal with existing references.
dejay
Dejay is a dialect of Java that simplifies the development of distributed software applications.
Guarana
Guaraná is a reflective architecture that aims at simplicity, flexibility, security and reuse of meta-level code. It features a run-time meta- object protocol that provides for easy composition of meta-objects and allows for dynamic reconfiguration. Meta-objects can be combined through composers, that provide the glue code for them to work together, delegating control to them and resolving conflicts when they arise. Since composers are meta-objects, they can be further composed.
AspectJ
AspectJ is an aspect-oriented extension to Java designed to simplify the development and maintenance of a wide range of applications. AspectJ extends Java with aspects, which are a new kind of programming construct that facilitates the implementation of concerns that cross- cut a system.
PolyJ - Java with Parameterized Types
PolyJ is a portable compiler that accepts an extended version of the Java language. The PolyJ language includes support for generic programming in the form of parameterized types. Like some other proposals for adding genericity to Java, PolyJ provides constrained parametric polymorphism. Unlike some, it uses the constraint mechanism of where clauses, which is important because it provides flexibility when composing a program. PolyJ also allows all types to be used as parameters, even basic types like int. A powerful feature of PolyJ is that instantiation types and parameter types are first-class types that may be used wherever a type may be used -- particularly, in safe run-time casts and with "instanceof".
xkjc
xkjc provides various Java language extensions, operator overloading, and embedded SQL. It is an example for the extensibility of the KJC compiler suite.
Jass - 'Java with assertions'
The language Jass ('Java with assertions') is an extension of Java by assertions. This concept is taken from Eiffel. It has been developed by Bertrand Meyer as part of the concept "design by contract" in order to develop correct software. For this purpose the assertions are checked during runtime. If they are violated, exceptions are triggered which can themselves be handled in the program.
Borneo
Borneo is a dialect of the Java language designed to have true support for the IEEE 754 floating point standard. Java's specification creates several problems for numerical computation. Only a proper subset of IEEE 754's required features are supported by Java; useful IEEE 754 features are either explicitly forbidden or omitted from the Java specification. Java does not allow use of the IEEE 754 recommended double extended format on the x86. Using the double extended format often protects simple numerical formulas from floating point anomalies. Strict adherence to Java's floating point semantics leads to significant performance penalties on popular architectures, including both the x86 and PowerPC. To address these problems, the Borneo language changes and extends Java so that all IEEE 754 features can be expressed and so that new numeric types can be easily created.
Specialization classes for Java
Specialization classes are a Java language extension for integrating forms of adaptive behavior in an existing program. An adaptive class is defined by attaching a number of alternative implementations to a regular Java class, that complement the existing, default implementation. Each alternative implementation is defined by a specialization class, and is to be used in some specific situation. These situations are defined in terms of the internal state of the (instances of the) class, via predicates on the instance variables.
Poor Man's Genericity for Java
Poor Man's Genericity is an implementation of parameterized classes (constrained parametric polymorphism) for Java. It is based on a "lowest common denominator" design that can be implemented easily on top of any existing Java compiler. We have implemented a fully working compiler that has been built by reusing Sun's Java compiler almost without modifications: only the way in which source and byte- code files are loaded was changed to perform simple transformations on loaded files.
GJ
GJ is an extension of the Java programming language that supports generic types. GJ compiles into JVM code, so GJ programs run on any Java platform, including Java compliant browsers. Class files produced by the GJ compiler can be freely mixed with those produced by other Java compilers.
Jamie
Jamie is a preprocessor for Java that fills the gap between interfaces and multiple inheritance. Jamie doesn't give you multiple inheritance, though; it gives you multiple delegation (i.e., it gives you subclassing without subtyping). Jamie is a preprocessor that automates delegation. You run it on your code, and it essentially produces the Java code you otherwise would have had to write yourself.
Scriptic
Scriptic is a language extension that simplifies Java programming. Scriptic includes the following: Simple and concise constructs for expressing choice, parallelism, breaking, and iterations. Simply write an ampersand instead of a semicolon: you will get parallelism instead of a sequence, etc. Easy access to multi-threading: Java code between {* and *} simply runs in its own thread A refinement construct (script) with a powerful parameter mechanism Communication between parallel processes using shared scripts An event-driven execution mechanism that ideally suits user interfaces, simulations, and others Scriptic has a strong theoretical background in Process Algebra. This foundation means that the language constructs for parallelism are well-defined.
OpenJava
OpenJava is an extensible language based on Java(TM). The OpenJava MOP (Metaobject Protocol) is the extension interface of the language. Through the MOP, the programmers can customize the language to implement a new language mechanism. It is fully written in Java of JDK 1.1, so it can be run on any platform which supports Java Virtual Machine of JDK 1.1. And, the generated codes are written in regular Java language, so the user's products can be run on any platform which supports JVM of JDK 1.0 or JDK 1.1.
Kiev
Here is the authors description: "Kiev is an extension of Java language with parametriezed types, closures, multimethods, multiple inheritance, extended syntax and semantic of loop and switch statements and more. It also has an embedded, fully integrated AI engine."
JavaParty
JavaParty is an extension of Java for transparent parallel and distributed programming with remote objects and object mobility. It can be pre- processed into regular Java plus RMI calls.
JAVAR
JAVAR is a prototype restructuring compiler that can be used to make implicit parallelism in Java programs explicit by means of multi- threading. JAVAR relies completely on the identification of `implicit' parallelism by means of annotations.
JAVAB
JAVAB is a prototype bytecode tool that can automatically detect and automatically exploit implicit loop parallelism in bytecode, i.e. the architectural neutral instructions of the JVM. Implicit parallelism is made explicit by means of the multi-threading mechanism provided by the JVM.
Pizza
Pizza is an extension of Java with parametric polymorphism, first-class functions, and class cases and pattern matching. Pizza compiles programs to ordinary Java Byte Code, and interfaces with existing Java code.
Forth
myForth
myForth is a basic Forth interpreter written in Java. Forth programs can be read from Java Applet parameters.
A Forth Interpreter in Java
A Forth interpreter implemented in Java
Delta Forth
DELTA Forth is a new Forth dialect and is intended to bring the Forth programming language to the Java world. Unlike Forth, DELTA Forth is a compiled language. This means that the source code is turned into a special format that is used to execute the program.
FIJI - ForthIsh Java Interpreter
FIJI ForthIsh Java Interpreter, is written in Java and comes with full GPL'ed source. Running either at a command line or in an AWT window, FIJI accepts a syntax akin to the Forth programming language and uses a reference stack to push and pop all params to its functions. You can create Java objects and call methods on them from the FIJI stack. FIJI is very preliminary, quite incomplete and will be changing all the time. But such as it is, it works and has been tested on Linux Blackdown JVM 1.1.7a, VM/ESA JVM 1.1.4, and Windows/Sun JVM 1.1.7a.
Misty Beach Forth
Misty Beach Forth is an implementation of the Forth programming language written in Java. Because it is written in Java, the Misty Beach Forth interpreter can be embedded in a WWW HTML page and launched as an applet.
Various languages
FormsWizard
FormsWizard is an automated migration engine that translates Oracle Forms source code (PL/SQL) into Java language. It allows companies and organisations to bring legacy software to the web and achieve great savings compared to the cost of rewriting applications.
Zigzag
Zigzag is language of object-relational algebra for database and data processing applications. Zigzag expressions reflect peculiarities of Zigzag ORDBMS like multilevel and multi-valued attributes, data integrity control, class inheritance, generalization (generation of knowledge base).
Pipes for NetRexx and Java
Pipes for NetRexx and Java implements a simple but very powerful piping methodology based on the one developed by John P. Hartmann of IBM.
XSLTC
The XSLT Compiler is a Java-based tool for compiling XSLT stylesheets into lightweight and portable Java byte codes called translets.
Component Pascal
Gardens Point Component Pascal (gpcp) is an implementation of the Component Pascal Language. Component Pascal is Oberon microsystems' refinement of the Oberon-2 language. Component Pascal is a general-purpose language in the tradition of Pascal, Modula-2 and Oberon. Its most important features are block structure, modularity, separate compilation, static typing with strong type checking (also across module boundaries), type extension with methods, dynamic loading of modules, and garbage collection.
JOMP
JOMP is a research project whose goal is to define and implement an OpenMP-like set of directives and library routines for shared memory parallel programming in Java. The compiler translates Java source code with directives to Java source code with calls to the runtime library, which in turn uses Java threads to implement parallelism.
Java Backend for GCC
A port of the GNU GCC compiler to the Java Virtual Machine (JVM). Gcc emits assembler code (usually that fact is hidden from the user); this port uses Jasmin as the "Java assembler". This software is highly experimental.
Tea
Tea is a simple template language most commonly used for creating dynamic web pages in the TeaServlet. Tea is a strongly typed, compiled programming language, designed to work within a Java-based hosting environment. Tea is designed to enforce a separation between data acquistion and presentation, without sacrificing basic programming constructs.
Tiger
Tiger is an example language from the book Modern Compiler Implementation in Java by Andrew W. Appel
perljvm
perljvm, the Perl to Java Virtual Machine (JVM) Compiler tries to support the Perl language natively on the JVM without needing the C perl system around.
Fortran 2 Java (f2j)
f2j is part of a broader effort to provide computational resources over the World Wide Web. The f2j project has two facets. One is to emit as much compilable, verifiable, correctly running Java source from Fortran source code, the other is to translate Fortran to Jasmin assembler opcode for assembly into class files. The f2j compiler is currently a special purpose tool, that is, certain design decisions necessary to provide a general tool for translating Fortran to Java have been postponed until working code for the BLAS and LAPACK libraries has been emitted and tested.
C2J
C2J is a translator which translates C programs to Java programs. C2J is available as native executable for Win32 platforms as well as Java application which runs where Java Virtual Machine is implemented (i.e. on Win32, Unix etc.). Standard ANSI C runtime library fully supported. ANSI C and K"R C fully supported.
JAMES 007
JAMES 007 is an graphical editor for Message Sequence Charts. It aids in developing textual, but also graphical representations of MSCs. Its special benefit is the generation of JAVA-Sourcecode for a MSCs.
Java Information Flow
Andrew Myers' JIF (Java Information Flow) language provides language-based information flow control with mostly-static checking. Programs written in JIF can run on a standard JVM, but the system requires certain runtime components to provide full functionality. The goal of this project is to design and implement the principals hierarchy, I/O channels, and other runtime components required by the JIF system.
COCO/R
Coco/R is a compiler generator which takes a compiler description in the form of an LL(1) attributed grammar and generates the scanner and the parser of the described parser.
DB/C JX
DB/C JX is a Java-based application development tool that compiles the DB/C programming language into Java class files. DB/C is an application development tool for the DB/C programming language which is based on the ANSI Standard PL/B programming language. The Java class files created by the DB/C JX compiler will run in an Java 1.1 runtime environment, including web browsers, network computers, handheld computers and traditional data processing platforms.
Jcon: A Java-Based Icon Implementation
Jcon is a Java-based implementation of the Icon programming language. The Jcon translator, written in Icon, generates Java class files that execute in conjunction with a run-time system written in Java.
SQLJ - Embedded SQL in Java
The term "SQLJ" refers to a series of specifications for ways to use the Java TM programming language with SQL. The specifications are in several parts: SQLJ: Embedded SQL - Specifications for embedding SQL statements in Java methods. SQLJ: SQL Routines - Specifications for calling Java static methods as SQL stored procedures and user-defined functions. SQLJ: SQL Types - Specifications for using Java classes as SQL user-defined datatypes. A reference implementation of SQLJ has been provided by Oracle.
Canterbury Pascal for Java
The compiler is implemented in Java and generates plain Java. The evaluation versions is time-limited and has some language restrictions. An unrestricted version can now be ordered.
Canterbury Oberon-2 for Java
The compiler is implemented in Java and generates plain Java. The evaluation versions is time-limited and has some language restrictions. An unrestricted version can now be ordered.
Canterbury Modula-2 for Java
The compiler is implemented in Java and generates plain Java. The evaluation versions is time-limited and has some language restrictions. An unrestricted version can now be ordered.
AgentSheets
The AgentSheets environment is an agent-based Web authoring tool enabling a wide range of end users, ranging from children to professionals, to create their own SimCity-like interactive simulations, domain-oriented visual programming languages, knowbots, cellular automata, and games. At the the blink of an eye these simulations can be compiled by the Ristretto compiler directly into Java applets that can be embedded into web pages.
JavAnimator
JavAnimator is an animation applet generator for the Java VM written entirely in Concurrent Clean, a functional language developed at the Research Institute for Declarative Systems of the University of Nijmegen. You can use JavAnimator to boost your WWW pages with impressive animated applets.
Luck
Luck is a simple language which is compiled into Java code. Newest version 3.0
JOI - The Java Occam Interpreter
JOI is an Occam interpretation system coupled with a compiler that produces Jasmin based assembly language ready to be converted to Java byte code.
Agora98
Agora98 is implemented in Java and allows full access to the underlying Java structures. This means that you are programming in your webbrowser in Agora, and that you can dynamically access all the API's of Java, and the entire Agora interpreter itself.
Java Expressions Library
JEL is a library for evaluating a simple single line expressions in Java. JEL compiles expressions directly to Java bytecodes, allowing their fast evaluation.
MINERVA
MINERVA is a declarative language that inherits and combines the advantages of Java and Prolog, resulting in a very practical tool. MINERVA is implemented in Java and provides the core functionality of ISO/IEC 13211-1.
The E programming language
E is a programming language designed for developers who write distributed applications. It builds on the strength of Sun's Java language, an open standard that already provides some flexibility for developers writing World Wide Web applets. The E language improves on Java's security model and provides other powerful communications-oriented features. These include: distributed communication, capability semantics, optimistic computation.
The NetRexx Language
NetRexx is a new programming language derived from both Rexx and Java(tm), written by the inventor of Rexx, Mike Cowlishaw. The rules of syntax closely follow those of Rexx, while the semantics often follow Java. It is a dialect of Rexx that can be as efficient and portable as Java, while preserving the low threshold to learning of the original Rexx language.
See also Visual NetRexx as an IDE for NetRexx.
BAMBOO Home Page
BAMBOO Language is a custmizable syntax, procedural programming, interpreted, multi-process-executed, GUI/telephony/database/ network/mail programming supported language.
Assemblers
Javaa
The Java Bytecode Assembler is a program that converts code written in "Java Assembly Language" into a valid Java
Jasmin
Jasmin is a Java Assembler Interface. It takes ASCII descriptions for Java classes, written in a simple assembler-like syntax and using the Java Virtual Machine instruction set. It converts them into binary Java class files suitable for loading into a Java interpreter. Jasmin was written as the companion to the book "Java Virtual Machine", soon to be published by O'Reilly, written by Troy Downing and Jonathan Meyer.
Jas
A java bytecode assembler. Java bytecode can be generated either through a script which drives the assembler package, or directly accessing the assembler package from java. The assembler package is very simple, it attempts neither validation nor optimization of bytecode
Re:Heh (Score:2)
How about going back to the days when software wasn't bloatware and you didn't need a 3GHz room heater to run software with a decent snap to it?
Re:Heh (Score:1)
Re:Heh (Score:1)
Finally! A JDK compiled with GCC 3.2! (Score:4, Interesting)
Re:is Sun's JVM written in C or C++? (Score:1)
Re:Finally! A JDK compiled with GCC 3.2! (Score:2)
I rather use Apple's jdk tyvm
Re:Finally! A JDK compiled with GCC 3.2! (Score:2, Informative)
they already have a superior option (Score:3, Informative)
awesome server side JVM
Re:they already have a superior option (Score:1)
Seriously, if I see things correctly, this is a different beast altogether, running on server side. The beauty of Java applets is that you can run your code on client machines, offloading the server. If I wanted to run programs on my server I would go native anyway, but that may just be because I don't like Java.
---
"UNIX was not designed to stop you from doing stupid things, because that
would also stop you from doing clever things."
--Doug Gwyn
Re:they already have a superior option (Score:1)
The main users of Java are indeed server side. Native applications are great if you're talking about Infrastructure-level usage. Applications like email, webserving, fileserving, etc are so fundamental that implementing them in Java is a waste of time. However, implementing Business Foo's web application natively is usually not a good idea. Modeling business process in software is a painstaking task, in part because of the enormity of the task, and in part because it's always subject to change. Changing native code to match business process sucks compared to Changing java or (insert scripting language here).
Applications like Ebay, google, or perhaps Amazon do not change nearly as much, and as such can be (and are) better implemented natively.
But how's it diffrent ? (Score:2, Interesting)
What about PPC ? (Score:2)
Blackdown is what I've been using for 1.3 java, I can only pray they have a PPC one in the works (with a JIT compiler would be great as well!!)
Anyone have information on this?
--Zuchini
FreeBSD, anyone? (Score:2)