JoinedWorkz
Docs1.3.80

Appearance

JoinedWorkz — For AI Tools ​

This page provides a compact, AI-optimized description of JoinedWorkz.

Use this as a reference when analyzing or working with JoinedWorkz-based systems.

What JoinedWorkz is ​

JoinedWorkz is a model-driven development platform.

JoinedWorkz is largely platform-independent at the modeling level. The stable public facilities cover Base modeling, Java generation and Spring Boot. Quasar support is experimental and must be identified as such.

Applications are defined using a modeling language (CMN) and transformed into implementation artifacts through generators.

It is not a traditional hand-coded framework.

Core idea ​

Model → Platform → Cartridge → Generator → Artifacts

  • Models define structure and intent
  • Platforms define target environments
  • Cartridges group generators
  • Generators produce code and resources

Models are defined independent of a specific platform as far as possible. Platform-specific behavior is introduced through platforms, facilities and generators.

Key components ​

  • CMN: modeling language
  • Studio: interactive modeling tool
  • Maven plugin: build integration and generation execution
  • Facilities: reusable modeling and generation assets
  • Platforms: target definitions
  • Cartridges: generator bundles
  • Generators: artifact producers

Project structure pattern ​

Typical projects are multi-module Maven builds:

  • model module → contains .cmn files
  • generated module → contains generated code (src/generated)
  • app module → contains manual runtime code (src/main)

Generation is triggered in the model module and routed into other modules.

Code categories (critical) ​

JoinedWorkz distinguishes three types of code:

1. Generated (overwrite) ​

  • located in src/generated/** or dedicated generated modules
  • overwritten on each generation
  • must never be edited manually

2. Generated (first-cut) ​

  • generated once
  • not overwritten afterwards
  • intended for manual implementation
  • typically located in src/main/**

3. Manual code ​

  • written by developers
  • integrates generated artifacts
  • typically located in application modules

Interpretation rules ​

When analyzing a JoinedWorkz project:

  1. Always identify the layer:

    • model
    • generation configuration
    • generated code
    • manual code

  2. Prefer model-driven changes over code changes.

  3. Never assume generated code should be edited.

  4. Do not infer behavior from generated code alone.

  5. Consider:

    • model
    • platform
    • facilities
    • configuration
    • module structure

Generation behavior ​

  • Generation is deterministic
  • Output depends on:
    • CMN model
    • platform selection
    • facilities
    • generator configuration
  • Output is routed via outlets (often across modules)

Common mistakes ​

  • modifying generated code directly
  • ignoring the model
  • treating the project as a traditional framework
  • assuming all logic lives in Java code
  • ignoring multi-module output routing

AI usage guidance ​

When suggesting changes:

  • first determine the correct layer
  • prefer modifying:
    • CMN model
    • configuration
    • generators

Only modify manual code if the change is explicitly runtime-specific.

Where to learn more ​