GraalVM is an ecosystem and runtime that provides performance advantages to JVM languages like Java, Scala, Groovy, and Kotlin as well as other languages. It includes a just-in-time compiler called Graal that improves efficiency, polyglot APIs for combining languages, and SDK for embedding languages and creating native images. Installation can be done with the JDK which includes Graal starting with JDK 9, or by directly downloading GraalVM from Oracle's website.
GraalVM is a high-performance runtime that can accelerate applications written in Java and other JVM languages. It includes a new just-in-time (JIT) compiler called Graal that can compile code ahead-of-time into a standalone native image executable. This ahead-of-time compilation allows applications to start faster and use less memory compared to the traditional HotSpot JVM. GraalVM is best suited for applications that benefit from fast startup times and a small memory footprint like command-line tools, containerized services, and embedded systems.
GraalVM is a high-performance, polyglot VM that can run programs in different languages. It addresses issues with the JVM like performance, startup times, updates, and legacy code. GraalVM uses an optimizing compiler called Graal that can make programs 2-5 times faster than the default C2 compiler through optimizations like inlining and partial escape analysis. Programs can also be compiled to native using SubstrateVM for faster startup times and lower memory footprint, but with less dynamic behavior. Quarkus addresses this by allowing the use of JVM frameworks like Spring and Hibernate within a GraalVM native environment.
Graal is a dynamic meta-circular research compiler for Java that is designed for extensibility and modularity. One of its main distinguishing elements is the handling of optimistic assumptions obtained via profiling feedback and the representation of deoptimization guards in the compiled code. Truffle is a self-optimizing runtime system on top of Graal that uses partial evaluation to derive compiled code from interpreters. Truffle is suitable for creating high-performance implementations for dynamic languages with only moderate effort. The presentation includes a description of the Truffle multi-language API and performance comparisons within the industry of current prototype Truffle language implementations (JavaScript, Ruby, and R). Both Graal and Truffle are open source and form themselves research platforms in the area of virtual machine and programming language implementation (http://openjdk.java.net/projects/graal/).
How and Why GraalVM is quickly becoming relevant for developers (ACEs@home - ...Lucas Jellema
Starting a Java application as fast as any executable with a memory footprint rivaling the most lightweight runtime engines is quickly becoming a reality, through Graal VM and ahead of time compilation. This in turn is a major boost for using Java for microservice and serverless scenarios. The second major pillar of GraalVM is its polyglot capability: it can run code in several languages - JVM and non-JVM such as JavaScript/ES, Python, Ruby, R or even your own DSL. More importantly: GraalVM enables code running in one language to interoperate with code in another language. GraalVM supports many and increasingly more forms of interoperability. This session introduces GraalVM, its main capabilities and its practical applicability - now and in the near future. There are demonstrations of ahead of time compilation and runtime interoperability of various non-JVM languages with Java.
Codineers Meetup Rosenheim on 2022-10-20
GraalVMs native-image ermöglicht es, JVM Bytecode direkt in Maschinencode zu übersetzen. Das daraus resultierende Executable benötigt keine JVM zum Laufen, startet schneller und verbraucht weniger Speicher als eine traditionelle JVM-Anwendung – ein Segen für Cloud Computing, bei dem jeder CPU-Cycle und Megabyte an RAM bezahlt werden muss. Wäre es nicht großartig, wenn unser Lieblingsframework, Spring Boot, GraalVM direkt out of the box unterstützen würde? In diesem Talk zeigt Moritz Halbritter, Spring Boot committer, was mit Spring Boot 3 und Spring Framework 6 alles möglich sein wird und erlaubt auch einen Blick unter die Motorhaube, um zu sehen, wie das alles implementiert ist.
Maven is a build tool that can manage a project's build process, dependencies, documentation and reporting. It uses a Project Object Model (POM) file to store build configuration and metadata. Maven has advantages over Ant like built-in functionality for common tasks, cross-project reuse, and support for conditional logic. It works by defining the project with a POM file then running goals bound to default phases like compile, test, package to build the project.
GraalVM is an ecosystem and runtime that provides performance advantages to JVM languages like Java, Scala, Groovy, and Kotlin as well as other languages. It includes a just-in-time compiler called Graal that improves efficiency, polyglot APIs for combining languages, and SDK for embedding languages and creating native images. Installation can be done with the JDK which includes Graal starting with JDK 9, or by directly downloading GraalVM from Oracle's website.
GraalVM is a high-performance runtime that can accelerate applications written in Java and other JVM languages. It includes a new just-in-time (JIT) compiler called Graal that can compile code ahead-of-time into a standalone native image executable. This ahead-of-time compilation allows applications to start faster and use less memory compared to the traditional HotSpot JVM. GraalVM is best suited for applications that benefit from fast startup times and a small memory footprint like command-line tools, containerized services, and embedded systems.
GraalVM is a high-performance, polyglot VM that can run programs in different languages. It addresses issues with the JVM like performance, startup times, updates, and legacy code. GraalVM uses an optimizing compiler called Graal that can make programs 2-5 times faster than the default C2 compiler through optimizations like inlining and partial escape analysis. Programs can also be compiled to native using SubstrateVM for faster startup times and lower memory footprint, but with less dynamic behavior. Quarkus addresses this by allowing the use of JVM frameworks like Spring and Hibernate within a GraalVM native environment.
Graal is a dynamic meta-circular research compiler for Java that is designed for extensibility and modularity. One of its main distinguishing elements is the handling of optimistic assumptions obtained via profiling feedback and the representation of deoptimization guards in the compiled code. Truffle is a self-optimizing runtime system on top of Graal that uses partial evaluation to derive compiled code from interpreters. Truffle is suitable for creating high-performance implementations for dynamic languages with only moderate effort. The presentation includes a description of the Truffle multi-language API and performance comparisons within the industry of current prototype Truffle language implementations (JavaScript, Ruby, and R). Both Graal and Truffle are open source and form themselves research platforms in the area of virtual machine and programming language implementation (http://openjdk.java.net/projects/graal/).
How and Why GraalVM is quickly becoming relevant for developers (ACEs@home - ...Lucas Jellema
Starting a Java application as fast as any executable with a memory footprint rivaling the most lightweight runtime engines is quickly becoming a reality, through Graal VM and ahead of time compilation. This in turn is a major boost for using Java for microservice and serverless scenarios. The second major pillar of GraalVM is its polyglot capability: it can run code in several languages - JVM and non-JVM such as JavaScript/ES, Python, Ruby, R or even your own DSL. More importantly: GraalVM enables code running in one language to interoperate with code in another language. GraalVM supports many and increasingly more forms of interoperability. This session introduces GraalVM, its main capabilities and its practical applicability - now and in the near future. There are demonstrations of ahead of time compilation and runtime interoperability of various non-JVM languages with Java.
Codineers Meetup Rosenheim on 2022-10-20
GraalVMs native-image ermöglicht es, JVM Bytecode direkt in Maschinencode zu übersetzen. Das daraus resultierende Executable benötigt keine JVM zum Laufen, startet schneller und verbraucht weniger Speicher als eine traditionelle JVM-Anwendung – ein Segen für Cloud Computing, bei dem jeder CPU-Cycle und Megabyte an RAM bezahlt werden muss. Wäre es nicht großartig, wenn unser Lieblingsframework, Spring Boot, GraalVM direkt out of the box unterstützen würde? In diesem Talk zeigt Moritz Halbritter, Spring Boot committer, was mit Spring Boot 3 und Spring Framework 6 alles möglich sein wird und erlaubt auch einen Blick unter die Motorhaube, um zu sehen, wie das alles implementiert ist.
Maven is a build tool that can manage a project's build process, dependencies, documentation and reporting. It uses a Project Object Model (POM) file to store build configuration and metadata. Maven has advantages over Ant like built-in functionality for common tasks, cross-project reuse, and support for conditional logic. It works by defining the project with a POM file then running goals bound to default phases like compile, test, package to build the project.
The document describes a presentation on Gradle as a build automation system. It will cover what Gradle is, why it is useful compared to other tools like Ant and Maven, and how to write Gradle scripts. Specifically, it will discuss project structures in Gradle, how to configure Gradle scripts, and introduce common plugins like the Java plugin.
This document provides an overview of Spring Boot and some of its key features. It discusses the origins and modules of Spring, how Spring Boot simplifies configuration and dependency management. It then covers examples of building Spring Boot applications that connect to a SQL database, use RabbitMQ for messaging, and schedule and run asynchronous tasks.
Abstract: "Performance with Native Images"
GraalVM is a high-performance polyglot runtime for dynamic, static, and native languages. One of the abilities of GraalVM is to compile Java programs ahead of time into native images that offer performance comparable to running on the JVM but have instant startup times and much lower runtime overhead. Generating native images is proven to work on real-world applications. In this session, you will learn how native images work and what is required to generate them and will look at several examples of compiling programs ahead of time and packaging them into minimal containers. You’ll also see how to configure native image generation, work around the limitations, and configuring your application to use native images.
Here are slides from basic training for Gradle.
This training is aimed to help Java Developers to get hands-on experience to use Gradle as a primary build tool for Java source code starting from simple compilation continuing with different kinds of tests and finishing with code quality analysis and artefacts publishing.
Introduction to Jenkins and how to effectively apply Jenkins to your projects.
Jenkins Growth , Companies using Jenkins , Most downloaded and Used Plugins.
This document provides an overview of integrating microservices with Apache Camel and JBoss Fuse. It introduces Apache Camel as a lightweight integration library that uses enterprise integration patterns and domain-specific languages to define integration "flows" and "routes". It describes how Camel supports features like dynamic routing, REST APIs, backpressure, load balancing, and circuit breakers that are useful for building microservices. The document also introduces JBoss Fuse as a development and runtime platform for microservices that provides tooling, frameworks, management capabilities and container support using technologies like Apache Camel, CXF, ActiveMQ and Karaf.
This document introduces Quarkus, an open source Java framework for building container-native microservices. Quarkus uses GraalVM to compile Java code ahead-of-time, resulting in applications that are up to 10x smaller and 100x faster to start than traditional Java applications. It is optimized for Kubernetes and serverless workloads. Quarkus achieves these benefits through ahead-of-time compilation using GraalVM, which analyzes code statically and removes unused classes and code to generate efficient native executables.
Learn All Aspects Of Maven step by step, Enhance your skills & Launch Your Career, On-Demand Course affordable price & classes on virtually every topic.Try Before You Buy
Quarkus - a next-generation Kubernetes Native Java frameworkSVDevOps
For years, the client-server architecture has been the de-facto standard to build applications. But a major shift happened. The one model rules them all age is over. A new range of applications and architectures has emerged and impacts how code is written and how applications are deployed and executed. HTTP microservices, reactive applications, message-driven microservices, and serverless are now central players in modern systems.
Quarkus has been designed with this new world in mind and provides first-class support for these different paradigms. Developers using the Red Hat build of Quarkus can now choose between deploying natively compiled code or JVM-based code depending on an application’s needs. Natively compiled Quarkus applications are extremely fast and memory-efficient, making Quarkus a great choice for serverless and high-density cloud deployments.
Speakers
1) Shanna Chan, Senior Solutions Architect at Red Hat
2) Mark Baker, Senior Solutions Architect at Red Hat
Speaker Bios
Shanna Chan - Shanna is passionate about how open source solutions help others in their journey of application modernization and transformation of their business into cloud infrastructures. Her background includes application developments, DevOps, and architecting solutions for large enterprises. More about Shanna at http://linkedin.com/in/shanna-chan
Mark Baker - Mark’s experiences coalesce around solution /business architecture and leadership bringing together people in both post / pre-sales software projects bridging traditional legacy systems (i.e. Jakarta (JEE) MVC) with Cloud tolerant and Cloud native open source in the journey of modernization and transformation. More about Mark at http://linkedin.com/in/markwbaker-tsl
Maven is a project management and comprehension tool. Maven provides developers a complete build lifecycle framework. Development team can automate the project's build infrastructure in almost no time as Maven uses a standard directory layout and a default build lifecycle.
In case of multiple development teams environment, Maven can set-up the way to work as per standards in a very short time. As most of the project setups are simple and reusable, Maven makes life of developer easy while creating reports, checks, build and testing automation setups.
Maven is a build tool that helps manage Java projects and automates common tasks like compiling code, running tests, and managing dependencies. It uses a Project Object Model (POM) XML file to store build configuration which defines project dependencies, plugins, and other metadata. Maven standardizes project layout, builds, documentation, and the release process.
The Path Towards Spring Boot Native ApplicationsVMware Tanzu
SpringOne 2020
The Path Towards Spring Boot Native Applications
Sébastien Deleuze, Spring Framework Committer at VMware
Andy Clement, Director at VMware
GraalVM allows building native applications from Java and other JVM languages. It includes a new just-in-time compiler called Graal and the Truffle framework for building language interpreters. GraalVM also includes Sulong, which allows running LLVM-based languages on the JVM. The presenter discussed using GraalVM to build a native executable for a Zookeeper CLI tool called zkstat from Java code using techniques like ahead-of-time compilation with SubstrateVM, configuring reflection, and building a Docker image for distribution.
Spring Boot is a framework for creating stand-alone, production-grade Spring based applications that can be "just run". It aims to provide a radically faster and widely accessible starting experience for developing Spring applications. Spring Boot applications can be started using java -jar or traditional WAR deployments and require very little Spring configuration. The document then discusses system requirements, development environment, creating a simple Hello World application, using Spring Boot Admin to monitor applications, configuring databases, Spring Data JPA, REST controllers, caching with EhCache, building web applications with Thymeleaf, and project structure.
The document discusses Java compilation and the Java Virtual Machine. It explains that Java code is first compiled to bytecode, then just-in-time compiled by the JVM to native machine code using multiple compilers. The JVM uses a technique called tiered compilation that starts with simple compilation and progresses to more optimized compilation. Tiered compilation aims to provide both fast startup and high performance.
The document discusses the benefits of using Gradle over other build tools like Eclipse, Ant, and Maven. Gradle combines features from Ant like flexibility with Maven's lifecycle and ease of use. It uses Groovy for its build scripts and supports plugins, dependencies, and conventions over configuration similar to Maven. Gradle allows building multiple projects with dependencies and supports composite builds that include other complete builds. The document provides examples of using Gradle with Java, web, and multi-project builds.
The document discusses using Maven for automation builds. It covers quick starting a Maven project, the Maven lifecycle and phases, dependency and plugin management, and integrating Maven with IDEs like Eclipse. Key points include how to create a basic Maven project, the different Maven directories, common Maven commands, using the Surefire plugin to run tests, and configuring test dependencies.
GraalVM is a high-performance runtime for dynamic, static, and native languages. GraalVM supports Java, Scala, Kotlin, Groovy, and other JVM-based languages. At the same time, it can run the dynamic scripting languages JavaScript including node.js, Ruby, R, and Python. In this session we'll talk about the performance boost you can get from running your code on GraalVM, look at the examples of running typical web-applications with it, enhancing them with code in other languages, creating native images for incredibly fast startup and low memory overhead for your services. GraalVM offers you the opportunity to write the code in the language you want, and run the resulting program really fast.
This document provides an overview of Oracle WebLogic and how it compares to OC4J. It discusses the key WebLogic concepts like domains, administration servers, managed servers, and clusters. It also covers the various administration tools for WebLogic like the admin console and WLST scripting. The document demonstrates how to use WLST to start NodeManager and monitor server states. It provides tips on tuning the JVM and changing WebLogic ports. The agenda concludes with a hands-on session on installing and configuring a WebLogic domain.
This document discusses Jenkins Pipelines, which allow defining continuous integration and delivery (CI/CD) pipelines as code. Key points:
- Pipelines are defined using a Groovy domain-specific language (DSL) for stages, steps, and environment configuration.
- This provides configuration as code that is version controlled and reusable across projects.
- Jenkins plugins support running builds and tests in parallel across Docker containers.
- Notifications can be sent to services like Slack on failure.
- The Blue Ocean UI in Jenkins focuses on visualization of pipeline runs.
Graal and Truffle: Modularity and Separation of Concerns as Cornerstones for ...Thomas Wuerthinger
Multi-language runtimes providing simultaneously high performance for several programming languages still remain an illusion. Industrial-strength managed language runtimes are built with a focus on one language (e.g., Java or C#). Other languages may compile to the bytecode formats of those managed language runtimes. However, the performance characteristics of the bytecode generation approach are often lagging behind compared to language runtimes specialized for a specific language. The performance of JavaScript is for example still orders of magnitude better on specialized runtimes (e.g., V8 or SpiderMonkey).
We present a solution to this problem by providing guest languages with a new way of interfacing with the host runtime. The semantics of the guest language is communicated to the host runtime not via generating bytecodes, but via an interpreter written in the host language. This gives guest languages a simple way to express the semantics of their operations including language-specific mechanisms for collecting profiling feedback. The efficient machine code is derived from the interpreter via automatic partial evaluation. The main components reused from the underlying runtime are the compiler and the garbage collector. They are both agnostic to the executed guest languages.
The host compiler derives the optimized machine code for hot parts of the guest language application via partial evaluation of the guest language interpreter. The interpreter definition can guide the host compiler to generate deoptimization points, i.e., exits from the compiled code. This allows guest language operations to use speculations: An operation could for example speculate that the type of an incoming parameter is constant. Furthermore, the guest language interpreter can use global assumptions about the system state that are registered with the compiled code. Finally, part of the interpreter's code can be excluded from the partial evaluation and remain shared across the system. This is useful for avoiding code explosion and appropriate for infrequently executed paths of an operation. These basic mechanisms are provided by the underlying language-agnostic host runtime and allow separation of concerns between guest and host runtime.
We implemented Truffle, the guest language runtime framework, on top of the Graal compiler and the HotSpot virtual machine. So far, there are prototypes for C, J, Python, JavaScript, R, Ruby, and Smalltalk running on top of the Truffle framework. The prototypes are still incomplete with respect to language semantics. However, most of them can run non-trivial benchmarks to demonstrate the core promise of the Truffle system: Multiple languages within one runtime system at competitive performance.
This document provides an overview of Graal, a high-performance dynamic compiler for Java written in Java. It discusses key features such as support for speculative optimizations and deoptimization. It also covers Graal's intermediate representation, optimization phases, and how it can be used for custom compilations and static analysis. The document aims to provide insight into Graal and its capabilities as a research compiler.
The document describes a presentation on Gradle as a build automation system. It will cover what Gradle is, why it is useful compared to other tools like Ant and Maven, and how to write Gradle scripts. Specifically, it will discuss project structures in Gradle, how to configure Gradle scripts, and introduce common plugins like the Java plugin.
This document provides an overview of Spring Boot and some of its key features. It discusses the origins and modules of Spring, how Spring Boot simplifies configuration and dependency management. It then covers examples of building Spring Boot applications that connect to a SQL database, use RabbitMQ for messaging, and schedule and run asynchronous tasks.
Abstract: "Performance with Native Images"
GraalVM is a high-performance polyglot runtime for dynamic, static, and native languages. One of the abilities of GraalVM is to compile Java programs ahead of time into native images that offer performance comparable to running on the JVM but have instant startup times and much lower runtime overhead. Generating native images is proven to work on real-world applications. In this session, you will learn how native images work and what is required to generate them and will look at several examples of compiling programs ahead of time and packaging them into minimal containers. You’ll also see how to configure native image generation, work around the limitations, and configuring your application to use native images.
Here are slides from basic training for Gradle.
This training is aimed to help Java Developers to get hands-on experience to use Gradle as a primary build tool for Java source code starting from simple compilation continuing with different kinds of tests and finishing with code quality analysis and artefacts publishing.
Introduction to Jenkins and how to effectively apply Jenkins to your projects.
Jenkins Growth , Companies using Jenkins , Most downloaded and Used Plugins.
This document provides an overview of integrating microservices with Apache Camel and JBoss Fuse. It introduces Apache Camel as a lightweight integration library that uses enterprise integration patterns and domain-specific languages to define integration "flows" and "routes". It describes how Camel supports features like dynamic routing, REST APIs, backpressure, load balancing, and circuit breakers that are useful for building microservices. The document also introduces JBoss Fuse as a development and runtime platform for microservices that provides tooling, frameworks, management capabilities and container support using technologies like Apache Camel, CXF, ActiveMQ and Karaf.
This document introduces Quarkus, an open source Java framework for building container-native microservices. Quarkus uses GraalVM to compile Java code ahead-of-time, resulting in applications that are up to 10x smaller and 100x faster to start than traditional Java applications. It is optimized for Kubernetes and serverless workloads. Quarkus achieves these benefits through ahead-of-time compilation using GraalVM, which analyzes code statically and removes unused classes and code to generate efficient native executables.
Learn All Aspects Of Maven step by step, Enhance your skills & Launch Your Career, On-Demand Course affordable price & classes on virtually every topic.Try Before You Buy
Quarkus - a next-generation Kubernetes Native Java frameworkSVDevOps
For years, the client-server architecture has been the de-facto standard to build applications. But a major shift happened. The one model rules them all age is over. A new range of applications and architectures has emerged and impacts how code is written and how applications are deployed and executed. HTTP microservices, reactive applications, message-driven microservices, and serverless are now central players in modern systems.
Quarkus has been designed with this new world in mind and provides first-class support for these different paradigms. Developers using the Red Hat build of Quarkus can now choose between deploying natively compiled code or JVM-based code depending on an application’s needs. Natively compiled Quarkus applications are extremely fast and memory-efficient, making Quarkus a great choice for serverless and high-density cloud deployments.
Speakers
1) Shanna Chan, Senior Solutions Architect at Red Hat
2) Mark Baker, Senior Solutions Architect at Red Hat
Speaker Bios
Shanna Chan - Shanna is passionate about how open source solutions help others in their journey of application modernization and transformation of their business into cloud infrastructures. Her background includes application developments, DevOps, and architecting solutions for large enterprises. More about Shanna at http://linkedin.com/in/shanna-chan
Mark Baker - Mark’s experiences coalesce around solution /business architecture and leadership bringing together people in both post / pre-sales software projects bridging traditional legacy systems (i.e. Jakarta (JEE) MVC) with Cloud tolerant and Cloud native open source in the journey of modernization and transformation. More about Mark at http://linkedin.com/in/markwbaker-tsl
Maven is a project management and comprehension tool. Maven provides developers a complete build lifecycle framework. Development team can automate the project's build infrastructure in almost no time as Maven uses a standard directory layout and a default build lifecycle.
In case of multiple development teams environment, Maven can set-up the way to work as per standards in a very short time. As most of the project setups are simple and reusable, Maven makes life of developer easy while creating reports, checks, build and testing automation setups.
Maven is a build tool that helps manage Java projects and automates common tasks like compiling code, running tests, and managing dependencies. It uses a Project Object Model (POM) XML file to store build configuration which defines project dependencies, plugins, and other metadata. Maven standardizes project layout, builds, documentation, and the release process.
The Path Towards Spring Boot Native ApplicationsVMware Tanzu
SpringOne 2020
The Path Towards Spring Boot Native Applications
Sébastien Deleuze, Spring Framework Committer at VMware
Andy Clement, Director at VMware
GraalVM allows building native applications from Java and other JVM languages. It includes a new just-in-time compiler called Graal and the Truffle framework for building language interpreters. GraalVM also includes Sulong, which allows running LLVM-based languages on the JVM. The presenter discussed using GraalVM to build a native executable for a Zookeeper CLI tool called zkstat from Java code using techniques like ahead-of-time compilation with SubstrateVM, configuring reflection, and building a Docker image for distribution.
Spring Boot is a framework for creating stand-alone, production-grade Spring based applications that can be "just run". It aims to provide a radically faster and widely accessible starting experience for developing Spring applications. Spring Boot applications can be started using java -jar or traditional WAR deployments and require very little Spring configuration. The document then discusses system requirements, development environment, creating a simple Hello World application, using Spring Boot Admin to monitor applications, configuring databases, Spring Data JPA, REST controllers, caching with EhCache, building web applications with Thymeleaf, and project structure.
The document discusses Java compilation and the Java Virtual Machine. It explains that Java code is first compiled to bytecode, then just-in-time compiled by the JVM to native machine code using multiple compilers. The JVM uses a technique called tiered compilation that starts with simple compilation and progresses to more optimized compilation. Tiered compilation aims to provide both fast startup and high performance.
The document discusses the benefits of using Gradle over other build tools like Eclipse, Ant, and Maven. Gradle combines features from Ant like flexibility with Maven's lifecycle and ease of use. It uses Groovy for its build scripts and supports plugins, dependencies, and conventions over configuration similar to Maven. Gradle allows building multiple projects with dependencies and supports composite builds that include other complete builds. The document provides examples of using Gradle with Java, web, and multi-project builds.
The document discusses using Maven for automation builds. It covers quick starting a Maven project, the Maven lifecycle and phases, dependency and plugin management, and integrating Maven with IDEs like Eclipse. Key points include how to create a basic Maven project, the different Maven directories, common Maven commands, using the Surefire plugin to run tests, and configuring test dependencies.
GraalVM is a high-performance runtime for dynamic, static, and native languages. GraalVM supports Java, Scala, Kotlin, Groovy, and other JVM-based languages. At the same time, it can run the dynamic scripting languages JavaScript including node.js, Ruby, R, and Python. In this session we'll talk about the performance boost you can get from running your code on GraalVM, look at the examples of running typical web-applications with it, enhancing them with code in other languages, creating native images for incredibly fast startup and low memory overhead for your services. GraalVM offers you the opportunity to write the code in the language you want, and run the resulting program really fast.
This document provides an overview of Oracle WebLogic and how it compares to OC4J. It discusses the key WebLogic concepts like domains, administration servers, managed servers, and clusters. It also covers the various administration tools for WebLogic like the admin console and WLST scripting. The document demonstrates how to use WLST to start NodeManager and monitor server states. It provides tips on tuning the JVM and changing WebLogic ports. The agenda concludes with a hands-on session on installing and configuring a WebLogic domain.
This document discusses Jenkins Pipelines, which allow defining continuous integration and delivery (CI/CD) pipelines as code. Key points:
- Pipelines are defined using a Groovy domain-specific language (DSL) for stages, steps, and environment configuration.
- This provides configuration as code that is version controlled and reusable across projects.
- Jenkins plugins support running builds and tests in parallel across Docker containers.
- Notifications can be sent to services like Slack on failure.
- The Blue Ocean UI in Jenkins focuses on visualization of pipeline runs.
Graal and Truffle: Modularity and Separation of Concerns as Cornerstones for ...Thomas Wuerthinger
Multi-language runtimes providing simultaneously high performance for several programming languages still remain an illusion. Industrial-strength managed language runtimes are built with a focus on one language (e.g., Java or C#). Other languages may compile to the bytecode formats of those managed language runtimes. However, the performance characteristics of the bytecode generation approach are often lagging behind compared to language runtimes specialized for a specific language. The performance of JavaScript is for example still orders of magnitude better on specialized runtimes (e.g., V8 or SpiderMonkey).
We present a solution to this problem by providing guest languages with a new way of interfacing with the host runtime. The semantics of the guest language is communicated to the host runtime not via generating bytecodes, but via an interpreter written in the host language. This gives guest languages a simple way to express the semantics of their operations including language-specific mechanisms for collecting profiling feedback. The efficient machine code is derived from the interpreter via automatic partial evaluation. The main components reused from the underlying runtime are the compiler and the garbage collector. They are both agnostic to the executed guest languages.
The host compiler derives the optimized machine code for hot parts of the guest language application via partial evaluation of the guest language interpreter. The interpreter definition can guide the host compiler to generate deoptimization points, i.e., exits from the compiled code. This allows guest language operations to use speculations: An operation could for example speculate that the type of an incoming parameter is constant. Furthermore, the guest language interpreter can use global assumptions about the system state that are registered with the compiled code. Finally, part of the interpreter's code can be excluded from the partial evaluation and remain shared across the system. This is useful for avoiding code explosion and appropriate for infrequently executed paths of an operation. These basic mechanisms are provided by the underlying language-agnostic host runtime and allow separation of concerns between guest and host runtime.
We implemented Truffle, the guest language runtime framework, on top of the Graal compiler and the HotSpot virtual machine. So far, there are prototypes for C, J, Python, JavaScript, R, Ruby, and Smalltalk running on top of the Truffle framework. The prototypes are still incomplete with respect to language semantics. However, most of them can run non-trivial benchmarks to demonstrate the core promise of the Truffle system: Multiple languages within one runtime system at competitive performance.
This document provides an overview of Graal, a high-performance dynamic compiler for Java written in Java. It discusses key features such as support for speculative optimizations and deoptimization. It also covers Graal's intermediate representation, optimization phases, and how it can be used for custom compilations and static analysis. The document aims to provide insight into Graal and its capabilities as a research compiler.
Updates on the current status of Graal VM, a platform dedicated to run multiple programming languages at excellent performance. Experimental binaries are available from http://www.oracle.com/technetwork/oracle-labs/program-languages/overview/index.html.
This document outlines 10 backend engineering best practices that were learned the hard way by a company that ingests terabytes of data daily and stores petabytes of data. The lessons include: (1) focus on operational cost by choosing a few technologies to master rather than using the best tool for every job, (2) invest in getting code to production quickly through testing and automation, (3) treat infrastructure as "cattle" that can be replaced rather than personalized "pets", (4) centralize logging, (5) implement asynchronous queueing, (6) engage product managers during production issues, (7) create centralized dashboard for system and business metrics, (8) use percentiles for metrics, (9) codify
Modularity of The Java Platform Javaday (http://javaday.org.ua/)Martin Toshev
Project Jigsaw aims to provide modularity for the Java platform by defining modules for the JDK and restructuring it. This will address problems caused by the current monolithic design and dependency mechanism. OSGi also provides modularity on top of Java by defining bundles and a runtime. Project Penrose explores interoperability between Jigsaw and OSGi modules.
Security Аrchitecture of Тhe Java PlatformMartin Toshev
The document summarizes the evolution of the Java security model from JDK 1.0 to the current version. It discusses how the security model started with a simple trusted/untrusted code separation and gradually evolved to support signed applets, fine-grained access control, and role-based access using JAAS. It also discusses how the security model will be applied to modules in future versions. Additionally, it covers some of the key security APIs available outside the sandbox like JCA, PKI, JSSE, and best practices for secure coding.
Writing Stored Procedures with Oracle Database 12cMartin Toshev
This document discusses writing Java stored procedures with Oracle Database 12c. It begins by comparing PL/SQL and Java stored procedures, noting that both can be executed directly in the database and recompiled when source code changes. It then covers writing Java stored procedures by loading Java classes into the database, mapping Java methods to PL/SQL functions/procedures, and invoking them. Managing procedures includes monitoring with JMX and debugging with JDBC. New features in Oracle 12c include support for multiple JDK versions, JNDI, and improved debugging support.
The learning curve for security is severe and unforgiving. Specifications promise infinite flexibility, habitually give old concepts new names, are riddled with extensions, and almost seem designed to deliberately confuse. For a back-end REST developer, choking all this down for the first time is mission impossible. With an aggressive distaste for fancy terminology, this session delves into OAuth 2.0 as it pertains to REST and shows how it falls into two camps: stateful and stateless. The presentation also details a competing Amazon-style approach called HTTP Signatures and digs into the architectural differences of all three, with a heavy focus on the wire, showing actual HTTP messages and enough detail to have you thinking, “I could write this myself.”
Writing Stored Procedures in Oracle RDBMSMartin Toshev
This document discusses writing Java stored procedures with Oracle RDBMS. It covers the differences between PL/SQL and Java stored procedures, how to write Java stored procedures, manage them, and new features in Oracle Database 12c. Key points include: Java procedures use a JVM inside Oracle RDBMS, writing procedures involves loading Java classes and mapping methods, and managing procedures includes debugging, monitoring the JVM, and setting compiler options.
Writing Java Stored Procedures in Oracle 12cMartin Toshev
The session discusses the innerworkings ot the Oracle Aurora JVM, the process of writing and maintaining Java stored procedures and the new features in Oracle database 12c.
This document discusses modularity in Java applications and platforms. It covers OSGi, a popular modular system for Java that allows bundles to be installed and updated dynamically. It also discusses Project Jigsaw, which aims to add built-in modularity to the Java platform starting in JDK 9 by defining Java modules. Project Penrose explores interoperability between OSGi and Jigsaw modular systems.
Introductory presentation for the Clash of Technologies: RxJS vs RxJava event organized by SoftServe @ betahouse (17.01.2015). Comparison document with questions & answers available here: https://docs.google.com/document/d/1VhuXJUcILsMSP4_6pCCXBP0X5lEVTsmLivKHcUkFvFY/edit#.
This document provides an overview of Spring RabbitMQ. It discusses messaging basics and RabbitMQ concepts like exchanges, queues, bindings. It then summarizes the Spring AMQP and Spring Integration frameworks for integrating RabbitMQ in Spring applications. Spring AMQP provides the RabbitAdmin, listener container and RabbitTemplate for declaring and interacting with RabbitMQ components. The document contains code examples for configuring RabbitMQ and consuming/producing messages using Spring AMQP.
KDB database (EPAM tech talks, Sofia, April, 2015)Martin Toshev
KDB is an in-memory column-oriented database that provides high-performance for real-time and historical large volumes of data. It is used widely in the financial industry. KDB supports the Q programming language for querying and manipulating data, and can be deployed in a distributed environment. The Java API provides simple connection and query methods to access a KDB database. KDB is well-suited for use cases involving capturing market data feeds and analyzing FIX messages.
Gábor Horváth - Code Generation in Serializers and Comparators of Apache FlinkFlink Forward
This document discusses code generation for serializers and comparators in Apache Flink. Currently, Flink serializers use reflection which reduces performance. The document proposes generating serialization code at runtime to eliminate reflection and improve efficiency. It shows benchmark results demonstrating a 6x speedup from generated serializers and comparators compared to Flink's current approach. Future work is discussed to further optimize serialization performance and address challenges of dynamically generated code.
Security Architecture of the Java platformMartin Toshev
The document discusses the evolution of the Java security model from JDK 1.0 to recent versions. It started with a simple sandbox model separating trusted and untrusted code. Over time, features like applet signing, fine-grained permissions, JAAS roles and principals, and module-based security were added to enhance the security and flexibility of granting access to untrusted code. The model aims to safely execute code from various sources while preventing unauthorized access.
Eclipse plug-in development seminar held by the Bulgarian Java User group covering basic aspects of Eclipse plug-in development and the new stuff in e4
The HaLVM is a Haskell virtual machine that runs directly on the Xen hypervisor. It was created as a lightweight platform for testing microkernel-based operating system designs. The HaLVM boots in milliseconds and uses minimal resources. It provides a base for developing simple cloud services and isolated network applications through its small memory and disk footprint.
Service Discovery and Registration in a Microservices ArchitecturePLUMgrid
Microservices, Service Discovery and Registration have been heading towards the peak of inflated expectations on the Gartner Hype cycle for over the last year or so, but there has often been a lack of clarity as to what these are, why are they needed or how to implement them well.
Service discovery and registration are key components of most distributed systems and service oriented architectures. In this session we will talk about what, why and how of service registration and discovery in distributed systems in general and OpenStack in particular.
We will talk about some of the technologies that address this challenge like Zookeeper, Etcd, Consul, Mesos-DNS, Minuteman, SkyDNS, SmartStack or Eureka. We will also address how these technologies as well as existing OpenStack projects can be used to solve this problem inside OpenStack environments.
The document provides an overview of the Graal VM, which is a new just-in-time (JIT) compiler for the Java Virtual Machine (JVM) that brings high performance to scripting languages via the Truffle API. It discusses how Graal generates machine code from an optimized AST rather than bytecode, and how the Truffle API allows creation of language interpreters in Graal. Performance benchmarks show Graal improving performance for languages like JavaScript, Ruby, and R compared to other implementations. Future directions include supporting more languages and compiler optimizations in Graal's extensible framework.
GraalVM is a new polyglot virtual machine that allows running JVM languages as well as other languages like JavaScript, Python, and R. It provides several advantages over traditional JVMs including being a drop-in replacement for OpenJDK that can improve performance, the ability to ahead-of-time compile Java programs into native images for faster startup times, seamless interoperability between supported languages, and common debugging and monitoring interfaces. Key features include running as a replacement JVM, including Graal as an alternative JIT compiler in OpenJDK 11, ahead-of-time compilation to native images, support for additional languages via Truffle, and allowing Java programs to be used as native libraries from other languages.
This document discusses GraalVM, a universal virtual machine that enables high performance and interoperability between programming languages. It introduces key concepts like JIT compilation, AOT compilation, C2 JIT, Graal JIT, and Substrate VM. It provides examples of using Graal JIT and AOT compilers on a sample Java application and compares the performance. Finally, it summarizes the capabilities and future directions of GraalVM, including running existing applications more efficiently across languages and embedding languages in native applications.
GraalVM can be used as a drop-in replacement for the JDK to run Java programs. It includes the Graal just-in-time compiler which can provide better performance than the default HotSpot compiler. GraalVM also includes the native-image tool which can compile Java bytecode ahead-of-time to native executables without dependencies, improving startup time significantly. This enables using Java for more dynamic workloads like microservices that require fast startup. Reflection and dynamic proxies require additional configuration for native images. Docker images can also be built from native executables to distribute applications.
GraalVM can be used as a drop-in replacement for the JDK to run Java programs. It includes the Graal just-in-time compiler which can provide better performance than the default HotSpot compiler. GraalVM also allows ahead-of-time compilation of Java bytecode into native images using SubstrateVM, eliminating the overhead of interpretation and compilation at runtime. These native images have minimal dependencies and fast startup times, making them suitable for containerized microservices and cloud applications.
HOW TO CREATE AWESOME POLYGLOT APPLICATIONS USING GRAALVMOwais Zahid
Key to creating world-class solutions lies in the effectivity of cross-team collaboration and lead time. When multiple teams involved in a project, it is critical to take cross-platform and cross-language aspects into account. Introducing GraalVM, a universal virtual machine created to address an issue of teams struggling to collaborate because of varying preference of programming languages.
In this session, we will look at how you can use GraalVM to create polyglot applications with ease. It is a hands-on live coding session where we will look at Ruby, NodeJS & Java interoperability.
Enabling Java: Windows on Arm64 - A Success Story!Monica Beckwith
The document provides an overview of Microsoft's efforts to port OpenJDK to Windows on Arm64. It discusses the background of OpenJDK and Arm64, details of the port including Windows and Arm64 specific nuances, and the timeline of the port from initial work to current testing and benchmarking efforts. It also introduces the team behind the port and highlights some of their key learnings and accomplishments.
The new GraalVM from Oracle supports multiple language including JavaScript, Python, Ruby, R, C++ as well as Java and other JVM languages. This opens up interesting possibilities for polygot enterprise applications. Now you can use a Node library in a Java application or call an R statistical function from an EJB. Previously, this type of integration was extremely challenging. This session will provide recipes to get up and running along with best practices and some cool demos.
Code: https://github.com/rcuprak/graalvm_jee
The document provides an overview of Java and its evolution over the past 40 versions. It discusses key features and enhancements in recent versions of Java including Java 9-14. It also outlines some of Oracle's major Java projects including Valhalla, Loom, Panama, Amber, and ZGC which are focused on improving performance, concurrency, and developer productivity. The document contains several copyright notices and is intended for informational purposes only.
Dan Vega discussed new features and capabilities in Spring Boot 3 and beyond, including support for JDK 17, Jakarta EE 9, ahead-of-time compilation, observability with Micrometer, Docker Compose integration, and initial support for Project Loom's virtual threads in Spring Boot 3.2 to improve scalability. He provided an overview of each new feature and explained how they can help Spring applications.
Python is popular amongst data scientists and engineers for data processing tasks. The big data ecosystem has traditionally been rather JVM centric. Often Java (or Scala) are the only viable option to implement data processing pipelines. That sometimes poses an adoption barrier for organizations that have already invested in other language ecosystems. The Apache Beam project provides a unified programming model for data processing and its ongoing portability effort aims to enable multiple language SDKs (currently Java, Python and Go) on a common set of runners. The combination of Python streaming on the Apache Flink runner is one example. Let’s take a look how the Flink runner translates the Beam model into the native DataStream (or DataSet) API, how the runner is changing to support portable pipelines, how Python user code execution is coordinated with gRPC based services and how a sample pipeline runs on Flink.
Flink Forward Berlin 2018: Thomas Weise & Aljoscha Krettek - "Python Streamin...Flink Forward
Python is popular amongst data scientists and engineers for data processing tasks. The big data ecosystem has traditionally been rather JVM centric. Often Java (or Scala) are the only viable option to implement data processing pipelines. That sometimes poses an adoption barrier for organizations that have already invested in other language ecosystems. The Apache Beam project provides a unified programming model for data processing and its ongoing portability effort aims to enable multiple language SDKs (currently Java, Python and Go) on a common set of runners. The combination of Python streaming on the Apache Flink runner is one example. Let’s take a look how the Flink runner translates the Beam model into the native DataStream (or DataSet) API, how the runner is changing to support portable pipelines, how Python user code execution is coordinated with gRPC based services and how a sample pipeline runs on Flink.
Java is a general-purpose programming language that is both compiled and interpreted. It allows developers to "write once, run anywhere," meaning that Java code can run on any device that supports a Java Virtual Machine (JVM), without needing to be recompiled. The key features of Java include being simple, object-oriented, robust, secure, portable, and high-performance. Java code is first compiled into bytecode, which can then be executed by a JVM on various operating systems like Windows, Linux, and macOS.
Java ScriptingJava Scripting: One VM, Many Languageselliando dias
The document discusses using scripting languages with the Java platform. It provides an overview of scripting languages and their uses. It explains how the Java virtual machine can run many languages and leverage their advantages while providing scalability. Examples are given of integrating scripts with Java applications and invoking script functions from Java. Future directions like JSR 292 for dynamic invocation are also covered.
Getting started with Emscripten – Transpiling C / C++ to JavaScript / HTML5David Voyles
The video for this talk can be found here:https://channel9.msdn.com/Blogs/raw-tech/Getting-started-with-Emscripten--Transpiling-C--C-to-JavaScript--HTML5
I cover how to transpile code from C/C++ to HTML5/JS using Emscripten, an open source compiler tool from Mozilla and Alon Zakai.
Building highly scalable data pipelines with Apache SparkMartin Toshev
This document provides a summary of Apache Spark, including:
- Spark is a framework for large-scale data processing across clusters that is faster than Hadoop by relying more on RAM and minimizing disk IO.
- Spark transformations operate on resilient distributed datasets (RDDs) to manipulate data, while actions return results to the driver program.
- Spark can receive data from various sources like files, databases, sockets through its datasource APIs and process both batch and streaming data.
- Spark streaming divides streaming data into micro-batches called DStreams and integrates with messaging systems like Kafka. Structured streaming is a newer API that works on DataFrames/Datasets.
JDK 10 is the first release with a 6-month cadence. It includes new features like local variable type inference with the var keyword and Application Class-Data Sharing to reduce memory usage. Performance improvements were made like parallel full GC for G1. JDK 10 also adds experimental support for Graal as a Java-based JIT compiler and improves container awareness. Future releases will continue adding new features from projects like Panama, Valhalla, and Loom.
This document discusses security aspects of Java modules and compares them to OSGi bundles. It explains that the Java module system brings improved security while fitting into the existing security architecture. Modules introduce another layer of access control and stronger encapsulation for application code. Both modules and bundles define protection domains and can be signed, but modules lack OSGi's notion of local bundle permissions. The new module system enhances security while modularizing the Java platform.
Java 9 Security Enhancements in PracticeMartin Toshev
This document discusses security enhancements to Java 9 including TLS and DTLS support. TLS 1.0-1.2 and the upcoming TLS 1.3 are supported via the JSSE API. DTLS 1.0-1.2 is also now supported to provide security for unreliable transports like UDP. The TLS Application-Layer Protocol Negotiation extension allows identifying the application protocol during the TLS handshake. Other enhancements include OCSP stapling, PKCS12 as the default keystore, and SHA-3 hash algorithm support.
This document provides an overview of Spring RabbitMQ, which is a framework for integrating Java applications with the RabbitMQ message broker. It discusses messaging basics and RabbitMQ concepts like exchanges, queues, bindings and message routing. It then summarizes how Spring RabbitMQ can be used to configure RabbitMQ infrastructure like connections, templates, listeners and administrators either directly in Java code or using Spring configuration. It also briefly mentions how Spring Integration and Spring Boot can be used to build messaging applications on RabbitMQ.
Martin Toshev presented on attack vectors against Oracle database 12c. He began by providing real world examples of attacks, such as privilege escalation exploits. He then discussed potential attack vectors, including those originating from unauthorized, authorized with limited privileges, and SYSDBA users. Finally, he outlined approaches for discovering new vulnerabilities and recommended tools for testing Oracle database security.
This document discusses concurrency utilities introduced in Java 8 including parallel tasks, parallel streams, parallel array operations, CompletableFuture, ConcurrentHashMap, scalable updatable variables, and StampedLock. It provides examples and discusses when and how to properly use these utilities as well as potential performance issues. Resources for further reading on Java concurrency are also listed.
RabbitMQ is an open source message broker that implements the AMQP protocol. It provides various messaging patterns using different exchange types and supports clustering for scalability and high availability. Administration of RabbitMQ includes managing queues, exchanges, bindings and other components. Integrations exist for protocols like STOMP, MQTT and frameworks like Spring, while security features include authentication, authorization, and SSL/TLS encryption.
The document discusses attacking Java EE application servers by exploring various attack vectors and strategies. It outlines how attacks could originate externally, from within the application server itself, or from deployed applications. It then discusses tools that can be used to exploit vulnerabilities and recommends secure coding practices like applying patches, implementing proper security configurations, and performing testing to harden applications and servers against attacks.
Security Architecture of the Java Platform (http://www.javaday.bg event - 14....Martin Toshev
The document summarizes the evolution of the Java security model from JDK 1.0 to the present. It discusses how the security model started with a sandbox that divided code into trusted and untrusted domains. It evolved to support signed applets, fine-grained access control using security policies, and role-based access with JAAS. More recent updates applied the security model to modules. The document also discusses APIs for secure coding outside the sandbox, like JCA, PKI, JSSE, and following best practices like least privilege.
Modularity of the Java Platform (OSGi, Jigsaw and Penrose)Martin Toshev
Seminar "Modularity of the Java Platform" of the Bulgarian Java User Group.
Topics of the seminar:
Modularity 101
Modularity on top of the platform: OSGi
Modularity of the platform: Jigsaw
OSGi and Jigsaw interoperability: Penrose
Presentation on the new features introduced in JDK 8, presented on the 26.02.2013 in Sofia University in front of students and members of the Bulgarian java user group.
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
Transform Your Communication with Cloud-Based IVR SolutionsTheSMSPoint
Discover the power of Cloud-Based IVR Solutions to streamline communication processes. Embrace scalability and cost-efficiency while enhancing customer experiences with features like automated call routing and voice recognition. Accessible from anywhere, these solutions integrate seamlessly with existing systems, providing real-time analytics for continuous improvement. Revolutionize your communication strategy today with Cloud-Based IVR Solutions. Learn more at: https://thesmspoint.com/channel/cloud-telephony
Mobile app Development Services | Drona InfotechDrona Infotech
Drona Infotech is one of the Best Mobile App Development Company In Noida Maintenance and ongoing support. mobile app development Services can help you maintain and support your app after it has been launched. This includes fixing bugs, adding new features, and keeping your app up-to-date with the latest
Visit Us For :
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
UI5con 2024 - Keynote: Latest News about UI5 and it’s EcosystemPeter Muessig
Learn about the latest innovations in and around OpenUI5/SAPUI5: UI5 Tooling, UI5 linter, UI5 Web Components, Web Components Integration, UI5 2.x, UI5 GenAI.
Recording:
https://www.youtube.com/live/MSdGLG2zLy8?si=INxBHTqkwHhxV5Ta&t=0
Microservice Teams - How the cloud changes the way we workSven Peters
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
Everything You Need to Know About X-Sign: The eSign Functionality of XfilesPr...XfilesPro
Wondering how X-Sign gained popularity in a quick time span? This eSign functionality of XfilesPro DocuPrime has many advancements to offer for Salesforce users. Explore them now!
Top 9 Trends in Cybersecurity for 2024.pptxdevvsandy
Security and risk management (SRM) leaders face disruptions on technological, organizational, and human fronts. Preparation and pragmatic execution are key for dealing with these disruptions and providing the right cybersecurity program.
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdfVALiNTRY360
Salesforce Healthcare CRM, implemented by VALiNTRY360, revolutionizes patient management by enhancing patient engagement, streamlining administrative processes, and improving care coordination. Its advanced analytics, robust security, and seamless integration with telehealth services ensure that healthcare providers can deliver personalized, efficient, and secure patient care. By automating routine tasks and providing actionable insights, Salesforce Healthcare CRM enables healthcare providers to focus on delivering high-quality care, leading to better patient outcomes and higher satisfaction. VALiNTRY360's expertise ensures a tailored solution that meets the unique needs of any healthcare practice, from small clinics to large hospital systems.
For more info visit us https://valintry360.com/solutions/health-life-sciences
Measures in SQL (SIGMOD 2024, Santiago, Chile)Julian Hyde
SQL has attained widespread adoption, but Business Intelligence tools still use their own higher level languages based upon a multidimensional paradigm. Composable calculations are what is missing from SQL, and we propose a new kind of column, called a measure, that attaches a calculation to a table. Like regular tables, tables with measures are composable and closed when used in queries.
SQL-with-measures has the power, conciseness and reusability of multidimensional languages but retains SQL semantics. Measure invocations can be expanded in place to simple, clear SQL.
To define the evaluation semantics for measures, we introduce context-sensitive expressions (a way to evaluate multidimensional expressions that is consistent with existing SQL semantics), a concept called evaluation context, and several operations for setting and modifying the evaluation context.
A talk at SIGMOD, June 9–15, 2024, Santiago, Chile
Authors: Julian Hyde (Google) and John Fremlin (Google)
https://doi.org/10.1145/3626246.3653374
SOCRadar's Aviation Industry Q1 Incident Report is out now!
The aviation industry has always been a prime target for cybercriminals due to its critical infrastructure and high stakes. In the first quarter of 2024, the sector faced an alarming surge in cybersecurity threats, revealing its vulnerabilities and the relentless sophistication of cyber attackers.
SOCRadar’s Aviation Industry, Quarterly Incident Report, provides an in-depth analysis of these threats, detected and examined through our extensive monitoring of hacker forums, Telegram channels, and dark web platforms.
7. Overview of the Graal VM
Some background …
static compilation vs dynamic compilation
static compiler
source code (e.g. JVM bytecode)
dynamic compiler
runtime
machine code
runtime
source code (e.g. JVM bytecode)
machine code
8. Overview of the Graal VM
• The javac tool performs static compilation of Java
sources to bytecode
• The JVM may perform dynamic compilation of
bytecode to machine code for optimization using a
JIT (Just-in-Time) compiler
9. Overview of the Graal VM
• Graal is a new JIT (Just-in-Time) compiler for the
JVM
• Brings the performance of Java to scripting
languages (via the Truffle API)
• written in Java
10. Overview of the Graal VM
• In essence the Graal JIT compiler generates
machine code from an optimized AST rather than
bytecode
• However the Graal VM has both AST and bytecode
interpreters
11. Overview of the Graal VM
• The Graal VM supports the following types of
compilers (apart from the Graal JIT compiler):
--vm server-nograal // server compiler
--vm server // server compiler using Graal
--vm graal // Graal compiler using Graal
--vm client-nograal // client compiler
--vm client // client compiler running Graal
12. Overview of the Graal VM
• The Truffle API:
– is a Java API
– provides AST (Abstract Syntax Tree) representation of
source code
– provides a mechanism to convert the generated AST
into a Graal IR (intermediate representation)
13. Overview of the Graal VM
• The Truffle API is declarative (uses Java
annotations)
• The AST graph generated by Truffle is a mixture of
control flow and data flow graph
• Essential feature of the Truffle API is the ability to
specify node specializations used in node rewriting
14. Overview of the Graal VM
• The Truffle API is used in conjunction with custom
annotation processor that generates code based
on the Truffle annotations used in the interpreter
classes
Truffle
Interpreter
javac
Annotation
processor
Compiled
Interpreter
Generated
Interpreter
source code
15. Overview of the Graal VM
• General architecture:
HotSpot VM (C++)
Graal (Java)
Truffle (Java) Java Other JVM language
JavaScript Ruby R
Other interpreted
language
Graal <–> Hotspot adapter (C++, Java)
Maxine VM (Java)
Graal <–> Maxine
adapter (Java)
16. Overview of the Graal VM
• Let’s see, for example, how a JavaScript interpreter
works in Graal …
17. Overview of the Graal VM
HotSpot VM (C++)
Graal (Java)
Truffle (Java) Java Other JVM language
JavaScript Ruby R
Other interpreted
language
Graal <–> Hotspot adapter (C++, Java)
Run JavaScript file: app.js
18. Overview of the Graal VM
HotSpot VM (C++)
Graal (Java)
Truffle (Java) Java Other JVM language
JavaScript Ruby R
Other interpreted
language
Graal <–> Hotspot adapter (C++, Java)
JavaScript Interpreter parses app.js and converts it to Truffle AST
19. Overview of the Graal VM
HotSpot VM (C++)
Graal (Java)
Truffle (Java) Java Other JVM language
JavaScript Ruby R
Other interpreted
language
Graal <–> Hotspot adapter (C++, Java)
The app.js Truffle AST is converted to Graal IR (AST)
20. Overview of the Graal VM
HotSpot VM (C++)
Graal (Java)
Truffle (Java) Java Other JVM language
JavaScript Ruby R
Other interpreted
language
Graal <–> Hotspot adapter (C++, Java)
The Graal VM has bytecode and AST interpreters along with a JIT compiler
(optimizations and AST lowering is performed to generate machine code
and perform partial evaluation)
21. Overview of the Graal VM
HotSpot VM (C++)
Graal (Java)
Truffle (Java) Java Other JVM language
JavaScript Ruby R
Other interpreted
language
Graal <–> Hotspot adapter (C++, Java)
When parts of app.js are compiled to machine code by the Graal compiler
the compiled code is transferred to Hotspot for execution by means of
Hotspot APIs and with the help of a Graal – Hotspot adapter interface
22. Overview of the Graal VM
HotSpot VM (C++)
Graal (Java)
Truffle (Java) Java Other JVM language
JavaScript Ruby R
Other interpreted
language
Graal <–> Hotspot adapter (C++, Java)
Compiled code can also be deoptimized and control is transferred back to
the interpreter (e.g. when an exception occurs, an assumption fails or a
guard is reached)
23. Overview of the Graal VM
• Optimizations done on the Graal IR include:
– method inlining
– partial escape analysis
– inline caching
– constant folding
– arithmetic optimizations and others …
24. Overview of the Graal VM
• Currently supported languages include:
– JavaScript (Graal.JS)
– R (FastR)
– Ruby (RubyTruffle)
– Experimental interpreters for C, Python, Smalltalk, LLVM
IR and others …
(some are not open-sourced as of the time of this presentation)
25. Overview of the Graal VM
• The SimpleLanguage project provides a showcase
on how to use the Truffle APIs
Source file Parser Truffle AST Graal VM
27. Building the Graal VM
• The Graal VM interoperates with JEP 243: Java-
Level JVM Compiler Interface
• In that regard two modes of operation are
supported – via the Graal VM or via the JVMCI
(JVM Compiler Interface)
28. Building the Graal VM
• Early access builds of Graal available for download
• You can build Graal on any supported platform
(Windows, Linux, MacOS, Solaris) from source
code
29. Building the Graal VM
git clone https://github.com/graalvm/mx.git
export PATH=$PWD/mx:$PATH
git clone https://github.com/graalvm/graal-core.git
cd graal-core
mx --vm graal build
mx vm
30. Building the Graal VM
• The MX tool is a Python (2.7) tool that manages the
Graal projects and allows to:
- update sources and run JUnit tests and benchmarks;
- builds (sub)projects (Java and C++ sources can be built
separately);
- runs VM tools (such as IGV or c1visualizer) that can aid
development of Graal or language interpreters;
- can be used to generate IDE project files for Graal development
(support for Eclipse and NetBeans)
33. Performance benchmarks
• According to various JVM benchmarks such as SPECjvm2008
and Scala Dacapo the Graal compiler positions between the
client and server JVM compilers
(source: One VM to Rule Them All, Thomas Wuertinger)
• In general Truffle interpreters provide much better
performance for some dynamic languages
34. Performance benchmarks
• Graal.JS – shows improvement of 1.5x in some cases
with a peak of 2.6x compared to V8 (running Google Octane’s
benchmark)
• RubyTruffle – shows improvements between 1.5x and 4.5x in some
cases with a peak of 14x compared to JRuby
• FastR - shows improvements between 2x and 39x in some cases
with a peak of 94x compared to GnuR
(source: One VM to Rule Them All, Thomas Wuertinger)
36. Future directions
• Graal provides an extensible framework for
researching and experimenting with other
compiler optimizations
• In that regard new types of compiler optimization
may be introduced in the VM that address runtime
behavior in certain scenarios
37. Future directions
• Graal provides an extensible framework for
creating language interpreters further simplified by
the Truffle API
• In that regard more languages can be introduced
that run in the Graal VM
• Currently existing languages that compile to
bytecode may support Truffle in the future
38. Future directions
• Graal provides an extensible framework for
different types of operating systems and CPU
architectures
• In that regard CPU architectures and operating
systems might be supported by Graal
41. References
Graal - A Bytecode Agnostic Compiler for the JVM, Thomas Wuerthinger, JVM
Language Summit
http://medianetwork.oracle.com/video/player/1113230360001
Graal and Truffle: One VM to Rule Them All
http://www.slideshare.net/ThomasWuerthinger/graal-truffle-
ethdec2013?qid=848a4965-9768-40d5-b167-
ccd8eb7d1659&v=&b=&from_search=2
42. References
Graal and Truffle: Modularity and Separation of Concerns as Cornerstones for
Building a Multipurpose Runtime
http://www.slideshare.net/ThomasWuerthinger/2014-0424-graal-
modularity?qid=0e86ed21-0b8f-4087-9212-
68f76546d674&v=&b=&from_search=4
Dynamic Compilation - Thomas Wuerthinger
https://www.youtube.com/watch?v=RLsG2kE1EMI
https://www.youtube.com/watch?v=U_QpToYLsO0
JVMLS 2012: Graal
http://medianetwork.oracle.com/video/player/1785432492001
43. References
Graal Tutorial at CGO 2015 by Christian Wimmer
http://lafo.ssw.uni-linz.ac.at/papers/2015_CGO_Graal.pdf
Writing a language in Truffle: Part 1 - Using Truffle and Graal
https://cesquivias.github.io/blog/2014/10/13/writing-a-language-in-truffle-
part-1-a-simple-slow-interpreter/
Writing a language in Truffle: Part 2 - Using Truffle and Graal
http://cesquivias.github.io/blog/2014/12/02/writing-a-language-in-truffle-
part-2-using-truffle-and-graal/
45. References
R as a citizen in a Polyglot world: The promise of the Truffle framework
http://user2015.math.aau.dk/presentations/112.pdf
Truffle/C Interpreter
http://www.manuelrigger.at/downloads/trufflec_thesis.pdf
Graal.JS - high-performance JavaScript on the JVM talk by Christian Wirth
https://www.youtube.com/watch?v=OUo3BFMwQFo
Notas del editor
The JVM may also perform deoptimization.
This essentially means the Graal VM can run in client/server mode but also use the Graal JIT compiler in certain scenarios
Truffle can be used for static analysis as well
Truffle can be used for static analysis as well
Without Graal you will be need to write a bytecode compiler.
There are high level optimization on the AST and low level optimization (after the AST is lowered).
In inline caching the callee is cached at the call site instead of a dynamic callee method lookup.
-
Some of the languages are not open-sourced as of the time of this presentation (such as GraalJS).
Interpreter executables are provided in the official distribution under <GraalVM>/bin/ (e.g. <GraalVM>/bin/js for GraalJS)
Up to JDK 9 Graal had to use a modified version of Hotspot.
With JDK9 the JVMCI enables the deployment of Graal on top of an existing JVM without further modifications (using JVMCI).