It was a keenly watched race. The race to the top slot among general purpose programming languages. It apparently affected a lot many people than we thought it should.

The associated messaging was partisan in nature. Java got associated with the legacy while Python got associated a few new age computing like the Cloud or AI or ML. Java is equally capable of running AI/ML workloads. But in today's world, labelling has gained much higher weighage than independent analysis.

Around the same time, the world woke up to a fact that Java, the torchbearer of the open source movement, was actually not completely free. It had an owner, and the owner had the right to charge for its use.
That was the original notice that shook the open source world. The amount Oracle asked for was nominal. People were enraged about the betrayal of the open source cause. SMEs, who had used Java for anything and everything, did not know where to hide for cover. More than money, it was the additional paperwork that bothered many.

Popular support for Java was on the wane for quite some time. Developers no longer liked the verbosity that invariably came with static and strong typing. A "Hello World" in Java cannot be shorter than this:
class HelloWorld {


    public static void main(String[] args) {


        System.out.println("Hello, World!"); 


    }


}
While in Python it is:
print('Hello, world!')
Java's behaviour is distinctly bureaucratic when it comes to handling "foreign" objects like database connections or XML files.

Here is some minimalistic code for parsing each element of an XML element and printing its value:
public class XMLParser {


   public static void main(String[] args){


      try {


         DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();


         Document doc = dBuilder.parse(new File("xml input"));


         NodeList nl=doc.getDocumentElement().getChildNodes();





         for(int k=0;k<nl.getLength();k++){


             printTags((Node)nl.item(k));


         }


      } catch (Exception e) {/*err handling*/}


   }





   public static void printTags(Node nodes){


       if(nodes.hasChildNodes()  || nodes.getNodeType()!=3){


           System.out.println(nodes.getNodeName()+" : "+nodes.getTextContent());


           NodeList nl=nodes.getChildNodes();


           for(int j=0;j<nl.getLength();j++)printTags(nl.item(j));


       }


   }


}
@ Source https://stackoverflow.com/questions/14566596/loop-through-all-elements-in-xml-using-nodelist

In Python you just do this:
import xml.etree.ElementTree as ET


tree = ET.parse('test.xml')


for elem in tree.iter():j


     print(elem)
Python literature is replete with examples like that. There is a "Pythonic" way of writing Python. It is concise and elegant. Functions are Objects too. That opens up a lot of possibilities for dynamic programming.

So is it time for IT Managers all over the world to panic and rush to move out of legacy Java code? Like their previous generation had to do with COBOL? Fortunately, Java runs on its own virtual machine, which gives system scientists an opportunity to use it for developing and executing other programming languages as well for the same environment. Wikipedia comes up with a long categorised list when queried. Out of that, the following are the popular ones:
The others, in different stages of growth and decline, are attached below:
Out of the popular ones, only Groovy can take on Python head on. It is concise and dynamically typed. A product of the Apache Foundation, Groovy occasionally shows the intellectual brilliance usually associated with the group. It is good to see the features like record class, anonymous functions, domain specific language etc. implemented. It is also deeply reassuring that there exist people who do not shy away from intellectual rigour.