DEV Community: Assembla

Reducing crunch and burnout in Game Dev with... DevOps

Claudia Fernandes — Thu, 28 Sep 2023 16:54:35 +0000

As the conversation around crunch and burnout in game development continues, and studios struggle to find enough devs and artists, DevOps can be a valuable tool for improving workflows.

What does DevOps look like in Game Dev?

DevOps in game development typically takes advantage of cloud storage and computing to improve communication and collaboration among team members. It can also involve Test-Driven Development (TDD) to speed up iteration and improve development cycles. DevOps practices can be leveraged to create repeatable processes for game launches, updates, and patches.

The Benefits of DevOps for Game Devs

Increased efficiency through automation: Game DevOps automation can be implemented across a wide range of areas, from process workflows to automated builds and deployment. Source code management solutions provide automated security and increased performance, and allow for easy roll-back to previous versions.
Improved project management: In a DevOps environment, developers and producers work together to break work down into smaller and more manageable chunks, improve regression testing, create emergency contingency plans, and a host of other methods to improve productivity and eliminate waste. Using a suite of reporting and task management tools gives project managers valuable insights into their teams, and real-time progression tracking through UIs that visualize task schedules can help managers improve workflows.
Better scaling and less overhead: In a DevOps environment, developers can quickly respond to changes in scale and adjust accordingly. Particularly for teams leveraging hosted DevOps tools, this gives smaller studios a head start with tools that can easily scale as the team grows. While an on-prem or dedicated cloud instance requires a significant resource investment, leveraging tools like cloud-based Perforce VCS allows teams to stay lean and agile.

Transitioning to DevOps

An effective transition to DevOps requires a clear understanding of your team's current needs and long-term goals. Another consideration is flexibility and support for extensions and integrations. Every studio and project is unique, so being able to choose the tools and practices that best apply to your current goals, with the ability to adapt as your needs evolve, is very powerful.

Archiving Files in Perforce (Archive Typemap)

Claudia Fernandes — Thu, 14 Sep 2023 12:11:45 +0000

First, why you should archive files in Perforce

The archive functionality in Perforce improves storage efficiency, streamlines backups, reduces network traffic, improves overall performance, space management, and scalability. These benefits contribute to a more streamlined and optimized version control workflow for development teams (usually gamedev teams).

How the Archive Typemap works

It allows you to store older or infrequently accessed versions of files in a compressed format, which reduces the storage footprint on your server and improves overall system performance. Only the most recent and actively used files remain readily accessible, while archived files are stored separately.

Most importantly, you can streamline a workflow by archiving files; you can exclude them from regular backups and focus on critical data. This reduces backup time, storage requirements, and associated costs. Archiving also enables you to restore specific files or versions as needed without restoring the entire repository.

How it improves system performance

Let’s say you have files that are not accessed frequently. Archiving large files or binary assets that are not frequently accessed can significantly reduce network traffic. This way, when you sync your workspaces or update your local copies, Perforce retrieves only the necessary files, resulting in faster sync times and reduced bandwidth consumption.

It’s worth noting that the archive feature helps improve overall system performance by reducing the size of the repository. Smaller repositories result in faster operations such as syncing, branching, merging, and searching, mainly when dealing with large codebases or projects with extensive histories.

Use it to manage disk space

Archiving files helps you better manage disk space on your server. Whether you're using Perforce in the cloud or on-prem, removing older versions or less frequently used files from the active repository frees up space for new development work and ongoing projects. This allows you to maintain a well-organized and efficient version control environment.

Final thoughts

More changelists, history, this means as your projects and repositories grow over time, archiving becomes even more valuable. It enables you to accommodate increasing file sizes and handle expanding codebases without compromising system performance or overwhelming storage capacity.

Bugs in Agile Development

Claudia Fernandes — Wed, 13 Sep 2023 13:32:05 +0000

If you're using agile methodologies, it’s likely that:

You're a CTO, Development Manager, or Senior Developer, and
You spend a majority of your time actually managing your development team’s workflow

Today, I'll share four ways that software teams can adapt current agile practices to make bug resolution easier and faster.

Allocate time in sprints for fixing errors and prevent bug overwhelm

If a development team pushes code into production and relies on tests and a QA processes before deployment, it could be falling on your customers to find and report problems they encounter.

Unfortunately independent research found that only 1% of users actually report issues.

The best thing we can do to prevent revenue loss from errors is to have processes in place to both find and respond to errors before users even notice. How do most companies achieve this?

Rigorous testing before deployment is certainly one of the best ways to maintain a company culture of producing quality code at all times.

Buggy software means customers are having a poor experience – and as team leaders it’s our job to make sure that doesn’t happen.

We can make the process a little easier by using our agile processes together with a continuous deployment strategy. For example, our friends at Raygun, discovered that “when a team gets locked into a sprint it can become much harder to recognize and fix bugs”.

We actively avoid locking all but the lowest priority errors into sprints – rather we have time set aside inside our sprints to allow us to find errors and fix them on the spot. This way, it doesn’t affect our sprint work, and issues get addressed as soon as they come up, rather than waiting for an end user to find them.

The most important takeaway is to always keep your code deployable. By always keeping your master branch matching your production code, you can fix a bug and deploy knowing that other ongoing fixes and features aren’t creeping into a bug fix deployment.

Improve communication between support and dev teams to keep customer relations strong

Errors do slip through the cracks. Understanding how best to manage these errors and the customers who become affected is an important part of the error handling process.

It’s not always easy for developers to replicate issues for customers so they can be fixed quickly. So sometimes errors do get lost in communication.

This is especially true for last minute fixes and changes. When we ‘tweak’ code, inadvertently introducing errors becomes much more likely. Especially when there are strict deadlines to be met.

Keeping your whole team looking at the bigger picture (from coding right through to how the user is experiencing the software) helps the dev team communicate with support so they can get information to customers quickly and effortlessly.

Get as much contextual information on errors as possible for faster fixes

In agile methodology, traditionally bugs may appear on issue tracker backlogs or within your agile management tool as tickets/tasks.

When tickets get assigned, the error can remain unsolved until deeper diagnostics on the issue are discovered.

Getting full contextual information on an error is extremely difficult unless you have crash and error reporting software.

Hands down, this is the biggest time saver and the best way to resolve errors in your current agile methodology.

Most crash and error reporting software will pull extremely detailed information on location and damage caused by errors that slip through the testing process. Using a tool like Assembla to deliver that information to a team member cuts the time in the communication process.

If you have allocated time in your sprint to errors rather than locking in fixes, there’s still hard work to be done by your team. However, having the correct tools in your toolkit will greatly improve.

Prioritize fixes (without leaving out the non critical bugs)

Because of the flexible nature of agile practices, lots of small, last minute changes can be introduced into a developer’s workflow.

This usually means two things:

Common bugs make repeat appearances (meaning minor recurring bugs get through the cracks);
Bug fixes can become stagnant under high priority tasks.

Unfortunately, recurring bugs and ‘minor’ fixes are still affecting end users – someone is still getting a poor experience of your application.

Staying on top of the errors inside your agile workflow is critical – which comes back round to practicing test driven development.

Every bug is a chance to build a test. If you find a bug, write a test! This prevents recurring bugs and keeps the culture of producing quality code in your team strong.