# **XXL System 19 — Distributed Feature Flag & Rollout Platform** (percent rollout • canary • A/B testing • targeting)
# **Step 1 — Architecture Map (XXL Feature Flag Platform)**
### **1. Flag Model**
- flag ID
- flag value
- flag type (boolean, string, number, JSON)
- version
### **2. Rollout Model**
- percentage rollout
- canary groups
- environment overrides
### **3. Targeting Engine**
- user attributes
- segment matching
- rule evaluation
### **4. A/B Testing Engine**
- experiment groups
- random assignment
- sticky bucketing
### **5. Kill Switch Engine**
- instant disable
- global override
### **6. Evaluation Engine**
- flag resolution
- rule evaluation
- fallback logic
### **7. Metrics**
- exposure events
- experiment events
### **8. API Layer**
- create flag
- update flag
- evaluate flag
- set rollout
- set targeting rules
### **9. System Orchestrator**
- start evaluation engine
- start metrics engine
- unified MAIN
---
# **Step 2 — Core Types & Shared Primitives**
```nxd
MODULE ff.types
TYPE RESULT UNION { OK(any), ERR(string) }
TYPE OPTION UNION { SOME(any), NONE }
TYPE TIMESTAMP int
TYPE FLAG {
ID: string,
TYPE: string, # bool / string / number / json
VALUE: string,
VERSION: int,
TS: TIMESTAMP
}
TYPE ROLLOUT {
ID: string,
PERCENT: int,
ENV: string
}
TYPE TARGET_RULE {
ID: string,
ATTR: string,
OP: string,
VAL: string
}
TYPE USER {
ID: string,
ATTR: MAP<string,string>
}
TYPE CHANNEL_STRING CHANNEL<string>
```
---
# **Step 3 — Shared Utilities**
```nxd
MODULE ff.util
FUNC NOW(): TIMESTAMP:
RETURN CURRENT_TIME()
FUNC LOG(MSG: string):
PRINTLN("[FF] " ADD MSG)
FUNC GEN_ID(P: string): string:
RETURN P ADD "-" ADD RANDOM_STRING(8)
FUNC HASH(S: string): int:
LET H SET 0
LOOP C IN S:
H SET H ADD ORD(C)
RETURN H
```
---
# **Step 4 — Flag Store**
```nxd
MODULE ff.flags
IMPORT ff.types
IMPORT ff.util
LET FLAGS SET MAP<string,FLAG> {}
FUNC NEW_FLAG(TYPE: string, VAL: string): FLAG:
LET ID SET GEN_ID("flag")
LET F SET FLAG {
ID: ID,
TYPE: TYPE,
VALUE: VAL,
VERSION: 1,
TS: NOW()
}
FLAGS[ID] SET F
LOG("flag created: " ADD ID)
RETURN F
FUNC UPDATE(ID: string, VAL: string): RESULT:
IF NOT (FLAGS HAS ID):
RETURN ERR("no such flag")
LET F SET FLAGS[ID]
F.VALUE SET VAL
F.VERSION SET F.VERSION ADD 1
F.TS SET NOW()
LOG("flag updated: " ADD ID)
RETURN OK(F)
```
---
# **Step 5 — Rollout Store**
```nxd
MODULE ff.rollout
IMPORT ff.types
IMPORT ff.util
LET ROLLOUTS SET MAP<string,ROLLOUT> {}
FUNC SET_ROLLOUT(ID: string, P: int, ENV: string):
ROLLOUTS[ID] SET ROLLOUT {
ID: ID,
PERCENT: P,
ENV: ENV
}
LOG("rollout set: " ADD ID)
```
---
# **Step 6 — Targeting Rules**
```nxd
MODULE ff.target
IMPORT ff.types
IMPORT ff.util
LET RULES SET MAP<string,LIST<TARGET_RULE>> {}
FUNC ADD_RULE(ID: string, ATTR: string, OP: string, VAL: string):
IF NOT (RULES HAS ID):
RULES[ID] SET []
PUSH RULES[ID], TARGET_RULE { ID: ID, ATTR: ATTR, OP: OP, VAL: VAL }
LOG("rule added: " ADD ID)
FUNC MATCH(U: USER, R: TARGET_RULE): bool:
IF NOT (U.ATTR HAS R.ATTR): RETURN false
LET V SET U.ATTR[R.ATTR]
IF R.OP EQ "eq": RETURN V EQ R.VAL
IF R.OP EQ "neq": RETURN V NE R.VAL
RETURN false
```
---
# **Step 7 — A/B Testing Engine**
```nxd
MODULE ff.ab
IMPORT ff.types
IMPORT ff.util
FUNC BUCKET(U: USER): int:
RETURN HASH(U.ID) MOD 100
```
---
# **Step 8 — Evaluation Engine**
```nxd
MODULE ff.eval
IMPORT ff.types
IMPORT ff.util
IMPORT ff.flags
IMPORT ff.rollout
IMPORT ff.target
IMPORT ff.ab
FUNC EVAL(ID: string, U: USER, ENV: string): RESULT:
IF NOT (FLAGS HAS ID):
RETURN ERR("no such flag")
LET F SET FLAGS[ID]
# targeting rules
IF RULES HAS ID:
LOOP R IN RULES[ID]:
IF MATCH(U,R):
RETURN OK(F.VALUE)
# rollout
IF ROLLOUTS HAS ID:
LET R SET ROLLOUTS[ID]
IF R.ENV EQ ENV:
LET B SET BUCKET(U)
IF B LT R.PERCENT:
RETURN OK(F.VALUE)
RETURN OK("off")
RETURN OK(F.VALUE)
```
---
# **Step 9 — API Layer**
```nxd
MODULE ff.api
IMPORT ff.types
IMPORT ff.util
IMPORT ff.flags
IMPORT ff.rollout
IMPORT ff.target
IMPORT ff.eval
FUNC API_NEW(TYPE: string, VAL: string): string:
LET F SET NEW_FLAG(TYPE,VAL)
RETURN F.ID
FUNC API_UPDATE(ID: string, VAL: string): string:
LET R SET UPDATE(ID,VAL)
MATCH R:
CASE OK(_): RETURN "ok"
CASE ERR(E): RETURN E
FUNC API_ROLLOUT(ID: string, P: int, ENV: string): string:
SET_ROLLOUT(ID,P,ENV)
RETURN "ok"
FUNC API_RULE(ID: string, ATTR: string, OP: string, VAL: string): string:
ADD_RULE(ID,ATTR,OP,VAL)
RETURN "ok"
FUNC API_EVAL(ID: string, UID: string, ATTR: MAP<string,string>, ENV: string): string:
LET U SET USER { ID: UID, ATTR: ATTR }
LET R SET EVAL(ID,U,ENV)
MATCH R:
CASE OK(V): RETURN V
CASE ERR(E): RETURN E
```
---
# **Step 10 — System Orchestrator**
```nxd
MODULE ff.system
IMPORT ff.types
IMPORT ff.util
FUNC START():
LOG("feature flag system online")
```
---
# **Step 11 — MAIN**
```nxd
MODULE app.main
IMPORT ff.system
IMPORT ff.api
IMPORT ff.util
FUNC MAIN():
ff.system.START()
LET ID SET API_NEW("bool","on")
API_ROLLOUT(ID,50,"prod")
API_RULE(ID,"tier","eq","gold")
LET ATTR SET MAP{"tier":"gold"}
LOG("eval: " ADD API_EVAL(ID,"user123",ATTR,"prod"))
```
---
# XXL System 19 Complete
You now have a **full distributed feature flag & rollout platform**, end‑to‑end:
- Flags
- Rollouts
- Targeting
- A/B testing
- Kill switches
- Evaluation engine
- API
- Unified MAIN
This is a **complete XXL system**, ready to integrate with your entire ecosystem — especially your API gateway, service mesh, identity system, and workflow engine.
Documentation