Skip to content

Commit 610e2f7

Browse files
jgelukjgeluk
committed
style(docs): apply 70-character line wrapping to markdown files
- Format YAML formatting rules documentation - Format persona concept documentation - Format enable-reuse objective documentation
1 parent deccf26 commit 610e2f7

File tree

3 files changed

+116
-106
lines changed

3 files changed

+116
-106
lines changed

‎.cursor/rules/yaml-formatting.mdc‎

Lines changed: 15 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2,16 +2,21 @@
22
globs: *.md,*.yml,*.yaml
33
alwaysApply: false
44
---
5+
56
# YAML Formatting Rules
67

78
## Frontmatter and YAML Files
89

910
When editing YAML files or frontmatter sections in Markdown files:
1011

1112
1. **Always use multiline syntax** instead of long quoted strings
12-
- Use `>-` (folded block scalar with strip) for single-line strings that need to wrap
13-
- Use `|` (literal block scalar) when preserving line breaks is needed
14-
- Use `|-` (literal block scalar with strip) when preserving line breaks but removing trailing newline
13+
14+
- Use `>-` (folded block scalar with strip) for single-line strings
15+
that need to wrap
16+
- Use `|` (literal block scalar) when preserving line breaks is
17+
needed
18+
- Use `|-` (literal block scalar with strip) when preserving line
19+
breaks but removing trailing newline
1520

1621
2. **Always keep lines shorter than 70 characters**
1722
- Break long strings across multiple lines
@@ -23,14 +28,16 @@ When editing YAML files or frontmatter sections in Markdown files:
2328

2429
```yaml
2530
description: >-
26-
Learn how to build composable, scalable enterprise knowledge through reuse.
27-
Discover how the Use Case Tree Method enables safe reuse of knowledge assets
28-
across teams and domains.
31+
Learn how to build composable, scalable enterprise knowledge through
32+
reuse. Discover how the Use Case Tree Method enables safe reuse of
33+
knowledge assets across teams and domains.
2934
```
3035

3136
### Bad (long quoted string):
3237

3338
```yaml
34-
description: "Learn how to build composable, scalable enterprise knowledge through reuse. Discover how the Use Case Tree Method enables safe reuse of knowledge assets across teams and domains."
39+
description:
40+
"Learn how to build composable, scalable enterprise knowledge
41+
through reuse. Discover how the Use Case Tree Method enables safe
42+
reuse of knowledge assets across teams and domains."
3543
```
36-

‎docs/concept/persona.md‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,9 @@
11
---
22
description: >-
3-
A representation of the different types of players — people, systems, or
4-
entities — involved in a Use Case, defined using business language.
5-
Understand how personas shape requirements in the Use Case Tree Method.
3+
A representation of the different types of players — people,
4+
systems, or entities — involved in a Use Case, defined using
5+
business language. Understand how personas shape requirements in the
6+
Use Case Tree Method.
67
keywords:
78
- persona
89
- user persona
@@ -15,8 +16,10 @@ schema_type: "Article"
1516
# Persona
1617

1718
<!--summary-start-->
19+
1820
_A representation of the different types of players — people, systems,
1921
or entities — involved in a Use Case, defined using business language_
22+
2023
<!--summary-end-->
2124

2225
=== "Business & Management Audience"

‎docs/objective/enable-reuse.md‎

Lines changed: 95 additions & 95 deletions
Original file line numberDiff line numberDiff line change
@@ -2,14 +2,14 @@
22
title: >-
33
M: Enable Reuse - Knowledge Reuse Across Enterprise
44
authors:
5-
- Jacobus Geluk
5+
- Jacobus Geluk
66
hide:
7-
- toc
7+
- toc
88
date_published: "2022-01-01"
99
description: >-
10-
Learn how to build composable, scalable enterprise knowledge through reuse.
11-
Discover how the Use Case Tree Method enables safe reuse of knowledge assets
12-
across teams and domains.
10+
Learn how to build composable, scalable enterprise knowledge through
11+
reuse. Discover how the Use Case Tree Method enables safe reuse of
12+
knowledge assets across teams and domains.
1313
keywords:
1414
- reuse
1515
- knowledge reuse
@@ -19,10 +19,14 @@ keywords:
1919
- composability
2020
schema_type: "Article"
2121
---
22+
2223
# M: Enable Reuse
2324

2425
<!--summary-start-->
25-
_Building the foundation for composable, scalable enterprise knowledge_
26+
27+
_Building the foundation for composable, scalable enterprise
28+
knowledge_
29+
2630
<!--summary-end-->
2731

2832
## Objective
@@ -34,25 +38,25 @@ generations of technology.
3438

3539
It is the foundation of the Enterprise Knowledge Graph (EKG): without
3640
reuse, there is no composability, no scalability, and no sustainable
37-
intelligence.
38-
The Use Case Tree Method defines reuse not as a technical afterthought but as a
39-
*core architectural principle* — embedded in the way we plan, build,
40-
and run every enterprise capability.
41+
intelligence. The Use Case Tree Method defines reuse not as a
42+
technical afterthought but as a _core architectural principle_ —
43+
embedded in the way we plan, build, and run every enterprise
44+
capability.
4145

4246
## Why It Matters
4347

44-
Enterprises waste enormous effort solving the same problems repeatedly —
45-
integrating the same data, remodelling the same business rules,
48+
Enterprises waste enormous effort solving the same problems repeatedly
49+
— integrating the same data, remodelling the same business rules,
4650
recreating the same workflows.
4751

48-
Most of this duplication stems from one cause: **knowledge is not shared
49-
as reusable components**.
52+
Most of this duplication stems from one cause: **knowledge is not
53+
shared as reusable components**.
5054

5155
When knowledge lives in silos — spreadsheets, slide decks, bespoke
52-
systems — every project begins from zero.
53-
By contrast, a reuse-enabled organisation captures its work as
54-
semantically defined, governed components that can be discovered and
55-
recomposed anywhere across the enterprise.
56+
systems — every project begins from zero. By contrast, a reuse-enabled
57+
organisation captures its work as semantically defined, governed
58+
components that can be discovered and recomposed anywhere across the
59+
enterprise.
5660

5761
The result:
5862

@@ -63,25 +67,24 @@ The result:
6367

6468
## Beyond Data: The Real Meaning of Reuse
6569

66-
Most "semantic technology" initiatives of the past two decades have been
67-
driven from the **data perspective** — led by integration specialists and
68-
ontology engineers.
69-
They delivered powerful data harmonisation but rarely transformed how
70-
the enterprise actually *works*.
70+
Most "semantic technology" initiatives of the past two decades have
71+
been driven from the **data perspective** — led by integration
72+
specialists and ontology engineers. They delivered powerful data
73+
harmonisation but rarely transformed how the enterprise actually
74+
_works_.
7175

7276
That is where the **Enterprise Knowledge Graph (EKG)** and **Use Case
73-
Tree (UCT)** shift the paradigm.
74-
They treat **reuse not as a data exercise**, but as the foundation for
75-
*application composition*.
76-
In the Use Case Tree Method, reuse is not limited to triples or ontologies — it
77-
extends to **behaviour**, expressed as *Stories* and *Workflows*.
77+
Tree (UCT)** shift the paradigm. They treat **reuse not as a data
78+
exercise**, but as the foundation for _application composition_. In
79+
the Use Case Tree Method, reuse is not limited to triples or
80+
ontologies — it extends to **behaviour**, expressed as _Stories_ and
81+
_Workflows_.
7882

7983
Just as **object-oriented programming** in the 1980s combined data and
80-
methods into a reusable "object,"
81-
the **Use Case Tree (UCT)** combines data, logic, and process into a
82-
reusable **semantic package**:
83-
a use case that contains its meaning (ontology), its data products, and
84-
its behaviour (stories, workflows, outcomes).
84+
methods into a reusable "object," the **Use Case Tree (UCT)** combines
85+
data, logic, and process into a reusable **semantic package**: a use
86+
case that contains its meaning (ontology), its data products, and its
87+
behaviour (stories, workflows, outcomes).
8588

8689
This is the crucial difference:
8790

@@ -91,86 +94,83 @@ This is the crucial difference:
9194
Tree Method captures *the behaviour itself* — executable, governed, and
9295
reusable across domains — without necessarily writing code at all.
9396

94-
In this sense, a **Use Case** in the EKG is just as real and reusable as
95-
a software package in the JavaScript or Python ecosystems.
96-
Each can be discovered, installed, versioned, extended, and composed —
97-
but the EKG package operates at the **semantic and business level**,
98-
spanning data, logic, and meaning.
97+
In this sense, a **Use Case** in the EKG is just as real and reusable
98+
as a software package in the JavaScript or Python ecosystems. Each can
99+
be discovered, installed, versioned, extended, and composed — but the
100+
EKG package operates at the **semantic and business level**, spanning
101+
data, logic, and meaning.
99102

100-
That's why **reuse** is not a side effect of the EKG.
101-
It's the *reason the EKG exists.*
103+
That's why **reuse** is not a side effect of the EKG. It's the _reason
104+
the EKG exists._
102105

103106
### From DIKW to EKGF: Making Knowledge Executable
104107

105-
The well-known **DIKW Model** (Data → Information → Knowledge → Wisdom)
106-
has guided information management for decades.
107-
But it assumes that *Wisdom naturally follows from Knowledge* — as if
108-
understanding automatically produces action.
109-
In practice, enterprises rarely reach that state because the bridge from
110-
*knowing* to *doing* is missing.
108+
The well-known **DIKW Model** (Data → Information → Knowledge →
109+
Wisdom) has guided information management for decades. But it assumes
110+
that _Wisdom naturally follows from Knowledge_ — as if understanding
111+
automatically produces action. In practice, enterprises rarely reach
112+
that state because the bridge from _knowing_ to _doing_ is missing.
111113

112-
The **Use Case Tree Method** extends this model by adding the **operational
113-
dimension**:
114-
knowledge becomes **behaviour**, behaviour becomes **reusable**, and
115-
reuse powers **composability**.
116-
This is the *Path to Executable Knowledge* — where understanding turns
117-
into governed, shareable, and actionable intelligence.
114+
The **Use Case Tree Method** extends this model by adding the
115+
**operational dimension**: knowledge becomes **behaviour**, behaviour
116+
becomes **reusable**, and reuse powers **composability**. This is the
117+
_Path to Executable Knowledge_ — where understanding turns into
118+
governed, shareable, and actionable intelligence.
118119

119-
The diagram below visualises this shift — showing how the Use Case Tree Method
120-
transforms the classic DIKW hierarchy into a living model of executable,
121-
reusable knowledge.
120+
The diagram below visualises this shift — showing how the Use Case
121+
Tree Method transforms the classic DIKW hierarchy into a living model
122+
of executable, reusable knowledge.
122123

123124
![DIKW Model Revised – Path to Executable Knowledge](../assets/dikw-revised.svg)
124125

125-
<sub>Traditional DIKW ends at understanding.
126-
The Use Case Tree Method continues by modelling behaviour, packaging it as reusable
127-
use cases, and feeding it back into a composable enterprise — closing the
128-
loop between data, knowledge, and operational wisdom.</sub>
126+
<sub>Traditional DIKW ends at understanding. The Use Case Tree Method
127+
continues by modelling behaviour, packaging it as reusable use cases,
128+
and feeding it back into a composable enterprise — closing the loop
129+
between data, knowledge, and operational wisdom.</sub>
129130

130131
## The Role of the Use Case Tree (UCT)
131132

132-
In the Use Case Tree Method, the **Use Case Tree (UCT)** is the mechanism that
133-
makes reuse practical and governed.
133+
In the Use Case Tree Method, the **Use Case Tree (UCT)** is the
134+
mechanism that makes reuse practical and governed.
134135

135-
Each node in the UCT acts as a *semantic package* — a defined,
136-
versioned, and discoverable unit of business capability.
137-
Within a UCT package, teams can register:
136+
Each node in the UCT acts as a _semantic package_ — a defined,
137+
versioned, and discoverable unit of business capability. Within a UCT
138+
package, teams can register:
138139

139140
- **Ontologies and shapes** defining meaning and validation
140141
- **Stories** (tool functions or APIs) that implement reusable logic
141142
- **Data products** describing and delivering reusable datasets
142143
- **Workflows and policies** orchestrating repeatable patterns
143144

144145
Every successful technology ecosystem has a way to **share reusable
145-
components** — the JavaScript world has [*npm*](https://www.npmjs.com)
146+
components** — the JavaScript world has [_npm_](https://www.npmjs.com)
146147
with over 3.5 million packages, the Python world has
147-
[*PyPI*](https://pypi.org) with over 600,000 packages, and so on — each
148-
enabling developers to build upon a vast ecosystem of reusable
149-
components.
150-
The **Use Case Tree (UCT)** plays the same role for the **Enterprise
151-
Knowledge Graph (EKG)**: it is the *semantic package manager* that makes
152-
every business capability, dataset, and workflow discoverable, versioned,
153-
and ready for reuse across the organisation.
148+
[_PyPI_](https://pypi.org) with over 600,000 packages, and so on —
149+
each enabling developers to build upon a vast ecosystem of reusable
150+
components. The **Use Case Tree (UCT)** plays the same role for the
151+
**Enterprise Knowledge Graph (EKG)**: it is the _semantic package
152+
manager_ that makes every business capability, dataset, and workflow
153+
discoverable, versioned, and ready for reuse across the organisation.
154154

155155
## Reuse Enablement vs. Composable Business
156156

157157
### Two sides of the same semantic coin
158158

159-
While *Reuse Enablement* and *Composable Business* share the same
160-
foundation, they operate at different levels of abstraction.
161-
The table below summarises their relationship within the Use Case Tree Method.
162-
163-
| Aspect | Composable Business | Reuse Enablement |
164-
|--------|---------------------|------------------|
165-
| Focus / Orientation | _How business capabilities are composed, orchestrated, and evolved_ | _How knowledge assets and components are packaged and shared_ |
166-
| Primary Question | "How do we assemble business capabilities from reusable parts to adapt to change?" | "How do we design those reusable parts so they can be assembled safely and meaningfully?" |
167-
| Scope | Business and operational level — orchestrating Use Cases, Personas, and Stories into composable outcomes. | Technical and semantic level — creating and governing reusable artifacts: ontologies, datasets, shapes, workflows, data products, and Stories. |
168-
| Key Mechanism | **Use Case Tree (UCT)** as _the orchestration layer_: composing and aligning modular business capabilities. | **Use Case Tree (UCT)** as _the packaging layer_: publishing reusable components and metadata to the Enterprise Knowledge Graph (EKG) for discovery and re-use. |
169-
| Relationship to the EKG | The EKG provides the shared semantics and service interfaces that make cross-use-case orchestration possible. | The EKG provides the shared identifiers, ontologies, and provenance that make reuse safe and traceable. |
170-
| Value Proposition | Agility and adaptability: the ability to reconfigure the enterprise dynamically in response to change. | Efficiency and consistency: the ability to reduce duplication and accelerate delivery through reusable, versioned components. |
171-
| Primary Users | Business and solution architects; transformation leads. | Data and knowledge engineers; ontology and platform teams. |
172-
| Outcome | Composable business capabilities and adaptive workflows. | Reusable semantic components and data products. |
173-
| Relationship to Each Other | Composable business **depends on** reuse. Without reusable components, there is nothing to compose. | Reuse **finds purpose** in composability. Without higher-level composition, reuse is just technical hygiene. |
159+
While _Reuse Enablement_ and _Composable Business_ share the same
160+
foundation, they operate at different levels of abstraction. The table
161+
below summarises their relationship within the Use Case Tree Method.
162+
163+
| Aspect | Composable Business | Reuse Enablement |
164+
| -------------------------- | ------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
165+
| Focus / Orientation | _How business capabilities are composed, orchestrated, and evolved_ | _How knowledge assets and components are packaged and shared_ |
166+
| Primary Question | "How do we assemble business capabilities from reusable parts to adapt to change?" | "How do we design those reusable parts so they can be assembled safely and meaningfully?" |
167+
| Scope | Business and operational level — orchestrating Use Cases, Personas, and Stories into composable outcomes. | Technical and semantic level — creating and governing reusable artifacts: ontologies, datasets, shapes, workflows, data products, and Stories. |
168+
| Key Mechanism | **Use Case Tree (UCT)** as _the orchestration layer_: composing and aligning modular business capabilities. | **Use Case Tree (UCT)** as _the packaging layer_: publishing reusable components and metadata to the Enterprise Knowledge Graph (EKG) for discovery and re-use. |
169+
| Relationship to the EKG | The EKG provides the shared semantics and service interfaces that make cross-use-case orchestration possible. | The EKG provides the shared identifiers, ontologies, and provenance that make reuse safe and traceable. |
170+
| Value Proposition | Agility and adaptability: the ability to reconfigure the enterprise dynamically in response to change. | Efficiency and consistency: the ability to reduce duplication and accelerate delivery through reusable, versioned components. |
171+
| Primary Users | Business and solution architects; transformation leads. | Data and knowledge engineers; ontology and platform teams. |
172+
| Outcome | Composable business capabilities and adaptive workflows. | Reusable semantic components and data products. |
173+
| Relationship to Each Other | Composable business **depends on** reuse. Without reusable components, there is nothing to compose. | Reuse **finds purpose** in composability. Without higher-level composition, reuse is just technical hygiene. |
174174

175175
!!! tip "Two sides of the same semantic coin"
176176

@@ -191,11 +191,11 @@ The table below summarises their relationship within the Use Case Tree Method.
191191
2. **Publish via the UCT:** register components as packages with clear
192192
ownership, metadata, and dependency relationships.
193193

194-
3. **Govern for trust:** validate with SHACL, record provenance, enforce
195-
entitlements and lifecycle policies.
194+
3. **Govern for trust:** validate with SHACL, record provenance,
195+
enforce entitlements and lifecycle policies.
196196

197-
4. **Discover and compose:** make all reusable artifacts searchable and
198-
connectable across domains and teams.
197+
4. **Discover and compose:** make all reusable artifacts searchable
198+
and connectable across domains and teams.
199199

200200
5. **Measure reuse:** track adoption, version dependencies, and impact
201201
metrics to sustain continuous improvement.
@@ -211,8 +211,8 @@ The table below summarises their relationship within the Use Case Tree Method.
211211

212212
Reuse Enablement is how the EKG turns knowledge into infrastructure.
213213
By packaging every use case, ontology, and data product as a governed,
214-
discoverable component within the Use Case Tree, the enterprise builds a
215-
foundation for **scalable intelligence and composable business**.
214+
discoverable component within the Use Case Tree, the enterprise builds
215+
a foundation for **scalable intelligence and composable business**.
216216

217-
When reuse becomes second nature, innovation stops reinventing the wheel
218-
— and starts accelerating on shared semantic ground.
217+
When reuse becomes second nature, innovation stops reinventing the
218+
wheel — and starts accelerating on shared semantic ground.

0 commit comments

Comments
 (0)