Dashboard
記事
記事 / Blogページ
用語抽出進捗
このDashboardの対象のうち、workflow.term.statusで用語候補抽出済みと示された項目数です。
記事一覧
A unified development operation connecting applied Models to execution
SimpleModeling constructs Domain, Use Case, and Application Models from the Object, Knowledge, and Literate constituents. It distinguishes Application Modeling, which concretizes Use Case intent into an Application Model, from Model Realization, which connects an approved Executable Model to design, implementation, and execution through CML (Cozy Modeling Language), Cozy, AI, and Textus.
AAA
Building on the significance of DSL-driven development in the AI era, this article reconsiders AI-assisted Component-Based Development centered on the literate model (see dsl-ai.dox for details).
AI, Category Theory, and Pratītyasamutpāda
Generative AI, knowledge graphs, and category theory all share a common principle: the world arises from relations. This essay explores how the semantic space of AI resonates with the Buddhist concept of dependent origination (pratītyasamutpāda) and the morphisms of category theory.
AI-Assisted Development Cycle with ChatGPT, VSCode, and SIE
This article outlines an AI-assisted development cycle that integrates ChatGPT, the VSCode AI Agent, and the Semantic Integration Engine (SIE). By allowing AI to navigate and reason across specifications, models, and source code, development becomes more consistent with domain knowledge.
AI-Collaborative Literary Software Development｜AIと分業する、文芸的ソフトウェア開発の実践
This article summarizes the current state of my personal AI-driven development approach, in which ChatGPT and VS Code Codex are used selectively to rapidly iterate through specification, design, implementation, and verification.
AI-Driven Program Generation ― Possibilities and Challenges
In recent years, generative AI has advanced to the point where it can generate source code from natural language prompts. This has enabled partial automation of what was previously manual implementation, raising expectations for improved development efficiency.
AIとDSLが拓く新時代──プログラミングの焦点はメタ層へ移りつつあります。
AIが開発の現場に入り始め、ボイラープレートや定型コードの生成が日常化しつつあります。 これに伴い、エンジニアの関心はコード記述そのものから、生成をどう設計し制御するかへ移っています。
AI時代に向けたOO技術体系の再整理
AI時代に向けたOO技術体系の再整理
AI負債とUP/CBD
## LEAD
An overview of the AI-era development stack in which AI unifies BoK → literate model → DSL → CNCF.
This article integratively organizes the development process, CBD, DSL, code generation, and execution platform (CNCF)—previously discussed separately—into a single vertical stack. In SimpleModeling, knowledge organized in the BoK is reflected in the literate model, defined structurally as a DSL, and guaranteed by the CNCF execution platform, forming an end-to-end architecture. AI not only supports understanding, structuring, generation, and validation at each layer, but also functions as a mediating device that connects them across layers. When this vertical continuity is established, the natural language world and the implementation technology world are no longer divided, enabling an evolvable development stack that preserves structural integrity.
CBD Enabled by DSL and Execution Platform: Implementable Component Structure
This article argues that through the combination of a DSL and an execution platform, CBD becomes an implementable structural reality. By rigorously defining analysis models as a DSL in Cozy and structurally guaranteeing those specifications at runtime through CNCF, components become not merely design concepts but concrete entities that can be registered, discovered, and connected. Furthermore, by integrating a cloud-native architecture centered on CQRS, the externalization of quality attributes, and asynchronous abstraction, CBD is redefined as an executable architectural unit suited for the AI era.
CBD-Centered Development Process in the AI Era
In the AI era of software development, the design of system structure becomes more important than the capability of code generation. This article organizes a basic framework for AI-assisted development, using the Unified Process (UP) as the backbone of the process and Component-Based Development (CBD) as the central architectural structure.
CBDとMDD
Category entry.
Demo of the Semantic Integration Engine for AI Collaboration
An overview and live demo of the Semantic Integration Engine (SIE), which transforms BoK knowledge into RDF and vector representations for AI-ready semantic retrieval.
Exploring the Knowledge Graph of SimpleModeling
A visual and interactive demonstration of the JSON-LD/RDF-based knowledge graph behind SimpleModeling.org.
Glossary Management
At SimpleModeling.org, the operation of the glossary is automated as part of building and utilizing a Body of Knowledge (BoK).
Harness Engineering and SimpleModeling
SimpleModeling integrates BoK, literate models, DSL, and execution platforms to extend Harness Engineering into a foundation that governs execution based on meaning. It reduces gaps between specification and implementation and enables consistent quality and reproducibility required in the AI era.
Integration between the Semantic Integration Engine and ChatGPT
This article explains, at the protocol level, what happens when the Semantic Integration Engine and ChatGPT are integrated via MCP (Model Context Protocol),focusing on how ChatGPT uses SIE’s knowledge, performs reasoning, and generates the final response.It provides a detailed explanation from a protocol-level perspective. The important point is that ChatGPT is not requesting “the answer itself” from SIE,but rather retrieving the materials and evidence it needs to reason on its own. In this article, we recreate a simulated MCP session,and examine why SIE’s response structure—concept / passage / graph / score—has a high degree of affinity with the reasoning model of generative AI.
Low-Cost AI-Driven Development
Category entry.
My Personal AI-Driven Development Project Management
Category entry.
Operate SIE via the CLI — A minimal REST-based client｜CLIを通じてSIEを操作する ― RESTを基盤とした最小クライアント
This section explains how to use the REST API provided by the Semantic Integration Engine as a CLI (Command Line Interface). By using the CLI, SIE’s semantic search capabilities can be easily accessed from a wide range of execution environments, including shell scripts and generative AI systems.
Presentation–Application–Domain Semantic Integration
A unified architecture where UI, application logic, and domain knowledge operate in semantic lockstep.
Reframing development processes in the AI era through a comparison of UP and agile
This article examines how the premises of development processes are changing with the advent of generative AI, using the characteristics of the Unified Process as a comparative axis against agile development. In the AI era, not only programs but also natural-language artifacts such as models, specifications, and design documents become primary sources of truth. Under this premise, the Unified Process—designed as a model-centric framework—serves as a valuable reference for rethinking development processes that collaborate with AI.
Reinterpreting the Unified Process in the AI Era
In the previous article, we organized the development process for the AI era by positioning the Unified Process as the structural backbone of the process and Component-Based Development as the central structure of development. The Unified Process defines the software development process through three core principles: Iterative & Incremental development, Architecture-Centric design, and Use-Case Driven development. These principles remain valid even in the age of AI. However, in an environment where AI-based code generation has become commonplace, the meaning and role of each principle need to be understood somewhat differently from how they were interpreted in the past. In this article, we revisit the three fundamental principles of the Unified Process as a guide and re-examine the nature of the development process in the AI era.
Scalaプラットフォーム
Category entry.
Semantic Integration Engine/MCP Session
Category entry.
SimpleModeling&SIEの狙いと意義
Category entry.
The Value of CBD in the AI Era
While AI accelerates software development, it has also introduced a new challenge: structural instability. This article revisits the contemporary value of CBD by examining not only its original structural strengths, but also its role in the AI era—through structural constraints that improve generation accuracy, boundaries and specifications that suppress instability, and reusability enhanced by AI. CBD should not be regarded merely as a reuse technique, but rather be re-evaluated as a foundational technology that stabilizes development in an AI-first era.
This article uses the Unified Process (UP) as a guiding framework to reorganize software development processes and project management in the AI era. In particular, it clarifies how the role of AI changes across the phases of inception, elaboration, construction, and transition.
This article uses the Unified Process (UP) as a guiding framework to reorganize software development processes and project management in the AI era. In particular, it clarifies how the role of AI changes across the phases of inception, elaboration, construction, and transition.
Using the Semantic Integration Engine from VSCode via MCP｜VSCodeからSemantic Integration EngineをMCP経由で利用する― An attempt to integrate a knowledge graph into the local development environment ―｜― ローカル開発環境に知識グラフを統合する試み ―
This article explains the configuration for using the Semantic Integration Engine (SIE) from VSCode via MCP (Model Context Protocol). Following the REST and ChatGPT integrations, it introduces the design and demo setup for VSCode integration as an entry point for AI-assisted development and knowledge utilization in the local development environment.
文芸モデリングとAI
文芸プログラミング
永続オブジェクト考察
Category entry.
AI and Humans Co-evolving a Executable Specification｜AIと人間が共に育てる「動く仕様書」
In the AI era of software development, it is essential to cultivate specifications, design, and implementation together without isolating them, allowing continuous movement between these activities. This article organizes a practical SimpleModeling approach centered on executable specifications (Executable Specifications), including up-and-down movement of analysis models and pair analysis / pair design with AI.
CBDで生成範囲を明確にし、DSLとメタ・プログラミングで仕様と生成を統合します。
コンポーネント単位で設計境界を定め、DSLで仕様を形式化し、メタ・プログラミングで生成を固体化します。AI時代の開発におけるSimpleModelingの構造的アプローチを説明します。
CNCF Authorization Model
CNCF authorization evaluates both operation entry points and resource access. Roles, permissions, relations, and ABAC are normalized into capabilities and guards, and evaluated through a unified decision model.
Conclusion
Conclusionは???
Consequence
Consequenceは???
Error Concept
This article organizes the concepts and terminology of errors in SimpleModeling.
Execution Context
Category entry.
HelloWorld Execution Model of CNCF｜HelloWorldで体感するCNCFの実行モデル ― command / server / client / script are all the same｜― command / server / client / script はすべて同一である ―
The shortest path to understanding CNCF is to actually run it first. By starting with command execution and moving on to server, client, and custom components, you can confirm that the internal execution model remains the same even when the execution form changes.
Job Management in CNCF
CNCF Job Management manages Command execution state, results, and diagnostics. It handles synchronous execution, synchronous execution with Job tracking, asynchronous execution, and synchronous execution with asynchronous continuation through one model, and it organizes follow-up processing after Event publication as either synchronous or asynchronous subscriptions.
Object Model + Functional Execution Model
Category entry.
Observability in CNCF
In AI-driven development, one of the central questions is how to achieve non-functional requirements such as Security and Observability. Even observability alone requires many cross-cutting concerns such as distributed tracing, metrics, structured diagnostics, payload protection, and integration with external observability platforms. Delegating these concerns to individually generated implementations rapidly increases generation, review, and operational costs while also destabilizing quality assurance. For this reason, once sufficient structural information is described in the Literate Model, the CML&CNCF model compiler and execution framework establish Security and Observability as cross-cutting runtime behavior.
Semantic Message Flow Diagram
The Semantic Message Flow Diagram is a diagramming method that integrates control flow and data flow using a single flow notation. It represents both system-internal behavior and information propagation with a unified causal line, and can be used for architectural descriptions and extensions of robustness diagrams.
Showable
Category entry.
SimpleModeling Reference Profile
Category entry.
Subsystem–Component–Componentlet Architecture
The Subsystem–Component–Componentlet structure defines a three-tier architectural decomposition that bridges conceptual, logical, and physical perspectives in system design.
Textus Samples 01.a: Invocation Source
01.a-invocation-source-lab shows how the same minimal.main.hello selector can be used while switching the Component source between a development directory and a component repository.
Textus Samples 01.b: Startup Shapes
01.b-startup-shapes-lab uses the same minimal.main.hello example to examine the runtime role differences among command, server, and client.
Textus Samples 01.c: Builtin And Help Surface
01.c-builtin-and-help-lab distinguishes the sample-defined minimal.main.hello from runtime-provided builtin surfaces such as meta.help and admin.system.ping.
Textus Samples 01: Minimal Execution
This article uses the 01-minimal family to examine the smallest Textus Component / Service / Operation and how it is invoked on the CNCF engine.
Textus Samples 01:Component Script
01.d-component-script is a textus-tutorial 0.1.3 sample for learning the script-style operational form that connects a small management command to a Textus operation contract.
Textus Samples 02:Component Packaging
The 02-component family shows the basic development step from an in-development Textus component project to a packaged artifact.
Textus Samples 03: CML Generated Component
The 03-component-cml family shows how to generate a Textus component surface from CML and run it on the same runtime.
Textus Samples 04: CRUD Basics
The first half of the 04-crud family shows the CRUD surface generated from an entity model and basic data import/read behavior.
Textus Samples 04: CRUD Runtime Shapes
04.d through 04.f examine generated CRUD through server/client execution, explicit synchronous execution, and nested value persistence.
Textus Samples 05: Operation Contract
The 05-operation family shows how CML Service / Operation / Input / Output definitions become user-facing Textus component contracts executed by the CNCF engine.
Textus Samples 06:CQRS
The 06-cqrs family shows the CNCF engine shape for separating update Commands and read Queries.
Textus Samples 07:Event Driven Flow
The 07-event-driven family shows Command-driven Event emission, reaction processing, and job tracing.
Textus Samples 08: Job Management
The 08-job family inspects asynchronous Command results, state, history, and control through the job surface.
Textus Samples 09:Aggregate
The 09-aggregate family shows CNCF engine execution shapes for treating an aggregate root and members as one consistency boundary.
Textus Samples 10:View
The 10-view family examines view services, named views, and paged search as the read side of CQRS.
Textus Samples 11:Subsystem
The 11-subsystem family shows the basic Subsystem shape for composing Components at runtime.
Textus Samples 12:Subsystem Wiring
12-subsystem-wiring is the minimal wiring sample where one Component calls another Component inside one Subsystem.
Textus Samples 13.a:Observability Stack
13.a-observability-stack-lab is an observability stack sample using OpenTelemetry Collector, Jaeger, Prometheus, and Grafana.
Textus Samples 13: Observability with Jaeger
13-observability-jaeger is the minimal sample for sending CNCF engine runtime traces to Jaeger through OpenTelemetry.
Textus Samples: Launchers and Installation
This article explains the Textus / Cozy Textus product names, the internal CNCF engine, and the roles of the cozy, cncf, and textus launchers before learning Textus component development with textus-tutorial 0.1.3.
Understanding the CNCF Execution Model Through HelloWorld
SimpleModeling is a development methodology based on component-oriented principles.To make component-oriented development viable, an execution system for components is required in addition to the definition of conceptual models.For this purpose, the Cloud Native Component Framework has been developed as a component framework for cloud applications that run on cloud platforms. In this article, we will explore the execution model of the Cloud Native Component Framework through a HelloWorld example.
エラー・システム
SimpleModelingリファレンス・プロファイルでは関数型プログラミングにも適用できるエラーシステムを用意しています。
オブジェクトと関数の関係を軸に、システムを構造と振る舞いの両面からとらえるモデルです。
SimpleModelingメソッドでは、ドメインの構成要素を「オブジェクト」と「関数」の二つの観点で整理し、モデル全体を理解しやすくします。
# Application Modeling | Orchestrating Domains to Fulfill Users’ Goals
Category entry.
# Part 9: Application Modeling — final English video
Category entry.
# Storyboard
Category entry.
# Storyboard
Category entry.
# Storyboard
Category entry.
# YouTube掲載情報
Category entry.
# 第9回 アプリケーション・モデリング：日本語確認動画
Category entry.
# 第9回 日本語まとめPDF・確認動画
Category entry.
# 第9回インフォグラフィック・確認用初稿
Category entry.
# 複数ドメインを束ねる ― アプリケーション・モデリング
Category entry.
A higher-level framework for designing the development system itself, enabling adaptation to the era of knowledge-driven and AI-assisted development.
The Meta Development System Framework is a higher-level model for integratively designing development methods, processes, and architectures. It defines a cyclical development mechanism that includes knowledge modeling and AI assistance, providing a theoretical foundation for self-improving development systems.
AIと人が協調できる開発構造を設計する、新しいタイプのアーキテクト。
メタ・アーキテクトは、業務ごとに作られるDSLを SimpleModelingの中核モデル(CML/Object-Functional Model)に変換し、 AIやBoKとつながる仕組みを設計します。
AI支援の時代に、技術とビジネスを統合して設計するエンジニア像。
SimpleModeling.orgが提唱する開発ロールです。 従来のフルスタック・デベロッパーを、よりビジネス側に寄せた形で再定義します。
AI開発ハーネス — AI駆動開発を実用にする
AI開発ハーネスは、AIによる解釈・探索・補完を、モデル、アーキテクチャ、実行、検証などソフトウェア工学の成果と結び付ける仕組みです。AIが補った判断を明示して確かめ、採用された意味をプログラムとランタイムで実行します。連載では異なるハーネスを組み合わせ、AIの新しい応用と開発の速さを業務アプリケーション級の開発へつなぐ方法を示します。
Application Modeling
Domain Models and Application Models view the same subject world through different purposes and concerns. Applications for different needs use a Domain Model that accumulates understanding of the subject world. Use Case Scenarios are made concrete through Collaborations and Interactions. We review their mappings to Services and Operations and describe the approved executable Model in CML.
Architecture-Centric in SimpleModeling
SimpleModeling adopts an architecture-centric approach derived from the Unified Process. Architecture is treated not merely as a design artifact, but as the organizing structure that guides requirements, analysis, design, implementation, and operation. By applying architectural viewpoints from the earliest stages, models become more coherent, analyzable, and AI-friendly.
Knowledge Modeling for AI Collaboration
A Knowledge Model is a constituent of a SimpleModeling Model that supports defining Models through CML, reviewing a Domain Model, creating and reviewing a Use Case Model, and answering inquiries for Domain understanding. Terms defined in the Glossary map occurrences of the same concept across Object, Knowledge, and Literate Models. Generative AI presents candidates and explanations; people approve their meaning and evidence.
Literate Modeling
Literate Modeling treats organizing Stories as Narratives as an important form while also organizing Vision, requirements, decision records, existing specifications, and conventional documents that explain Domain Model concepts, rules, and relationships in natural language as Literate Models with explicit meanings, identities, and mappings to other Model elements. SmartDox is the full-spec primary description language, while Markdown is also allowed. textus-bok turns Literate Models into Knowledge Models and connects them to generative AI, which principally generates, updates, and manages the Object Model. People review the results through the visualizations, differences, and evidence provided by textus-cbd-support, then return approval or findings to the AI. Literate Models also serve as authoritative sources for facts from which requirements specifications, user guides, design explanations, and other purpose-specific documents can be composed.
Model Structure and the Use of Views
Part 4 takes the Model as its subject and composes Capabilities and Aspects through the Domain Model and Use Case Model axes. The Object Model makes the formal structure concrete, while purpose- and concern-selected Views support understanding, evaluating, and applying the complex Model.
Modeling Technology System
A Knowledge System collects, organizes, and classifies existing technologies and provides a map for understanding them. A Software Development Methodology selects the needed technologies from that knowledge, defines their roles and use, and guides practice. A SimpleModeling Model is composed of an Object Model for formal structure and execution examples, a Knowledge Model for generative-AI knowledge structures, and a Literate Model for human-readable context and intent. Domain Modeling organizes the three constituents with emphasis on problem-domain meaning, structure, rules, and boundaries. Application Modeling organizes them with emphasis on Use Case realization, Collaborations, Interactions, state transitions, Events, Services, and Operations. Domain Modeling is not entirely static, and Application Modeling does not own every dynamic element. Approved executable formal structures are connected to executable software through CML, Cozy, AI, and Textus as Model Realization. Quality attributes remain cross-cutting design concerns.
Object Modeling as a Structural Foundation
A SimpleModeling Model is composed of Object, Knowledge, and Literate Models, which are combined by purpose into Domain, Use Case, and Application Models. The Object Model contains an Executable Model that defines general structure and Behavior and an Execution Example Model that presents concrete executions such as Interactions. Execution examples provide inductive constraints for design and validation, while current CML targets only the Executable Model. CML, Cozy, and Textus absorb platform-oriented mechanisms so Object Modeling can focus on describing the Domain Model.
SimpleModeling Development Process
Category entry.
SimpleModeling Development Process in the AI Era
SimpleModeling integrates literate modeling, DSL, and execution platform to enable AI-driven development processes. This article reconstructs a minimal development workflow based on Essence as a BoK → Cozy → CNCF → SKILL pipeline.
SimpleModeling Development Process with Essence Framework
The SimpleModeling Development Process is composed by selecting and combining Practices such as Use Case Lite, Scrum Solo, Cloud Native CBD, BoK, Cozy Domain Modeling, Code Generation, and DevOps on top of the Essence Kernel. CNCF is positioned as the execution foundation. This article provides a draft definition using Method View, Process Flow View, Work Product View, Role/Agent View, Automation View, and Lifecycle View.
SimpleModeling Development Processの系譜
From Unified Process to AI-Driven Model-Centric Development
SimpleModeling Reference Profile
Category entry.
Unified Processとアジャイルの統合的進化
Agile Evolutions and Modern Reinterpretations of the Unified Process
What SimpleModeling Has Pursued
SimpleModeling has built a path from models to executable software through CML, DSLs, Literate Models, Cozy, and Textus. Cozy transforms CML into executable software, while AI fills implementation gaps that Cozy cannot transform completely. Textus runs the resulting software. Meanwhile, people have performed most of the work of constructing a Domain Model from knowledge. With the BoK as a shared foundation for collaboration among domain experts, developers, and AI, the path from Knowledge to Executable Software can be treated as one methodology.
Why Reconstruct Software Development Methodology?
With the arrival of AI, the domain model has become a working abstraction with a realization path to implementation that can directly drive development forward. AI translates domain models into implementations and fills in the necessary implementation details. The primary subject handled by humans therefore shifts from describing implementation step by step to software models representing the target world, responsibilities, execution, and knowledge. Because model quality strongly influences software quality, modeling becomes the new choke point, requiring existing software engineering to be reconstructed as a modeling-centered methodology.
アプリケーション・モデリング
ドメイン・モデルとアプリケーション・モデルは、同じ対象世界を異なる目的と関心から捉えます。対象世界の理解を蓄積するドメイン・モデルを、ニーズごとのアプリケーション・モデルから利用します。ユースケースシナリオを協調や相互作用によって具体化し、サービスやオペレーションへの対応を確認して、承認した実行可能モデルをCMLで記述します。
ドメイン・モデリング
第8回は、用語と概念を出発点に、コンテキスト、境界づけられたコンテキスト、ユビキタス言語を使って問題領域を分割し、オブジェクト・モデル、知識モデル、文芸モデルから一つのドメイン・モデルを組織する方法を扱います。SimpleModelingでは、生成AIがtextus-bokを通して文芸情報と知識モデルを参照し、オブジェクト・モデルを主として生成、更新します。開発者はtextus-cbd-supportが提供する可視化、差分、根拠、影響範囲、検証情報を使ってモデルをレビューし、フィードバックを生成AIへ返します。この反復的な開発ループによってモデルの妥当性を高めます。
モデル・ハーネス — モデルでソフトウェアを記述する
モデル・ハーネスは、ドメイン知識に近い表現でソフトウェアを記述し、処理系の検査と実行によって生成・変更を制約する基盤です。要求モデルとの対応を保持し、ソフトウェアが果たす目的も確認します。第3回では概念・関係・規則による静的な構造、第4回では状態機械を含む動的な振る舞いを具体化します。
開発メソッドを軸に知識とプロセスを統合するフレームワーク
開発メソッドを核として、プロセススタイル、ビジネスモデリング、実行環境、BoKやAIとの接続を可能にする知識指向のフレームワークを構想します。
Conceptual Model / Analysis Model / Design Model
A domain model is a representation of the real world transformed into a model that can be manipulated by software. The key point is to faithfully reproduce the "conceptual world" held by experts in the target problem domain.
Domain Model Elements
SimpleModeling uses the following fundamental elements to construct domain models.
Entity Analysis and Design
We explore the differences between analysis models and design models of entities, which are central to domain models.
Observation
By semantically classifying all phenomena occurring during application runtime and recording them along with causes, severity, handling strategies, stakeholders, and technical contexts (such as trace information and execution environments), they can be consistently utilized for logging, monitoring, analysis, auditing, troubleshooting, alerting, and error reporting.
Profile : Base DataType
This is a profile of basic data types used in domain models in SimpleModeling.
SimpleObject
In the SimpleModeling Reference Profile, the abstract class SimpleEntity is defined as the base class for all entity objects. Except for special cases, all entity objects are expected to derive from SimpleEntity. SimpleEntity provides a comprehensive set of attributes commonly needed by entity objects, allowing designers to define entity objects by simply adding domain-specific attributes. SimpleObject is defined as the base class of SimpleEntity. SimpleObject is an abstract object in SimpleModeling that defines the common attributes of domain objects. Value objects can optionally use SimpleObject as their base class. SimpleObject is composed by delegating various generic attribute groups, each of which can also be reused individually as components of value objects.
SimpleObjectの記述的メタ情報モデル
本章では、SimpleObject におけるメタ情報属性の体系を定義します。エンティティや値オブジェクトが持つ説明属性を多層構造で整理し、識別・表示・導入・補足といった異なる目的に対応できるようにしています。
ドメイン・モデルの構成
Category entry.
ドメイン・モデル操作メカニズム
Category entry.
国際化
Category entry.
文芸モデル
Cozy Modeling Languageによるモデル記述です。
AI reads, understands, and learns from models. It transforms the SmartDox site into a BoK, internalizing and applying knowledge through it.
SmartDox documents are the smallest units describing literate models, while the SmartDox site serves as a structured knowledge architecture that organizes them. The site contains both regular documents and CML (Cozy Modeling Language) documents. The SmartDox command analyzes the entire site, generating HTML and Web Metadata from regular documents, and HTML, MCP, and Web Metadata from CML documents. By integrating these outputs, the site is reconstructed as a BoK (Body of Knowledge). Through RAG (Retrieval-Augmented Generation), AI refers to the BoK, fusing tacit and explicit knowledge, forming a continuous cycle of understanding (assimilation) and learning (promotion).
AIはコードを生成できますが、意味を理解しているわけではありません。 SimpleModelingでは、文芸モデルとコンポーネント設計によってこの問題に対処します。
AIによる自動コーディングは、構文的には正しいコードを出力できますが、 しばしば意味的には不正確な結果を生みます。 SimpleModelingでは、文芸モデル駆動開発（Literate MDD）と Component-Based Development（CBD）を組み合わせることで、 こうした構造的な課題に対して「意味を補い、境界を定める」対策を講じています。
BoK as Knowledge Representation
<b>Body of Knowledge（BoK）</b>は、知識を体系的に構造化し、AIが理解・参照・昇格できる形で保持する知識表現基盤です。
Connecting Book Knowledge Beyond Metadata
How SIE links book knowledge with external RDF knowledge spaces.
Information and Knowledge in CNCF
Category entry.
Knowledge Processing Model in SimpleModeling
The knowledge processing model in SimpleModeling is structured as a transformation pipeline: “meaning → structure → definition → behavior → execution → reality.” Context governs the entire pipeline, and reality emerges through the evaluation of effects.
Multi-origin Ranked Evidence Fusion
Category entry.
SIE acquires Book information from ISBN and materializes it as RDF-linked knowledge.
Semantic Integration Engine (SIE) does not treat a Book as mere bibliographic metadata. Instead, SIE assigns its own local RDF node identity and attaches open knowledge sources such as Open Library, DBpedia, and Wikidata to build explainable knowledge structures.
SimpleModeling.org provides a structured RDF/OWL architecture composed of Vocabulary, Ontology, Schema, and ABox layers. This article explains how each TTL file corresponds to Semantic Web layers such as TBox and RBox.
SimpleModeling.org maintains a multi-layered ontology system: Vocabulary for stable URIs, Ontology for conceptual structures (TBox/RBox), Schema for physical JSON-LD/Turtle shapes, and ABox for concrete document instances. Together, these form a coherent knowledge representation pipeline.
SimpleModelingは、情報を構造化し、動的に扱い、知識へと進化させる情報アーキテクチャです。
SimpleModeling.orgは、ソフトウェア開発の方法論を超えて、 情報を設計・運用・公開するための包括的な情報アーキテクチャとして構築されています。 静的な文書構造（SmartDox）と動的なモデル構造（CML）を統合し、 AIが理解・参照できる知識基盤（BoK）へと接続します。
SmartDoxから派生した語彙定義DSL「LexiDox（レキシドックス）」を紹介し、 Glossary・Vocabulary・Lexiconの関係とSimpleModeling.orgでの役割分担を整理する。
LexiDoxは、SmartDoxをメタ言語として用いる語彙・意味体系記述DSLである。 SimpleModeling.orgでは、Glossary（用語集）、Vocabulary（語彙体系）、Lexicon（意味ネットワーク）を階層的に構成し、 AIが理解できる知識構造としてBoKを形成する。
The Philosophy of 1.5hop+: Meaning-Oriented Concept Neighborhoods
1.5hop+ is a knowledge graph exploration approach that constructs concept neighborhoods based on semantic structure rather than fixed traversal distance. By leveraging CML/UML metamodel structures, it provides sufficient semantic context for generative AI, balancing accuracy and efficiency.
This document systematizes URI design and versioning strategies for RDF/OWL in SimpleModeling.org, fully unifying naming rules for Ontology, Schema, Site, Category, and Glossary vocabularies.
Ontology IRIs are extensionless canonical IRIs, physical files use Turtle, and JSON-LD is dedicated to article metadata. This document presents a foundational design enabling both coherence and evolvability of the vocabulary system.
We connect the SECI model to the AI era through the AI Knowledge Creation Architecture. The knowledge-creation loop—composed of knowledge promotion and knowledge circulation—may serve as an important guiding line for envisioning a future SECI-AI model.
In this article, we define the flow of knowledge in AI utilization as the AI Knowledge Creation Architecture and show that its structure may serve as a foundational architecture for adapting the SECI model to the AI era. We position AI’s processes of knowledge activation, assimilation, expression, and promotion within their conceptual correspondence to the SECI model.
describeContext
Category entry.
情報アーキテクチャは、静的構造から動的操作を経て、知識進化を設計する段階へ進化する。
SimpleModelingは、情報アーキテクチャを出発点として、 AIが関与する知識開発（Knowledge Development）の領域へと拡張します。 文芸モデルを媒介に、情報がAIに理解され、内化され、昇格していく。 それが次世代のソフトウェア開発＝AI協調型知識開発です。
A model that unifies narrative and structure for humans and AI to understand together.
A Literate Model is a knowledge representation method that integrates natural-language narratives and formal model structures within a single document, enabling both human readability and AI interpretability.
Cozy Modeling Language
Category entry.
Literate Model Example: Address
This is a sample article to give you a quick sense of a literate model using an address model example. For an explanation of what a literate model is, see what-is-literate-model.dox.
English
Category entry.
Object-Oriented Analysis and Design Course for Cloud Applications
We have launched a 47-part lecture series titled “Object-Oriented Analysis and Design for Cloud Applications” at the General Incorporated Association MaruLabo.
Better-Java
本格的な関数プログラミングはオブジェクト指向プログラミングとはアプローチの仕方が異なるため、なかなかすんなりと使いこなすことができるようにはならないかもしれません。
Monad Evaluation Styles
Some monads, like Option, evaluate immediately, while others, like State, build up a program that is only evaluated when run is invoked. This article introduces these two categories as "Data Monads" and "Program Monads".
Monad Introduction
関数型プログラミングにおけるモナドの基本構造と代表的な実装例を説明します。
Scala is a language for generative and AI-assisted literate model–driven development.
Scala forms the foundation of SimpleModeling as a unified language suitable for code generation and AI-assisted development from literate models.
Scalaをシンプルに使いこなすための三段階アプローチ
Better Javaの思想を出発点に、三段階でScalaの理解を深める実践的な導入方針です。
ロードマップ
オブジェクト関数統合プログラミング(Object-Functional Programming)は
Architecture
SimpleModeling.orgはモデリングを中心としたソフトウェア開発の技術情報サイトです。文芸モデル駆動開発を軸にドメイン・モデリングやオブジェクトと関数の統合、コンポーネント指向開発、クラウド・ネイティブ・アプリケーション構築といった技術情報を提供します。
B
A
BoK Building
SimpleModeling.org is a technical information site focused on modeling technologies centered around Literate Model-Driven Development (Literate MDD).
Mission
SimpleModeling.orgは以下のミッションを通じてビジョンの実現を目指します。
Purpose of This Site
SimpleModeling.org is a technical information site focused on modeling-centric software development.
RDF Term Acceptance
Category entry.
Values
Value意味と行動指針
Vison
SimpleModelingのビジョンです。
b
Lead
ゴール
ホームページのタイトルにある通り本サイトの目標は以下のものです。
サイト構成
Development Process Domain Modeling Cloud Native CBD Object-Oriented Foundation Object-Functional Programming Corss Cutting Concern UX/UI Marulabo Cozy MDD
スキルセットとステージ
SimpleModeling.orgでは、ソフトウェア開発におけるエキスパート人材の育成を視野に入れ、学習と成長のステージを3段階に整理しています。以下は、各ステージで習得すべき代表的な技術・知識の概要です。
SmaartDox文法
SmartDox文書の文法です。
メッセージ・フロー図
メッセージ・フロー図はSimpleModelingの記事中で用いる独自のダイアグラムです。
命名方針
make create get take
命名規約
本サイトのプログラムで使用する命名規約です。
[BPStudy] Literate Model-Driven Approach to Software Development in the AI Era
This is a report on the session introducing the overall vision of Literate Model-Driven Development proposed by SimpleModeling.org for software development in the AI era. A Literate Model is a knowledge unit that integrates natural-language explanations with structured model descriptions, providing a form that AI can interpret and reconstruct. Through this approach, the BoK is built as a Retrieval Knowledge Base that AI can search, reference, and internalize, enabling effective knowledge utilization by generative AI. Anticipating the shift from programming-driven to knowledge-driven development, the session explored new directions for development styles where humans and AI work in close collaboration.