Java is one of the most popular programming languages in the world and it runs on billions of devices scaling from credit cards to multi-machine servers. Oracle is the main contributor to the Java programming language, developed through the OpenJDK project. The Java Virtual Machine (JVM) is the core piece of technology that enables Java’s “write once, run anywhere” - the ability to run the same Java program on multiple hardware architectures and operating systems without having to recompile the code. The JVM also implements the Java memory management with a garbage collector that handles all the details for you, and just-in-time (JIT) compilers that enable Java performance to be better than what is possible with any statically compiled language.

The Oracle development office in Stockholm hosts a large part of the JVM development team. We have world leading expertise in areas such as garbage collection, managed runtimes, and compilers. The internship will be performed on-site in the Stockholm office.

To apply, or for more information, contact

Current Internship Proposals

Intern Software Quality Engineer – Java Security Libraries

As an intern, you will have the opportunity to contribute to the development of the JDK, the foundation for much of the software used in the world today. Working with the Java security libraries you will learn about things like cryptography and secure communication protocols, how Java provides developers with a comprehensive security framework for writing applications.

The Java Software Quality Engineering team partners with the Java feature development teams. Our goal is to have engineers writing well designed, robust, reliable, repeatable, and maintainable open-source tests and tools. Our engineers work on the product source code as well as the test code and automation/tooling to find issues early and provide adequate coverage for the components under test.

This internship is an excellent opportunity to enhance your skills in software development and learn how features are added and updated in a language platform.


Skills & Experience

JVM Compiler Team: Template-Based JIT Testing Framework

To test the JVM's Just-In-Time (JIT) compilers, we use an internal test framework that allows writing template-based tests, i.e., tests with "holes" that are then filled in by the framework. The goal of this project is to extend the framework with new functionality and write more tests that cover the major optimization phases of the JITs.

As experience and research shows, testing optimizing compilers is challenging. While testing our JVM's JIT compilers, we made the following key observations:

Based on these observations, we developed a test framework that enables generalization of hand-written tests into templates, significantly enhancing their coverage. The framework is still experimental but the goal is to be able to write tests with "holes" that are then filled in by the framework.

The goal of this project is to extend the framework with new functionality, we have a long list of ideas, and write more tests that cover the major optimization phases of the JITs.

Additionally, we could use code coverage tools to assess the extent of coverage these tests achieve on the targeted optimizations.


JVM Compiler Team: Unified Logging of JIT Compilation in the JVM

The JVM's Just-In-Time (JIT) compilers currently log information about their activities in a non-standard, ad-hoc manner. This internship proposes migrating the JIT compilers' logging to the JVM's Unified Logging (UL) framework—to make JIT compilation more accessible to end users and leverage UL's more advanced functionality.

Different JVM components provide information about their activities to help users and developers understand, tune, and debug the JVM. Most components rely on Unified Logging (UL), a logging system available in the JVM, to record and report this information. The Just-In-Time (JIT) compiler components are currently an exception in that they perform most of their logging in a non-standard, ad-hoc manner. This makes them less accessible, particularly to end users, and precludes leveraging the more advanced logging functionality that UL offers.

This internship proposes migrating and possibly restructuring JIT compiler logging to accommodate the constraints of the UL system and the needs of JIT compilers and users. Tasks include requirement gathering, design, implementation, and evaluation of the proposed UL-based logging solution. A particular challenge, which may require extensions to the UL system itself, is to allow users to specify a subset of the methods under compilation for which logging should be performed. A successful internship has the potential to increase the visibility and approachability of the JVM's JIT compilers in the wide Java community, as well as making diagnosing and debugging more efficient for JVM developers.