Cloud on foojay.io - Friends of OpenJDK

BoxLang AWS, Azure, and Google Secrets Manager Module Released

Tue, 21 Jul 2026 11:38:18 +0000

Every production application carries secrets: database passwords, API tokens, encryption keys. The question is never whether to manage them – it’s how badly the current approach is going to hurt you.

Hardcoded credentials in config files get committed to repos. Environment variables sprawl across deployment pipelines with no audit trail. Custom integration code for each cloud provider means three different patterns to maintain, test, and rotate. And when a key needs to rotate at 2am? Someone is waking up.

Warm Up Fast, Run Lean: Vertical Scaling for Java on Kubernetes with Azul Prime and Kedify

Fri, 17 Jul 2026 08:02:07 +0000

Autoscaling on Kubernetes has evolved significantly, but many production systems still rely on reactive scaling based on CPU and memory utilization. The issue is that resource metrics often lag behind real demand. By the time the CPU rises, users may already be experiencing unacceptable latency.

For most real services, horizontal scaling should be driven by proactive workload signals such as request rate, concurrency, or queue depth, rather than raw CPU alone. To learn more about this, see this post on autoscaling delay and proactive metrics.

BoxLang 1.15.0 Released: Blazing Fast Strings, Runtime Portability, and much more

Tue, 14 Jul 2026 17:57:10 +0000

BoxLang 1.15.0 is a high-impact release with two big headlines and a long tail of hardening. The first headline is a massive performance upgrade to string handling : a new first-class BoxStringBuilder type, compile-time literal folding, smarter &= semantics, and a runtime concat strategy that automatically switches to builder-backed accumulation once your expression gets big enough. Your existing string-heavy code just got faster. No rewrites required.

The second headline is architectural. Every class loader in the BoxLang runtime and module system has been fully abstracted behind a pluggable IClassLoaderFactory interface. That single seam is what unlocks the Android runtime and Ahead-of-Time (AOT) compiled runtimes such as GraalVM Native Image that we have on the roadmap. The default behavior is unchanged, but the ceiling just got a lot higher.

Why We Moved Our Timefold Java Worker Pods from AMD to ARM64

Wed, 08 Jul 2026 15:25:58 +0000

When we investigated unexpected performance variance in our Timefold Solver worker pods on our platform, we traced it to hyperthreading on AMD (x86-64) cloud instances. Switching to ARM (ARM64), where each vCPU maps to a physical core, eliminated the problem and roughly doubled effective throughput per dollar for concurrent solver workloads.

Originally written by Timefold engineers Lars Beckmann, Jenne De Bleser and Lukáš Petrovický

Adapted for foojay by Tom Cools

Quarkus Unpacked: Insights from the Foojay Podcast

Tue, 23 Jun 2026 12:36:54 +0000

I recently had the pleasure of joining the Foojay podcast to talk about Quarkus in depth. The conversation covered a lot of ground, from what makes Quarkus different to the practical trade-offs between JVM and native mode. This post captures the key questions and answers from that discussion, lightly edited for readability.{#_quarkus_unpacked_insights_from_the_foojay_podcast}

If you have been following this blog series, note that the third installment on building your own stack with Quarkus is coming next. Consider this a bonus entry that distills the podcast conversation into a format you can read, reference, and share.

Building Java Containers Without a Dockerfile: Azul Zulu and Paketo Buildpacks

Thu, 18 Jun 2026 08:15:45 +0000

This is the 5th post in the Azul Zulu Docker Official Images series:

Every post in this series so far has shown you a Dockerfile. You pick a base image, copy a JAR, set an entrypoint, and ship. That works well. But Spring Boot developers often skip the Dockerfile entirely and still get a production-ready container with Azul Zulu as the JVM thanks to Paketo Buildpacks. Here is how that works, and how to configure it.

Foojay Podcast #96: Local AWS Development Without LocalStack: Meet Floci, the GraalVM-Powered Alternative

Mon, 25 May 2026 06:36:00 +0000

What if you could run 35 AWS services locally in under 25 milliseconds, using just 13 megabytes of memory, with a single Docker command and no cloud bill? That’s exactly what Floci does.

In this episode, Frank Delporte talks with Hector Ventura, the creator of Floci, a free and open-source cloud emulator built with Quarkus and GraalVM native compilation. Hector walks us through why he built it when LocalStack dropped its open-source community edition, how AI tooling helped him accelerate development of new service integrations, the challenges of keeping GraalVM happy with third-party libraries, and the road ahead for Azure and GCP support.

All Azul Zulu Container Images Explained: CA, SA, and Chainguard

Wed, 20 May 2026 09:56:00 +0000

Previously in this series:

The launch of Azul Zulu as Docker Official Images was a milestone, but it’s just one of several ways to get Azul Zulu Builds of OpenJDK in a container. Depending on whether you’re evaluating Azul Zulu, running it in production under a support contract, or operating in a high-security environment, the right image source will vary. In this post, I’ll show you all the possibilities.

Using the Azul Zulu Docker Official Images: From Simple Pull to Lean Container

Fri, 08 May 2026 09:05:22 +0000

Previously in this series:

Azul Zulu is now a Docker Official Image , so getting a trusted, secure Java base image is now just a FROM azul-zulu line in your Dockerfile. But pulling the right image is just the beginning. This post shows you how to use these images in practice, and how a few extra steps can seriously cut the size of what you ship.

The Road to Docker Official Images for Java: The Azul Zulu Story

Fri, 24 Apr 2026 08:57:12 +0000

Previously in this series:

Trusted Java Containers: Azul Zulu OpenJDK Joins Docker’s Official Images

After more than two years of collaboration, reviews, and back-and-forth with the Docker team, Azul Zulu Builds of OpenJDK have officially joined Docker’s Official Images program. This is not just a badge of honor. It changes how Java developers can pull and trust their container base images.

The formal announcement is on the Azul blog . In this post, I’ll walk you through what happened, why it matters, and how to start using these images today.

AWS Nitro and CPU Graviton Meets Unikernels

Fri, 10 Apr 2026 16:26:25 +0000

AWS Nitro and CPU Graviton Meets Unikernels: Java and Quarkus on ARM64 AWS Graviton with Nanos Unikernel

Java and Jakarta EE Truly Meet Unikernels

The key message of this article is simple and strong:

any Java or Jakarta EE application is already ready to benefit from the advantages of unikernels.

Java and Jakarta EE, including modern frameworks such as Quarkus, can immediately take advantage of the unikernel model without waiting for new languages, new runtimes, or radical rewrites.

From Zero to Full Observability with Dash0

Sat, 04 Apr 2026 06:35:47 +0000

This guide walks through the complete process of deploying a minimal Spring Boot service to Kubernetes and adding full observability using the Dash0 Kubernetes Operator — without making any changes to the application code.

Dash0 is an OpenTelemetry-native observability platform that collects and correlates traces, metrics, and logs, and provides infrastructure monitoring across Kubernetes resources — pods, nodes, namespaces, deployments, daemonsets, statefulsets, jobs, and cronjobs — as well as cloud infrastructure such as AWS. Its Kubernetes operator can automatically instrument workloads at the pod level, with no changes required to application code or container images.

Introducing Floci: A High-Performance, GraalVM-Powered AWS Emulator

Fri, 03 Apr 2026 19:00:53 +0000

The Motivation: Why Another AWS Emulator?

As Java developers, we are used to local-first development. Tools that emulate the cloud environment have become essential for keeping feedback loops tight and costs at zero. However, the ecosystem has shifted. Many of us have felt the friction of:

Mandatory Authentication: Needing to log in or use tokens just to run local tests.
Heavy Resource Footprint: Docker containers that consume a lot of resources.
Slow Startup: Waiting several seconds for the environment to be ready.

I created Floci (from the floccus cloud formation) to solve these specific pain points. It is a 100% open-source, MIT-licensed alternative designed for speed, privacy, and simplicity.

Does Language Still Matter in the Age of AI? Yes — But the Tradeoff Has Changed

Wed, 25 Mar 2026 16:37:20 +0000

I keep hearing the same question in architecture reviews, slack threads, and conference Hallways:

“If AI is writing the code, does language even matter anymore?”

It does. More than ever, actually — just not for the reasons we’ve been arguing about for the last decade.

The Bottleneck Has Moved

For decades, we optimized for developer productivity. How fast can someone write code? How expressive is the language? How quickly can we ship features?

Introducing the BoxLang Spring Boot Starter: Dynamic JVM Templating for Spring

Thu, 19 Mar 2026 14:20:02 +0000

Spring Boot developers know the pain of evaluating view technologies. Thymeleaf is great — until you need more expressiveness. FreeMarker is powerful — until the syntax fights you. What if you could write templates in a dynamic JVM language that gives you the full power of the platform, feels natural, and requires zero setup to integrate?

Meet the BoxLang Spring Boot Starter.

TL;DR: Drop one dependency into your Spring Boot 3 app and start writing dynamic .bxm templates powered by BoxLang — a modern, expressive JVM language. Zero configuration. Full web scopes. 100% Java interoperable. Not only that, you get full access to BoxLang’s framework capabilities so you can integrate tons of features into your Spring Boot applications:

BoxLang 1.11.0 Release

Tue, 17 Mar 2026 09:40:04 +0000

We’re proud to announce BoxLang 1.11.0, a highly focused performance and stability release that delivers measurable speed improvements across every BoxLang application, with zero code changes required. The team invested deeply in bytecode generation, class loading, lock management, and type casting to produce one of the most impactful runtime optimization releases to date. Alongside the performance wave, this release resolves critical concurrency bugs, hardens DateTime handling, and ships powerful new developer tooling.

JC-AI Newsletter #14

Tue, 03 Mar 2026 15:11:53 +0000

Two weeks have passed and a lot have been happening on the field of artificial-intelligence.

Two weeks have passed and a lot has been silently yet visibly happening in the field of artificial intelligence. This newsletter brings interesting developments, including Dario Amodei’s (Anthropic) view on the progress achieved in the LLM field and his response to the utilization of these models for specific kinds of military purposes, as well as OpenAI’s response to it. Aside from the fact that development may follow more sigmoids instead of exponential progress, it is important to have awareness of utilization across branches. Does prompting and clarifying the goal influence agent responses, and if so, how? How far are we from reliable robotics applications? How much bias is introduced when clinical data is being analyzed?

Announcing Cloud-Native BoxLang for $5/Month

Mon, 23 Feb 2026 16:39:44 +0000

TL;DR: We just released a production-ready starter template that deploys a modern BoxLang application to DigitalOcean App Platform in under 5 minutes—starting at just $5/month. One-click deployment, auto-scaling, automatic redeployments, and zero downtime included.

Cloud-Native BoxLang Has Never Been Easier

Today, we’re excited to announce the BoxLang DigitalOcean Starter Template—a complete, production-ready solution that takes you from zero to deployed BoxLang application in minutes, not hours.

For many developers evaluating modern JVM languages, the question isn’t “Can it run?” but rather “How easily can I get this into production?” With this starter, the answer is now: ridiculously easy.

Unikernel: Profiling and Troubleshooting JVM on Nanos Unikernel

Wed, 11 Feb 2026 13:50:41 +0000

Profiling a Java Application Running Inside an Unikernel with JProfiler

Unikernels are often associated with minimalism and tight resource control.

But can we profile a Java application running inside a unikernel using a standard JVM profiler?

The answer is yes.

In this guide, we will walk step by step through profiling a Quarkus

application running inside a Nanos unikernel using JProfiler and
IBM Semeru JRE 25 (OpenJ9).

No special hacks. Just standard JVM tooling.

DocBox v5 - Reborn: Modern API Docs for BoxLang & CFML

Tue, 27 Jan 2026 12:15:45 +0000

Welcome to DocBox v5! We didn’t just update DocBox. We rebuilt it from the ground up.

DocBox v5.0.0 represents a complete architectural rewrite—modern syntax, blazing performance, and a stunning new look that finally brings API documentation into 2025. Gone are the clunky HTML pages of yesteryear. Say hello to a gorgeous, theme-driven single-page application that makes browsing your API docs feel like using a premium developer tool. We have also released a dedicated module for BoxLang: BX-DOCBOX. A fully interactive CLI tool for generating your docs from the command line using pure BoxLang.

BoxLang AI v2: Enterprise AI Development Without the Complexity

Thu, 22 Jan 2026 15:09:25 +0000

One Year. 100+ Features. Unlimited Possibilities.

Just one year ago, in March 2024, we launched BoxLang AI 1.0. Today, we’re thrilled to announce BoxLang AI v2—a massive leap forward that positions BoxLang as one of the most powerful and versatile AI framework on the JVM. This release is 9-months in the making, with over 100 new features! This would have not been possible without all the new features that the BoxLang JVM language exposes to developers like: Server Side Events, HTTP Streaming, HTTP pooling, Caching, and so much more.

Not a Lucid Web3 Dream Anymore: x402, ERC-8004, A2A, and The Next Wave of AI Commerce

Fri, 09 Jan 2026 16:05:58 +0000

This article is for technically savvy readers, especially developers, protocol designers, and product teams working with AI agents, APIs, or crypto rails, who want a clear view of how these areas connect.
It explains how x402, ERC-8004, and agent discovery layers turn APIs and agents into small usage-based businesses, and what that means for real systems over the next 1–3 years.

Vocabulary for this article

In this article, I use the term micro business for a very small overall business, and nano business for a single x402-priced endpoint or agent that earns on its own from per-call payments in stablecoins.

AP2 (Agent Payment Protocol): AP2 defines how agents pay each other. It standardizes how a service quotes a price, how payment is confirmed, and how both sides record what was bought, so payments fit directly into automated agent workflows. In practice, it is a protocol that lets one machine pay another machine for work, without a human in the loop.

A2A (Agent-to-Agent communication): A2A covers how agents talk, pass context, and coordinate work. It lets agents call each other, exchange structured messages, and chain tasks instead of acting as isolated scripts.

x402: x402 is an HTTP-based payment protocol for APIs. A server responds with status 402 Payment Required, the price, and a payment route, and the client pays by using stablecoins on-chain and then retries the request to get the result.

ERC-8004 (8004): ERC-8004 standard is an on-chain registry for agents. It gives each agent an identity and a place to store reputation data, so other agents and tools can decide whom to trust and which services to call.

Foreword

x402 and ERC-8004 .

Optimizing Java for the Cloud-Native Era with Quarkus

Tue, 06 Jan 2026 21:09:00 +0000

This article explores how Quarkus can help organizations reduce costs, streamline development, and modernize their Java applications for today’s cloud-native environments. It outlines the real-world benefits of adopting Quarkus and highlights how its core features address the performance and scalability challenges commonly associated with traditional Java frameworks.

Quarkus is already being adopted across industries. One example is Orange, a global telecom provider that selected Quarkus to support its 5G API initiative, and benefited from fast startup times, a lightweight footprint, and seamless integration with Kubernetes.

Java and Jakarta EE and the Evolution of the Cloud with Nanos Unikernel

Tue, 06 Jan 2026 20:51:09 +0000

The evolution of the Java and Jakarta Enterprise ecosystem is converging toward an increasingly simple, efficient, and scalable architecture that improves security, delivers higher performance, and reduces hardware and infrastructure costs.

For years, Kubernetes has been considered the de‑facto standard for modernizing Java applications in a cloud‑native direction. However, Kubernetes is not the only way to achieve scalability, continuous upgrades, and isolation. An alternative approach — often underestimated — is to leverage the hypervisors already included and fully managed by major cloud providers , using Unikernel images based on Nanos .

Quarkus: A Runtime and Framework for Cloud-Native Java

Tue, 06 Jan 2026 13:46:50 +0000

Public clouds such as AWS, Microsoft Azure, and Google Cloud, and platforms like Red Hat OpenShift, favor services that start fast and stay lean. Quarkus is engineered for exactly that.

Build time processing reduces runtime overhead and results in rapid startup, a small memory footprint, and frictionless deployment across Kubernetes, OpenShift, serverless, and managed container services in any cloud. If your Java services need to start in milliseconds, run dense on shared nodes, and still feel great to build, Quarkus was made for that job.

Make Java Fleets Warm Up Faster on AWS With Azul Optimizer Hub

Thu, 18 Dec 2025 08:35:52 +0000

Traditional Java executes code in slower interpreted mode, known as Java warmup, until it can build an optimized profile. This means it can only start optimizing once the application takes traffic and touches the critical code paths. Just when you are scaling out for a large bump in traffic, your machines are running at their slowest and are splitting their available CPU power between handling requests and performing expensive JIT optimizations

JC-AI Newsletter #3

Tue, 19 Aug 2025 08:06:34 +0000

The first and second newsletters introduced a 14-day cadence, and even though it is the holiday season for many of us, we are sticking to the promised period.

The current newsletter vol.3, brings a collection of valuable articles focusing on challenges that are commonly reported through reported breakthroughs in the field of artificial intelligence. Although some articles may remain open or contain suggestions for future research due to the intensive development and utilization efforts of agentic AI systems, these articles can be considered valuable to the community, increasing awareness and understanding of ongoing challenges.

Monolith vs Microservices in 2025

Mon, 04 Aug 2025 13:45:09 +0000

In recent years, the tech world has been buzzing with debates about architecture choices. However, 2025 offers a more balanced perspective.

Simplicity, developer experience, and maintainability are reshaping how teams design software.

From Infrastructure as Code (IaC) to “vibecoding” culture, and from startups to enterprises, many rethink their position on the monolith vs microservices 2025 spectrum.

So, what has actually changed?

🔵⚪⚪⚪⚪⚪

🔁 Terraform and IaC: Changing Architecture with Confidence

How Infrastructure as Code helps teams adapt architecture efficiently

Infrastructure as Code tools like Terraform make architecture changes easier. Nevertheless, the process is not effortless.

Sustainability Starts with Your Runtime: Meet a Green JVM

Tue, 15 Jul 2025 14:20:00 +0000

Reducing spend in the cloud is a top priority for many organizations, and a high-performance Java platform can help cloud cost reduction efforts. These same optimizations can help organizations achieve sustainability goals, including achieving carbon net-zero. And pursuing sustainability goals can also lead to financial advantages.

Cloud costs are under the microscope, and reducing spend in the cloud is a top priority for many organizations. We’ve been helping customers on that journey with Azul Platform Prime, a high-performance Java platform that runs code faster, uses fewer compute resources, and helps cut your cloud bill .

Jakarta EE 11 Web Profile Released, Enabled by Eclipse GlassFish

Tue, 22 Apr 2025 11:06:19 +0000

The Jakarta EE 11 Web Profile has officially been released on March 30, 2025 — bringing a cleaner, more modern baseline to the Jakarta EE platform, with strong alignment to recent Java versions, improved modularity, and the removal of legacy specifications.

Although it comes later than planned, due to unexpected challenges in refactoring the Jakarta EE TCK (compatibility kit), this release marks a key shift toward a more cloud-native, developer-focused platform — and we’re proud to say that Eclipse GlassFish was the first implementation to pass the Jakarta EE 11 Web Profile TCK and enable the specification’s final approval.

Optimizing the Garbage Collector when Migrating Cloud Workloads

Wed, 16 Apr 2025 10:27:49 +0000

You might associate Arm primarily with smartphones and the Java-based Android runtime. However, OpenJDK has supported AArch64 on Linux since 2014— before Arm-based cloud instances were widely available. Fast forward a decade and major cloud providers have their own Arm-based instances like AWS Graviton, Microsoft Azure Cobalt, and others, prompting many organizations to migrate Java workloads from x86 to multi-architecture environments.

A multi-architecture deployment shift allows an organization to be adaptable and choose the architecture with the ideal price to performance ratio. Large independent software vendors, such as Uber, are already making this transition .

Spring Cloud Stream: Demystifying Event-Driven Architecture

Fri, 28 Feb 2025 08:34:32 +0000

Consider a bustling restaurant environment. The kitchen receives a flood of orders, waitstaff dart between tables, and patrons anxiously glance at their watches. Each time a waiter takes an order, he or she must verify it with the kitchen and wait for the kitchen to prepare the meal before attending to another table. This cumbersome method hampers efficiency, leaving the restaurant unable to meet customer demand.

Now envision an alternative situation. Instead of enduring delays, waitstaff enter orders into a centralized system, prompting the kitchen to begin meal preparation immediately upon receipt. As soon as the kitchen prepares the food, waiters receive instant notifications, enabling them to serve customers promptly without any delays. This exemplifies event-driven architecture: a fluid, real-time system where they exchange information asynchronously, promoting scalability and quick responsiveness.

A solution to the problem of cluster-wide CRDs

Thu, 30 Jan 2025 11:55:14 +0000

I’m an average Reddit user, scrolling much more than reading or interacting. Sometimes, however, a post rings a giant red bell. When I stumbled upon If you could add one feature to K8s, what would it be? , I knew the content would be worth it.

The most voted answer is:

Namespace scoped CRDs

A short intro to CRDs

Kubernetes comes packed with existing objects, such as Pod, Service, DaemonSet, etc., but you can create your own: the latter are called Custom Resource Definitions. Most of the time, s are paired with a custom controller called an operator. An operator subscribes to the lifecycle events of CRD(s). When you act upon a CRD by creating, updating, or deleting it, Kubernetes changes its status, and the operator gets notified. What it does depends on the nature of the CRD.

Foojay Podcast #64: Interviews at JFall about opensource, OpenJDK evolutions, Project Loom, JVM,...

Mon, 23 Dec 2024 10:51:20 +0000

Let’s wrap up this year with more interviews from the JFall conference.

In this episode you’ll learn more about Foojay, JVM internals and writing your own programming language, Project Loom and structured concurrency, learning at conferences, code reviews, creating desktop applications with Java, infrastructure as code, JUG Noord, and much more!

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Run a Java Lambda Function From a Docker image

Wed, 11 Dec 2024 16:16:36 +0000

Have you ever wanted to deploy a Java Serverless function, but package it with a Docker Image? That is possible now with AWS new Container support. This guide will show you how to try it yourself, step by step!

The Hello Lambda Function project contains an AWS Lambda maven application with AWS Java SDK 2.x dependencies.

Here follows instructions from AWS Document on building Lambda for Java .

The sample code seen below can be found in my GitHub repository: hello-lambda .

Speed up your Spring Batch with Native Image and GraalVM

Tue, 10 Dec 2024 15:47:53 +0000

Spring Batch is often used for data processing jobs that don’t run continuously. Instead, they start, process, and stop,which makes them a perfect candidate for GraalVM Native Image. Unlike traditional Java applications that require a long JVM startup time, Native Images execute almost instantly, giving a significant performance boost.

In this article, you’ll learn how to build a Spring Batch application that reads a CSV file, logs its content, and writes it to a PostgreSQL database.We’ll see how to compile it into a Native Image using GraalVM , and most importantly**, we’ll benchmark the difference between** running it as a traditional JAR and as a native binary.

GlassFish is rolling forward. What’s New?

Tue, 26 Nov 2024 15:11:17 +0000

The Evolution Continues. GlassFish, which used to be a popular application server, free to use and reliable, is evolving again. If you’ve been holding onto your old GlassFish instances, there’s good news—things have gotten a lot more exciting recently.

Since we created the OmniFish company and started improving GlassFish in 2022 (read about that story in Oh, What Did You Do to GlassFish?! ), a lot has happened around GlassFish. We joined the Eclipse GlassFish project and joined the Jakarta EE Working Group as well.

Changes Included in Release 24.08 of Azul Zing Builds of OpenJDK

Fri, 18 Oct 2024 13:53:56 +0000

Azul Zing Builds of OpenJDK, the optimized Java runtime within Azul Platform Prime , has reached the release of the 24.08 Stable Release line. Zing builds are available in two versions:

Stream Builds : Fast-moving monthly releases (end of the month) that include the latest features and changes in PSU releases. These are free for development and evaluation. Using Stream Builds in production requires an active subscription. Their version number is based on year and month. For instance, “24.07.0.0” is the July Stream Build of 2024.
Stable Builds : Builds that incorporate only CPUs, PSUs, and Azul Zing critical fixes and do not uptake new features and non-critical enhancements from Stream Builds. Stable Builds are our primary vehicle for delivering time-sensitive bug fixes to customers and are only available to Azul customers. Their version number is based on the Stream Build they originated from. For instance, “23.08.500.0” was derived from the August Stream Build of 2023 but already had multiple updates, as the 500 number indicates.

As stream builds happen in a fixed schedule, all changes are included in the release notes . Twice a year (in February and August), a Stream build becomes the new Stable build, providing a new version with many more improvements. In this post, we want to give you an overview of all the combined improvements in the 24.08 Stable Line.

Easily containerize Java applications with cloud native buildpacks

Mon, 07 Oct 2024 09:15:53 +0000

The concept of containers has helped to bring Java developers closer than ever to the cloud-native idiom of ‘write once, run anywhere.’

Effectively and efficiently containerizing your Java application can be much more of a challenge than you might originally expect, especially when you might not be a container expert. Having to write and maintain a dockerfile, run a Docker daemon as root, wait for all the builds to complete, and then finally push the image to a remote registry can be complex, time-consuming, and frustrating!

Azul Brings Java from Edge to Cloud

Fri, 27 Sep 2024 11:30:22 +0000

In Part 1 of this series, “A Fresh Look at Embedded Java ,” we explored the use of Java for embedded use cases.

Azul and its Zulu Build of OpenJDK (Zulu) are the ideal partners in this part of the software world.

Let’s expand and look at the cloud part of a typical end-to-end solution with sensors, edge devices, client applications, and cloud services.

Azul Platform Core for edge devices and client applications

Because Java delivers fast development speed thanks to its amazing methods and tools and its impressive performance in handling massive amounts of data, it’s the ideal programming language for building applications for edge devices that collect data from various sensors.

Run true-to-production tests on your Java applications

Tue, 24 Sep 2024 11:48:46 +0000

As supported by the 12 factor and 15 factor app methodologies, in application development, we’ve come to realize just how important it is to test our applications in a true-to-production environment before releasing them to consumers. This helps us to mitigate potential failures and spot bugs that could appear in production but be missed in testing due to environmental differences and ensure we have high confidence in our applications being deployed to production environments. But, traditionally, developers have struggled with replicating an application’s production environment locally.

Help update the Twelve-Factor app methodology

Thu, 05 Sep 2024 07:44:26 +0000

The 12 factor application methodology is being updated and we need your help with it! Be a part of this project helping to update and modernize the original methodology to enable it to be even more effective for modern cloud-native applications.

What is the 12 factor app methdology?

Originally created back in 2012, the 12-factor app methodology was designed to provide a set of guidelines for helping developers and organizations to design and build cloud-native applications. This methodology was defined by the developers at Heroku, but has been adopted and even in some cases extended by the community since then.

Get recognized for your cloud-native Java development skills

Thu, 29 Aug 2024 16:08:34 +0000

In a world where in-demand skills are critical for job success, security, and progression, it’s vital that we, as developers, ensure we are showcasing our skills to the wider world. This can include qualifications, courses, and badges, all of which help us to advertise our skills and highlight our professional experiences and expertise.

So, to help make this easier (and free!) for Java developers, the Open Liberty team created the first-ever Liberty badge: Liberty Developer Essentials !

Creating 12-factor cloud-native Java apps with open source

Fri, 23 Aug 2024 05:30:51 +0000

Learn how you could create cloud-native Java apps that are portable, scalable, and reliable with the 12 factor app methodology and open source Java frameworks.

Created in 2012, the 12-factor app methodology was designed to provide a set of guidelines for helping developers and organizations to design and build cloud-native applications. We’ll explore how you can take advantage of each of these 12 factors to create applications, utilizing open source technologies, that thrive in the cloud.

Run AI-enabled JakartaEE/MicroProfile apps with LangChain4j

Mon, 12 Aug 2024 22:14:36 +0000

Artificial Intelligence (AI) is an exciting and disruptive field that is already transforming businesses, and even entire industries, by enabling automation, improving decision-making and unlocking new insights from data.

With the rise in large language models (LLMs) such as ChatGPT, there is a significant shift in the performance of AI and its potential to drive enterprise value. So, how will this impact on software development and the creation of cloud-native Java applications for enterprises?

Foojay Podcast #55: Embedded Java, Part 2

Mon, 01 Jul 2024 08:21:42 +0000

As a backend developer, you may not realize that Java was initially born on embedded devices like set-top boxes and gateways. We discussed this topic for the first time almost three years ago in Foojay Podcast #2 with James Gosling, Johan Vos, Erik Costlow, and Frank Delporte .

In this episode #55, we look into the history of the Java Micro Edition and how things evolved. Nowadays, with processors becoming increasingly powerful, we can run the exact same Java runtime on any Linux system, from the biggest cloud servers to the smallest Raspberry Pi Zero.

Foojay Podcast #53: JCON Report, Part 5 – CQRS, JOOQ, GraphQL, API, Vaadin, OpenRewrite, ErrorProne, Gateways, Proxies,...

Mon, 17 Jun 2024 09:24:52 +0000

This is the final part of the JCON interviews. Did I save the best for last? It’s up to you to decide…

In this episode you’ll hear Simon Martinelli, Nicolas Fränkel, Marcus Hellberg, Rick Ossendrijver, and Abdel Sghiouar.

We talked about a bunch of topics like evolving your APIs, GraphQL, Java versus Kotlin versus Rust, Vaadin, AI and ChatGPT, OpenRewrite, ErrorProne, Infrastructure, and a lot more.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Foojay Podcast #51: Persistence, Evolving your Career, Jakarta EE, GlassFish, Messaging via Telegram

Mon, 03 Jun 2024 08:03:53 +0000

This is part 3 of the JCON interviews.

Frank meets Otavio Santana, who recently wrote the book “Mastering the Java Virtual Machine.” At JCON, he talked about the persistence layer and how you can evolve your career.

You’ll also learn more about Jakarta EE, GlassFish, and a PET project with messaging via Telegram.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Exploring Cost-Effective Solutions for Stateful Rest Services

Mon, 27 May 2024 13:13:02 +0000

A Case Study with IBM Cloud Code Engine, EclipseStore, and IBM Cloud Object Storage

In the dynamic realm of cloud computing, finding cost-effective solutions for stateful rest services that don’t necessarily require scaling can be a nuanced challenge.

In this article, we’ll take a pragmatic look at a use case leveraging IBM Cloud Code Engine , EclipseStore , and IBM Cloud Object Storage (COS) . The goal is to shed light on how this can be a practical and economical alternative, particularly when scalability is not a primary concern.

Is your Java application ready for the next generation of server CPUs?

Wed, 08 May 2024 08:03:53 +0000

If you only know about Arm CPU architecture from working on smartphones or Raspberry Pi devices, it might come as a surprise to you that there are also high-performance, cloud-scale Arm CPUs already on the Java market.

The share of cloud and server workloads running on Arm is increasing every year. Back in 2011, Arm released the AArch64 instruction set, the first 64-bit support on Arm CPUs. Since then, Arm’s silicon partners have been producing a range of systems-on-chip (SoCs) that adopt Arm’s high performance CPUs. These power a broad range of diverse devices and technologies, including flagship smartphones , laptops , industrial IoT , servers, and even powerful super computers .

IntelliJ IDEA and Open Liberty - Effective Java app development

Fri, 12 Apr 2024 13:36:25 +0000

See how you can use Liberty Tools for IntelliJ IDEA to enable rapid, easy, and efficient development of cloud-native Java applications with Open Liberty and WebSphere Liberty

When it comes to integrated development environments, within the Java community, IntelliJ IDEA is the most popular IDE amongst professional developers. It is the preferred IDE of choice by two-fifths of developers, making up the biggest majority of IDE users in this community, according to JRebel’s 2023 Java Developer Productivity Report .

Minimize costs utilizing the cloud with Spring-Data-Eclipse-Store

Tue, 13 Feb 2024 15:26:37 +0000

Sooner or later any Spring application needs to store data. And of course, the first and easiest move is to utilize Spring Data JPA . You can set up your data storage without knowing which relational database you will use in production and simply start coding without worrying about that.

It is the easiest and most convenient way to store data (in a relational database like PostgreSQL), yet in the cloud environment it is also an expensive way. Pricing at AWS RDS starts at 30$/month with tiny-Instances and always have fixed monthly costs regardless of its usage.

Foojay Podcast #38: Java in the Cloud

Mon, 25 Dec 2023 12:02:46 +0000

Java was born in 1995, when the internet as we know it today didn’t exist yet.

Cloud servers, Docker, Kubernetes, distributed systems, scaling up and down… these things are now part of our daily job, but Java wasn’t originally designed for it.

In this episode, we want to learn if the recent evolutions in OpenJDK, and ongoing related projects, will make Java a full Cloud member.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Strategies for Managing State in Chronicle Services

Fri, 01 Dec 2023 08:41:44 +0000

Introduction

In distributed, microservice-based applications, the management of state is one of the most important, yet difficult aspects of design.

Ensuring the accuracy and consistency of state without introducing excessive complexity that affects performance or flexibility to support evolving requirements requires careful thought.

This article discusses issues around state management and shows how the Chronicle Services framework provides support to deal with these in ways that maintain a resilient and high performing microservices architecture.

How we developed the Eclipse OpenJ9 CRIU Support for fast Java start-up

Wed, 19 Jul 2023 15:33:39 +0000

Checkpointing and restoring the JVM makes applications run faster because all the startup work is done before deployment. This means that in serverless cloud applications, the end-user of the application perceives no delay when the application starts. You can try it out now with your own apps on Open Liberty with Eclipse OpenJ9. But if you want to know more, here’s how we tackled the technical challenges of developing the Eclipse OpenJ9 CRIU Support.

Vaadin 24.1: Bringing You More Than Minor Improvements!

Thu, 15 Jun 2023 14:58:13 +0000

I am pleased to share with you the newest release of Vaadin 24.1.

While Vaadin 24.0 was about upgrading the technology baseline and compatibility, this version brings you some new features.

Here are the best of them!

Visual View Builder

Built into start.vaadin.com, Visual View Builder helps you to create application prototypes using Vaadin UI components, generate Java code and share your prototypes to gather feedback.

Your First Vaadin Spring Application in 2023

Thu, 25 May 2023 12:08:30 +0000

Spring pun intended, but I wanted to update the guide for beginners interested in combining these two technologies.

By following these steps, you’ll have a basic Vaadin-Spring Boot application up and running in no time.

Recently I noticed that it is 8 years since Vaadin was first released in start.spring.io . Since then, there have been many additions to both Spring boot and Vaadin.

Recent upgrade toJava 17 and Jakarta EE 9 baseline. Vaadin 24 added a new pre-compiled frontend mod e making the initial startup matter of seconds (native compilation using GraalVM would make that even faster). And many many more. Time to grow a new project.

Managing Data Residency: Concepts & Theory

Tue, 16 May 2023 09:18:20 +0000

Cloud computing has opened a Pandora’s Box of many original issues compared to sound old on-premise systems. I believe that chief among them is Data Residency, or Data Location.

Data localization or data residency law requires data about a nation’s citizens or residents to be collected, processed, and/or stored inside the country, often before being transferred internationally. Such data is usually transferred only after meeting local privacy or data protection laws, such as giving the user notice of how the information will be used and obtaining their consent.

Developer vs. ChatGPT Part I: Writing a Spring Boot Microservice

Thu, 27 Apr 2023 15:25:12 +0000

We pit a seasoned Java developer against the all-knowing generative AI to find out once and for all: Can an AI generate a Java microservice end-to-end?

There’s a lot of buzz around Generative AI tools for code generation. It’s no secret that the future of developer productivity goes alongside tools such as GitHub Copilot and OpenAI’s ChatGPT to enable us, developers, to produce code better and faster. These tools can learn from our existing code and suggest new code based on the desired functionality, most importantly, they can even write documentation and tests!

How to Automatically Create Microservices Architecture Diagrams

Thu, 20 Apr 2023 08:01:21 +0000

In application development, microservices is an architectural style where larger applications are structured as a collection of smaller, independent, yet interconnected services.

While this allows for highly maintainable and testable applications (as each service can be maintained independent of the larger application), the problem with this method is the inherent complexity of interactions between microservices.

It can be difficult for developers and team members to visualise how these microservices are connected to each other. We have been looking for ways to produce architectural diagrams that illustrate these interactions.

My Evaluation of the Scaleway Cloud Provider

Fri, 31 Mar 2023 09:54:20 +0000

A couple of years ago, I developed an app that helped me manage my conference submission workflow.

Since then, I have been a happy user of the free Heroku plan.

Last summer, Heroku’s owner, Salesforce, announced that it would stop the free plan in November 2022.

I searched for a new hosting provider and found Scaleway .

In this article, I’d like to explain my requirement, why I chose them, and my experience using them.

How to Build and Deploy a Real-time Cloud-based Logging System

Fri, 24 Mar 2023 15:04:51 +0000

Logs and traces generated by applications are valuable sources of information that can help detect issues and improve performance.

However, they are often treated separately from other data, even though they are no different from the data an application works with.

In this tutorial, we will explore a different approach: treating logs and traces as part of a scalable cloud storage repository that can be analysed with the same techniques used for big data.

Failover Client with the Hazelcast Viridian Serverless

Fri, 24 Mar 2023 14:55:42 +0000

Failover is an important feature of systems that rely on near-constant availability.

In Hazelcast, a failover client automatically redirects its traffic to a secondary cluster when the client cannot connect to the primary cluster.

Consider using a failover client with WAN replication as part of your disaster recovery strategy.

In this tutorial, you’ll update the code in a Java client to automatically connect to a secondary, failover cluster if it cannot connect to its original, primary cluster.

Vaadin 24: Java 17, Jakarta EE 10, Servlet 6, Spring Boot 3

Wed, 22 Mar 2023 09:22:27 +0000

Vaadin 24 delivers a significant step forward with a new technology baseline that includes Java 17, Jakarta EE 10, Servlet 6.0, Spring 6.0, and Spring Boot 3.

This ensures you can continue building Vaadin Flow apps with the latest Java technologies.

It also provides several exciting improvements that help you build Java applications even faster. Let me introduce some of them.

Faster build times

You can now experience significantly improved build and start-up times during development.

Authenticate with OpenID Connect and Apache APISIX

Thu, 09 Mar 2023 07:51:47 +0000

Lots of companies are eager to provide their identity provider: Twitter, Facebook, Google, etc. For smaller businesses, not having to manage identities is a benefit. However, we want to avoid being locked into one provider.

In this article, I want to demo how to use OpenID Connect using Google underneath and then switch to Azure.

OpenID Connect

The idea of an authorization open standard started with OAuth around 2006. Because of a security issue, OAuth 2.0 superseded the initial version. OAuth 2.0 became an in 2012:

Web App Startup in 3ms with RIFE2 and GraalVM

Tue, 21 Feb 2023 09:12:55 +0000

RIFE2 applications already launch quickly with a regular JVM thanks merely calling Java methods, lambdas and doing object instantiations at startup. There are no annotations to scan for, nor any declarations or config files to parse and resolve.

The RIFE2 v1.3.0 release introduced experimental support for GraalVM Ahead-Of-Time compilation with native-image, reducing the startup time of the bootstrap project from 177ms to an incredible 3ms.

Try it out yourself

In order to try this out, you can download the latest GraalVM JDK 19 distribution, and follow the steps to install native-image on your machine.

Getting Started with RIFE2 Java Web Framework v1.0.0

Tue, 07 Feb 2023 07:44:45 +0000

RIFE2 is a very recently released and completely re-imagined version of my RIFE framework from 10 years ago.

You can find all the details on the project website and on GitHub .

What is RIFE2?

RIFE2 provides an opinionated full stack web framework, without external dependencies, in a 2MB jar. It is designed as a whole to make the creation of dynamic web applications and REST web services very fast while preserving maintainability and leveraging the strengths of the Java platform. You can still pull in other Java libraries and frameworks, of course, however, the layers of RIFE2’s full stack have knowledge about each-other, which provides many convenient features and shortcuts.

How to Run a Java Application with CRaC in a Docker Container

Wed, 01 Feb 2023 09:41:11 +0000

CRaC (Coordinated Restore at Checkpoint) is an OpenJDK project that was developed by Azul to solve the problem of “slow” startup times of the Java Virtual Machine in a microservice environment.

The most up-to-date guidelines can be found on “Coordinated Restore at Checkpoint Usage Guidelines ” in the Azul Docs.

When the JVM runs your application code, it does things like interpreting, compiling and optimizing code to make your application run as fast as possible under the given workload. This is great but can take some time and especially when you run short lived microservices you don’t want to wait until the JVM has produced the most optimized code.

Modular Monolithic in Practice

Wed, 25 Jan 2023 08:01:08 +0000

With the usage of microservices in application modernization, we have seen both the advantages and disadvantages of maintaining such software development styles.

When we create applications mostly in enterprise organizations, the first thing that comes to our mind now is how to decouple our applications.

But there will be times when creating too many microservices is not the best way and may cost you time and money.

Because of that, one alternative is to leverage the use of modules.

How to Reduce Cloud Cost by 99% for EDA Kafka Applications

Wed, 11 Jan 2023 13:35:41 +0000

While the Cloud offers great convenience and flexibility, the operational cost for applications deployed in it can sometimes be significant.

In this article, we show a way to substantially reduce operating costs in latency-sensitive Event-Driven Architecture (EDA) Java applications by migrating from Kafka to Chronicle Queue open-source, which is a more resource-efficient andlower-latency queue implementation.

What is EDA?

An EDA (Event-Driven Architecture) application is a distributed application where events (in the form of messages or DTOs) are produced, detected, consumed, and reacted to.

What’s New in Jakarta REST 3.1 in Jakarta EE 10?

Thu, 05 Jan 2023 11:30:17 +0000

The Representational State Transfer or RESTful architecture is a stateless, HTTP based communication standard for modern applications. It was originally proposed by Dr. Roy Fielding in his PhD thesis.

It has, over the years, become the default programming language-agnostic means of enabling machine-to-machine communication.

An application written in the Django framework in Python can have REST resources that are consumed by another application written in Java with Jakarta EE. Similarly, a Jakarta EE application can create resources that can be consumed by a C# application.

Hilla 1.3: Build React + Spring Boot Apps Faster

Thu, 15 Dec 2022 00:01:50 +0000

Hilla is a full-stack web framework for Spring Boot.

With its type-safe server communication, building apps is faster (autocomplete everywhere) and refactoring them is safer (compile time errors vs production).

Hilla includes 45+ UI components and integrated build tooling so you can get a full-stack project running in a minute.

Hilla 1.3 adds support for using React to build the frontend.

Release highlights

New: React support (including React wrappers for all Vaadin components)
New: Hilla CLI

Release blog post | Release notes

Vaadin 23.3 Improves Kubernetes, Three New Components

Wed, 14 Dec 2022 23:59:15 +0000

The Vaadin 23.3 release includes three new UI components and improvements to the Vaadin Acceleration Kits for easier deployments in clustered environments (support for rolling updates, horizontal scaling, high availability, and session replication).

Release highlights

Release blog post | Release notes

SpringOne TLV World Tour Trip Report

Fri, 09 Dec 2022 22:00:00 +0000

My talk was accepted by SpringOne in San Francisco. I never went to that conference and was really looking forward to it. This year would probably be amazing with the Spring 6.0 and Spring Boot 3.0 releases. So many groundbreaking changes. Unfortunately, my travel budget at Lightrun was cut, and I eventually left. This meant I had to cancel the trip, I would have paid for travel, but San Francisco is both far and prohibitively expensive. I’ll have to take a raincheck.

What is An Application Server? In 3 Minutes!

Thu, 01 Dec 2022 17:01:44 +0000

Low on time and want to know what an ‘application server’ really is?

Here we offer our explanation. This video covers the difference between application servers and web servers, what an application server can do to make your life as a developer easier, and more, all in less time than your average pop song!

This is a high-level view that might be helpful to pass on to managers and procurement teams who aren’t sure what an application server is.

Payara Launches Payara Cloud – Serverless for Jakarta EE

Tue, 15 Nov 2022 16:31:30 +0000

The cloud native application runtime automates tasks like Kubernetes deployment, ingress and YAML.

Payara has launched a new product ++Payara Cloud++ , designed to run Jakarta EE apps easily and quickly on the cloud.

Developers simply upload any web application following the Jakarta Web Profile specification and run it in a containerized Payara Micro instance.

Payara Cloud deals with infrastructure, allowing them to build the code and concentrate on business logic.

EJB support in Piranha via CDI

Tue, 15 Nov 2022 14:14:42 +0000

Enterprise Beans was once the face of Java EE, but as we discussed in the previous article , is currently de-emphasised in Jakarta EE.

However, since there’s so much existing code using Enterprise Beans, a certain level of support is still desired.

Piranha Cloud , a relatively new runtime supporting Jakarta EE, takes a somewhat novel approach to Enterprise Beans. Instead of implementing a separate container, Piranha Cloud, via the OmniBeans project, maps Enterprise Beans annotations to equivalent functionality in CDI itself, or to technologies in Jakarta EE leveraging CDI (such as Jakarta Transactions).

Clean Ways to Shutdown Spring Boot Applications

Fri, 04 Nov 2022 14:11:00 +0000

For the last three to four years, I have been working on Spring Boot and its associations, such as Spring Cloud, Spring Data, and Spring Security.

I have always been tempted to use the combination of Ctrl+C and task kill for the purpose of killing Spring Boot applications or processes. It can be automated by a batch script, but usually I was quite lazy to do this myself, as the combination of actions used to serve the purpose!

What is MicroProfile?

Thu, 22 Sep 2022 09:03:08 +0000

The Java programming language can be enhanced with specifications. An specification is a baseline platform definition - a framework - to guide concrete implementations.

One of these specifications is called MicroProfile.

But what is MicroProfile specification, what is it used for and why might you need it?

This article explains all!

What Is MicroProfile?

The MicroProfile specification is a set of Enterprise Java APIs and technologies, designed to help with the challenge of building microservices architectures in Java.

How the world caught up with Apache Cassandra

Thu, 15 Sep 2022 16:50:50 +0000

The O’Reilly book, Cassandra: The Definitive Guide, features a quote from Ray Kurzweil, the noted inventor and futurist: {#speakable-summary}

“An invention has to make sense in the world in which it is finished, not the world in which it is started.”

This quote has a prophetic ring to it, especially considering my co-author Eben Hewitt included it in the 2010 first edition of this book we wrote, back when Apache Cassandra, the open-source, distributed, and highly scalable NoSQL database, was just on its 0.7 release.

Serverless is the New Timeshare

Fri, 09 Sep 2022 07:53:18 +0000

We have a shared amnesia. When I speak to younger developers about past technologies, I often get blank stares. To be fair, some of that is because I’m a bit “intense” or “weird” but some of that is because. Huh? Really? Did we have that?

Case in point XA transactions and 2PC (Two Phase Commit). We have a young generation that’s completely ignorant of that capability and the fact that this was “a thing”. Did the requirement for transaction management somehow vanish?

Ignore Infrastructure, Focus on Code, with Jakarta EE and Payara

Tue, 09 Aug 2022 09:59:12 +0000

Java EE, now Jakarta EE, makes it possible for developers to focus purely on the development of a Java enterprise application, solving the business logic without needing to think about infrastructure and operations when writing code.

Payara Cloud extends this philosophy by also eliminating the need to worry about infrastructure and operations when preparing your application to run in the cloud.

Together, Jakarta EE and Payara Cloud let you focus on writing code and delivering solutions to business challenges from the moment you write your first piece of code to the day people are using your application successfully on the cloud.

How to deploy a Vaadin application to Google Cloud App Engine

Tue, 26 Jul 2022 08:27:20 +0000

I tried to deploy a Vaadin application to Google Cloud App Engine.

It was not as straightforward as expected, so I want to share my findings.

The example project is available on GitHub: https://github.com/simasch/vaadin-appengine-demo

The Vaadin Application

First, I’ve created a new Vaadin application: https://start.vaadin.com

Then I did a production build:

mvn package -Pproduction

That will generate an executable JAR file in the target directory.

The End of the Beginning for Apache Cassandra

Tue, 12 Jul 2022 17:43:39 +0000

Image: Pixabay

Editor’s note: This story originally ran on July 27, 2021, the day that Apache Cassandra 4.0 was released.{#4bbb}

Today is a big day for those of us in the Apache Cassandra community. After a long uphill climb, Apache Cassandra 4.0 has finally shipped . I say finally, because it has at times seemed like an elusive goal. I’ve been involved in the Cassandra project for almost 10 years now and I have seen a lot of ups and downs.{#d6a4}

Securely Authenticate to Google Cloud from GitHub

Mon, 02 May 2022 08:57:00 +0000

Recently, I designed a simple metrics-tracking system.

A Python script queries different providers’ APIs for metrics, e.g., Twitter, GitHub, etc.

The idea is to run this script each day, store them in Google BigQuery and provide an excellent data visualization in Google Data Studio.

I’m a big fan of automation, so I’m using GitHub Actions.

Accessing Google Cloud with a Service Account

I query the different APIs with different Python libraries. All of them allow authenticating by passing a parameter. In general, it’s a token. One can store the value in a GitHub secret, get it as an environment variable in the GitHub Action and use it in the code.

Polyglot Cloud Native Debugging: Beyond Logs/APM

Tue, 18 Jan 2022 07:55:51 +0000

I’ve done quite a few conference talks since I became a developer advocate for Lightrun . One of my most popular talks has a title similar to the title of this article. In this article I’ll try to cover the gist of the talk.

Cloud-Native Applications

There’s practically an alphabet soup of terms covering public cloud, hybrid cloud, etc. There’s also a lot of overlap between the various terms. The nice thing about this topic is that it applies, regardless. You will run into problems with microservices, architecture and monolithic applications or serverless.

Building Stateful Microservices in the Cloud Native World

Tue, 04 Jan 2022 09:34:13 +0000

Cloud Native computing is all about working with stateless data and serverless systems. But we all live in a stateful world, in which data flows through systems interconnected with one another through complex networks.

So how can systems be able to manage and track the flow of data in a coherent fashion and in a stateless world?

We will first iron out a few terminologies that some folks appear to be using almost interchangeably in the current cloud computing era:

The future of cloud-native databases begins with Apache Cassandra 4.0

Wed, 29 Dec 2021 07:40:00 +0000

“Reliability at massive scale is one of the biggest challenges we face at Amazon.com, one of the largest e-commerce operations in the world; even the slightest outage has significant financial consequences and impacts customer trust.”

This was the first line of the highly impactful paper titled “Dynamo: Amazon’s Highly Available Key-value Store.” Published in 2007, it was written at a time when the status quo of database systems was not working for the massive explosion of internet-based applications. A team of computer engineers and scientists at Amazon completely re-thought the idea of data storage in terms of what would be needed for the future, with a firm footing in the computer science of the past. They were trying to solve an immediate problem but they had unwittingly sparked a huge revolution with distributed databases and the eventual collision with cloud-native applications.