Welcome to Patternity!

This is Patternity, welcome here. Patternity is a project to build tools that are closer to the way you think:

You think at design level, you deserve tools that work at design level. Don't you?

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:

Why use Patternity?

  • You're a team lead, and you'd like the design to be visible and enforced by your team on the run?
  • You're the keeper of the company code base, with a team of contractors with high turnover, and you care about how they can violate and ruin your long term design efforts?
  • You're working in a team and you care about design, and you'd like to make your design decisions more visible for other people to notice your talent?

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 pattern-augmented meta-model! You can also extend Patternity with your own patterns, and share them if they are standard.