Seed Projects
The goal of the Machanism project is simple: to create libraries that can work together to build the applications we need.
To achieve this, we start by defining the base entities we’ll work with. These entities form the foundation of the system. The Seed Project serves as a crystallization place for all functionality related to these base entities. It ensures that key workflows, rules, and integrations are organized in one place for reuse and scalability.
Next, we define the main use cases and adapters—the critical workflows and integrations that drive the application. Finally, the project is built to produce reusable artifacts.
Now, this might sound like a plan for creating a regular application, but let me make one thing absolutely clear: it is not. A Seed Project is not a blueprint meant to be cloned when developing your own application.
Instead, the Seed Project provides a set of ready-made libraries and interfaces, designed to give you everything you need to implement your custom functionality and libraries, while ensuring everything is aligned with the core base entities.
With Seed Projects, you’re not starting from scratch—you’re starting with a solid, reusable framework that acts as a crystallization point, paving the way for modular, scalable development.
Project List
| Name | Domain | Program Language |
|---|---|---|
| Macha | e-commerce | java, typescript |
| Machb | e-commerce | typescript |
| Machc | e-commerce | python, typescript |
Project Structure
Core
The Core Project forms the foundational layer of a Machanism Seed Project. It provides the critical building blocks needed for developing reusable and modular components within the ecosystem.
The Core project contains:
- Entities: Represent the domain-specific data and its business rules. These are the key objects that define the structure and behavior of the system.
- Use Case Interactors: Encapsulate the application's business logic, orchestrating workflows by implementing specific use cases. These interactors define how entities should interact in various scenarios.
- Adapters: Provide flexible interfaces for connecting the Core logic to external systems (e.g., APIs, databases, or other external components).
- Base Interfaces: Define reusable and extendable contracts that ensure consistency and compatibility across projects. These interfaces act as a shared foundation for integrating with other layers such as Application and MachaOn projects.
By providing these foundational components, the Core project defines the functional backbone of any Seed Project. It ensures that business logic remains centralized, domain-focused, and agnostic of implementation details, paving the way for scalable and maintainable solutions.
Applications
The Applications Project serves as the customization layer within a Machanism Seed Project. It adapts and tailors the functionality provided by the Core project to meet specific use cases or special requirements.
While the Applications project is designed to be flexible, it often maintains a similar structure to the Core project to ensure compatibility and alignment with the modular framework.
Key aspects of an Applications project include:
- Customization: Provides specific implementations or adjustments to the Core’s base entities, use case interactors, and adapters, tailored to unique workflows or environments.
- Configuration: Includes settings and logic for adapting the Core functionality to deployment-specific requirements such as region-specific rules, API variations, or unique infrastructure needs.
- Specialized Logic: Goes beyond the general-purpose Core logic to address specialized scenarios without altering the Core framework, ensuring that the system remains modular and scalable.
The Applications project acts as the bridge between the Core and the real-world use cases, embedding customization while maintaining the modular and reusable nature of the broader Machanism ecosystem. This separation ensures that specialized functionality is cleanly isolated from the shared Core logic, preserving maintainability and flexibility.
MachaOn
The MachaOn Project is the final step in the Machanism ecosystem. It serves as the build and deployment layer, integrating components from Core and Applications projects and preparing them for operational use.
Key characteristics of MachaOn projects include:
- Integration: Combines reusable libraries from Core and Applications projects, assembling them into a fully-functional application.
- Additional Implementation: Offers opportunities to develop new features or extend existing functionality for deployment-specific needs.
- Blueprint and Reference Implementation: Serves as a reference project or a template for creating customized customer projects. It provides a practical example of how Core and Applications bricks can be composed, making it easier for teams to build tailored solutions.
- Multiple Variants: In a Seed Project, there can be multiple MachaOn Projects, each representing a unique final configuration designed to meet specific requirements or deployment scenarios.
MachaOn projects are essential for delivering a complete, deployable system. They ensure all modular components are seamlessly integrated and fully operational, allowing developers to adapt and customize for various use cases while maintaining consistency with the Machanism philosophy of Divide and Use.
How to work with a seed project
Working with a Seed Project is a fundamental part of the Machanism ecosystem, and understanding its workflow and purpose is essential to use it effectively.
A Seed Project is not a traditional application template or blueprint—it is a framework designed to build modular, reusable components, or 'bricks', aligned with the base entities, use cases, and adapters defined in the Core library. Acting as a crystallization point for functionality related to base entities, it provides ready-made libraries and interfaces to guide the development of reusable modules. The primary goal of a Seed Project is to enable you to create and extend your own functionality and develop separate libraries based on these reusable components.
Instead of cloning a Seed Project to build an application, you reference it to develop separate libraries. These libraries rely on the base entities and interfaces provided by the Seed Project to ensure compatibility within the broader Machanism ecosystem. For instance, you can define workflows using libraries from the Seed Project that align seamlessly with the Core framework, ensuring consistent logic and smooth integration with other bricks.
Testing is a critical step in this process. To validate your libraries, use a customized MachaOn Project. This specialized project enables you to compose your library alongside other required libraries from the Seed Project and test their compatibility and functionality in a controlled environment. The MachaOn Project integrates all the essential modular bricks, ensuring your library performs as expected and aligns with the larger ecosystem.
Once development and testing are complete, the final step is to build and publish your libraries as artifacts in the artifact repository. This ensures:
- Reusability of your libraries across multiple projects.
- Version control for smooth updates and compatibility with other artifacts.
- Loosely coupled components that maintain independence while being a part of the larger ecosystem.
Here are the key steps for leveraging Seed Projects effectively:
- Do not clone the Seed Project—it’s not meant to be an application blueprint.
- Treat the Seed Project as a reference framework to build and test new functionality.
- Develop separate libraries using a modular approach and connect them via artifact dependencies, avoiding direct coupling or relative paths.
- Use a customized MachaOn Project to combine your library with essential libraries from the Seed Project for robust testing and validation.
- Publish your artifacts to the artifact repository, making them available as dependencies for other libraries and applications.
By following this workflow, you unlock the full power of Seed Projects, creating scalable, modular, and reusable solutions in alignment with the Machanism philosophy: Divide and Use.