Frequently Asked Questions

Dennis Forge introduces a different way of thinking about code transformations. Instead of executing changes blindly, Dennis generates deterministic plans that can be inspected, exported, signed, verified, and applied safely. Dennis follows a simple principle: plans first, changes come later after reviewing.

General

What problem does Dennis solve?

Large code transformations are risky. Traditional scripts or codemods often modify files immediately, making it difficult to review what will actually change. Dennis solves this by generating a deterministic transformation plan before any modification happens.

The plan becomes the source of truth. You can review it, edit it, export it, sign it, and only then apply it.

Is Dennis a refactoring tool?

Not exactly. Dennis is better described as a transformation planning engine. It helps you define and apply large structured changes across a codebase.

What does "deterministic" mean?

Deterministic means that the same input always produces the same output. Given the same codebase and dictionary, Dennis will generate exactly the same plan.

This guarantees reproducibility and makes plans safe to review, store, and share.

Why the name "Dennis Forge"?

The name reflects the philosophy behind the tool.

A forge is a place where things are crafted carefully, through deliberate steps and visible processes. Nothing happens by accident, and nothing is hidden.

Dennis follows the same idea. Instead of modifying code blindly, it generates transformation plans that can be inspected, reviewed, and executed intentionally.

The name Dennis is also a quiet homage to Dennis Ritchie, co-creator of the C programming language and one of the foundational engineers of modern computing.

Ritchie’s work emphasized simplicity, clarity, and tools that give programmers control rather than hiding complexity behind abstraction. Dennis tries to follow that same spirit.

Dennis does not change your code automatically. It helps you shape change deliberately.

DEX Artifacts

What is a DEX artifact?

DEX stands for Dennis Export Artifact.

It is a portable package containing a transformation plan, metadata, and optional cryptographic signatures.

DEX artifacts allow teams to share transformation plans safely between machines or environments.

What is inside a DEX file?

Internally a DEX file is a deterministic tar.gz archive containing:

Can I inspect a DEX artifact manually?

Yes. DEX files are intentionally transparent. You can rename them to .tar.gz and inspect them with standard tools.

Security & Trust

Why does Dennis support signatures?

Signatures allow teams to verify that a transformation plan has not been altered. A signed artifact can be validated before execution.

What cryptography does Dennis use?

Dennis uses the Ed25519 signature scheme through PyNaCl. This algorithm is widely used and provides strong security with small keys.

What happens if a signature is invalid?

Dennis checks the authoritative signature (the most recent one).

If that signature fails but a previous signature is still valid, Dennis warns the user and recommends re-signing the artifact.

Can signatures be replaced?

No. Signatures are append-only. Historical signatures remain part of the artifact to preserve provenance.

Why should I trust Dennis with my life's work?

You shouldn't blindly trust Dennis. Dennis is designed so that you don't have to.

Every transformation Dennis performs is based on a deterministic plan that you can inspect before execution. Nothing happens automatically or behind the scenes.

Plans are human-readable JSON documents. You can review them manually, export them, edit them, store them in Git, or discard them entirely.

When packaged as a DEX artifact, the plan can also be cryptographically signed and verified before it is applied.

This means that Dennis does not ask for trust. It provides transparency, reproducibility, and verification mechanisms so that trust can be built through inspection.

If you can see the plan, you control the change.

Dennis does not modify your code until you explicitly tell it to. The plan is always the source of truth.

What prevents Dennis from corrupting my codebase?

Dennis does not modify your code immediately. Every change is first expressed as a deterministic plan that can be reviewed before execution.

The plan lists every file, line, and transformation that will occur. If something looks incorrect, you can edit or discard the plan before any modification happens.

Because the plan is the source of truth, changes are predictable and reproducible. Nothing is executed implicitly.

In addition, plans can generate inverse operations, allowing transformations to be reversed if necessary.

Is Dennis deterministic across machines? Does it require an internet connection?

Yes. Dennis is designed to produce deterministic results across machines. Given the same codebase and dictionary, Dennis will generate the same transformation plan.

Dennis also runs entirely locally. The CLI does not require an internet connection or any external service in order to scan projects, generate plans, or apply transformations.

This makes Dennis suitable for restricted environments, air-gapped systems, and teams that prefer to keep their source code fully under their control.

Plans and DEX artifacts are portable, so they can be stored in Git, shared between machines, or reviewed offline.

Dennis never transmits your source code anywhere unless you explicitly choose to export or share an artifact.

Workflow

What does a typical Dennis workflow look like?

            scan → plan → dex → sign → verify → apply

This workflow ensures that transformations remain inspectable and reversible.

Do I need the web interface?

No. Dennis is CLI-first. Everything can be done locally using the command line.

Can Dennis undo changes?

Yes. Dennis plans are reversible by design. Inverse plans can be generated to undo transformations.

Open Source

Is Dennis open source?

Yes. Dennis is released under the MIT license. The CLI and core engine will always remain open.

Will Dennis become a SaaS?

Possibly. A hosted forge may exist in the future for collaboration and artifact sharing, but the deterministic core will remain open source.

Can I self-host Dennis?

Yes. The CLI runs locally and does not require any external service.

Why not just use a regex script or sed?

For small changes, a quick script may be enough. However, large transformations across many files quickly become difficult to audit and maintain.

Traditional scripts execute immediately and often provide little visibility into what will change beforehand.

Dennis separates the planning stage from the execution stage. You can generate a transformation plan, inspect it, modify it, and only then apply it.

This approach reduces risk when working with large or critical codebases.

Future Development

Will Dennis support other languages?

The current version focuses on Python workflows, but the architecture is designed to support additional language scanners in the future.

Will plugins be supported?

Future versions may support scanner plugins for different ecosystems such as PHP, JavaScript, or React.

Is Dennis stable?

Dennis is evolving, but the artifact format and deterministic principles are designed to remain stable over time.

Philosophy

“An archive is not merely a place where truths are stored. It is a machine built so that tomorrow may still trust yesterday.”

Dennis exists to make large code transformations safer, clearer, and more accountable.