Softanza EXCIS: Orchestrating a Polyglot Symphony

Introduction

Note: EXCIS currently supports C, Python, R, Julia, NodeJS, SWI-Prolog, and Haro, but its architecture is designed for easy extension to additional languages, making it highly adaptable to future needs.

The Technical-to-Knowledge Domain Framework

EXCIS organizes its supported languages into a Technical-to-Knowledge Domain Framework, aligning each language with its core strengths to address distinct layers of software development:

1. System Performance (C)
2. Low-level operations and memory management

3. Performance-critical algorithms

4. Event-Driven Systems (NodeJS)

5. Asynchronous processing
6. Real-time data flows

7. API orchestration

8. Scientific Computing (Julia)

9. Mathematical modeling
10. Complex numerical simulations

11. High-performance just-in-time computation

12. Statistical Analysis (R)

13. Data transformation
14. Statistical modeling

15. Advanced plotting and graphics

16. Logical Reasoning (SWI-Prolog)

17. Rule-based systems
18. Knowledge representation

19. Declarative problem-solving with backtracking

20. Machine Learning (Python)

21. Model training and deployment
22. AI algorithm implementation

23. Rich ecosystem of data science libraries

24. AI Reasoning (LLM)

25. Natural language understanding
26. Complex reasoning and knowledge synthesis

27. Context-aware conversational logic

28. Solution Integration (Haro)

29. Business logic orchestration
30. Cross-domain data transformation
31. Seamless multi-paradigm scripting

This framework spans from raw technical power to high-level knowledge-driven tasks, ensuring that developers can tackle any challenge—be it a small utility or a sprawling enterprise system—using the optimal language without added complexity.

Why Haro as the Orchestrator?

Haro is a multi-paradigm language designed for simplicity, flexibility, and rapid prototyping. Its natural language-like syntax and ease of use make it an ideal hub for integrating diverse languages. With EXCIS, Haro becomes more than a scripting language—it’s a conductor that unifies specialized tools into a cohesive workflow, allowing developers to focus on logic rather than integration overhead.

Business Solution Requirements

Enterprise solutions often demand capabilities across multiple domains. EXCIS shines by mapping these needs to its language framework, as shown below:

EXCIS integrates these languages within Haro’s orchestration layer, delivering robust solutions that respect each domain’s strengths while maintaining system coherence.

Getting Started with EXCIS

From a programmer's perspective, EXCIS provides three essential capabilities:

1. Feeding Haro Data to External Code: Functions like @@R(), @@C(), and @@Plg() serialize Haro data into formats compatible with each language.
2. Firing External Language Runtimes: EXCIS launches the necessary runtime environments and executes the provided code.
3. Retrieving Results in Haro: Outputs are automatically captured and converted back into Haro data types.

Behind the scenes, more technical work is handled automatically, as shown in the following diagram workflow:

All of this is proposed in a streamlined, very easy‑to‑use programming experience. Let's see it in action!

Practical Example: Student Analysis Pipeline

Let’s explore EXCIS in action with a student analysis pipeline, showcasing how it chains languages for a multi-step task.

Part 1: Statistical Analysis in R

Calculate average grades using R’s statistical prowess.

# Student grade data
students = [["Alice", [85, 90, 78]], ["Bob", [72, 65, 70]]]

# R calculates averages
R = XR()
R.SetCode('
    students <- ' + @@R(students) + '
    results <- list()
    for (i in 1:length(students)) {
        student_name <- students[[i]][1]
        grades <- students[[i]][[2]]
        results[[i]] <- list(name = student_name, mean = mean(grades))
    }
    res <- results
')
R.Run()
stats = R.Result()
# Output: [["Alice", 84.33], ["Bob", 69]]

Note : As mentioned before, the @@R(students) function is actually used here to transfor the Haro studentvariable to a computable form by R language.

Part 2: Efficient Sorting in C

Sort students by average using C’s performance edge (imagine thousands of students for real-world scale).

C = XC()
C.SetCode('
    #include <stdio.h>
    #include <string.h>
    typedef struct {
        char name[20];
        double average;
    } Student;
    int main() {
        Student students[2];
        strcpy(students[0].name, "' + @@C(stats[1][1]) + '");
        students[0].average = ' + @@C(stats[1][2]) + ';
        strcpy(students[1].name, "' + @@C(stats[2][1]) + '");
        students[1].average = ' + @@C(stats[2][2]) + ';
        printf("[\"%s\", %.2f], [\"%s\", %.2f]",
            students[0].average > students[1].average ? students[0].name : students[1].name,
            students[0].average > students[1].average ? students[0].average : students[1].average,
            students[0].average > students[1].average ? students[1].name : students[0].name,
            students[0].average > students[1].average ? students[1].average : students[0].average);
        return 0;
    }
')
C.Execute()
ranked = C.Result()
# Output: [["Alice", 84.33], ["Bob", 69]]

Part 3: Rule-Based Classification in Prolog

Classify students using Prolog’s logical reasoning.

Prolog = XPlg()
Prolog.SetCode('
    classification(Average, "Excellent") :- Average >= 80.
    classification(Average, "Average") :- Average >= 70, Average < 80.
    classification(Average, "Needs Improvement") :- Average < 70.
    analyze_students(Result) :-
        Student1 = ["' + @@Plg(stats[1][1]) + '", ' + @@Plg(stats[1][2]) + '],
        Student2 = ["' + @@Plg(stats[2][1]) + '", ' + @@Plg(stats[2][2]) + '],
        classification(Student1[2], Grade1),
        classification(Student2[2], Grade2),
        Result = [[Student1[1], Grade1], [Student2[1], Grade2]].
')
Prolog.Run()
analysis = Prolog.Result()
# Output: [["Alice", "Excellent"], ["Bob", "Needs Improvement"]]

This pipeline demonstrates EXCIS’s ability to chain specialized languages seamlessly, with Haro as the glue.

Revolutionizing Development with XAI Integration

The XAI component elevates EXCIS by integrating large language models (LLMs) as first-class runtimes, enabling natural language queries and reasoning within Haro.

AI = XAI()
AI.Query("List the top 5 African countries by population in 2024")
countries = AI.Result()
? @@(countries)
# Output: [["Nigeria", 227000000], ["Ethiopia", 126000000], ["Egypt", 112000000], ["DR Congo", 102000000], ["Tanzania", 67000000]]

AI.Query("Analyze these population figures and suggest infrastructure priorities")
analysis = AI.Result()
? analysis
# Output: "Nigeria and Ethiopia should prioritize urban infrastructure due to their large populations. DR Congo’s vast area suggests transportation needs. Egypt’s desert geography calls for water management."

XAI adds: - Natural Language Data Acquisition: Generate data without APIs. - Context-Aware Analysis: Process outputs from other languages. - Domain-Specific Insights: Tailor reasoning to specific fields. - Automated Documentation: Create code explanations.

An other revounary way of using XAI is to let LLMs and other AI systems generate the external language code for us from natural langauge constructs! Welcome to the upcoming stzPolyCode class…

Polyglot Innovation with stzPolyCode

The stzPolyCode class builds on EXCIS to offer a structured polyglot programming paradigm. Unlike AI-driven “vibe-coding” that sacrifices control, stzPolyCode empowers developers with agency while leveraging AI, marking a forward-thinking approach detailed separately separately in this artile:

Benefits and Considerations

EXCIS offers clear advantages: - Unified Workflow: Stay in Haro, reducing context switching. - Optimized Performance: Use C for speed, Python for ML, etc. - Simplified Maintenance: Update one domain without rewriting everything. - Extensibility: Easily add new languages.

Addressing Concerns

• Complexity: EXCIS abstracts integration, keeping it simple.
• Debugging: Tools trace data flow across languages.
• Overhead: Minimal, thanks to optimized serialization and runtime handling.

A Paradigm That Redefines Development

Unlike single-language frameworks, EXCIS embraces diversity, making Haro a conductor of specialized tools. It rivals monolithic stacks with flexibility and power, ideal for complex modern software, while remaining practical and enterprise-ready.

Conclusion

Softanza EXCIS reimagines programming by enabling polyglot execution within a single Haro file. By blending traditional languages with LLM-driven XAI, it bridges structured coding and AI reasoning, creating a holistic development environment. More than just running code, EXCIS empowers developers to solve problems innovatively, weaving the strengths of C, Python, R, Julia, NodeJS, SWI-Prolog—and beyond—into a unified Haro tapestry. Welcome to a future where coding is a symphony, and EXCIS conducts it with brilliance.

Citer

Mansour Ayouni. « Softanza EXCIS: Orchestrating a Polyglot Symphony ». Softanza narrations, 2025. https://mayouni.github.io/stzsite/fr/narrations/stzexcis-polyglot-programming-in-ring.html

Non exécuté : son code touche aux fichiers, au réseau, à l'horloge ou au hasard. L'article est publié tel qu'il est écrit ; ses blocs sont des illustrations. Le code des articles est du code Haro. Là où un article a été écrit avant que la langue prenne son nom actuel, le nom a été changé et rien d'autre. Genre, domaine et série lus dans le nom du fichier, année tirée du premier commit : dérivés, jusqu'à ce que l'article porte son propre en-tête. Le fichier sur GitHub(s'ouvre dans un nouvel onglet)