AAAMP Elements

AAAMP is a short form for Actor, Asset, Action, Model, Process. FastBuilder derives these from the product story. 

Here is the brief summary:

@ACTOR

The role assigned to human user or doer. This element is created to centralize the system creation around the human user. You can use the @ACTOR variable in the prompts for building the code generator. The actors are stored in database with attributes derived from the @Model.

@ASSET

The information objects like document, file, etc as such that are handled by the user roles are called assets. These assets are stored in database with attributes derived from the @Model.

@ACTION

Simply said, as the name itself says, the action taken by the actor on asset is known as action. These actions are used for defining the methods, API end points and associated data privacy and control mechanism. 

@MODEL

Model is the attribute for an actor or asset. They are used to enumerate or classify the associated actor or assets in various part of the code generator. The @Model variable is used in the code generator and the list is passed as a comma separated array(like in javascript).

@PROCESS

A process is the attribute for action, but not similar to model. The process elements define the granularity of the action and are used to make robust code for the methods, APIs, security and other elements related to the action.

The AAAMP framework—Actor, Asset, Action, Model, and Process—is a structured approach used to derive the components of a system from a product story. Here's an explanation of its features and how each element contributes to building a cohesive system:

1. @ACTOR

• Definition: Refers to the roles assigned to human users or "doers" in the system.
• Feature: The central idea behind defining actors is to ensure the system revolves around the end-user's experience. The roles can range from customers to system administrators.
• Usage: The @ACTOR variable helps identify all human interactions within the system, shaping the design of user interfaces, APIs, and workflows. These actors are stored in the database, with attributes derived from the @Model, specifying detailed characteristics like user permissions or preferences.
• Purpose: To drive the user-centric design, ensuring the system aligns with real user needs and roles.

2. @ASSET

• Definition: Information objects such as documents, files, images, or any data the system handles or processes.
• Feature: These assets are the elements the actors interact with. Defining them clearly allows the system to manage how data is created, accessed, or modified.
• Usage: The @ASSET variable defines these objects within the system's architecture, allowing seamless management of data and resources. The database stores these assets with attributes based on the @Model, which can include metadata like file type, size, ownership, and access rights.
• Purpose: To ensure consistent handling of information, secure data access, and robust resource management.

3. @ACTION

• Definition: Actions are the activities performed by actors on assets.
• Feature: Each action represents an interaction between the user (actor) and the system's resources (assets). Examples include reading, editing, or deleting a file, submitting a form, etc.
• Usage: In the code generator, @ACTION variables define the methods or API endpoints, linking them with proper data control and privacy mechanisms. This ensures that user actions are consistently tracked, controlled, and authorized.
• Purpose: To create an efficient and secure way to perform user-initiated activities, driving functionality like workflows, permissions, and audit trails.

4. @MODEL

• Definition: Represents the attributes that define actors and assets.
• Feature: Models act as the schema or blueprint for defining both actors and assets, specifying their structure and behavior.
• Usage: The @Model variable serves as a classification mechanism for actors and assets. The attributes are passed as comma-separated arrays (e.g., in JavaScript), helping in the generation of consistent data models and business logic across the system.
• Purpose: To ensure that actors and assets are systematically categorized and handled with consistency, making code generation and management easier.

5. @PROCESS

• Definition: The process refers to the granularity of actions and how they are executed.
• Feature: Unlike models, processes break down actions into detailed steps, ensuring a more granular and secure system design.
• Usage: @PROCESS variables help in generating robust code for methods, APIs, security policies, and workflow automation. By breaking down actions into processes, the system can fine-tune permissions, security measures, and response mechanisms.
• Purpose: To provide the necessary detail for accurate and secure execution of actions, allowing complex systems to function with higher control and precision.

Overall Features of AAAMP:

• Human-centered design: Emphasizes building systems around users (actors), ensuring a user-friendly experience.
• Consistent Data Management: By clearly defining assets and actions, the system can handle data efficiently, securely, and consistently.
• Automated Code Generation: The structure of AAAMP allows for streamlined code generation, improving development speed and consistency.
• Security and Control: With actions tied to actors and processes, privacy and data security can be effectively managed and enforced.
• Granularity and Scalability: Processes enable detailed control over system behavior, making the system scalable and adaptable to complex requirements.

In summary, AAAMP provides a comprehensive framework to design, manage, and automate the system's workflow, focusing on actors, their actions, and the information (assets) they interact with, all while maintaining a strong emphasis on security and process-driven development.

Next: Promptset Basics