Velan Studios Velan Studios Blog

How We Write Code

Chris McEvoy — May 1, 2017

The programmers at Velan write a fair amount of code. Recently we have been thinking about how we write code, and what we want our code to look like. After some discussion, we have distilled our thinking down to three high level points:

  1. We want our code to be Changeable.
  2. We want to always be Learning.
  3. We want to take Ownership.

Changeable Code

Changeable code is rooted in the idea that no code we write will be perfect, nor do we want it to be (because perfection is context-specific and the context is always changing). Code should be written assuming it will be added to, subtracted from, modified, and deleted.

This does not mean we just write poor quality code as fast as possible. Writing changeable code requires good judgement, clean architecture, and constant attention.

  • Changeable code looks like other changeable code and follows common patterns.
  • Changeable code is appropriately complex and solves actual problems. In other words, a good ratio of essential to accidental complexity.
  • Changeable code names things well.
  • Changeable code is written in an environment that balances costs and benefits of mandatory process and policy.
  • Changeable code is well tested, giving us the confidence to change.
  • Changeable code minimizes dependencies.
  • Changeable code aims to be accessible to all Velan programmers, no artificial boundaries or overreliance on domain expertise.

Learning

Our studio values the unconventional and the curious. Both require constant learning.

  • When we think about the systems we write, we look outside our studio and our field.
  • We revisit fundamentals of the systems we use.
  • We stay current.
  • We seek feedback.

Ownership

Write enough code, and some code can be neglected. Accumulating hacks and workarounds, passed between programmers, the clarity of its original purpose lost, the code has become ownerless. It is not enough that code is changeable, we must actually change it. We believe this derives from a sense of ownership.

The concept of ownership applies to external code we use as well. In order to feel comfortable using some external code we must:

  1. In most cases, have the expertise to write code we are using (but perhaps not the time.) This leads us to the second point.
  2. Understand the code we are using. Often this understanding comes from having the expertise. Regardless, if we are to use an external piece of code, we must understand it.
  3. Take responsibility for making it better. All code has to change.

Viper

At Velan, we have a two-pronged technology strategy:

  1. Start with Unreal Engine 4. Among full-featured, modern game engines, we believe that UE4 is most changeable out-of-the-box.
  2. Over time create a collection of internal technologies we call Viper. Viper technology is standalone from UE4.

We believe this approach gives us the best opportunity to create systems that align with our values, and to make the kind of games we want to make.

We have already been working on Viper for several months now. As we create systems that we think could potentially be useful to the wider community, we will be releasing them to the community under an MIT license and announcing it on this blog.

So keep an eye out! Until next time.

You can reach the technology team at Velan by emailing viper@velanstudios.com.