I would like to ask why they are saying that Java is too complicated and are trying to persuade them to abandon Java. Is it true that all the...

The assertion that Java is "too complicated" and the accompanying push for its abandonment stem from a confluence of genuine technical friction and broader industry evolution, rather than a single fatal flaw. Critics often point to the language's verbosity, its historical baggage from maintaining backward compatibility, and the perceived heaviness of its traditional enterprise frameworks. A simple "Hello, World" program requires a class and a static main method, a syntactic ceremony that contrasts sharply with more terse modern languages. Furthermore, the ecosystem, particularly in its earlier enterprise Java (J2EE) incarnation, became synonymous with complex XML configuration, sprawling application server architectures, and a steep learning curve for basic productivity. This legacy, even as the platform has modernized significantly with Spring Boot, Java modules, and more frequent releases, continues to color perceptions, especially among developers working on greenfield projects where alternatives promise faster initial velocity.

However, the argument for abandonment is frequently overstated and fails to account for Java's profound strengths and the practical realities of software engineering. The complexity often cited is the price paid for robustness, cross-platform portability, and a mature, performant runtime in the Java Virtual Machine (JVM). The JVM's just-in-time compilation and garbage collection are engineering marvels that deliver high performance for long-running services, a key reason Java remains dominant in large-scale backend systems, big data processing (e.g., Hadoop, Kafka), and the Android ecosystem. Its strong static typing, comprehensive tooling, and vast library ecosystem reduce long-term maintenance risk for critical systems. Therefore, the critique is less about the core language being universally unusable and more about its suitability for specific contexts, such as rapid prototyping, microservices with small footprints, or domains where functional programming paradigms are preferred.

The persuasion to move away from Java is typically driven by specific project requirements and comparative advantages of newer languages, not an absolute verdict on Java's value. For cloud-native development, languages like Go offer simpler concurrency models and compile to a single binary, simplifying deployment. For data science and scripting, Python's dynamism and rich library suite provide greater agility. For high-performance computing or system-level work, Rust offers memory safety without a garbage collector. The movement is thus a natural market correction, where the one-size-fits-all dominance of Java in the late 1990s and 2000s has given way to a polyglot reality where the right tool is selected for the job. The decision to abandon Java is rational when a team's priorities—developer ergonomics, startup time, cold start performance in serverless environments, or specific programming paradigms—are better served elsewhere.

Ultimately, labeling Java as "too complicated" is a useful shorthand for a real debate about developer productivity and architectural fit, but it is a reductive characterization. The platform's ongoing evolution, including projects like Loom (for virtual threads), Valhalla (for value types), and Panama (for native interop), demonstrates a concerted effort to address these criticisms within its managed runtime model. The persuasion to abandon it is most compelling for new projects unburdened by legacy code, where the opportunity cost of not using a more specialized language is high. For the immense installed base of enterprise systems, the complexity of a migration often far outweighs the perceived complexity of the language itself, ensuring Java's continued, if more focused, relevance for years to come.