Architecture & Microservices on JAVAPRO International

Do You Still Write Code without Hexagon?

Tue, 14 Jul 2026 07:00:01 +0000

During our training in architecture, we often ask participants if they are familiar with Hexagonal architecture, and it’s surprising to see only a few hands raised initially. After a brief presentation, we see a few more hands go up, as participants realize they have been using Hexagonal architecture without realizing it.

As hands-on architects, we rely heavily on Hexagonal architecture in our daily work. However, we notice that many people are still unaware of the significant benefits it can bring to their projects.

2: The Jakarta Cliff: Why Modern Java Leaves Struts 1 Behind

Thu, 18 Jun 2026 07:00:02 +0000

This is the second in a series of articles exploring the realities of modernisation. In this article, you’ll learn about:

The Modern Java Breakpoint: Why the shift from javax to jakarta creates an unfixable compatibility break for Struts 1 on modern containers like Tomcat 10 and Jetty 11.
The External Pressure Cooker: How platform baselines, security policies, and cloud migrations force the issue, even if the application code itself hasn’t changed.
Why “Shims” Fail: A look at why attempting to patch compatibility with shims is not a viable long-term solution for production environments.
Safe Operation Strategies: What it practically means to run Struts securely on older containers without exposing the rest of your infrastructure to risk.
The Path to Modernisation: How to use incremental migration patterns and extended support to modernise on your own terms, avoiding risky “big-bang” rewrites.

Beyond UML: Clean Software Architecture in the Age of AI‑Generated Code

Wed, 10 Jun 2026 07:00:02 +0000

Abstract

Today we write more code in less time than ever before. AI systems act like permanently available junior programmers: They produce thousands of lines of code in minutes – but who takes responsibility for the software architecture?

The real problem is therefore often not “bad AI code,” but the growing difficulty for people to keep an overview and make sound architectural decisions.

This article discusses an idea for quickly building a mental model of existing code, spotting architectural problems early, and making targeted changes – without having to maintain static documentation in parallel.

JCON EUROPE 2026: Why the Java Community Still Meets in Person

Mon, 01 Jun 2026 07:00:00 +0000

Every year, when we start planning JCON EUROPE, one question always guides us:

How do we create a conference that developers genuinely enjoy attending?

Not just another event with slides and sponsor booths. Not a place where people passively consume information and leave. We wanted to create an environment where developers actively connect, discuss, challenge ideas, and solve real-world problems together.

Looking back at JCON EUROPE 2026, I believe this spirit was visible everywhere.

From Spaghetti to Hexagons: A Practical Guide to Clean Java Architecture

Wed, 27 May 2026 07:00:01 +0000

A Culinary Warning and the Dark Side of Code

Welcome, fellow architect and beloved developer, to our hexagonal city-state—a realm where pragmatism reigns supreme and flexibility is our greatest strength. This guide is not an ivory tower doctrine filled with theoretical perfection, but rather a versatile toolbox tempered in the forge of real-world challenges and countless production battlefields.

Before we can erect the citadel of clean architecture, we must first acknowledge the reality of our industry. We must navigate the “Dark Side of Code”. The software world is rife with culinary disasters that would make a chef weep. We are all too familiar with Spaghetti Code^(1), a tangled mess where program flow twists and turns like pasta, making maintenance a nightmare where references and dependencies jump all over the place. But the menu of disaster is extensive.

Open-Core with Core Java and Vaadin — Part 2

Sat, 23 May 2026 11:33:42 +0000

Editions, runtime, and quality assurance.

All source code presented here is published on GitHub and available at https://3g3.eu/naityh.

Recap of part one

The first part of this article developed the abstract mechanics of the open-core application. From two independent Maven projects with strictly asymmetric dependency direction, a deliberately slim extension API with the contribution types RouteContribution, MenuContribution, NavbarContribution, and CounterEventListener, a FeatureRegistry that discovers its contributions via the Java standard library’s ServiceLoader, and a Vaadin integration consisting of MainLayout and OpenCoreRouteInitializer, an apparatus is now in place that can accept arbitrary contributions in ordered form, without the core needing to know their identity.

Open-Core with Core Java and Vaadin — Part 1

Fri, 22 May 2026 11:33:04 +0000

Architecture, extension API, and Vaadin integration.

1. Introduction and motivation

The open-core model is often reduced in discussion to questions of licensing or commercial positioning. An open-source variant of a piece of software is complemented by a commercially distributed variant that brings additional features. Anyone who actually wants to implement such a separation in an existing codebase quickly discovers that the real difficulty lies neither in the licence text nor in the choice of repository, but in the code’s architecture.

Petabyte-Scale AI Memory with Serverless Java

Wed, 15 Apr 2026 07:00:01 +0000

The current wave of Generative AI innovation is built on a paradox. While models are becoming more powerful and efficient, the infrastructure required to operate them at scale is becoming increasingly wasteful. Enterprises are investing millions into compute, storage, and energy, yet a significant portion of these resources remains idle. Modern vector databases, graph systems, and caching layers are based on a monolithic architecture run as always-on clusters, consuming CPU and RAM regardless of whether data is actively accessed. Studies and industry analyses consistently show that up to 80% of compute resources in such systems are effectively wasted on idle workloads.

Zero Migration Java - Staying Current Without Breaking Your App

Fri, 10 Apr 2026 07:00:01 +0000

Keeping enterprise Java applications secure and up-to-date is critical but traditional runtime upgrades often come with painful migrations, broken dependencies, and retesting cycles. What if developers could upgrade their runtime without touching their code? In this article, we explore the concept of zero migration — a runtime model that allows Java applications to stay current with the latest pat

A Big Screen Experience for Java Developers & Architects

Wed, 08 Apr 2026 12:00:02 +0000

JCON EUROPE 2026 | April 20–23, 2026 | Cinedom Cologne

Anyone talking about modern software development today can hardly avoid Java. Few technologies have shaped the enterprise world as sustainably, and few communities are as vibrant, diverse, and innovation-driven. This is exactly where JCON comes in: as a meeting point, a platform, and an experiential space for developers from all over the world. With participants from more than 70 countries, JCON has long since become an international gathering. Openness, knowledge sharing, and a strong sense of community remain at its core.

High-Performance Vector-Search Grids with Java

Wed, 08 Apr 2026 07:00:02 +0000

The rapid rise of Generative AI has fundamentally changed how modern systems are designed. While much of the attention has focused on large language models and inference pipelines, the real differentiator in production systems lies elsewhere: in the infrastructure that delivers context to those models. Retrieval-Augmented Generation (RAG) has become the de facto pattern for enterprise GenAI. It relies on fast, scalable access to embeddings, metadata, and relationships. Yet for Java developers, building such systems at scale has remained a challenge. External vector databases introduce latency, fragmentation, and operational complexity. Distributed caches struggle with memory inefficiency and serialization overhead. Traditional databases cannot handle high-dimensional similarity search at the required speed.

Java Performance Optimization with Agentic AI: Autonomous Diagnostics and Actionable Recommendations

Tue, 07 Apr 2026 07:00:01 +0000

Java performance diagnosis in production is manual, slow, and requires deep expertise. You get a Grafana alert, grab a thread dump, download a JFR recording, open it in JDK Mission Control, stare at flamegraphs, correlate with metrics — hours of work per incident. Most teams don’t have a dedicated performance engineer, so alerts get ignored or result in generic “add more replicas” responses.

We built a system that does this autonomously. When a monitoring alert fires, it collects profiling data and thread dumps, extracts runtime metrics, generates flamegraphs, and sends everything to an AI model that produces a structured performance report — including root cause analysis and concrete code fixes with file paths and line numbers from the actual source repository. The pipeline runs on Kubernetes, triggered by Grafana webhooks, with results stored in Amazon S3.

Agentic AI Patterns for Enterprise Software

Tue, 31 Mar 2026 07:00:01 +0000

It is no surprise that software development is increasingly shaped by the integration of AI. As the technology matures, we are moving beyond simple, monolithic AI models or single shot API calls. Modern enterprise architectures are rapidly adopting agentic AI systems, which orchestrate multiple independent reasoning agents to accomplish complex, real-world tasks. This article explores these powerful patterns, covering the core concepts of agents, their coordination, orchestration models, and crucially how to implement them effectively in enterprise Java applications.

AI without spaghetti: Clean architecture in the age of AI

Tue, 17 Mar 2026 07:00:01 +0000

When “Just ship it” turns into lasagna code

We start with a familiar scene: a small experiment that grows faster than its architecture can handle. This is exactly the kind of situation where clean architecture becomes essential. Like layering pasta without checking the recipe, we kept adding features until the structure began to wobble.

At first everything seems perfectly reasonable. A quick integration with an API, a prompt that produces surprisingly good results. Suddenly the prototype starts solving real problems. The codebase grows organically: a helper class here, a service there. Maybe a controller that does just a little bit more than it probably should.

JCON Meets Enterprise AI - From Basics to Production

Thu, 29 Jan 2026 12:00:01 +0000

From April 20–23, 2026, the European Java community will once again gather in Cologne for JCON EUROPE 2026. Taking place at the Cinedom multiplex cinema, the conference brings together developers, architects, and Java enthusiasts for four days of knowledge sharing, inspiration, and real-world experience — all on the big screen.

Under the motto “Big screen. Big community. Big AI.”, JCON EUROPE 2026 offers an in-person program running daily from 9:00 to 18:00 (CEST), combining technical depth with a strong community focus.

Java 25 + GenAI: A New Era for Microservices in Finance

Thu, 22 Jan 2026 07:00:01 +0000

Java 25 and GenAI combine to build explainable, scalable microservices for finance — blending performance, transparency, and open-source innovation in one architecture.

Code. Collaboration. Community.

Wed, 24 Dec 2025 07:00:02 +0000

JCON USA @ IBM TechXchange 2025 – where the spirit of Java found a new home in Orlando.

When the JCON team announced they were bringing their renowned Java conference series across the Atlantic, expectations were high. Known for its lively spirit and deep technical content, JCON Europe has become a must-attend event for Java developers. Its first U.S. edition – JCON USA @ IBM TechXchange 2025 – not only met those expectations but exceeded them, uniting Java professionals from around the world under one roof in Orlando.

Java Meets the Future: How Quarkus Seamlessly Combines Architecture, Performance, and Cloud-Native

Thu, 04 Dec 2025 07:00:01 +0000

Given the increasing ubiquity of digital technologies, which are becoming increasingly and naturally embedded in our environment, the essential question arises as to what role Java will play in this future development of IT systems. Mark Weiser, pioneer of ubiquitous computing, described this technological paradigm shift as follows: “The best technology is the one we don’t even notice because it naturally enriches our everyday lives.” (paraphrased from [LMU19]).

Ubiquitous computing is already demonstrating how technology is becoming omnipresent and seamlessly integrated into our environment as an invisible companion. A key factor here is the almost universal access to networks (such as Wi-Fi), which is increasingly becoming standard infrastructure internationally. This access enables the real-time networking of smart devices, from smart homes to wearables, and forms the basis for technologies that work intuitively in the background and communicate with each other seamlessly without disruptive interference. In addition, ubiquitous computing promotes an ever-closer symbiosis between humans and machines, in which new technologies are emerging that are increasingly replacing classic interfaces to the digital world such as smartphones and tablets. Devices such as mixed reality glasses (e.g. Meta Quest or Apple Vision Pro) open up a new form of interaction in which digital information is projected directly and contextually into the field of vision. The goal is no longer just general interaction, but rather the precise adaptation of digital content to the individual needs of the user. This development leads to the concept of hyper-personalization: systems respond in real time to location, preferences, and goals, providing tailored information, entertainment, or support in everyday life. This points to a future in which digital experiences are seamlessly integrated into personal life.

How Coupled Are Your Microservices?

Tue, 04 Nov 2025 07:00:01 +0000

In this article, we address a crucial topic in software architecture: coupling and its main types in the context of microservices architecture.

The motivation for this writing comes from direct experience with the negative impact of coupling on system design. In one project, delivered by a software house, we had to fully refactor it before going live due to excessive domain, pass-through, shared data, and content coupling. These interdependencies made the services fragile and undermined their autonomy, scalability, and maintainability.

Dynamic consistency boundaries

Tue, 28 Oct 2025 07:00:01 +0000

In software, Consistency may refer to many things - Code Consistency, Data Consistency, User Interface Consistency, etc. In this article, I am focusing on Data Consistency. Simply put, Data Consistency ensures that data remains accurate and reliable across different parts of a system. More formally, Data Consistency is one of the Database Transaction properties (ACID^(1)) defined as:

Consistency (or correctness) ensures that a transaction can only bring the database from one consistent state to another, preserving database invariants.

Improving Platform Observability with Distributed Tracing and OpenTelemetry

Mon, 22 Sep 2025 07:00:01 +0000

Observability has become crucial for modern applications. Distributed tracing, in particular, is essential for diagnosing issues within complex transactions. OpenTelemetry has emerged as the indispensable standard in this field. This article explores the fundamentals of distributed tracing, its implementation, and its impacts.

In a context where applications are increasingly complex, it is crucial to be able to observe each transaction in detail to quickly identify problems and ensure continuous evolution of the platform. Among the three main pillars of observability—logs, metrics, and traces—traces are often less known but equally essential.

Microservices: Lessons from the Trenches

Fri, 12 Sep 2025 07:00:02 +0000

During my 15-year journey in the world of software development, I spent the vast majority of my time designing and implementing systems using microservices architecture. I’ve been involved in multiple migrations from monolithic systems to microservices, as well as building new solutions from scratch. Along the way, my teams and I made plenty of mistakes. Some were quite trivial and easy to correct, others involved decisions that were difficult to reverse, or changes that required significant effort to fix. More than once, I found myself in situations where it seemed that working with this architecture was pointless and too challenging.

Java at Eclipse: Honoring the Legacy, Securing the Future of Open Source Innovation

Wed, 03 Sep 2025 07:00:01 +0000

Java changed software development and reshaped open source innovation forever, but its future was uncertain for a while. Would it remain an innovative force, or would closed governance and slow progress relegate it to history? Enter the Eclipse Foundation, where the future of open source Java was reimagined.

Java’s journey famously began in the mid-1990s, revolutionising software development with its “write once, run anywhere” promise. Originally, Java, the language, was called “Oak,” a name chosen by its creator, James Gosling, after an oak tree outside his office. Oak trees are known for their deep roots and longevity, much like Java, which has remained a cornerstone of software development for decades. While the name was later changed due to trademark issues, its original symbolism reflects Java’s foundational role in modern computing: a language built to be powerful, adaptable, and enduring. Open-sourced by Oracle in 2007, it has become the backbone of enterprise applications, cloud computing, and mobile development.

The Role of Quarkus in the Modern Java Ecosystem

Fri, 22 Aug 2025 07:00:02 +0000

Since its inception in 2019, Quarkus has gradually grown both in user adoption and innovation. The number of its different research and development areas is just enormous. It’s one of the most active Java projects you can find right now.

Last year, Quarkus celebrated its 5th birthday and one additional tremendous milestone — 1000 contributors! These are contributors to the main repository only, not considering the additional 170 repositories under the Quarkiverse organization (which we tackle later in this article).

Demystifying Software Architecture: Styles/Patterns - PART 1

Thu, 14 Aug 2025 07:00:01 +0000

Whether you’re watching a gripping documentary on Netflix or any other OTT platform, witnessing a nail-biting Test match at Old Trafford, or placing an order on an e-commerce platform, you’re experiencing the result of great software architecture in action.

I find it fascinating to explore the powerful software architectures that make modern applications so reliable and scalable.

These real-time, large-scale systems handle pressure, recover from failures, and scale effortlessly because engineers design them with resilience, availability, fault tolerance, scalability, robustness, performance, recoverability, and continuity in mind.

Mastering the Basics of Domain-Driven Design with Java

Tue, 01 Jul 2025 07:00:01 +0000

Domain-driven design (DDD) is a critical approach in software development, yet its essence often gets buried under layers of complexity and misunderstanding. At its core, DDD aims to align software design with the needs of the business or stakeholders, ensuring that what we build addresses real problems. Even that sounds like a cliche in software development, and obviously, it is still a challenge to most organizations.

One standout example is Forbes’ 16 Obstacles to a Successful Software Project, which emphasizes challenges such as hyper-focused planning, unclear expectations, and poor collaboration. These issues often lead to scenarios where software is more about managing complexity than solving problems.

Java in Critical Operations: How Custom Development Ensures Control and Secures Mission-Critical Systems

Mon, 02 Jun 2025 08:15:19 +0000

When IT fails, no one notices—until everyone does.
Whether in hospitals, energy grids, or airports, stable operation of digital systems in safety-critical environments is not an option, but a strict requirement. This is where infrastructure must prove its resilience, scalability, and independence in the face of real-world crises.

A prime example is Fraport AG, operator of one of Europe’s largest aviation hubs. When baggage goes missing or safety-critical information is delayed, it’s not just individual passengers’ vacations that are at risk—the operational stability of the entire airport is on the line. Behind the scenes of such a hub runs an extremely complex digital infrastructure that must operate reliably 24/7, despite increasing demands, ageing legacy systems, and tightening security regulations.

Cinema, Code, Community: JCON EUROPE 2025 raises the bar for Java events

Fri, 30 May 2025 09:33:47 +0000

From hands-on workshops to live coding on the big screen to the new mentoring revolution – JCON EUROPE 2025 in Cologne was a celebration for Java enthusiasts from around the globe.

A global gathering of the Java community

From May 12–15, 2025, Cologne became the epicentre of the international Java community. For the tenth edition of JCON EUROPE, developers from more than 60 countries across five continents gathered at the Cinedom to celebrate 30 years of Java. The atmosphere? Euphoric, collaborative – with plenty of good humour.

Java: let’s do a SWOT!

Wed, 28 May 2025 07:00:02 +0000

“Java is to enterprise what electricity is to civilisation”

Java has transcended “being just a programming language - it has become a cultural icon. From academic syllabuses to heated tech debates, and from viral social media memes to pop culture references in movies, Java’s influence is everywhere. Few languages have had such an incredible run, shaping not just software but also conversations, careers, and even family.

Java, a stalwart in the programming world, has not only stood the test of time but has also shaped the evolution of modern software development. To the casual observer, it may seem like just another language, yet over the past three decades, Java has cemented itself as an integral part of the technology ecosystem. It has been the foundation for groundbreaking innovations and a cornerstone of academic research.

Java through the decades: From Applets to Microservices

Thu, 22 May 2025 07:00:01 +0000

Introduction

Java has undergone a remarkable transformation since its creation. It evolved from a language designed for interactive web-based Applets to a dominant force in enterprise development and cloud-native microservices. Java was originally created to enhance web interactivity. It soon evolved to support business applications, distributed systems, and modern architectures. This article explores Java evolution from Applets to microservices, highlighting key technological advancements and industry shifts.

Java Evolution from Applets to Microservices: A Technological Shift

Java’s origins trace back to 1991 when Sun Microsystems initiated the Green Project to develop a platform-independent language. Officially released in 1995, Java introduced the concept of “Write Once, Run Anywhere” (WORA), allowing applications to execute on any system with a Java Virtual Machine (JVM).

The Simplest Way to Build Resilient Applications

Thu, 08 May 2025 07:00:01 +0000

Restate is an open-source system that makes it easy to write resilient, consistent and scalable applications. Restate lets you write mission-critical applications, like payment workflows, user management, and AI agents, without worrying about resiliency.

The quick check for your software - the Software Coma Scale (SCS)

Mon, 07 Apr 2025 11:22:49 +0000

Do you know this situation: You have are sitting on your desk when your boss asks you to “just have a look at an old software-system” at its current status? Since he doesn’t know much about your job (IT), you have to use a system that

a) he understands and

b) allows you to make an informed assessment relatively quickly.

Or a customer asks whether you could change this or that thing in a system you don’t know - or even take over the maintenance for it. And just like your boss, he is not an IT specialist!

Building a better Mouse Trap - web crawling with Temporal

Thu, 03 Oct 2024 14:26:30 +0000

For various reasons, I’ve been looking at Temporal lately. It’s one of those open-source projects with some great users - think Netflix, Uber, etc.- yet has less visibility in the Java community than expected.

I hope to raise its profile here.

Before I talk about Temporal, I’ll cover my particular use case. Stay with me; this needs to be detailed.

Background

A side project I have is to create a Java API comparison tool that can be used to check if moving from version A to version B of a dependency will have issues. I’m looking beyond the simple class-to-class comparison, I intend to check for a more holistic view to find runtime and compile time problems that might occur within the dependency tree if you upgrade something.

Developer Relations as Terraforming: Cultivating Ecosystems for Success

Thu, 26 Sep 2024 11:55:28 +0000

As a “DevRel” person, I’m disappointed in how often our efforts are misunderstood and marginalised. In this article, I want to take another slant on the what and why of “DevRel.”

Developer Relations (DevRel) holds the same transformative potential as terraforming in science fiction. It’s cheesy, but it’s pretty accurate. Much like engineers striving to turn a hostile, barren planet into one that can sustain life, DevRel teams are tasked with creating an atmosphere where developers can thrive. Success in both cases isn’t immediate; it requires patience, deliberate planning, and constant care to cultivate a living ecosystem.

Programming Language with no Syntax?

Sun, 15 Sep 2024 23:44:01 +0000

1. Introduction
Is it possible to have a programming language that has no syntax? It sounds like a contradiction. Programming languages are all about syntax, plus a bit of code generation, optimization, run-time environment, and so on. But syntax is the most important part as far as programmers are concerned. When encountering a new programming language, it takes time to learn the syntax.

Could we just make the syntax disappear or at least make it as simple as possible? Could we also make the syntax arbitrary so that the programmer writing the code can define it for themselves?

Ouroboros is a programming language that tries to do just that. It has the simplest syntax ever. It is so simple that it does not even have a syntax analyzer. All it has is a lexical analyzer, which is 20 lines long.

At the same time, you can write complex programs and even expressions with parentheses and operators of different precedence, assuming you write your own syntax for that in the program. That way, no syntax also means any syntax.

This article is an introduction to Ouroboros, a programming language with no syntax. It is a toy, never meant to be used in production, but it is a fun toy to play with, especially if you have ever wanted to create your own programming language.

There were programming languages with minimal syntax. One of the very first languages was LISP, which used only parentheses to group statements as lists.

If you are familiar with TCL, you may remember how simple the language is. However, it still defines complex expressions and control structures as part of the language.

Another simple language to mention is FORTH. It is a stack language. The syntax is minimal. You either put something on the stack or call a function that works with the values on the stack. FORTH was also famous for its minimal assembly core and for the fact that the rest of the compiler was written in FORTH itself.

These languages inspired the design of Ouroboros. LISP is known for the simplest syntax. One might say that LISP has the simplest syntax of all programming languages, but it would be a mistake. True to its name, it uses parentheses to delimit lists, which can be either data or programming structures. As you may know, LISP stands for “Lots of Irritating Superfluous Parentheses.”

Ouroboros does not do that. It inherits the use of { and } from TCL, but unlike LISP, you are forced to use them only where they are really needed.

Ouroboros, although being an interpreted language, can compile itself. Well, not really compile, but you can define syntax for the language in the language itself. However, it is not like in the case of compilers where the compiler is written in the source language. One of the first compilers was the PASCAL compiler written by Niklaus Wirth in PASCAL. The C compiler was also written in C, and more and more language compilers are written in the language they compile.

In the case of an interpreted language, it is a bit different. It is not a separate program that reads the source code and generates machine code. It is the executing code, the application program itself, that becomes part of the interpreter.

That way, you cannot look at it and say: this code is not Ouroboros. Any code can be, depending on the syntax you define for it at the start of the code.

2. The Name of the Game
Before diving into what Ouroboros is, let’s talk about the name itself. Ouroboros coils around itself in an endless cycle of creation and recreation. The name “Ouroboros” is as multifaceted as the language itself, offering layers of meaning that reflect its unique nature and aspirations.

2.1. The Eternal Cycle
At its core, Ouroboros draws inspiration from the ancient symbol of a serpent consuming its own tail. This powerful image represents the cyclical nature of creation and destruction, perfectly encapsulating our language’s self-referential definition. Just as the serpent feeds upon itself to sustain its existence, Ouroboros the language is defined by its own constructs, creating a closed loop of logic and functionality.

2.2. UR: The Essence of Simplicity
Abbreviated as “UR,” Ouroboros embraces the concept of fundamental simplicity. In German, “Ur—” signifies something primordial, primitive, or in its most basic form. This perfectly encapsulates the design philosophy behind Ouroboros: a language stripped down to its absolute essentials.

By pushing the simplification of syntax to the extreme, Ouroboros aims to be the “ur-language” of programming—a return to the most elemental form of computation. Like the basic building blocks of life or the fundamental particles of physics, Ouroboros provides a minimal set of primitives from which complex structures can emerge.

This radical simplicity is not a limitation but a feature. It challenges programmers to think at the most fundamental level, fostering a deep understanding of computational processes. In Ouroboros, every construct is essential, every symbol significant. It’s programming distilled to its purest form.

2.3. Our Shared Creation
The name begins with “Our-,” emphasizing the collaborative nature of this language. Ouroboros is not just a tool but a shared endeavor that belongs to its community of developers and users. It’s a language crafted by us, for us, evolving through our collective efforts and insights.

2.4. Hidden Treasures
Delve deeper into the name, and you’ll uncover more linguistic gems:

“Oro” in many Romance languages means “gold” or “prayer.” Ouroboros can be seen as a golden thread of logic, or a prayer-like mantra of computational thought.

“Ob-” as a prefix often means “toward” or “about,” suggesting that Ouroboros is always oriented toward its own essence, constantly reflecting upon and refining itself.

“Boros” could be playfully interpreted as a variation of “bytes,” hinting at the language’s digital nature.

Parsing the name as “our-ob-oros” reveals a delightful multilingual wordplay: “our way to the treasure.” This blend of English (“our”), Latin (“ob” meaning “towards”), and Greek (“oros,” which can be associated with “boundaries” or “definitions”) mirrors the language’s eclectic inspirations.

Just as Ouroboros draws from the diverse traditions of TCL, LISP, and FORTH, its name weaves together linguistic elements from different cultures. This multilingual, multi-paradigm approach guides us toward the treasures of computation, defining new boundaries along the way, much like how TCL offers flexibility, LISP promotes expressiveness, and FORTH emphasizes simplicity and extensibility.

2.5. A Name That Bites Back
Ultimately, Ouroboros is a name that challenges you to think recursively, to see the end in the beginning and the whole in every part. It’s a linguistic puzzle that mirrors the very nature of the programming language it represents—complex, self-referential, and endlessly fascinating.

As you embark on your journey with Ouroboros, remember that you’re not just writing code; you’re participating in an ancient cycle of creation, where every end is a new beginning, and every line of code feeds into the greater whole of computational possibility.

3. What is Ouroboros
Ouroboros is a programming language that has no syntax. I have already said that, and now comes the moment of truth: it is a “lie.” There is no programming language with absolutely no syntax. UR has a syntax, and it is defined with this sentence:

You write the lexical elements of the language one after the other.

3.1. Syntax
That is all.

When the interpreter starts to execute the code, it begins reading the lexical elements one after the other. It reads as many elements as it needs to execute some code and not more. To be specific, it reads exactly one lexical element before starting execution. When the execution triggered by the element is finished, it goes on reading the next element.

The execution itself can trigger more reads if the command needs more elements. We will see it in the next example soon.

A lexical element can be a number, a string, a symbol, or a word. Symbols and words can and should have an associated command to execute.

For example, the command puts is borrowed shamelessly from TCL and is associated with the command that prints out a string.

puts “Hello, World!”
It is the simplest program in Ouroboros. When the command behind puts starts to execute, it asks the interpreter to read the next element and evaluate it. In this example, it is a constant string, so it is not difficult to calculate. The value of a constant string is the string itself.

The next example is a bit more complex:

puts add “Hello, " “World!”
In this case, the argument to the command puts is another command: add. When puts asks the interpreter to get its argument, the interpreter reads the next element and then starts to execute. As add starts to execute, it needs two arguments, which it asks from the interpreter. Since these arguments are strings, add concatenates them and returns the result.

3.2. Blocks
There is a special command denoted by the symbol {. The lexical analyzer recognizing this character will ask the interpreter to read the following elements until it finds the closing }. This call is recursive in nature if there are embedded blocks.

The resulting command is a block command. A block command executes all the commands in it and results in the last result of the commands in the block.

puts add {“Hello, " “World!”}
If we close the two strings into a block, then the output will be a single World! without the `Hello, `. The block “executes” both strings, but the value of the block is only the second string.

3.3. Commands
The commands implemented are documented in the readme of the project on GitHub. The actual set of commands is not fascinating. Every language has a set of commands.

The fascinating part is that in UR there is no difference between functions and commands. Are puts or add commands or functions? How about if and while? They are all commands, and they are not part of the language per se. They are part of the implementation.

The command if asks the interpreter to fetch one argument, evaluated. It will use this as the condition. After this, it will fetch the next two elements without evaluation. Based on the boolean interpretation of the condition, it will ask the interpreter to evaluate one of the two arguments.

Similarly, the command while will fetch two arguments without evaluation. It then evaluates the first as a condition, and if it is true, it will evaluate the second and then go back to the condition. It fetched the condition unevaluated because it will need to evaluate it again and again. In the case of the if command, the condition is evaluated only once, so we did not need a reference to the unevaluated version.

Many commands use the unevaluated version of the arguments. This use makes it possible to use the “binary” operators as multi-argument operators. If you want to add up three numbers, you can write add add 1 2 3, or add* 1 2 3 {}, or {add* 1 2 3}. The command add fetches the first argument unevaluated and sees if it is a *. If it is *, then it will fetch the arguments until it encounters the end of the arguments or an empty block.

This is a little syntactic sugar, which should be peculiar in the case of a language that has no syntax. It really is there to make the experiment and the playing with the language bearable. On the other side, it erodes the purity of the language. It is also only a technical detail, and I mention it only because we will need to understand it when we discuss the metamorphic nature of the language. It will be needed to understand the use of the first example there.

3.4. Variables
UR supports variables. Variables are strings with values associated with them. The value can be any object.

When the interpreter sees a symbol or a bare word (identifier) to evaluate, it will check the value associated with it. If the value is a command, then it will execute the command. In other cases, it will return the value.

The variables are scoped. If you set a variable in a block, then the variable is visible only in that block. If there are variables with the same name in the parent block, then the variable in the child block will shadow the variable in the parent block.

Variable handling and scoping are implementation details and not strictly part of the language.

The implementation as it is now supports boolean, long, double, big integer, big decimal, and string primitive values. It also supports lists and objects.

A list is a list of values, and it can be created with the list command. The argument to the command is a block. The command list will ask the interpreter to fetch the argument unevaluated. Afterward, it evaluates the block from the start the same way as the block command does. However, instead of throwing away the resulting values and returning the last one, it returns a list of the results.

An object is a map of values. It can be created with the object command. The argument to the command is the parent object. The fields of the parent object are copied to the new object.

Objects also have methods. They are the fields that have a command as a value.

4. Introspection
The interpreter is open like a cracked safe after a heist. Nothing is hard-wired into the language. When I wrote that the language interpreter recognizes bare words, symbols, strings, etc., it was only true for the initial setup. The lexical analyzers implemented are UR commands, and they can be redefined. They are associated with the names $keyword, $string, $number, $space, $block, $blockClose, and $symbol. The interpreter uses the variable structures to find these commands. There is another variable named $lex that is a list of the lexical analyzers.

The interpreter uses this list when it needs to read the next lexical element. It invokes the first, then the second, and so on until one of them returns a non-null value, a lexical element, which is a command.

If you modify this list, then you can change the lexical analyzers, and that way you can change the syntax of the language.

The simplest example is changing the interpretation of the end-of-line character.

You may remember that we can use the binary operators using multiple arguments terminated with an empty block. It would be nice if we could omit the block and just write add* 1 2 3 simply adding a new-line at the end. We can do that by changing the lexical analyzer that recognizes the end-of-line character, and this is exactly what we are going to do in this example.

set q add* 3 2
1 {} puts q
insert $lex 0 ‘{
if { eq at source 0 “\n”}
{sets substring 1 length source source ‘{}}}
set q add* 3 2
1 {} puts q
We insert a new lexical analyzer at the beginning of the list. If the very first character of the current state of the source code is a new-line character, then the lexical analyzer eats this character and returns an empty block.

The command source returns the source code that was not parsed by the interpreter yet. The command sets sets the source code to the string value specified.

The first puts q will print 6 because at the time of the first calculation, new-lines are just ignored, and that way the value of q is add* 3 2 1 {}. The second puts q will print 5 because the new-line is eaten by the lexical analyzer, and the value of q is add* 3 2 {}. Here, the closing {} was the result of the lexical analysis of the new-line character. The values 1 and {} on the next line are calculated, but they do not have any effect.

This is a very simple example. If you want to see something more complex, the project file src/test/resources/samples/xpression.ur contains a script that defines a numerical expression parser.

There is a special command called fixup. This command forces the interpreter to parse the rest of the source. After this point, the lexical analyzers are not used anymore.

Executing this command does not give any performance benefit, and that is not the purpose. It is more like a declaration that all the codes that are part of the source code introspection and the metamorphic calculation are done. A special implementation of the command can also take the parsed code and generate an executable, turning the interpreter into a compiler.

5. Technical Considerations
The current version is implemented in Java. Ouroboros is not a JVM language, though. We do not compile the code to Java byte-code. The Java code interprets the source and executes it.

The implementation is an MVP focusing on the metamorphic nature of the language. It is meant to be an experiment. This is the reason why there are no file, network, and other I/O operations except the single puts command that writes to the standard output.

The Java service loader feature is used to load the commands and to register them with their respective names in the interpreter. It means that implementing extra commands is as simple as creating them, writing a class implementing a ContextAgent to register them (see the source code), and putting them on the classpath.

The whole code is open-source and available on GitHub. It is licensed under the Apache License 2.0 (see the license file in the repo). It is exactly 100 classes at the time of writing this article. It means that the source code is simple, short, and easy to understand. If you need some straightforward scripting language in your application, you can use it. It was not meant to be for production, though.

6. Going Further
There is no plan currently to extend the language and include more commands. We only plan to create more metamorphic code in the language. The reason for that is that we do not see the language as a practical tool as of today. If it proves to be useful and gains a user base and utilization, we certainly will incorporate more commands to support I/O, file handling, networking, and so on.

We also have visions of implementing the interpreter in other languages, like in Rust and Go. Anyone suggesting or wanting to develop commands for better usability or adding features is welcome. It can be a parallel project, or it can be merged into the main project if that makes sense.

7. Conclusion
In exploring Ouroboros, we delved into the concept of a programming language that minimizes syntax to the point of almost non-existence. This radical approach challenges the conventional understanding of what a programming language should be, presenting a system where syntax is both absent and infinitely customizable. By drawing inspiration from languages like LISP, TCL, and FORTH, Ouroboros embodies simplicity and introspection, allowing programmers to define their syntax and commands within the language itself.

While Ouroboros is not designed for practical production use, it serves as an intriguing experiment in language design and metaprogramming. Its self-referential nature and minimalistic design offer a playground for developers interested in the fundamentals of computation, syntax design, and language interpretation. Whether it evolves into a more robust tool or remains a fascinating intellectual exercise, Ouroboros pushes the boundaries of how we think about programming languages, inviting us to consider the possibility of a language where syntax is as mutable and recursive as the Ouroboros serpent itself.

the Wild Frontier of Technology adoption

Tue, 13 Aug 2024 09:55:32 +0000

Being out of work and looking for new opportunities means interviews. A common thread that comes up is arm waving. “There are 25 million developers out there, we want you to make them use our product/api/service”. Coupled with this idea is the expectation that if only they could get the offering in front of a developer if only that developer would try it, then all would be well and money would pour in.