programming requires a time-predictable standard library.
to simplify means to eliminate the unnecessary so that the
necessary may speak."
Hofmann, Introduction to the
Javolution real-time goals are simple: To make your application faster and more time predictable!
That being accomplished through:
- High performance and time-deterministic (real-time)
xml base classes.
Javolution is the first library to provide fractal-based implementation of common
classes. For small size the performance is on-par with standard implementations, but for larger size
the difference is significant.
- Context programming
in order to achieve true separation of concerns (logging, performance, etc).
- A testing framework
addressing not only unit tests but also performance and regression tests as well.
- Straightforward and low-level parallel computing capabilities
- Struct and
Union base classes for
direct interfacing with native applications (e.g. C/C++).
- World's fastest and first hard real-time XML marshalling/unmarshalling
- Simple yet flexible configuration management
of your application.
- Javolution makes it easy to port any Java application
to C++ for native compilation (maven based) or to write Java-Like code directly in C++
(see Javolution C++ Overview).
- Javolution classes
are simple to use, even simpler than most JDK classes.
You don't need to guess the capacity of a
FastTable or a
size expand gently without ever incurring expensive resize/copy or rehash
- Developers may achieve true separation of
concerns (e.g. logging, configuration) through Context Programming
or by using classes such as Configurable.
- Javolution classes
are fast, very fast (e.g. Text
O[Log(n)] instead of
O[n] for standard
- All Javolution
classes are hard real-time compliant and have highly deterministic
behavior (in the microsecond range). Furthermore (unlike the standard
library), Javolution is
RTSJ safe (no memory clash or
memory leak when used with Java Real-Time extension).
- Javolution makes it easy for
to take advantage of multi-processors systems.
- Javolution's real-time collection classes
can be used in place of most standard collection classes and provide
numerous additional capabilities.
- Any Java class can be
XML format in any
form you may want, also no need to implement Serializable or for the
platform to support serialization
provides Struct and
Union classes for
direct interoperability with C/C++ applications.
- Most Javolution classes are stateless (state passed through parameters to methods or
available through context classes).
There is no static instance, orchestration classes (the high level classes holding the state) are typically created on-demand and recyclable.
This design approach makes Javolution and any product based on Javolution highly parrallelizable with no need for synchronization.
- Javolution can be either a Pure
Java Solution or a Pure Native Solution, small (less than 300 KBytes jar
file) and free; permission to use, copy, modify, and distribute
this software is freely granted, provided that copyright notices are preserved
The simplest way to use Javolution is through Maven
with the following dependency in your POM.xml
The native dynamic library (.dll or .so) is generated from the sources using the Maven Native Plugin
Released artifacts are available from the maven central repository,
snapshots are deployed to the java.net repository
|The standard Java distribution is an OSGi bundle
which can also be used as standalone Java library. The C++ distribution includes a port of standard Java classes, Javolution
classes, OSGi and JUnit. Below
is the table of correspondance between the Java packages and Javolution C++ namespaces.
|C++ Port Comments/Limitations
||Includes Thread, Class<T>, Enum<T> etc.
||Holds standard Java interfaces and Javolution implementations: FastMap<T>, FastTable<T>, FastSet<T> etc
||Also provides an embedded OSGi runtime (light).
||Usage examples are provided with Javolution source distribution (module test-cpp)
Developpers may download the
test-cpp maven submodule which illustrates the use of OSGi and JUnit in C++
Both libraries (Java and C++) provide benchmark tests.
Here are the Java benchmark results and
here are the C++ native test results.
Environment: Any (Android, J2SE, Native Windows/Linux/Solaris)
Compilers: All (including Visual C++, GCC, SOLARIS Studio)
Build tool: Maven
development, comments, issues, bug reporting).
Coding Standard Addendum.
Eclipse (UTF-8 Encoding)
- Eclipse plug-in to generate xml formats
from source code.
(questions/comments can be sent directly to the javoclipse
Colapi - Maven Plugin to format/colorize Java code in API documentation.
|Articles related to
Javolution (previously known as: J.A.D.E. Java
Addition to Default Environment):
Known projects using Javolution:
Known projects having a C++ port of their Java library or specifications based on Javolution:
- Resoa - Open Source project for SOA & Cloud computing
JScience - Java Tools and Libraries for the Advancement of Sciences.
- Glimworm - I.T. Firefly CMS Product
- ALMWorks - Bug-tracking systems, Deskzilla and JIRA Client.
- Open For Business - Open source enterprise automation software project.
- RADlab - Similator for radiation detection and measurement experiments.
- jgame - Real-time and embedded gaming API.
- MathEclipse - A symbolic mathematics engine written in Java.
- JRoboOp - Java package for robotics simulation with visualization of a 3D robot model.
- JMulTi - Time Series Analysis with Java.
- JStatCom - A Software Framework for Data Based Analysis.
- OVal - Object Validation Framework.
(Let us know if your project uses Javolution
and you would like it to be listed here)
- OSGi - Included in Javolution core distribution
- JUnit - Included in Javolution core distribution
Javolution's users can also show their
support with the "Powered By Javolution" button:
this is of course
- Februar 3, 2013: Javolution 6.0.0-SNAPSHOT
First glimpse to the first fractal collection (FastTable), others fractal
classes (TextBuilder, FastMap) coming soon...
- September 16, 2012: Javolution 6.0.0-SNAPSHOT
This release makes it easy for Java developers to translate their Java code to C++
or to write Java-Like C++ code without knowledge of the C++ intricacies.
- Your Java-Like C++ code is robust, multi-platforms (Windows/Linux/Solaris) and
can take advantage of any Java library which has already been ported.
- Your code can still interface directly with existing C/C++ libraries (no JNI required)
- Your native application exhibits nice real-time characterics. For example, there is
no GC pause, the base class javolution::lang::Object uses intrinsic (atomic) counters to
release memory when instances are dereferenced (intrusive smart pointer).
- You can write OSGi bundles in C++ and execute them using the light OSGi runtime provided.
- Memory allocation/deallocation for small objects is optimized and fast (on a par with Java)
- A single build tool (Maven) can be used for all your compilation needs (Java or C++)
- May 6, 2007: Javolution 5.0
Major Relase! Here are the most important changes:
- Separation of concerns: Two new
contexts have been added, the
and the SecurityContext.
PoolContext (too generic) has been replaced by the
implementation can be based on thread-local queues (default) or
RealtimeObject base class is superceeded by
the Realtime interface.
- New ValueType interface for
immutable objects which can be referenced by copy and can always be allocated
on the "stack"!
- New ArrayFactory to
allocates/recycle variable sizes arrays. "Stack" allocation is independent
from the array's size and significantly faster than "heap" allocation.
- September 18, 2006: Javolution 4.0
Classes renamed as per coding standard (e.g. XmlFormat => XMLFormat) [4.0.0]
- May 1, 2006: Javolution 3.7
Javolution is now the first library to be fully integrated with
the RTSJ Memory Model. If any container (collection, context, etc.)
is allocated in a non-heap memory area and its capacity increases,
the extension part is allocated in the same memory area
(see also Reusable) [3.7.0]
- September 26, 2005: Javolution 3.6
- March 3, 2005: Javolution 3.0
- October 4, 2004: Javolution 1.0
Spin-off of Java Addition
to Default Environment [1.0.0]