Developers tools that work at design level

As a developer you care about design. Patternity is a tool to help at design level, not just code level.

Tools that understand design can help better

With Patternity, check dependencies implied by your design decisions, make these decision visible in the code and in the Javadoc, and generate meaningful diagrams.

Enlarge your tools

Many kinds of tools can be enhanced by making them able to manipulate all the patterns in your code.

Here is a list of features that could be enhanced if they had access to the design model in your head, which in practice is represented by a meta-model that includes your patterns:

• Automatic diagrams (à la UMLGraph), where patterns can help a lot in choosing what to show and what to hide in a given diagram: for example a diagram could focus on every Aggregate within a domain, and nothing else
• Enforce dependencies (à la JDepend) between modules or even between single-classes, as many patterns clearly define which participant knows or ignores each other: a proxy knows its subject, not the other way round
• Static analysis with class-specific expectations (à la Checkstyle): patterns provide useful hints on what particular qualities matter or not for each design element: for example, Value Objects and Services are very different animals.
• And more (Javadoc, Dependency Injection etc.) and even yet to imagine...

Join the Patternity project!

Patternity is a new open-source project (Apache license v2) to build tools that are closer to the way you think (this means closer to the design level, where's your talent really is). The core of Patternity is a meta-model augmented with patterns to enable various tools to work at a higher level, at the design level.

You can contribute in several ways:

• Join the google group and give feedback (really appreciated)
• Build or adapt tools to exploit the augmented meta-model
• For one or several standard patterns, contribute configurations for one or several tools, once for all, for other to reuse

Why use Patternity?

• Though you care, you want to be sure you did not introduce dependencies by mistake
• You don't want to spend time drawing UML diagrams (they take forever to layout), but you'd still like to see some high-level picture of the structure
• You're a team lead, and you'd like the design to be visible for everyone?
• You want better visibility on the company code base, and you care about how someone can violate and ruin your design efforts?

Patternity can help you!

Just declare your design intents and decision in the code, using plain annotations (with source time retention if you don't want additional runtime dependencies). With just annotations, the design is made explicit: nobody can ignore it or pretend to ignore it. And because the design can evolve, annotations naturally evolve as well in the course of the refactorings.

But Patternity tools can do more, based on your declarations. Run an existing tool, or even build your own tool on top of the meta-model! You can also extend Patternity with your own patterns, and share them.