JoinedWorkz

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.

It can be used with different target stacks, including Java/Spring Boot and frontend technologies such as Vue.js or Angular.

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 ​