# Getting Started

This repository is a very small Java codebase with a lightweight documentation layer under `.codewiki/`. The source currently centers on three top-level classes — `Mixed`, `PatternA`, and `PatternB` — so the fastest way to understand it is to read the source directly and compare the classes side by side.

## What This Project Does

At a glance, this codebase looks like a compact example project for comparing implementation patterns and data-mapping styles in Java. There is no obvious framework layer or deep module hierarchy, which suggests the important behavior lives in a few simple classes rather than in infrastructure.

## Recommended Reading Order

1. [`overview.md`](../overview.md) — start with the repository summary to get the intended framing.
2. [`Mixed`](../../src/main/java/Mixed.java) — read the main coordinating class first.
3. [`PatternA`](../../src/main/java/PatternA.java) and [`PatternB`](../../src/main/java/PatternB.java) — compare the two supporting patterns or variants.
4. Revisit [`Mixed`](../../src/main/java/Mixed.java) after reading the supporting classes to understand how the pieces relate.

## Key Entry Points

These are the first classes to understand:

- [`Mixed`](../../src/main/java/Mixed.java) — the simplest place to start if you want the project’s central behavior.
- [`PatternA`](../../src/main/java/PatternA.java) — a focused example of one pattern or configuration style.
- [`PatternB`](../../src/main/java/PatternB.java) — a second pattern-oriented example, useful for comparison with `PatternA`.

## Project Structure

The repository is intentionally flat:

- `.codewiki/` contains the generated wiki pages and repository overview.
- `src/main/java/` contains the Java source files.
- There are no nested packages or additional subsystems visible in the current tree.

```mermaid
flowchart TD
  WikiRoot[".codewiki/"]
  SourceRoot["src/main/java/"]
  MixedClass["Mixed.java"]
  PatternAClass["PatternA.java"]
  PatternBClass["PatternB.java"]

  WikiRoot --> SourceRoot
  SourceRoot --> MixedClass
  SourceRoot --> PatternAClass
  SourceRoot --> PatternBClass
```

## Configuration

There is no obvious application-level configuration in the current tree. The main things to know are:

- `.codewiki/tree.json` controls the generated wiki structure.
- `.codewiki/overview.md` is the repository overview page.
- The Java files themselves currently contain only class-level fields and comments, so behavior appears to be encoded directly in source rather than driven by config.

If new runtime settings are added later, look first for project-level files at the repository root and then for constants or field maps inside the Java classes.

## Common Patterns

A few conventions stand out from the current source:

- **Small, single-purpose classes.** Each Java file is short and easy to scan.
- **Field-driven representation.** `PatternB` uses a `FIELD_MAP` constant, which suggests table-like or metadata-driven modeling.
- **Inline comments for meaning.** The code uses short comments to explain field intent, including some non-English annotations.
- **Minimal abstraction.** There are no visible interfaces, inheritance layers, or framework annotations, so the code is likely meant to stay straightforward.

## Best First Steps

If you are joining the team, do this in order:

1. Read the repository overview in [`overview.md`](../overview.md).
2. Open [`Mixed`](../../src/main/java/Mixed.java) and identify the main data it owns.
3. Compare [`PatternA`](../../src/main/java/PatternA.java) and [`PatternB`](../../src/main/java/PatternB.java) to understand the project’s two example styles.
4. Check `.codewiki/tree.json` whenever you need to confirm how the documentation is organized.

That should be enough to orient yourself before making changes or adding new code.