Java Language & PlatformConference50min
Big Runtimes Make Efficient Programs
Large runtimes, like the JVM, can improve both convenience and performance by enabling JIT compilation and garbage collection. This challenges the idea that smaller runtimes and more compile-time decisions are always faster, showing the real tradeoffs are more complex.
talk.summaryAiDisclaimer
Ron PresslerOracle
talkDetail.whenAndWhere
Wednesday, October 7, 16:40-17:30
TBA 6
talks.roomOccupancytalks.noOccupancyInfo
Every programming language except Assembly has a runtime - some bundled code that isn't a direct output of the compiler - that is used by most programs. Some programming languages, Java among them, have a relatively large runtime. Programming languages with relatively small runtimes tend to extract more information and make more decisions at compile-time, and some may intuit that this makes such programs faster. As we'll see, this intuition is wrong. A large runtime can not only make it more convenient to write many programs but also improve program performance.
AOT compilation and manual (or statically-determined) memory management introduce performance overheads that can become significant especially in large programs. While the JVM got its start as an effective way to abstract away differences in operating systems and hardware, it quickly became apparent that JIT compilers and moving garbage collectors serve as optimization vehicles for the overheads incurred by low-level languages with smaller runtimes, making the JVM an ideal target for large programs.
We will look at how big, sophisticated runtimes can make programs more efficient, see why the simplistic view of the convenience/performance tradeoff is wrong and how the real tradeoffs are more complex and interesting.
AOT compilation and manual (or statically-determined) memory management introduce performance overheads that can become significant especially in large programs. While the JVM got its start as an effective way to abstract away differences in operating systems and hardware, it quickly became apparent that JIT compilers and moving garbage collectors serve as optimization vehicles for the overheads incurred by low-level languages with smaller runtimes, making the JVM an ideal target for large programs.
We will look at how big, sophisticated runtimes can make programs more efficient, see why the simplistic view of the convenience/performance tradeoff is wrong and how the real tradeoffs are more complex and interesting.