Aug 12, 2022 (Market Insight Reports) -- New Jersey, United States- In this report by infinity Business Insights we have assessed the Rising benefits of business in the Java Web Frameworks Software market along the edge of developing endeavors of clients, and creating pay of groups towards the organizations are important for the statute concerns pushing the benefits improvement of the Java Web Frameworks Software market. Rising revenue for delayed helpfulness and reasonable abilities is one of the indispensable components to incite the improvement of the market throughout the decided time span. Another component to help with creating, the advancement of the Java Web Frameworks Software market is the developing name for inside the area as a result of the rising inside the example for globalization.
In any case, the figures and measurements of the Java Web Frameworks Software market in assessments to cultivate its prevalence inside the market by means of 2030. On account of the unbelievable premium and gigantic improvement in purchasers, the Asia Pacific district is projected to increment with the fastest CAGR at some stage in the decided span. China, Japan, and India are likely the most crucial customers across the world.
Receive the Sample Report of Java Web Frameworks Software Market 2022 to 2030:
The worldwide Java Web Frameworks Software market is expected to grow at a booming CAGR of 2022-2030, rising from USD billion in 2021 to USD billion in 2030. It also shows the importance of the Java Web Frameworks Software market main players in the sector, including their business overviews, financial summaries, and SWOT assessments.
Java Web Frameworks Software Market Segmentation & Coverage:
Java Web Frameworks Software Market segment by Type:On-premise, Cloud-based
Java Web Frameworks Software Market segment by Application:Individual, Enterprise, Others
The years examined in this study are the following to estimate the Java Web
Frameworks Software market size:
History Year: 2015-2019Base Year: 2021Estimated Year: 2022Forecast Year: 2022 to 2030
Cumulative Impact of COVID-19 on Market:
The review investigates client conduct and utilization, purchasing behaviors, organization processes, venture designs, and specialist connections inside the COVID-19 pandemic. The impact of the COVID-19 pandemic on the Java Web Frameworks Software market is tried seriously in this study report, which integrates specific insights, investigation, assessments, and expectations. The Java Web Frameworks Software Market studies look at moreover a close a take notice of the merchant and client scenes, notwithstanding key market methods for acquiring a forceful advantage inside the Java Web Frameworks Software market.
This report gives verifiable and gauges pay development at a global, close by, and America and gives an evaluation of the Java Web Frameworks Software market characteristics in every space and for sections from 2021 to 2030. For the reason for this report, Infinity Business Insights has sectioned the worldwide Java Web Frameworks Software market on type, application, rate reach, goal, and benefits channel to furnish its clients with explicit measurements.
The Key companies profiled in the Java Web Frameworks Software Market:
The study examines the Java Web Frameworks Software market’s competitive landscape and includes data on important suppliers, including Pivotal Software, Google, Vaadin, Meteor Development Group, Haulmont, Mozilla, Atlassian, Blue Spire, ObjectPlanet, Oracle, Secure Code Warrior, Big Faceless Organization, Liferay, Leaning Technologies, Codekitapp,& Others.
Microsoft Launches New Resource for Java Developers
Microsoft Launches New Resource for Java DevelopersBy David Ramel
Microsoft launched a resource web page for Java developers, described as a one-stop shop for tools and resources that enable Java jocks to productively code, deploy and scale their apps.
It's an expansion of continued investments in the Java developer experience and ecosystem from Microsoft, which on its site for the Microsoft Build of OpenJDK proclaims "We use more Java than one can imagine" across properties including Azure, Minecraft, SQL Server, Visual Studio Code, LinkedIn and more.
According to a spokesperson, the new Java at Microsoft web page features:
Resources including documentation, videos and samples that help Java developers build and scale efficiently on Microsoft Azure or any other OS.
A PDF that outlines how to code, deploy and scale Java development, empowering developers to use any tool, framework and application server on any OS.
A second paper that illustrates best practices from Microsoft on how the company itself uses Java, including significant parts of its business.
Regarding the best practices listed in that latter bullet point above, the site, for one example, can lead developers to FastTrack for Azure, which even targets ISVs and startups specifically with technical guidance and best practices to build apps on Azure in a custom program.
Another offering on the site, the "Code, Deploy, and Scale Java Your Way" e-book (bullet point No. 2 above), promises to help readers:
Continue writing code using the Java tools and frameworks they already know and love.
Deploy their Java applications using their preferred application servers and open source software.
Scale their Java applications easily and confidently including necessities such as security, supporting data and messaging services, caching, monitoring and automation.
"Many people are surprised to learn that we're using Java to run significant parts of Microsoft--and empower thousands of customers to do the same," said Microsoft's Julia Liuson in an Aug. 30 blog post on the company's Tech Community site titled "Microsoft is committed to the success of Java developers."
"Specifically, Bing -- Microsoft's web search engine, which also powers the search feature in the Windows Start menu -- uses Java to perform indexing-related functions," Liuson continued. "Beyond Bing, Azure's infrastructure control plane, and other divisions such as LinkedIn, Minecraft and Yammer use Java extensively. We have deployed over 2 million JVMs for our internal systems and business needs.
"We actively support Java community organizations to invest in and help promote the future of Java. We contribute to OpenJDK, and Eclipse Adoptium, Jakarta EE and MicroProfile in the Eclipse Foundation; we are also a member of the Java Community Process."
Microsoft Amps up its Support for Java Developers with a New Website
Microsoft today announced the launch of a new website designed to provide Java developers with a new level of support in the form of tools and resources that enable them to code, deploy, and scale their apps more productively.
The website is another brick in the foundation of support for Java developers that Microsoft has been building over the last couple of years (which my colleague, David Ramel, has been tracking quite diligently in Visual Studio Magazine.) The new site is chock-a-block (pun intended) with content and links to technical documentation, learning paths, and on-demand videos from Microsoft conferences and its Java Cloud Developer Advocacy team.
The list of resources provided by the site includes:
Documentation, videos, and samples designed to help Java developers build and scale efficiently on Microsoft Azure and other operating systems
A PDF that outlines how to code, deploy, and scale Java development meant to empower developers to use any tool, framework, and/or application server on any operating system
A white paper that illustrates best practices from Microsoft on how the company itself uses Java, including significant parts of its business.
"Many people are surprised to learn that we’re using Java to run significant parts of Microsoft," wrote Julia Liuson, President of Microsoft's Developer Division, in a blog post, "and to empower thousands of customers to do the same."
Liuson pointed out that Bing, Microsoft’s web search engine, which also powers the search feature in the Windows Start menu, uses Java to perform indexing-related functions. She also cited Azure’s infrastructure control plane and other divisions, such as LinkedIn, Minecraft, and Yammer, that use Java extensively. And Microsoft has deployed more than two million Java virtual machines (JVMs) for the company's "internal systems and business needs," she said.
As I reported in July, Microsoft joined two working groups in the Eclipse Foundation this year: the Jakarta EE Working Group, which focuses on the overall evolution of enterprise Java, and the MicroProfile Working Group, which focuses on optimizing enterprise Java for a microservices architecture. Microsoft also supports several other Java community organizations, including OpenJDK, and Eclipse Adoptium, Jakarta EE, and the venerable Java Community Process. And in 2019, it acquired leading Java app optimizer jClarity.
Redmond has partnered with a truly impressive number of leading vendors in the Java ecosystem. Azure Spring Apps, for example, was developed jointly with Pivotal /VMWare to provide native integrations with third-party application performance monitoring (APM) tools from New Relic, App Dynamics, Dynatrace, and Elastic. Microsoft's list of jointly developed solutions also includes Red Hat JBoss EAP on Azure App Service, WebSphere Application Server, WebSphere Liberty, and Open Liberty on Azure, Oracle WebLogic Server on Azure VMs and Azure Kubernetes Service, and Apache Kafka for Confluent Cloud. The has also attracted marquee names to Java on its Azure cloud platform, including Adobe, AIA, Bosch, Daimler, FedEx, J.B. Hunt, Kroger, Maersk, Mercedes Benz, and Swiss Re. The new website also links to an ebook entitled Code, Deploy, And Scale Java Your Way: Empowered Java Application Development in The Cloud. It's about building, migrating, and scaling Java apps on Azure. In the foreword, the author, Asir Selvasingh, a Principal Architect for Java on Microsoft Azure, writes: "I have witnessed Microsoft’s commitment to the Java ecosystem from the first row consistently for many years now…. Today, more and more Java developers are looking at how they can bring their existing Java applications to the cloud, or at how to build new cloud-native applications. This e-book covers the entire journey for developers and operators to code, deploy, and scale with confidence." (The author is worth following on Twitter.)
Another ebook linked to the site, How Microsoft Applies Java: The Inside Story, was written by Bruno Borges, Principal PM Manager in Microsoft's Java Engineering Group, and Theresa Nguyen, Senior Product Manager in that group. It's a great timeline of Microsoft's evolution from days of the Holy War on Anything Not .NET or Windows to its all-in embrace of open-source technologies.
Microsoft's commitment to Java has been real for some time, so that's not actually news, but I do think this latest step in the company's evolving investment in Java is worth reporting—and for you Java jocks out there, the website is worth a look.
Java Champion James Ward on the State of Java and JVM Languages
Key TakeawaysJava is still a great language, but Kotlin is a faster-developing, incremental alternative, while Scala takes Functional Programming to some extremes.
James prefers languages that let him write more correct code through a high level of validation at compile time.
Through Scala, James found programming paradigms and experiences that have altered his way of thinking.
Default mutability in Java is a "trillion-dollar mistake" because it makes it hard to reason about what the code does.
Project Loom’s approach is a game-changer because it removes the cognitive overload of reactive programming.
James Ward is a Java Champion and Kotlin Product Manager at Google. He hosts the "Happy Path Programming" podcast with Bruce "Thinking in Java" Eckel. In one episode, Eckel spoke of "people who are still trapped in the Java world." Ward agreed and called default mutability in Java the "trillion-dollar mistake" (referencing the "billion-dollar mistake" of NullPointerExceptions). InfoQ got curious about this Java champions' view on Java and asked Ward some questions. Here are the answers.
What is the role of the Kotlin Product Manager at Google? What are your day-to-day responsibilities?
Ward: There are two sides to the Kotlin PM job. I work with our Android teams and JetBrains on Kotlin language improvements and growth. I also work with many engineering teams within Google to help make their server-side and Android migrations from Java to Kotlin successful.
What is the state of JVM languages in 2022?
Ward: I began using the Java programming language 25 years ago and think it is still a great language. But I've also been able to work with more modern JVM languages over the past ten years, including Scala and Kotlin. Scala is great for developers wanting to take Functional Programming to some extremes. Kotlin is more of an incremental step for existing Java developers having good support for some Functional paradigms like immutability and sum types but lacking some of the "Monadic" features that Scala has. Both Kotlin and Scala have great interoperability with Java, enabling ecosystem sharing. JVM developers have many options for great languages and a lot of tooling overlap (build tools, IDEs, production/introspection tools, etc.). It is great that on the JVM, in one large ecosystem, there is such a spectrum of language options.
InfoQ: How much JVM back-end development happens in Kotlin these days? And how do you think Kotlin could become more popular there?
Ward: Overall, the Kotlin share of JVM servers is fairly small, but it is growing quickly. Google, for example, has seen significant growth in the use of Kotlin for server-side development. Developers who've either switched from Java or come from other languages report they are very satisfied with the experience. Null safety, coroutines, and expressiveness are often noted as important reasons why Kotlin is more productive and fun to work with.
Kotlin will definitely continue to grow on the server-side. Spring, Quarkus, and Micronaut have done quite a bit of work to make their Kotlin experiences great (such as coroutine interoperability for Reactive). Enterprises generally move pretty slowly with new technologies. Still, for many the move to Kotlin (on the JVM) is a much less risky and disruptive change than moving to Rust (for example). Also, Kotlin's interoperability with Java helps code migrations to be incremental instead of rewrites. Many teams I've worked with just add new code in Kotlin to an existing Java codebase.
Ward: If I were designing a programming language, I'd aim to have fewer searches and questions asked about my language. ;) Having been a programmer for over 30 years, I tend more towards languages that enable me to write more "correct" code that is testable and reusable. I don't like surprises in production, and I want to be able to refactor without fear. Having a compiler that can perform a high level of validation on my program is an essential feature. Sure I might not be able to write raw code as fast as others, but I do write code that is pretty unlikely to have bugs in production. If you consider fixing production bugs as part of the development cycle, then using modern languages on the JVM likely provides the highest productivity possible for many problem domains.
GraalVM produces native Java applications that start faster and use less memory. How will this affect the competitive position of JVM languages in the cloud?
Ward: Startup and memory overhead have definitely hindered the adoption of JVM technologies in some problem spaces (serverless, CLIs, Kubernetes operators, etc.). GraalVM Native Image, Kotlin/Native, and Scala Native help take these languages to places where typically interpreted or native languages used to be a better fit. Now we can have our cake (fast startup and minimal memory overhead) and eat it too (modern high-level languages). I recently created a server with the Kotlin Ktor library, which I can run on the JVM or compile to native with both Kotlin/Native and GraalVM Native Image. In the native case, the startup time was about 2 ms, the memory usage was 11 MB, and the binary was compacted down to 700 KB. For many use cases, we no longer need to make tradeoffs between native and modern/high-level languages.
What makes Scala so appealing to you?
Ward: Scala has a long learning curve. After over ten years with the language, I still feel like a novice. Which is great for me because I love learning new programming languages and enjoy the challenge. I also have really bought into many of the principles of Functional Programming but have not yet followed those all the way to Haskell, so Scala is a good place to be somewhat comfortable with JVM-based FP. I'm currently writing a book with Bruce Eckel and Bill Frasure about Effect Oriented Programming in Scala 3 and ZIO 2. Functional Effects represent a concept that makes a significant difference to the quality of software we create but isn't well supported yet in Java or Kotlin. There are many reasons to choose Java or Kotlin, but concepts like Effects are not on that list.
For which applications or problems is Scala a perfect fit? Where is it not?
Ward: Many factors determine technology fit. I've worked on projects recently where team structure implied that Java and Spring Boot were the best fit for the environment. One of the most significant factors to "fit" is the technology the team wants to use. I think this aligns with my Kotlin PM job goals which revolve around helping make Kotlin a technology that developers want to use.
JetBrains claims Kotlin is a "better Java," but Java is still 5-12 times as popular. Where do you see Kotlin's role today? And what will its role be in the future?
Ward: The Java language has evolved over time. But as the language architect (Brian Goetz) describes — it has a "last mover advantage," which in many cases is the right choice. If startups live by the slogan "move fast and break things," then enterprises live by the slogan "move slowly and break nothing," which is pretty consistent with how the Java language has evolved over the past 20 years or so. For me, I like to move faster than typical enterprise organizations enable (due to compliance, security, regulatory, and other reasons). So yeah, Kotlin is in some ways a "better Java," but "better" for me may not be "better" for everyone, and that is OK. The JVM and Android support both Java and Kotlin — and that is a good thing.
InfoQ: In episode 51 of your Happy Path Programming podcast, Bruce Eckel spoke of "people who are still trapped in the Java world" (around 33:15). You agreed. Please explain to our readers why you and Bruce feel this way.
Ward: 25 years ago, I wrote my Java like I wrote my Perl. Bruce's "Thinking in Java" transformed how I thought about programming. Now both Bruce and I have found programming paradigms and experiences that have had the same effect, totally altering the way we think about things. Bruce and I have not experienced these disruptions through Java (the language) but through other languages. I believe what Bruce and I were highlighting in that episode was not a knock against Java (the language) but a hope that programmers continually learn and find ways to grow, just as both Bruce and I have.
InfoQ: As described by Tony Hoare, NullPointerExceptions are the "billion-dollar mistake." Null safety in a language is the fix. Kotlin has it, and Dart and Swift even have sound null safety. Java doesn't have it and doesn't seem to get null safety anytime soon. Why do you think that is?
Ward: In Java, EVERYTHING that is not a primitive value is nullable. And it would require a massive overhaul of the whole language and standard library to change that. Many modern languages have a foundational principle that nullability should be expressed through the type system. It is just very hard or impossible to bolt on later. As described earlier, I aim to write programs that are more verifiably correct at compile time, and explicit nullability is one way I do that. One of the reasons I don't use the Java language much anymore is because expressing nullability in a compiler-verified way is tough.
InfoQ: You said that adding null safety is "very hard or impossible to bolt on later." Google's Dart accomplished this by adding null safety for applications and libraries seven years after version 1.0. ;-) Anyhow, what's your advice to Java developers who want to have fewer NullPointerExceptions?
Ward: The hard part isn't the language feature. It is all the APIs. According to the type system, everything in the Java standard library and most everything in the Java library ecosystem is nullable. For null safety to be useful and not gigantically annoying to deal with, all underlying types must correctly express their nullability. This is the change that is very hard or impossible to make.
InfoQ: In the same "Happy Path Programming" episode, you called default mutability in Java the "trillion-dollar mistake" (around 35:05). Please elaborate on why you think that is.
Ward: I've been bitten too many times with production issues where it was very hard to figure out the cause because I was unable to "reason" about the code in question. You see this when people post the "what does this code do" kind of puzzler on Twitter. Most of the time, it is a puzzler because the mutability makes it so my simple brain can't reason about what is happening. You never see people posting the same kinds of challenges in a purely immutable form because immutable values and pure functions are something my brain can comprehend. I'm certain that the more of our programs can be pure functions and values, the fewer bugs there will be in what we build.
How much do you think tool support (such as IDEs and build tools) matters for the success of a programming language?
Ward: I used to write a lot of code without the help of an IDE (vim — fight me, please), but now the IDE is an essential part of my productivity. One reason I love programming languages with great type systems is that the IDE provides much better hints as I write code. When I have to write code in dynamic languages, I wonder how anyone ever does anything without a million reference API lookups because I can't do anything without my IDE dot-completing all the options.
InfoQ: Talking about tools: Visual Studio Code had 14 million users in February 2021 and was the second-most loved IDE in Stack Overflow's "2022 Developer Survey" (neovim was number one). Let's assume that Visual Studio Code becomes the default free IDE for all developers, supporting all relevant programming languages and frameworks. How would that change software development?
Ward: VS Code is a great tool and, for many developers, has been a huge step forward from "Sublime Text," vim, or emacs. But for me, it is still significantly less helpful than IntelliJ (for JVM stuff), especially when it comes to refactoring. So I don't use it much, but I get that it very well may be the best code editor that developers have used (assuming they haven't used all of them).
InfoQ: Compilers reveal code errors. Static analyzers, such as Error Prone, Spotbugs, or PMD, show even more errors, including the dreaded NullPointerExceptions. Why aren't these static analyzers more widely used then?
Ward: Generally, I like to keep my toolchain as condensed as possible. Whether for performance, simplicity, or collaborative reasons, I prefer to put as much validation logic as possible into something the compiler can validate (i.e., the type system). To me, linters and static code analysis tools are a sign of something that should just be validated in the compiler. Still, likely, there are language constraints preventing that. These tools are good for improving code quality but also a strong signal to language designers of what they should be trying to move from meta-programming to just programming.
InfoQ: You said you "prefer to put as much validation logic as possible into something the compiler can validate." The Java compiler doesn't validate null safety, empty else branches, and such. But static analyzers like Google's Error Prone do. How do you see the benefits of adding these analyzers to Java versus the downsides of complicating your toolchain?
Ward: Linters and other static code analysis tools express limitations with the type system and compiler checks. These limitations will always exist, so the tools won't go away anytime soon. But hopefully, they help programming models and compilers to evolve, covering more of the possible foot guns over time.
InfoQ: Google's cross-platform UI framework Flutter takes less than a second to compile a change and update the application. Why is compiling and updating JVM applications still so slow by comparison?
Ward: The more a compiler does to validate the correctness of something, the longer it will take. I don't know any way around that. I can do zero-compilation on something, run it in production, then get runtime errors as a result. That is not the way I want to develop software. So to me, judgments of compile time have to be balanced with compiler value. However, I do often run Java, Kotlin, and Scala compilers incrementally with hot-reload in under a second (thank you, good caching). This debate needs to shift to "how long does it take to get to correct or bug-free" instead of "how long does it take to get something with an indeterminate amount of broken to production."
InfoQ: In my Spring Boot project, frequent class reloading failures negate my fast compilation speed. And with regards to your "get something with an indeterminate amount of broken to production" comment: I think compilation complexity for Dart (the language in Flutter) may be in the ballpark of Java. Still, Flutter recompiles and redeploys on mobile in one second most of the time. Most Java projects don't. Now Flutter owns its whole toolchain (language, compiler, runtime, framework, and build tool). Java doesn't (e.g., build tool and application framework). For developer productivity, how important is it that JVM languages own their whole toolchains?
Ward: Nothing is preventing similar inner-dev cycle times on the JVM from being that fast. A new Android Studio feature called Live Edit almost instantly updates the UI for Jetpack Compose apps, based on a code change, in an emulator, or on a device. Play Framework had sub-second server reloads on the JVM a decade ago, using some fancy classloader tricks. The challenge is mostly around investing the engineering time to make that experience fast and great. But for some reason, that hasn't been a huge priority in the JVM ecosystem. For server frameworks, Quarkus has done the best job optimizing this, and I'm sure there is more they could still do.
InfoQ: How would you define and measure the success of a programming language? For instance, you could say Scala is successful because it made functional programming more mainstream. You could also argue that Scala isn't successful anymore because it lost the #2 JVM language spot to Kotlin.
Ward: Goals matter, and everyone has different goals. For me, it is about value alignment. I really appreciate that the Flix programming language wrote down its goals/principles.
Flix is an incredibly successful programming language because it has done an amazing job executing its goals. If Flix set a goal to have 10 million active developers, they'd definitely be failing on that one (but I'd still like it because I agree with the principles of the language). Liking a language is different from the success of a language. As a Kotlin PM, one of my goals for the language is to make it easier for developers to build correct software (i.e., fewer production bugs). The language has already been shown to reduce Android app crashes by 20%, which is a big success. I'd like to take this further and continue to help reduce app and server-side errors with language and tooling improvements.
InfoQ: The history of software development is a history of increased levels of abstractions. But innovations like object-orientation and functional programming are more than 50 years old. How do you think the abstraction level has increased in the last 20 years? And how do you see it rising in the next 20 years?
Ward: Until recently, many of the ideas from Functional Programming were siloed into technologies for math nerds (of which I aspire to be someday). Now thanks to Scala (and others), we are beginning to see a fusion of OO and FP that makes FP accessible to the masses who may not be math nerds. This fusion will continue to play out for a while, helping to make our code more testable and reusable. Kotlin is a great example of that, being a bridge for many OO Java developers into "lite-FP," which doesn't require a degree in Category Theory. The next phase of this transition will include embracing the idea of "Effects" (separating pure functions from the small parts that talk to the external world / aren't referentially transparent). Many new programming languages already have this concept built-in: Flix, Unison, Roc, etc. Beyond effects, one concept we will likely see emerge is something like Datalog — a query language built into the general purpose language. I first saw this idea with Linq, then with Flix. Queries are a pretty universal need, whether for databases, lenses (updating immutable data structures), GraphQL, etc. So having an integrated and compiler-verified way to write queries is a significant advantage.
Which programming language has evolved the best?
Ward: This definitely depends on the definition of "best." If we consider this from a purely academic perspective, I think by many orders of magnitude, Scala has been the recipient of more Ph.D. research than any language I know. Many of the Scala language features end up in other languages, which is great for everyone. Python has done an amazing job of being a generally approachable language. I heard that many data-oriented professionals can't solve most of the typical programming challenges but can write the Python code that represents a complex mathematical algorithm or processes a massive data set using libraries like Pandas, NumPy, etc. Kotlin is a modern language with Java interop and multiplatform capability. So what is "best" depends on many factors.
Which upcoming feature of any JVM language excites you the most?
Ward: On the JVM side, Loom is game-changing. For most Java / JVM developers, "Reactive" has been a good idea but not worth the cognitive and complexity overhead. Kotlin Coroutines enabled a similar idea of zero-cognitive cost for async operations that appear imperative. Yet, for many JVM developers, Reactive will likely remain a "nice-to-have" feature until Loom is available in their organization. Given that timeframe, many developers on the JVM will use concurrency abstractions like Kotlin Coroutines and Scala ZIO Effects on JDK 8 before then. Given the challenges with the Loom timeframe, and the current availability of alternatives, I have to say the upcoming feature I'm most excited about in any JVM language is Scala's braceless syntax which is half there in Scala 3.0 and may reach completion in Scala 3.3. I love how little visual noise there is in my code relative to the problem I'm solving for. I know it seems silly that just removing the braces can have such an impact. But Python shows us that cognitive overhead may generally be the highest cost in most organizations. The hardest/most costly part of writing a correct program is not the text to bytecode/machine code transformation. It is the cost of correctly representing and reading human ideas in a form that computers can understand. It seems silly, but the braces in most code distract my brain from the human intent of the code.
If you could make one change to each JVM language, what would those changes be?
Ward: Java: There are a lot of changes I'd love to make, and that sounds like an indictment. But it isn't because on the JVM, you can either choose another language or accept that things move slowly, and that is good. If I had to pick one thing to change, it'd probably be better support for immutability. Default mutability is a recipe for non-deterministic programs.
Kotlin: When I program in Kotlin, the thing I most miss from Scala is a nice syntax for monadic chaining (called "do notation" in Haskell and a for comprehension in Scala). Like Kotlin coroutines, it makes code seem imperative when really it is chained function calls. I have no idea how that kind of thing should be added to Kotlin, but if done right, I think it'd be awesome.
Scala: The hardest thing about Scala is that there are many ways to do roughly the same thing. For example, there are at least three ways in Scala 3 to do something that is basically a Sum Type (sealed, enum, and logical OR). I don't know how you ever take things away in a programming language. Still, Scala complexity is a problem, and having many ways to do most things is a problem for the language.
COBOL is more than 60 years old and still in active use. Do you think developers will still write new Java applications when Java turns 60 in 2056?
Ward: For sure! Java is a critical part of so many of the systems we use every day. It is not going away, and with slow but progressive enhancements, it continues to improve (unlike COBOL). The larger Java ecosystem (including Kotlin, Scala, Clojure, Groovy, etc.) also continues to grow. As a whole, it is likely the largest developer ecosystem in the world. New JVM languages continue to emerge like Flix, showing that the innovation cycle isn't stopping anytime soon. Innovative and game-changing technologies like Testcontainers, GraalVM, and Kalix continue to emerge from the Java ecosystem, illustrating the strength to continue growing and improving for another 35 years (at least).
Please share your closing thoughts on JVM languages in 2022.
Ward: It is an exciting time to work with Java, Kotlin, and Scala! The tools and languages enable the highest developer productivity I've ever experienced. From phones to servers, Java technologies are behind the vast majority of critical systems we use every day. And for me, it is so nice to get to pick from many different languages on one platform.
InfoQ: James, we thank you for this interview.
Ward explained the podcast remarks well: When Eckel spoke of "people who are still trapped in the Java world," he was referring to developers using what he and James see as old paradigms in Java, such as procedural and object-oriented programming. In contrast, Eckel and Ward have embraced functional programming concepts in Scala that are not available in the Java language. And mutable code makes it harder for Ward to reason about that code and eventually produces more bugs, unlike pure functions and values that are immutable.
Which is the Best Java Training Institute in Noida?
APTRON Noida Online Java course at APTRON Noida will provide you the best knowledge on the various Java programs and applications with live experts. Learning Java Certification Course makes you a master in this subject that mainly includes the fundamentals of programming, creating complete applications, writing once run anywhere features, etc. Our Java Online Course module will provide you a way to become certified in Java coaching.
So, join hands with APTRON Noida for accepting new challenges and make the best solutions through the best Online Java Course. Learning Java beginner course basics and other features will make you an expert in Java functions and applications to deal with real-time tasks. APTRON Noida provides the best Online Java Training, where you will come to know how a Java Online Course features help to work in real-world platforms. Java Training in Noida at APTRON Noida will help you to get your training easily. Moreover, Java full stack Developer Course provides solutions to know about the development of applications using the Java platform. Java course in Noida with APTRON Noida will make you achieve the goal to become a certified Java Development expert.