Forem: Christos Drogidis

DoBu — Documentation Builder for the Ascoos Ecosystem

Christos Drogidis — Thu, 02 Apr 2026 07:33:57 +0000

A JML‑inspired Documentation DSL for multilingual docblocks

DoBu (DOcumentation BUilder) is a Documentation DSL designed for the Ascoos OS ecosystem.

It is not PHPDoc.

It is not Doxygen.

It is not MkDocs or Docusaurus.

DoBu is a semantic documentation layer that lives inside simple docblocks such as:

/* ... */

and transforms documentation structure into:

structured metadata
multilingual documentation
AST‑friendly nodes
exportable formats (Markdown, HTML, JSON, etc.)
documentation suitable for IDEs, tools, and Ascoos OS subsystems

DoBu can generate documentation text for any programming language that supports block comments.

Why DoBu Was Created

Ascoos OS is a kernel containing:

hundreds of encrypted classes
a DSL/AST macro engine
CiC interpreters
JML markup
AI/NLP subsystems
IoT handlers
mathematical and scientific libraries
proprietary security layers

No existing documentation tool could:

support multilingual metadata
embed mathematical formulas (LaTeX, MathML) with analysis
describe numerical behavior
include performance metrics
support cross‑references
generate documentation without exposing source code

Thus, DoBu was created as the semantic documentation layer of Ascoos OS.

What DoBu Is

Documentation DSL
Semantic metadata language
AST‑friendly docblock interpreter
Multilingual documentation engine
Extensible schema system
JML‑inspired syntax
Language‑agnostic
Kernel‑level documentation layer

Basic Syntax

/*
dobu {
    class:id(`tmyclass`),name(`TMyClass`),extends(`TObject`),namespace(`ASCOOS\OS\Kernel\MyClass`) {
        summary:langs {
            en {`Creating a new Ascoos OS class.`}
            el {`Δημιουργία μιας νέας Ascoos OS κλάσης.`}
        }
    }
}
*/

Class Documentation Example

/*
dobu {
    class:id(`tmyclass`),name(`TMyClass`),extends(`TObject`),version(`0.0.1`) {
        summary:langs {
            en {`Creating a new Ascoos OS class.`}
            el {`Δημιουργία μιας νέας Ascoos OS κλάσης.`}
        }
    }
}
*/

Method Example with Math & Behavioral Metadata

DoBu supports:

mathematical formulas (LaTeX, MathML)
numerical behavior
performance metrics
cross‑references
verification cases
multilingual descriptions

/*
dobu {
    method:id(`blackscholesputdividend`),name(`blackScholesPutDividend`),return(`float`) {
        summary:langs {
            en {`Prices a European put option with continuous dividend yield.`}
            el {`Αποτιμά ένα ευρωπαϊκό put option με συνεχή μερισματική απόδοση.`}
        },
        formula:type(`latex`),value(`\[ P = K e^{-rT} N(-d_2) - S_0 e^{-qT} N(-d_1) \]`)
    }
}
*/

Full Class Example

See the create-dobu-class.php file for a full demonstration inside a PHP class.

Multilingual Documentation

langs {
    en {`English text`}
    el {`Ελληνικό κείμενο`}
}

Cross‑References

see:langs {
    all {`
       • blackScholesCallDividend() 
       • binomialPutEuropean()`
    }
}

Export Formats

DoBu can export documentation to:

HTML
INI
JSON
Markdown
TOML
YAML
XML
and many more formats

Ideal for Proprietary Kernels

DoBu works even when:

source code is not available (stubs only)
documentation must not reveal internal logic
structured, machine‑readable documentation is required

Relationship with Ascoos OS

DoBu is built using Ascoos OS classes and is used for:

documenting Ascoos OS itself
documenting generated code
producing documentation for other languages

Why Developers Should Build Native AI Applications

Christos Drogidis — Thu, 02 Apr 2026 06:13:29 +0000

The Web5/WebAI Model of Ascoos OS: A Self‑Sufficient, User‑First Approach to Artificial Intelligence on the Web

Introduction

Artificial Intelligence has become a core component of the modern web. However, the way it is integrated into most applications remains dependent on external services and remote systems, creating limitations in performance, privacy, cost, and independence.

Ascoos OS proposes a different philosophy: a web where AI is not a service located somewhere else, but a capability owned by the user. A web where applications do not rely on third parties to function, and where data never leaves the user’s environment. This is the Web5/WebAI model.

1. The Need for Native AI Applications

Traditional approaches to AI integration rely on external providers. While functional, these architectures have inherent limitations:

Data is transferred outside the user’s environment.
Performance depends on latency and connectivity.
Functionality is not available offline.
Costs increase as usage increases.
AI has no access to system‑level data and mechanisms.
The user lacks true ownership and self‑sufficiency.

In a world where privacy, autonomy, and independence are becoming essential values, this model is no longer adequate.

2. The Ascoos OS Approach: AI as Infrastructure

Ascoos OS integrates Artificial Intelligence directly into the core of the web kernel. It does not treat AI as an add‑on, but as a foundational component of the system’s architecture.

This enables:

Local AI execution without external services.
Full ownership and control of data by the user.
Complete offline functionality.
Direct AI access to DSL, macros, events, files, and system data.
Applications that operate with true self‑sufficiency.
The ability for AI to influence system flow in real time.

The result is a web that does not depend on third parties, but is built around the user.

3. Examples of Native AI in Ascoos OS

The following examples demonstrate how AI behaves when it is part of the kernel rather than an external service. Their value lies in the fact that they form unified, locally executed pipelines.

3.1 Neural Workflow Composer – Learning from the System and Executing Macros

$composer = new TNeuralNetworkHandler();
$composer->compile([
    ['input' => 3, 'output' => 4, 'activation' => 'relu'],
    ['input' => 4, 'output' => 1, 'activation' => 'sigmoid']
]);
$composer->fit($systemData, $actions, epochs: 1000, lr: 0.01);

$score = $composer->predictNetwork([$currentState])[0];

if ($score > 0.5) {
    $macroHandler = new TMacroHandler();
    $macroHandler->addMacro(fn() => print("Executing optimized macro"));
    $macroHandler->runNext();
}

AI operates as part of the system, learns from its data, and influences its behavior in real time.

See Full Article

What is a Content Management System (CMS)

Christos Drogidis — Thu, 02 Apr 2026 05:48:14 +0000

Theoretical Approach, Historical Evolution and Modern Architectures

1. Introduction

Digital content management is one of the most important areas of modern information technology.

From the first static websites of the 1990s to today's multi-channel ecosystems, the need for organized, secure, and scalable information management has led to the development of Content Management Systems (CMS).

CMS have evolved from simple website updating tools into comprehensive knowledge management platforms, now serving as critical infrastructure for businesses, organizations, and public sector entities.

Their evolution is directly linked to the development of the internet, the increasing complexity of information systems, and the need for automation in content creation and delivery processes.

2. Definition and Theoretical Framework

A Content Management System is defined as software that enables the creation, organization, editing, storage, and publication of digital content without requiring specialized programming knowledge. Its core principle is the separation of content from presentation. Content is stored in a structured format, independent of how it will be displayed, allowing reuse across multiple environments and devices.

The theoretical foundation of CMS is connected to information science, knowledge management, and database theory. The concept of “content” is not limited to text but includes multimedia, metadata, structured entities, relationships, and semantic connections. Modern literature treats content as an information asset with value that must be organized, classified, and distributed in a way that maximizes its usefulness (Dublin Core Metadata Initiative, 2020).

See Full Article

Ascoos OS: A Different Logic in Programming

Christos Drogidis — Fri, 19 Dec 2025 02:37:47 +0000

In the world of software development, the “mainstream” is often presented as the only solution: PHPUnit for tests, CI/CD pipelines everywhere, frameworks that dictate your workflow. But Ascoos OS follows a different philosophy — it integrates testing, logging, and profiling directly into the runtime.

What Problem Does It Solve

Traditional testing tools (e.g., PHPUnit) require separate setup, configuration, and integration.
Testing is often treated as something “external” to the runtime.
This leads to more complexity and overhead.

With the TTestHandler class, Ascoos OS solves this problem: testing becomes part of the system itself, with a simple API that combines validation, logging, and execution timing.

Who Is It For

Developers who want quick and easy tests without external frameworks.
Teams that need runtime diagnostics and profiling in real time.
Open-source contributors who want to understand how Ascoos OS works and experiment with a different programming philosophy.

Example: `TTestHandler` + `AscoosThrowException`

Instead of relying on PHPUnit, we use the TTestHandler class to validate classes, objects, methods, and functions. At the same time, it logs results, measures execution time, and collects system statistics.

Additionally, Ascoos Exceptions produce multilingual UTF8 exception messages via the $AOS_ESTR table, ensuring error handling is localized and developer-friendly.

<?php
use ASCOOS\OS\Kernel\Tests\TTestHandler;
use ASCOOS\OS\Kernel\Core\TObject;
use ASCOOS\OS\Kernel\Core\DebugLevel;

global $AOS_LOGS_PATH;

// Configure properties
$properties = [
    'logs' => [
        'useLogger' => true,
        'dir' => $AOS_LOGS_PATH . '/',
        'file' => 'test_handler.log',
        'level' => DebugLevel::Info
    ],
    'lang' => 'en-US',
    'debug' => [
        'precision' => 4,
        'log_threshold' => DebugLevel::Info
    ]
];

// Initialize TTestHandler
$testHandler = new TTestHandler($properties);

// Initialize TObject
$object = new TObject();

// Check class existence
$testHandler->checkClass(TObject::class, true);

// Check object validity
$testHandler->checkObject($object, true);

// Check method availability
$testHandler->checkMethod($object, 'getClassMetadata', true);

// Execute AscoosThrowException with timing
$result = $testHandler->executeWithTiming(function () {
    AscoosThrowException(InvalidArgumentException::class, 100);
}, [], true);

print_r($result); 
// Logs exception, multilingual message, execution time, and system stats

// Free resources
$testHandler->Free();
$object->Free();

Why It Matters

This approach makes testing part of the system itself. Instead of separating runtime and validation, Ascoos OS unifies them. The result: faster development, integrated diagnostics, and tools that reflect our philosophy of programming freedom.

Learn more at the official Ascoos OS website

Join the discussion: r/ascoos

What Is a Software Version Number?

Christos Drogidis — Sun, 07 Dec 2025 16:43:55 +0000

Understand in 5 minutes how to read every version correctly

Have you ever seen versions like 26.0.0.10301, 17.4.1, 3.13.1, 1.28.4+exp.sha.41af286, 26.2.0-beta.3 or 2.0.0-alpha.7 and wondered what they actually mean?

The version number is not decorative. It is the identity of every release and, when properly structured, tells you at a glance whether the update is safe or requires caution.

What you should ask your vendor or development team

Do you strictly follow Semantic Versioning 2.0?
How do you name your alpha/beta/rc versions?
What build format do you use and why?
Do you release patch updates at least once a month?
Is there automated testing and a rollback plan?

See full article...

HTML is Dead, Long Live JML

Christos Drogidis — Tue, 02 Dec 2025 12:49:15 +0000

Introduction

HTML was the language that built the Web. But today it has become a burden: full of legacy baggage, ambiguities, inconsistencies, and security gaps. Every browser has its own rendering engine, every framework tries to patch the problems, and developers spend countless hours debugging issues that should not exist.

It’s time to say it clearly: HTML is dead.

The future of Web markup is JML (JSON Markup Language).

Why HTML Can’t Continue

Legacy baggage: Decades of backward compatibility.
Ambiguity: Tags with unclear or context‑dependent behavior.
Security: Inline scripts, injection, parsing quirks.
Inconsistency: Different results across browsers.

What is JML

JML is a new markup language that:

Uses JSON‑like syntax for clarity and predictability.
Transforms into DSL and AST for safe parsing.
Produces HTML only when the structure is fully valid.
Provides warnings for structural issues.
Supports HTML5, SVG, MathML, custom elements, ARIA, and more without hacks.

JML Example

HTML Code

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Profile</title>
    <meta name="description" content="Basic profile page">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="preload" as="style" href="./assets/css/style.css">
    <link rel="icon" type="image/x-icon" href="./favicon.ico">
    <link rel="canonical" href="./">
    <script type="text/javascript" src="./assets/js/app.js"></script>
    <style>
      .card { border: 1px solid #ccc; padding: 16px; border-radius: 8px; }
      .name { font-weight: 600; }
    </style>
  </head>
  <body>
    <header id="top" class="site-header">
      <h1>Welcome</h1>
    </header>
    <main>
      <section class="card">
        <h2 class="name">Jane Doe</h2>
        <p data-info="safe">Front-end developer</p>
        <a href="./contact.html" rel="noopener">Contact</a>
        <img src="./assets/img/avatar.png" alt="Profile photo" width="120" height="120">
      </section>
    </main>
  </body>
</html>

JML Code

html:lang('en') {
  head {
    meta:charset('utf-8')
    title {
      `Profile`
    }
    meta:name('description'),content('Basic profile page')
    meta:name('viewport'),content('width=device-width, initial-scale=1')
    link:rel('preload'),as('style'),href('./assets/css/style.css')
    link:rel('icon'),type('image/x-icon'),href('./favicon.ico')
    link:rel('canonical'),href('./')
    script:type('text/javascript'),src('./assets/js/app.js')
    style {
      `.card { border: 1px solid #ccc; padding: 16px; border-radius: 8px; }
      .name { font-weight: 600; }`
    }
  }
  body {
    header:id('top'),class('site-header') {
      h1 {
        `Welcome`
      }
    }
    main {
      section:class('card') {
        h2:class('name') {
          `Jane Doe`
        }
        p:data-info('safe') {
          `Front-end developer`
        }
        a:href('./contact.html'),rel('noopener') {
          `Contact`
        }
        img:src('./assets/img/avatar.png'),alt('Profile photo'),width('120'),height('120')
      }
    }
  }
}

DSL Code

TAG html LANG 'en'
  TAG head
    TAG meta CHARSET 'utf-8'
    TAG title
      TEXT 'Profile'
    TAG meta NAME 'description' CONTENT 'Basic profile page'
    TAG meta NAME 'viewport' CONTENT 'width=device-width, initial-scale=1'
    TAG link REL 'preload' AS 'style' HREF './assets/css/style.css'
    TAG link REL 'icon' TYPE 'image/x-icon' HREF './favicon.ico'
    TAG link REL 'canonical' HREF './'
    TAG script TYPE 'text/javascript' SRC './assets/js/app.js'
    TAG style
      TEXT '.card { border: 1px solid #ccc; padding: 16px; border-radius: 8px; }
      .name { font-weight: 600; }'
  TAG body
    TAG header ID 'top' CLASS 'site-header'
      TAG h1
        TEXT 'Welcome'
    TAG main
      TAG section CLASS 'card'
        TAG h2 CLASS 'name'
          TEXT 'Jane Doe'
        TAG p DATA-INFO 'safe'
          TEXT 'Front-end developer'
        TAG a HREF './contact.html' REL 'noopener'
          TEXT 'Contact'
        TAG img SRC './assets/img/avatar.png' ALT 'Profile photo' WIDTH '120' HEIGHT '120'

Why JML is Safe

Validator: The TJMLValidator class in Ascoos OS halts transformations on syntax errors.
Predictable parsing: No “undefined behavior.”
Visual debugging: Warnings for structural issues.
Independence: Not tied to browser DOM quirks.

JML Studio

JML Studio is the online tool for producing JML documents.

Just like Microsoft Word is the editor for .docx, JML Studio is the editor for .jml.

It offers:

Tabs: Editor, HTML, DSL, AST, HTML → JML.
Export to .jml and .html.
Online preview: JML → HTML conversion for instant verification.

The Vision

JML is not just another language. It is the next markup standard:

Clean.
Secure.
Extensible.
Predictable.

With JML, developers won’t waste time debugging quirks. They’ll build on a language that doesn’t betray them.

Conclusion

HTML is dead. JML is the future.

With JML Studio, you can start creating and testing JML documents today. But the essence lies in the JML language itself: the new secure markup for the Web.

Long live JML.

Case Study: CiC (Cross‑Interpreter Communication) with WordPress & Joomla in Ascoos OS

Christos Drogidis — Mon, 01 Dec 2025 05:43:39 +0000

We’ve released a new case study demonstrating how Ascoos OS implements CiC.

Instead of connecting systems, CiC turns each CMS into an interpreter capable of executing, translating, and exchanging logic in real time.

In this example, WordPress hooks are interpreted and translated into macros, while Joomla APIs are bridged and executed. The results are combined seamlessly in a shared runtime.

🔗 Full code and documentation

This is a practical step toward Web5 interoperability and the foundation of WebAI.

Would love to hear your thoughts on extending CiC to other interpreters (Drupal, Python APIs, etc.).

Getting Started with Ascoos Web Extended Studio (AWES)

Christos Drogidis — Sat, 29 Nov 2025 15:12:22 +0000

What is AWES?

Ascoos Web Extended Studio (AWES) is a portable web development suite for Windows 64-bit.

It provides a complete stack for developers and designers who need flexibility, modularity, and the ability to test projects across multiple versions of PHP, databases, and web technologies — all without installation.

Key Features

Portable environment: Just unzip and run — no installation required.
Multi-version PHP & MariaDB: Run different versions side by side for legacy and modern projects.
Full stack included: Apache, PHP (5.6–8.x), Node.js, Python, MariaDB, MongoDB, FileZilla FTP, SVN repositories, phpMyAdmin, and more.
GUI with 600+ shortcuts: Advanced toolbar with support for 40 languages.
Integrated tools: Visual Studio Code, Notepad++, Firefox Developer Edition, Chromium Portable, Sniptool, FastStone Image Viewer.
CGI support: Execute Python, Node.js, and Perl via Apache CGI.
Open-source friendly: Free to use, with active community support.

Why Use AWES?

Flexibility: Test applications in different environments without switching installations.
Education & Testing: Perfect for experimenting with new versions or teaching web technologies.
All-in-one solution: Everything you need for web development in one portable package.
Safe coexistence: Runs independently without interfering with other stacks like XAMPP or WAMP.

How to Get Started

Download AWES from SourceForge.
Unzip the package (e.g., C:\AWES).
Launch the GUI and choose your preferred stack (PHP, Node.js, Python, etc.).
Start building, testing, and deploying your projects locally.

Resources

Conclusion

AWES is more than just a local server — it’s a complete web development studio.

If you’re a developer who values portability, interoperability, and open-source freedom, AWES is a powerful tool to add to your workflow.

Forem: Christos Drogidis

DoBu — Documentation Builder for the Ascoos Ecosystem

A JML‑inspired Documentation DSL for multilingual docblocks

Why DoBu Was Created

What DoBu Is

Basic Syntax

Class Documentation Example

Method Example with Math & Behavioral Metadata

Full Class Example

Multilingual Documentation

Cross‑References

Export Formats

Ideal for Proprietary Kernels

Relationship with Ascoos OS

Why Developers Should Build Native AI Applications

Introduction

1. The Need for Native AI Applications

2. The Ascoos OS Approach: AI as Infrastructure

3. Examples of Native AI in Ascoos OS

3.1 Neural Workflow Composer – Learning from the System and Executing Macros

What is a Content Management System (CMS)

Theoretical Approach, Historical Evolution and Modern Architectures

1. Introduction

2. Definition and Theoretical Framework

Ascoos OS: A Different Logic in Programming

What Problem Does It Solve

Who Is It For

Example: TTestHandler + AscoosThrowException

Why It Matters

What Is a Software Version Number?

Understand in 5 minutes how to read every version correctly

What you should ask your vendor or development team

HTML is Dead, Long Live JML

Introduction

Why HTML Can’t Continue

What is JML

JML Example

HTML Code

JML Code

DSL Code

Why JML is Safe

JML Studio

The Vision

Conclusion

Case Study: CiC (Cross‑Interpreter Communication) with WordPress & Joomla in Ascoos OS

Getting Started with Ascoos Web Extended Studio (AWES)

What is AWES?

Key Features

Why Use AWES?

How to Get Started

Resources

Conclusion

Example: `TTestHandler` + `AscoosThrowException`