TAG

Tag - GitLab Games

About Tag - GitLab Games

At GitLab Games, we understand the power of tags. They are the essential metadata that brings order to the chaos of game development, allowing for efficient organization, seamless collaboration, and ultimately, faster iterations. Tags, in the context of our game development efforts hosted on GitLab, act as labels, keywords, or identifiers associated with various aspects of a project. These aspects could range from code commits and issues to merge requests and even individual game assets. By leveraging the tagging system effectively, we can unlock a new level of project management and efficiency that significantly impacts our development workflow.

The Purpose of Tags in GitLab Games

Tags serve multiple vital functions within our GitLab-based game development environment. Firstly, they provide a robust system for categorization. Imagine a vast repository of code, assets, and documentation. Without a coherent tagging strategy, navigating and finding specific resources would be an overwhelming task. Tags allow us to classify items based on type, function, priority, or any other relevant characteristic, making it simple to pinpoint the required information. For example, we can use tags to differentiate between artwork assets created for different levels, gameplay mechanics, or character designs. This level of granularity enables targeted searches and filters, streamlining our workflows.

Secondly, tags facilitate effective issue tracking and resolution. When reporting bugs or requesting features, we use tags to provide additional context and categorize the issue according to its severity, area of impact, or the specific developer assigned to resolve it. This helps to prioritize issues, manage workload distribution, and ultimately resolve problems more efficiently. For instance, an issue related to character animation might be tagged with "animation," "character," and "high-priority" to ensure it receives immediate attention from the appropriate team members.

Thirdly, tags are instrumental in version control and release management. We use tags to mark specific commits representing stable releases or significant milestones. This allows us to easily revert to previous versions, track changes between releases, and provide clear benchmarks for future development. We consistently utilize tags to denote pre-alpha, alpha, beta, and release candidate builds, allowing our team and stakeholders to quickly identify the current state of the game.

Implementing a Strategic Tagging System

For tags to truly shine, it's essential to implement a well-defined and consistently applied tagging system. This involves establishing clear guidelines for naming conventions, tag usage, and overall structure. Here's our approach:

• Define a Controlled Vocabulary: We create a predetermined list of acceptable tags for common categories such as asset type, feature area, and priority level. This ensures consistency and prevents tag proliferation. For instance, if we're tagging audio assets, we might limit the choices to "music," "sound effect," "voiceover," etc.
• Establish Naming Conventions: We adhere to specific naming conventions to avoid ambiguity. For example, we might use lowercase letters, underscores to separate words, and prefixes to indicate the category of the tag (e.g., "asset_character," "bug_critical"). Consistency is critical for filtering and searching effectively.
• Enforce Tag Usage: We require all team members to consistently apply tags to commits, issues, merge requests, and assets. Automated checks and linting tools can help to enforce these guidelines. We integrated pre-commit hooks that alert developers if required tags are missing.
• Document the System: We create a comprehensive document outlining our tagging system, including naming conventions, usage guidelines, and a list of approved tags. This document serves as a central reference point for all team members and ensures that everyone is on the same page. We have a dedicated section in our internal wiki that details all tag-related procedures.

Practical Examples of Tag Usage in GitLab Games

Let's explore some practical examples of how we leverage tags within our game development projects:

1. Asset Management: We tag 3D models with "asset_3d," textures with "asset_texture," and audio files with "asset_audio," along with additional tags indicating their purpose (e.g., "asset_3d_character," "asset_texture_environment"). This allows us to quickly locate specific types of assets within our massive asset library.
2. Bug Reporting: We tag bug reports with "bug," along with tags indicating the severity (e.g., "bug_critical," "bug_minor"), the area of impact (e.g., "bug_gameplay," "bug_ui"), and the assignee (e.g., "bug_assigned_john"). This provides a clear overview of the bug landscape and allows us to prioritize and track bug fixes effectively.
3. Feature Development: We tag feature requests with "feature," along with tags indicating the status (e.g., "feature_planned," "feature_in_progress," "feature_completed"), the priority (e.g., "feature_high," "feature_medium," "feature_low"), and the area of impact (e.g., "feature_combat," "feature_inventory"). This helps us manage the feature backlog, track progress, and prioritize feature development based on strategic goals.
4. Release Management: We tag commits representing stable releases with "release," along with the version number (e.g., "release_1.0," "release_1.1"). This allows us to easily revert to previous versions, track changes between releases, and provide clear benchmarks for future development. Furthermore, we add tags indicating the target platform ("release_pc", "release_mobile").

Advanced Tagging Techniques

Beyond the basics, we also employ some advanced tagging techniques to further enhance our development workflow:

• Hierarchical Tagging: We use a hierarchical tagging system to create a more granular and organized structure. For example, we might use "asset" as a top-level tag, with sub-tags like "asset:3d," "asset:texture," and "asset:audio." This allows us to perform broader searches while maintaining a high level of specificity. We can easily find all assets with "asset" or limit the search to 3D models with "asset:3d."
• Tag Aliases: We define tag aliases to simplify the tagging process and reduce the risk of errors. For example, we might create an alias for "critical_bug" that automatically applies the tags "bug" and "severity_critical." This streamlines the tagging workflow and ensures consistency across the team.
• Automated Tagging: We automate the tagging process using scripts and tools. For example, we might automatically tag commits that include specific keywords or file types with the appropriate tags. This reduces the manual effort required for tagging and ensures that tags are applied consistently. We have automated scripts that automatically tag new assets based on their file extension and directory location.

The Benefits of Effective Tag Management

By embracing a strategic and well-managed tagging system, we reap numerous benefits, including:

• Improved Organization: A clear and consistent tagging system creates a well-organized and easily navigable repository, saving time and effort in finding the resources you need.
• Enhanced Collaboration: Shared understanding and consistent application of tags promote seamless collaboration and communication among team members.
• Increased Efficiency: Faster searches, streamlined issue tracking, and automated processes all contribute to increased efficiency and productivity.
• Better Version Control: Clear tagging of releases and milestones simplifies version control and makes it easier to track changes and revert to previous states.
• Data-Driven Insights: Tag data can be analyzed to gain valuable insights into project progress, bug trends, and resource allocation.

Tagging and GitLab CI/CD

We also leverage tags within our GitLab CI/CD pipelines. This allows us to trigger specific build and deployment processes based on the presence of certain tags. For example, we can configure our pipeline to automatically deploy a new release to our staging environment when a commit is tagged with "release_staging." This automation significantly streamlines our deployment process and reduces the risk of errors. Our CI/CD configuration files are meticulously crafted to recognize specific tag patterns and execute corresponding actions, guaranteeing a reliable and controlled deployment process.

Conclusion

In conclusion, tags are not merely cosmetic labels; they are the foundational building blocks of efficient game development within GitLab Games. A well-designed and consistently applied tagging system can unlock a wealth of benefits, from improved organization and enhanced collaboration to increased efficiency and better version control. By embracing a strategic approach to tag management, we can transform our GitLab repository into a well-oiled machine, empowering our team to focus on what matters most: creating amazing games. We continue to refine our tagging strategies to keep pace with our growing project complexities. We recognize that the power of tags lies in their adaptability and consistency.