Libraries
Libraries are specialized projects that serve as reusable containers for resources that can be shared across multiple applications.
Unlike regular applications, which are intended for creating and managing specific workflows, libraries are designed to house common elements—like processes, enumerations, and media assets—that other applications may rely upon.
This makes libraries a cornerstone for establishing consistency and efficiency across various projects.
Key features
-
Resource Sharing:
- Libraries facilitate the reuse of resources like processes, enumerations, and media assets across different applications. This allows for a more modular design, where commonly used elements are stored centrally.
- Resources in a library can be included in other applications by setting the library as a dependency.
-
Dependencies:
- An application can add a library as a dependency, meaning it will have access to the resources stored in that library.
- Dependencies are managed through builds; each application can choose a specific version (build) of a library to depend on. This ensures that updates in the library do not automatically impact all applications unless intended.
-
Versioning:
- Just like applications, libraries can be versioned. Each version of a library captures the state of its resources at a specific point in time.
- This versioning allows applications to lock dependencies to specific library versions, providing stability and predictability during runtime.
Managing libraries
-
Creating a Library:
- Libraries can be created similarly to applications. The creation process involves setting a name, defining the resources it will contain, and managing its configuration settings.
- Once created, resources can be added to the library incrementally, allowing for iterative development.
-
Managing Library Resources:
- Users can create, edit, delete, or version resources within the library. Resources include processes, enumerations, media files, and other elements that can be referenced by applications.
- A library can have multiple versions, each capturing the resource state. This allows backward compatibility with older application builds relying on specific library versions.
-
Adding Library Dependencies to Applications:
- In the application workspace, libraries can be set as dependencies under the Dependencies section.
- Users can select which build version of the library to reference. This allows applications to control how library changes affect them by choosing to update the dependency to newer library builds as needed.
Libraries can be added as a depedency only to Work-In-Progress (WIP) application versions.
Library build process
- Builds in Libraries are tagged versions, allowing a snapshot of the current library resources to be used by applications. Each build in a library captures the state of all its resources.
- Applications referencing a library can specify the exact build to use, ensuring that changes to the library do not inadvertently impact dependent applications.
Use cases
-
Centralized Resource Management:
- Organizations that need to maintain a standard set of processes or other resources can use libraries to store these centrally. Each application can then use the same library resources, ensuring consistency.
-
Version-Controlled Dependency Management:
- By utilizing builds and versioning within libraries, applications can safely depend on specific versions, reducing the risk of unexpected behavior due to resource updates.
-
Streamlining Updates Across Applications:
- When an update is required across multiple applications that rely on the same resources, it can be done by updating the library and releasing a new build. Each application can then choose to update to the new build when ready.
Best practices
- Use libraries for resources that need to be standardized across multiple applications.
- Carefully manage dependencies and choose specific builds to avoid unexpected runtime behavior.
- Leverage versioning to maintain a clear history of resource changes, allowing rollbacks if necessary.
Libraries thus play a crucial role in modularizing the development process, enabling reusable and maintainable components across different applications. This leads to improved project organization, reduced redundancy, and simplified resource management.
FAQs
Was this page helpful?