Take look at this [announcement][1]:

&gt;For product releases after Java SE 8, Oracle will designate a release, every three years, as a Long-Term-Support (LTS) release.

This means another LTS (ver. 17) should be 3 years after Java 11, so in September 2021. Java 14, however, was released in March 2020, so no LTS.

Java 8 is LTS, but it is not a part of 3-year release cycle, which was announced long after the release of java 8.

  [1]: https://www.oracle.com/java/technologies/java-se-support-roadmap.html

As others have quoted, Oracle is to designate a release as LTS every 3 years.  However, as I read this policy, the designated release does *not* need to be the last one, or even one produced during the same year.  For example, the release to be designated as LTS during 2021 could be (though not very probably) Java 14 instead of 16 or 17, depending on adoption, stability, and other important factors.  If this were the correct interpretation, I&#39;d actually agree with it as it would not put the development of new features on freeze (or severe slowdown) as the end of each 3-year period approaches.

Bottom line, we&#39;ll see.

I get the following error messages when I open my terminal, Hyper: 

```
[oh-my-zsh] Insecure completion-dependent directories detected:
drwxrwxr-x  7 dwaynethe2nd  admin  224 Apr 25 15:00 /usr/local/share/zsh
drwxrwxr-x  4 dwaynethe2nd  admin  128 Apr 25 14:53 /usr/local/share/zsh/site-functions
```

Zsh detects insecure completion-dependent directories

I&#39;m creating a system where I want to generate Google Meet meeting from NodeJS code. Is there API for creating a new meeting in Google Meet ? There is button `Create new meeting ` on https://meet.google.com/ and I want to do something similar using API&lt;br/&gt;
I know that it is possible to create meeting using Google Calendar API but I&#39;m looking for direct API for Google Meet without creating calendar event. 

[EDIT]
It does not solve my problem, but maybe would help someone else. There is also option to generate meeting using https://meet.google.com/lookup/[custom-meeting-name] but you need to have Google Workspace (former GSuite)

Is there direct API for Google Meet?

Java 14 is **non-LTS**.

Given the new release train of 6 monthly releases and that 8 and 11 were LTS, should Java 14 not have been the **next LTS release**?

Or is purely based on the Java architects to decide which they pick for LTS?

I did search online but couldn&#39;t find an answer. 

Why is Java 14 not LTS?

Java 14 is non-LTS.
Given the new release train of 6 monthly releases and that 8 and 11 were LTS, should Java 14 not have been the next LTS release?
Or is purely based on the Java architects to decide which they pick for LTS?
I did search online but couldn't find an answer.

I figure most of you know that `goto` is a reserved keyword in the Java language but is not actually used. And you probably also know that `goto` is a Java Virtual Machine (JVM) opcode. I reckon all the sophisticated control flow structures of Java, Scala and Kotlin are, at the JVM level, implemented using some combination of `goto` and `ifeq`, `ifle`, `iflt`, etc.

Looking at the JVM spec https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.goto_w I see there&#39;s also a `goto_w` opcode. Whereas `goto` takes a 2-byte branch offset, `goto_w` takes a 4-byte branch offset. The spec states that 

&gt; Although the *goto_w* instruction takes a 4-byte branch offset, other factors limit the size of a method to 65535 bytes (&#167;4.11). This limit may be raised in a future release of the Java Virtual Machine.

It sounds to me like `goto_w` is future-proofing, like some of the other `*_w` opcodes. But it also occurs to me that maybe `goto_w` could be used with the two more significant bytes zeroed out and the two less significant bytes the same as for `goto`, with adjustments as needed.

For example, given this Java Switch-Case (or Scala Match-Case):

```
     12: lookupswitch  {
                112785: 48 // case &quot;red&quot;
               3027034: 76 // case &quot;green&quot;
              98619139: 62 // case &quot;blue&quot;
               default: 87
          }
      48: aload_2
      49: ldc           #17                 // String red
      51: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      54: ifeq          87
      57: iconst_0
      58: istore_3
      59: goto          87
      62: aload_2
      63: ldc           #19                 // String green
      65: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      68: ifeq          87
      71: iconst_1
      72: istore_3
      73: goto          87
      76: aload_2
      77: ldc           #20                 // String blue
      79: invokevirtual #18 
      // etc.
```

we could rewrite it as 

```
     12: lookupswitch  { 
                112785: 48
               3027034: 78
              98619139: 64
               default: 91
          }
      48: aload_2
      49: ldc           #17                 // String red
      51: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      54: ifeq          91 // 00 5B
      57: iconst_0
      58: istore_3
      59: goto_w        91 // 00 00 00 5B
      64: aload_2
      65: ldc           #19                 // String green
      67: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      70: ifeq          91
      73: iconst_1
      74: istore_3
      75: goto_w          91
      79: aload_2
      81: ldc           #20                 // String blue
      83: invokevirtual #18 
      // etc.
```

I haven&#39;t actually tried this, since I&#39;ve probably made a mistake changing the &quot;line numbers&quot; to accommodate the `goto_w`s. But since it&#39;s in the spec, it should be possible to do it.

My question is whether there is a reason a compiler or other generator of bytecode might use `goto_w` with the current 65535 limit other than to show that it can be done?

Do any compilers for the JVM use the &quot;wide&quot; goto?

I am getting this exception  `
java.lang.NoClassDefFoundError: Could not initialize class org.codehaus.groovy.vmplugin.v7.Java7  and java.lang.NoClassDefFoundError: Could not initialize class org.codehaus.groovy.reflection.ReflectionCache
`) when i run the spring boot application

I am using below tools

***STS 3.9.10 release &lt;br/&gt;
Open JDK 14 64 bit &lt;br/&gt;
Spring boot 2.2.5 &lt;br/&gt;***

It worked fine with oracle jdk but its failing to run with openjdk.  I am not using any groovy libs. This is maven based spring boot project.


java.lang.NoClassDefFoundError: Could not initialize class org.codehaus.groovy.vmplugin.v7.Java7

I love project [Lombok](https://projectlombok.org/) but in these days I&#39;m reading and trying some of the new features of java 14.

Inside the new capability, there is the [record](https://openjdk.java.net/jeps/359) keyword that allows creating a class with already built-in the following functionality: constructor, private final fields, accessors, equals/hashCode, getters, toString methods.

Now my question is: is better to rely on the feature of Lombok or should we start using the record functionality:

Is better to use this:

```java
record Person (String name, String surname) {}
```

or that:

```java
@AllArgsConstructor
@ToString
@EqualsAndHashCode
public class Person {
  @Getter private int name;
  @Getter private int surname;
}
```

What are the pros and cons of the both approach?


Lombok getter/setter vs Java 14 record

What is the difference between Azul OpenJDK, Zulu OpenJDK and OpenJDK?

I have a legacy application that takes an integer, converts it to a binary string, reverses that string, and then gets the positions of bits (ones) as a list of integers.  For example:

```
6 -&gt; &quot;110&quot; -&gt; &quot;011&quot; -&gt; (2,3) 
7 -&gt; &quot;111&quot; -&gt; &quot;111&quot; -&gt; (1,2,3)
8 -&gt; &quot;1000&quot; -&gt; &quot;0001&quot; -&gt; (4)
```

What is a succinct and clear way to accomplish this in modern Java without the String operations? The conversion to and from String seems wasteful to me, and I know there&#39;s no simple way to flip a String (no `String.reverse()`) anyway.

In Java, how to get positions of ones in reversed binary form of an integer?

When compiling the code below with the Java compiler from OpenJDK 8, the call to `foo()` is done via an `invokespecial`, but when OpenJDK 11 is used, an `invokevirtual` is emitted.

```java
public class Invoke {
  public void call() {
    foo();
  }

  private void foo() {}
}
```

Output of `javap -v -p` when `javac` 1.8.0_282 is used:

```
  public void call();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #2      // Method foo:()V
         4: return
```

Output of `javap -v -p` when `javac` 11.0.10 is used:

```
  public void call();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokevirtual #2      // Method foo:()V
         4: return

```

I don&#39;t get why `invokevirtual` is used here since there cannot be an override of `foo()`.

After digging a bit it seems that the purpose of `invokevirtual` on private methods is to allow nested classes to call private methods from the outer class. So I tried the code below:

```java
public class Test{
  public static void main(String[] args) {
    // Build a Derived such that Derived.getValue()
    // somewhat &quot;exists&quot;.
    System.out.println(new Derived().foo());
  }

  public static class Base {

    public int foo() {
      return getValue() + new Nested().getValueInNested();
    }

    private int getValue() {
      return 24;
    }

    private class Nested {

      public int getValueInNested() {
        // This is getValue() from Base, but would
        // invokevirtual call the version from Derived?
        return getValue();
      }
    }
  }

  public static class Derived extends Base {

    // Let&#39;s redefine getValue() to see if it is picked by the
    // invokevirtual from getValueInNested().
    private int getValue() {
      return 100;
    }
  }
}
```

Compiling this code with 11, we can see in the output of `javap` that `invokevirtual` is used both in `foo()` and in `getValueInNested()`:

```
  public int foo();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=4, locals=1, args_size=1
         0: aload_0

         // ** HERE **
         1: invokevirtual #2  // Method getValue:()I
         4: new           #3  // class Test$Base$Nested
         7: dup
         8: aload_0
         9: invokespecial #4  // Method Test$Base$Nested.&quot;&lt;init&gt;&quot;:(LTest$Base;)V
        12: invokevirtual #5  // Method Test$Base$Nested.getValueInNested:()I
        15: iadd
        16: ireturn
```

```
  public int getValueInNested();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: getfield      #1  // Field this$0:LTest$Base;

         // ** HERE **
         4: invokevirtual #3  // Method Test$Base.getValue:()I
         7: ireturn
```

All of this is a bit confusing and raises some questions:

* Why `invokevirtual` is used to call private methods? Is there a use case where replacing it by an `invokespecial` would not be equivalent?
* How does the call to `getValue()` in `Nested.getValueInNested()` not pick the method from `Derived` since it is called via `invokevirtual`?

Why does the Java compiler 11 use invokevirtual to call private methods?

We&#39;re currently migrating from Java 8 to Java 11. However, upgrading our services was less painful, than we anticipated. We basically only had to change the version number in our `build.gradle` file and the services were happily up and running. We upgraded libraries as well as (micro) services that use those libs. No problems until now.

Is there any *need* to actually switch to modules? This would generate needless costs IMHO. Any suggestion or further reading material is appreciated.

To clearify, are there any consequences if Java 9+ code is used without introducing modules? Can it e.g. become incompatible with other code?

Is there any need to switch to modules when migrating to Java 9 or later?

The `record` preview feature (JEP 384) introduced in JDK 14 are a great innovation. They make it much easier to create simple immutable classes that are a pure collection of values without the loss of context inherent in the generic tuple classes in various libraries.

The description of the JEP, written by Brian Goetz (https://openjdk.java.net/jeps/384) explains the intent very well. However I was expecting a closer association with the eventual introduction of value types. The original aims of value types were quite extensive: essentially allowing potentially significant performance improvements for objects whose *value* is all that matters by removing all the overhead not required for these types of object (e.g. reference indirection, synchronisation). Plus it could provide syntactical niceties such as `myPosition != yourPosition` instead of `!myPosition.equals(yourPosition)`.

It seems as though the restrictions of records are very close to the types of restrictions that would be required on a potential value type. Yet the JEP makes no reference to these aims in the motivation. I tried unsuccessfully to find any public records on these deliberations.

So my question is: are records intended to be part of a possible move towards value types or are these completely unrelated concepts and future value types may look completely different?

My motivation for asking the question: if records become a permanent part of the language it would be an added incentive to adopt them in code if there is the possibility of significant performance benefits in a future release.



Content Type	Original Author	Original Content on Stackoverflow
Question	Andy Cribbens	View Question on Stackoverflow
Solution 1 - Java	Andronicus	View Answer on Stackoverflow
Solution 2 - Java	Mario Rossi	View Answer on Stackoverflow

Why is Java 14 not LTS?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Is there direct API for Google Meet?

Zsh detects insecure completion-dependent directories

Attributions