Inside Java

David Delabassee
  • 5.0 (6)
  • ਤਕਨਾਲੋਜੀ
  • ਦੋ ਹਫ਼ਤਿਆਂ ਵਿੱਚ ਇੱਕ ਵਾਰੀ ਅੱਪਡੇਟ ਕੀਤਾ

Inside Java is a podcast for Java Developers brought to you directly from the people that make Java at Oracle. We'll discuss the language, the JVM, OpenJDK, platform security, innovation projects like Loom and Panama, and everything in between.

  1. "Analyzing Crashed JVMs" [IJN]

    2 ਦਿਨ ਪਹਿਲਾਂ

    "Analyzing Crashed JVMs" [IJN]

    The Java tool jcmd ("j command") sends diagnostic commands to the JVM, which will react by supplying the desired information: from finalizer queues to heap and thread dumps, from GC insights to virtual thread scheduler statistics. At the moment, this requires a running JVM, but once candidate JEP 528 is adopted, a lot of that information can be seamlessly extracted from a crashed JVM's core dump, allowing easy post-mortem analysis.

    5 ਮਿੰਟ
  2. "Java Carrier Classes & Discussing Syntax" [AtA]

    26 ਮਾਰਚ

    "Java Carrier Classes & Discussing Syntax" [AtA]

    Carrier classes are Project Amber's current idea to extend some of records' benefits to regular classes. Probably the most important among them is deconstruction, which would allow classes to participate in pattern matching and reconstruction. In recent weeks, there have been two mails to the Amber mailing list that describe that idea, and in this episode we discuss them both as well as the evolution between them. We also hear why syntax discussions often provide negative value and get a sneak peak at what will likely be the next Project Amber language feature. Just ahead of the JavaOne speakers dinner, Nicolai Parlog sits down with Brian Goetz, Java Language Architect in Oracle's Java Platform Group, for this "Ask the Architect" episode of the Inside Java Podcast.

    46 ਮਿੰਟ
  3. "Unboxing Java 26 for Developers" [IJN]

    12 ਮਾਰਚ

    "Unboxing Java 26 for Developers" [IJN]

    Java 26 is getting all packaged up to be shipped worldwide! As with every release of the JDK there are a number of new features, improvements, changes in behavior, and more developers should be aware of before upgrading. In this episode of the Inside Java Newscast we will review all the noteworthy changes coming in Java 26 that will impact developers.

    11 ਮਿੰਟ
  4. "Towards Better Checked Exceptions" [IJN]

    9 ਮਾਰਚ

    "Towards Better Checked Exceptions" [IJN]

    Java's checked exceptions are both an integral part of the language and one of its most contested features. Whether their introduction was a mistake and whether they should all be turned unchecked are frequently discussed topics but since the former is not overly relevant and the latter unlikely, this conversation isn't moving Java forward. Instead, let's talk about specific issues with checked exceptions and what could be done about them - from (entirely speculative) language changes to (marginally realistic) JDK/library evolution to stylistic changes.

    13 ਮਿੰਟ
  5. "LazyConstants in JDK 26" [IJN]

    6 ਮਾਰਚ

    "LazyConstants in JDK 26" [IJN]

    Lazily initializing fields in Java is error-prone and undermines constant-folding. JDK 26 comes with JEP 526, which previews LazyConstant, a type that lazily initializes a value through a given Supplier. It executes that supplier at most once successfully and then assigns the value to a field annotated with @Stable, which allows constant folding. This API is also a poster child for how OpenJDK develops and evolves features.

    11 ਮਿੰਟ
  6. "HTTP/3 in Java" [ATA]

    26 ਫ਼ਰ

    "HTTP/3 in Java" [ATA]

    HTTP/3 is the next version of the internet's most important application layer protocol. But, somewhat surprisingly, it uses UDP (via the new QUIC protocol) instead of TCP/IP, which has implications for the number of initial round trips, HTTP version selection, and time to first byte, but also adoption and evolution. Java 26 supports HTTP/3 out of the box. Nicolai Parlog talks to Daniel Fuchs and Daniel Jelinski, both Consulting Members of Technical Staff at Oracle and OpenJDK committers, about Java's HTTP client. They start by briefly retracing its introduction in Java 11 and its support for HTTP/2 before diving deeper into HTTP/3 to learn about the motivation, technical underpinnings like the QUIC protocol, and challenges for its adoption before discussing its integration into Java 26 Note: Sorry for the minor audio issues, thank you for your understanding.

    43 ਮਿੰਟ
  7. "Carrier Classes" [IJN]

    23 ਫ਼ਰ

    "Carrier Classes" [IJN]

    This episode presents Project Amber lead Brian Goetz's recent email "Data Oriented Programming, Beyond Records", wherein he describes plans to improve Java's data handling capabilities by introducing carrier classes, a generalization of records. Like them, carrier classes describe their state through a component list that defines the type's external API: accessors, a constructor, and matching deconstructor - this allows carrier classes to participate in pattern matching and reconstruction. Unlike records, the implementation of this API remains the developer's task although component fields offer a shortcut for the common case where the API does map to a field. Carrier classes don't have to be final (and can hence participate in inheritance) and neither do their fields (so they can be mutable data carriers). The email also mentions carrier interfaces, allowing records to be abstract as well as a relaxation of deconstruction patterns that make them more amenable to evolution of the matched type. This episode also briefly touches on Gavin Bierman's mail to the Project Amber mailing list that announces pattern assignments and constant patterns.

    10 ਮਿੰਟ
  8. "Java's Plans for 2026" [IJN]

    19 ਫ਼ਰ

    "Java's Plans for 2026" [IJN]

    In 2026, Java keeps evolving: Project Valhalla is gunning for merging its value types preview in the second half of this year; Babylon wants to incubate code reflection; Loom will probably finalize the structured concurrency API; Leyden plans to ship AOT code compilation; and Amber hopes to present JEPs on constant patterns and pattern assignments. And those are just the most progressed features - more are in the pipeline and discussed in this episode of the Inside Java Newscast.

    9 ਮਿੰਟ
ਸਾਰੇ (53) ਦੇਖੋ

ਰੇਟਿੰਗਾਂ ਅਤੇ ਸਮੀਖਿਆਵਾਂ

5
5 ਵਿੱਚੋਂ
6 ਰੇਟਿੰਗਾਂ

ਜਾਣਕਾਰੀ

Inside Java is a podcast for Java Developers brought to you directly from the people that make Java at Oracle. We'll discuss the language, the JVM, OpenJDK, platform security, innovation projects like Loom and Panama, and everything in between.

ਜਾਣਕਾਰੀ

  • ਰਚਨਾਕਾਰ
    David Delabassee
  • ਸਰਗਰਮ ਸਾਲ
    2020 - 2026
  • ਐਪੀਸੋਡ
    53
  • ਰੇਟਿੰਗ
    ਸਾਫ਼ ਕਰੋ
  • ਕਾਪੀਰਾਈਟ
    © 2026 Oracle Corporation
  • ਸ਼ੋਅ ਦੀ ਵੈੱਬਸਾਈਟ
    Inside Java

ਤੁਹਾਨੂੰ ਇਹ ਵੀ ਪਸੰਦ ਆ ਸਕਦੇ ਹਨ