Reviews (1-25 of 25)
At this point, I am very impressed. There was a learning curve to understand GraalVM, the polyglot features, and native-compiles. Pluralsight has a good fundamentals overview. The home site for GraalVM has a number of good "getting started" guides.
The areas that we are seeing major impacts in are software size, load time, and cold start time. These are critical benefits as we try to minimize the size of our containers and reduce cold-start time. The end result is more container services can be deployed with the same hardware. This could have a significant financial benefit over running code in a JVM.
We are also investigating the Polyglot features, such as running Node.js and Python in GraalVM. The ability to combine Java and Node.js could present some interesting features to combine the best of our libraries.
In my opinion, this product and technology will significantly improve the performance and footprint of Java-based containers to serverless containers, Kubernetes, and OpenShift.
- Reducing software cold start time
- AOT--Native compile, which removes the dependency on the JRE and JVM
- Reduces application size. Combining native-compile and EXE compression significantly reduces the size of our containers
- Native compiles. We have problems figuring out how to package jars with all dependencies for compilation. This might be our problem as we progress through the learning curve.
- More support and testing for Sprint and GraalVM.
- I recommend providing installer packages instead of downloading zip files.
- Reduced application size.
- Faster cold start, which improves HTTP request/response-based software.
- Native compiles dramatically simplifies building and deploying Java-based containers.
- Native compiles often significantly improves application performance.
- Polygot language supports
- Better performance
- Interoperability with different languages
- Native images can be created
- Reactive support is not available
- Issue of Dependency Injection while dealing with non-Java Technology
- No support to Node.js
- Still needs lots of trial and error to workout
- Supports multiple languages on a single virtual machine
- Eliminates any foreign language execution overhead
- Enterprise edition with professional support is available
- It is quite new product on the market and it feels not completely mature
- We were getting rather big memory footprints when using it with Kotlin
- Easy way of collaborating technologies
- Resolving the issues with native images
- Enhancing the limitation of applications across the platforms
- GraalVM creates the virtual images for testing on the platforms like iOS and Android
- It supports both open-source and enterprise editions
- Documentation of and help with few minor issues with GraalVM commands
- Demoing the use cases with GraalVM capabilities
- Showcase how it is used across the platforms
- Integration with legacy C/C++ code libraries
- Good support for debugging and visualizing the runtime behavior of programs written in different languages
- Migration guide for migrating the existing Oracle JVM applications to Graal VM will help the existing customers with hundreds of Java Based applications to migrate.
- Language Interoperability
- Ahead of Time compilation
- Great Support
- Requires a separate download to use
- Unavailable with the current JDK versions
- Requires users to specifically use GraalVM to use our server platform
The problem with normal JNIs is how hard it is to implement Mixins and other features, with GraalVM this is very easy and performant. GraalVM's performance is also outstanding, making it faster to launch dev environments and other factors.
Other scenarios would be to take advantage of GraalVMs AOT features where performance is needed.
- High performance and it acts as JIT compiler. Optimizations like partial escape help a lot since it is not available in standard JIT compilers.
- Helps in running native languages on the JVM
- Helps in extension of JVM-Based application
- It is efficient for a smaller heap only as it impacts latency
- Generated native code is not fully efficient
- No thread dump and heap dump support
There's also spring framework support of GraalVM. Although it is at its initial stage, we can be hopeful that spring framework support does work and helps to improve using JAVA. This is a current limitation of GraalVM, but it can be overcome as per official information.
It is used to run the applications written in Kotlin, Python, Groovy, C++, and the interoperability is differentiated in the real-time shared runtime. We can also use the Native Image technology offered by GraalVM to compile the scripted applications well ahead of time before going into the binary code. The deployment and licensing costs approximately 25% less, reducing the overall cost.
- Performance is better because of latest compatibility with Java 11
- Standardized Software Development Kit and API design
- Multi language support to offer best services to international clients
- Supports all major programming languages
- Uses low memory
- Customer support can be improved
- Needs to support more integrations with micro services
With Oracle changing the JVM distribution license recently, GraalVM serves the purpose of managing the VM platform pretty efficiently. It is well suited for consistent process requirements. Since most of the companies depend heavily on Java for programming, GraalVM provides the best support for building Java applications and can be used for all products.
We can also mix programming languages in the same project, thus it removes the dependency of using a single programming language. This feature is provided by GraalVM and is known as "PolyGlot" apps.
- VM supports multiple programming languages
- Faster startup time of the application with reduced memory overhead
- Flexibility of the developers to choose any languages
- Performance enhancement in polyglot application is not the same in all languages.
- AOT compilation - Java Code To Native Image
- Minimal allocation of runtime memory
- Application starts in no time
- Works exceptionally well for Java applications, but more improvement is needed for non-Java applications.
As it supports many languages, creating software with multiple languages is a big advantage and provides flexibility for developers.
- Uniting various programming models in a single application
- Support for polyglot applications
- Faster execution of Java applications by creating ahead-of-time compiled native images
- Lower memory footprint
- Production-ready software
- Not all languages are supported by GraalVM.
Oracle GraalVM Enterprise Edition is being used in our department, and it has already proven to be highly beneficial and effective as it has been built to cater to enterprise-class application development on a global standard. It has shown significant improvements in application performance and efficiency due to its high-performance runtime.
- Multilingual Virtual Machine
- Run Programs Faster Anywhere
- Compiling applications ahead-of-time (AOT) into native Executable
- Can run either standalone or in the context of OpenJDK, Node.js or Oracle Database
- Lower Memory Footprint
- Compilation is not easy for all JVM code
1. Applications running in a regular just-in-time (JIT) compilation mode adding higher performance gains resulting from quality optimized algorithms.
2. Applications compiled ahead-of-time (AOT) into a native executable. It has the capability to run as a standalone application with instant startup having minimal memory footprint and minimal CPU utilization.
- Ahead-of-time compiled native images which start up faster
- Java libraries can be accessed from other programming languages.
- JIT compiler makes a long-running server process run even faster as time passes with optimization at runtime. Lack of this feature makes GraalVM not suited for certain applications
- All the libraries are not easily available or compiled down to GraalVM binary. Manual Involvement is needed to make some libraries work. Reflection-based libraries specifically do not work.
- There are runtime surprises in some cases and increases support needs
- Cloud Deployments make more sense with GraalVM due to the much lower memory footprints and faster startup times, at the same time reducing the billing.
- Smaller standalone native image deployments are more maintainable from a deployment PoV.
- Increased performance can reduce/eliminate the need to rewrite / port existing JVM based projects over to other languages, saving crucial time and money that can be better spent on solving newer problems or actually innovating, instead of chasing the same old problems with diminished returns on developer time and capital.
GraalVM Scorecard Summary
What is GraalVM?
GraalVM Community is available for free for any use.
GraalVM Enterprise provides additional performance, security, and scalability relevant for running applications in production. Users can get a version of GraalVM Enterprise that is free for evaluation and developing new applications via the Oracle Technology Network (OTN), or a commercially licensed version for production use via the Oracle Store.
- Has featureFree Trial Available?Yes
- Has featureFree or Freemium Version Available?Yes
- Has featurePremium Consulting/Integration Services Available?Yes
- Entry-level set up fee?Optional
GraalVM Technical Details
|Deployment Types:||On-premise, SaaS|
|Operating Systems:||Windows, Linux, Mac|