Introduction

This text serves as an additional resource to the book “Intent-Driven Development” with a specific focus on data aspects. We will not delve into data storage methods, as it’s presumed that an application server handles this aspect. Our primary focus is on interfacing with such a server and executing functions related to the data.

Our focus will be on user interactions and the realization of user intentions.

From the viewpoint of a user, although we have access to data, our primary aim is to comprehend it.

The challenge lies in extracting meaningful insights from this data.

Essentially, we are addressing the need to “help me understand the data I am looking at”

This is the realm of data analysis, which presents several challenges:

1. The need for specialized tools.

2. The requirement for adequate training.

The objective is to formulate queries about the data that enable users to extract insights, thereby assisting them in making informed decisions or taking action based on the data.

Instead of rigidly coding a specific solution for each query, a more generic approach to formulating queries is necessary.

Typically, this would involve using a custom user interface to establish the query’s intent.

However, this approach often introduces significant complexity, which many users find daunting and tend to avoid.

At its core, our goal is to enable users to define, either singularly or in combination, basic operations such as:

1. Filtering

2. Sorting

3. Grouping

4. Aggregating values

The enterprise

In an enterprise environment with multiple applications, each tailored to specific use cases, there are often features that overlap, such as the need to understand the data being used. While sharing these features across applications through a library is one approach, it’s not always feasible due to differences in development languages or environmental constraints. To circumvent these issues, shifting these overlapping features, like data clarity, to a middleware server can be a strategic move. This discussion will delve into what a middleware server entails and why it can be highly beneficial for an organization.

Certainly, let’s highlight some of the key advantages of utilizing a middleware server:

1. Reduced Client Load: By offloading processing-intensive operations to the server, devices with lower specifications can be effectively utilized.

2. Consistent Application Behavior: Centralizing features ensures uniform behavior across various applications that use these shared features.

3. Feature Reusability: Writing a feature once on the server allows for greater reusability across different user interface technologies.

4. Simplified Updates and Expansions: Any enhancements made on the middleware server automatically benefit all client applications using that middleware.

5. Enhanced Security: Centralizing features allows for better security measures by abstracting these mechanisms away from the data source.

6. Easier Scalability: Scaling a middleware server is generally more straightforward than scaling multiple client applications, thanks to server architectures being more adaptable to scaling.

7. Independent Server Deployment: The middleware server can be deployed independently of the clients, with a focus on maintaining backward compatibility.

8. Standardized Output Formats: Generating output graphics in common formats eliminates the need for each client to support custom visualizations.

9. Multi-Platform Support: Middleware servers can easily cater to various client platforms, including mobile, desktop, and web.

These advantages collectively result in enhanced flexibility on the client side, reduced workload, and greater standardization across the system.

Usability

Usability is a crucial factor that demands meticulous attention.

As previously mentioned, comprehending data involves operations like filtering, sorting, grouping, and aggregation, collectively forming a ‘data perspective’.

While a skilled designer can create a user interface to generically capture the user’s query intent, many users tend to avoid these interfaces due to the fear of making errors or being overwhelmed by their complexity, feature abundance, and extensive configuration options.

The challenge lies in determining how to define the query intent. While a complex user interface is one approach, a shift towards natural expression is essential. Utilizing natural language provides a more intuitive way for users to express their queries and intent. According to the principles of Intent-Driven Development, it is crucial for users to specify their intent without dictating how it is executed. Although a ‘perspective’ dictates the method of responding to queries, the integration of AI to translate natural language expressions into these perspective definitions is vital. Once the perspective is applied to the data, it yields the necessary answers and returns the processed results.

The result of a defined intent can take several forms.

1. Table of data

2. Graphic

3. Natural language

The result very much depends on the defined intent.

Intent can be defined as:

1. JSON intent definition

2. Natural language text

3. Natural language audio

I foresee that in the coming years, there will be a strong trend towards interactions with systems using more natural language. Personally, I favor audio as the preferred method of interaction, and I believe that the performance of these audio-responsive systems will be a critical factor in ensuring optimal usability.

Implementing this approach addresses numerous accessibility challenges.

At present, accessibility heavily relies on screen readers and complex support mechanisms.

With the proposed solution, a dedicated text-based application, similar to how the GPT mobile app functions, can be developed.

Utilizing audio-based natural language interaction significantly aids individuals with visual impairments.

Moreover, this system remains accessible to deaf and able-bodied individuals through text-based conversion.

Incorporating multimodal AI within an interface akin to Jupyter Notebook offers substantial flexibility, enhancing the overall user experience and accessibility.

Execute actions

The application server, equipped with CRUD (Create, Read, Update, Delete) functionalities and more, plays a significant role.

Beyond querying and understanding data, defining intents that target CRUD operations and custom actions is also feasible.

Centralizing access to these capabilities in the middleware server leverages natural language features already adept at handling query operations.

This centralization means that all client applications automatically gain access to these advanced features.

Utilizing verbal instructions opens up new possibilities for user interaction, especially in scenarios where traditional methods are impractical.

For instance, providing work order feedback on-site can be challenging when hands are dirty or occupied.

In such situations, interacting with the system via audio enables not only the querying of information but also the updating of data, all without the need to physically interact with traditional user interfaces