Introductional post - base content

Basic info

Adding tags

Signed-off-by: Michal Maléř <[email protected]>

Author: MichalMaler

_posts/2025-03-31-mmaler-blogpost-1-intro.adoc

@@ -0,0 +1,133 @@
+---
+layout: post
+title: 'Optimizing Java for the Cloud-Native Era with Quarkus'
+date: 2025-03-31
+tags: introduction development reactive performance java cloud
+synopsis: This blog post invites you to discover how Quarkus can help your company cut costs, streamline development, and modernize your Java stack for today’s cloud-native world.
+author: mmaler
+thumbnailimage: /assets/images/posts/mmaler-blog-posts/optimizing-java-with-quarkus-cloud.png
+---
+:imagesdir: /assets/images/posts/mmaler-blog-posts/
+ifdef::env-github,env-browser,env-vscode[:imagesdir: ../assets/images/posts/mmaler-blog-posts]
+
+= Optimizing Java for the Cloud-Native Era with Quarkus
+
+image::optimizing-java-with-quarkus-cloud.png[scaledwidth=100%]
+
+== Intro
+
+Hello! Mickey Maler, a Quarkus Technical Writer, is here.
+
+This short blog post invites you to discover how Quarkus can help your company cut costs, streamline development, and modernize your Java stack for today’s cloud-native world.
+I’ll walk you through real-world benefits, show what Quarkus brings to the table, and open the door to a smoother, faster way of building Java applications—especially in environments where traditional Java frameworks often struggle.
+
+By the end, you might find that switching to Quarkus is easier than you think—and that the support you need to make the move is already within reach.
+Before we explore the details, it's worth noting who is already adopting Quarkus.
+For a quick look at a real-world success story besides a dozen others, let's highlight and mention Orange to start with, a global telecom leader that leveraged Quarkus to achieve its development goals.
+
+* After evaluating multiple frameworks, Orange chose Quarkus as the optimal solution for exposing 5G APIs, thanks to its fast startup, lightweight footprint, modularity, and seamless Kubernetes deployment.
+Quarkus successfully deployed 10 APIs across 4G/5G network cores, with smooth upgrades and optimized resource usage.
+This solidified Quarkus as a key technology for telecom innovation.
++
+For a collection of user stories from the community, see the Quarkus user stories blog series. These stories highlight how different teams and organizations are using Quarkus in the real world.
+
+== What does Quarkus have to offer?
+
+=== Developer joy with live coding and dev mode
+
+Quarkus revolutionizes the development workflow with its live coding feature.
+In traditional Java development, the cycle of writing code, compiling, deploying, and refreshing is time-consuming.
+Quarkus streamlines this process: write your code and refresh the browser—Quarkus instantly detects changes, recompiles, and redeploys.
+This significantly boosts productivity and enhances the developer experience.
+
+=== Versatile build tool integration
+
+Quarkus integrates with popular build tools like Maven and Gradle, making adoption in many existing development workflows easier.
+Maven users benefit from first-class support, while Gradle users can build Quarkus projects with the help of community-maintained tooling, though it currently lacks feature parity with Maven.
+There’s also integration with JBang, offering another lightweight option for getting started.
+
+=== Cost efficiency and performance
+
+By optimizing for low memory usage and fast startup times, Quarkus enables higher-density deployments and rapid scaling.
+This efficiency leads to significant cost savings in cloud environments as resources are used more effectively.
+Companies looking to reduce cloud costs while maintaining high performance will find Quarkus an excellent solution.
+
+=== Reactive at its core
+
+At its core, Quarkus is built on Eclipse Vert.x, a high-performance reactive toolkit.
+Still, it allows developers to work primarily in an imperative style while leveraging the performance benefits of its reactive underpinnings.
+This hybrid approach allows developers to squeeze out even more efficiency from traditional imperative programming while offering the flexibility to adopt reactive patterns where they make sense.
+Unlike traditional reactive-only frameworks, Quarkus enables developers to combine both imperative and reactive styles in a single application.
+This is particularly beneficial for systems requiring high throughput and low latency, ensuring that applications remain robust under heavy load.
+Quarkus's reactive model makes it ideal for event-driven architectures and microservices.
+
+
+== Which of your current development pains could Quarkus solve effortlessly?
+
+In general, Quarkus will save you a lot of time and money as well as CPU and memory resources.
+Besides this, lets mention Dev Services and geared extension ecosystem.
+
+=== Dev Services
+
+Quarkus Dev Services reduce friction during development and testing by automatically provisioning required services such as databases, message brokers, or identity providers.
+For example, if your application includes PostgreSQL, Kafka, or Keycloak extensions, Quarkus can spin up the necessary containers without any manual setup.
+This allows you to focus on coding instead of configuring infrastructure, accelerating your local development workflow.
+
+=== Vast extension ecosystem
+
+Quarkus offers a rich extension ecosystem that simplifies integration with essential technologies such as databases, messaging systems, authentication providers, and cloud services.
+
+Popular extensions include:
+* `quarkus-hibernate-orm` and `quarkus-jdbc-postgresql` for seamless data persistence.
+* `quarkus-smallrye-reactive-messaging` and `quarkus-kafka-client` for reactive messaging and Apache Kafka integration.
+* `quarkus-oidc` for implementing OpenID Connect authentication and securing applications.
+* `quarkus-micrometer` and `quarkus-opentelemetry` for observability, metrics, and tracing.
+* `quarkus-container-image-docker` and `quarkus-kubernetes` for containerization and deployment to Kubernetes platforms.
+
+These extensions are widely adopted because they reduce boilerplate, provide reliable default configurations out of the box, and follow cloud-native best practices—making it easy to plug Quarkus into real-world architectures.
+
+== Even better Quarkus? Here’s what new tools are on the way
+
+=== Panache 2: Simplifying data access
+
+Hibernate ORM with Panache is a lightweight abstraction layer built on top of Hibernate ORM that simplifies data interactions and reduces boilerplate code.
+With the introduction of Panache 2, Quarkus expands its capabilities by integrating Hibernate Data Repositories and Jakarta Data under a unified API.
+This unified approach makes adopting, switching between, or combining different data access paradigms easier.
+By leveraging Hibernate's robust capabilities, Panache 2 enables developers to write concise and expressive queries while maintaining full compatibility with standard JPA features.
+This results in cleaner, more maintainable applications and an intuitive approach to database management.
+
+Panache 2 also introduces several key enhancements:
+Supports mixing stateless, managed, blocking, and reactive operations in a single API.
+Allows for the definition of generic or specialized entities (stateless, managed, blocking, reactive) and enables them to switch to another mode of operation via an API.
+
+* Unifies entity operations and repository operations by using nested interfaces.
+* Solves the user experience issue of repository injection by obtaining repository instances via generated static methods on the metamodel.
+* Supports type-unsafe repositories that are out of the box for every entity and every mode of operation (stateless, managed, blocking, reactive).
+* Provides type-safe repositories in addition to, or mixed with, type-unsafe repositories.
+
+These improvements make Panache 2 a powerful tool for developers looking for flexibility, efficiency, and ease of use when working with data in Quarkus.
+
+Of course, there's more exciting stuff on the horizon, but this is a blog post, not release notes! ;)
+
+== “OK, I would like to try it, but is it easy enough to migrate my workflow to Quarkus?”
+
+Migrating to a new framework can feel daunting, even when it promises better performance, lower costs, and an improved developer experience.
+It’s like being offered a better house in a better neighborhood, but hesitating because of the hassle of packing, moving, and settling in.
+
+With Quarkus, the transition doesn’t have to be painful.
+Thanks to its compatibility with existing Java standards, support for Jakarta EE and Spring APIs, and an extensive extension ecosystem, many projects can migrate incrementally, without rewriting everything from scratch.
+For example, the Spring compatibility layer allows reuse of familiar annotations and patterns, see the link:https://quarkus.io/guides/spring-di[Spring DI guide] to learn more.
+
+And if you need help? You’re not alone.
+Quarkus experts, like Roberto Cortez, can visit your company, demo what Quarkus can do, and guide you through the entire migration process—from architecture review to production readiness.
+
+All you need to do is make the decision and take the first step.
+Your team deserves a faster, leaner, cloud-native future.
+
+== Concluding note
+
+Quarkus is redefining Java development by combining modern features with the robustness of the Java ecosystem.
+Its focus on developer productivity, performance, and seamless integration positions it as a formidable framework for building efficient, cloud-native applications.
+Whether you're looking to optimize costs, enhance development speed, or adopt a reactive approach, Quarkus is a game-changer for Java developers.
+
+The end.