We’ve created 10 developer commandments after a team discussion about how we could improve our quality of work, ensure consistency and make sure our code meets QA and industry standards. All of us chipped in and shared ideas on what we think could work, what was important for development and what we needed to keep in mind when working on a project together.
It was a big team effort and we were very much interested in hearing thoughts from the most junior members, as well as the most senior - everybody’s ideas counted! Shortly after, our ten commandments of development at Degree 53 were born. We thought it would be interesting to share them in case it’s useful for other teams too.
1. Don't dive in without a plan. Stay calm and think about what you're doing.
This means don’t just start writing code if you don’t know what it’s supposed to do. Similarly, If you’re writing a spec, don’t rush into it before understanding its purpose and what you’re meant to be building.
2. Always document what you are doing and comment your code. Update it when something changes.
You’re not the only person who will be working on the code and someone else might be using it later on when you’re away or have left the business, so they will need to understand why you’ve done certain things. In future, you might not even remember what you were doing while writing the code either. For anyone starting working on an existing code, comments and any notes are crucial in understanding the progress made over the project which can affect the end result.
3. Understand the bigger picture. Get explanations for things you don’t understand.
If you’ve been asked to do something, find out why, as there might be a bigger reason which could affect your course of action and what you might do with this project.
4. Always follow the coding standards. Always keep in mind the flaws of your language/framework.
There are standards for each different language (some general, some D53 specific) to make sure that everyone can understand it and uses the same patterns. It’s important for developers to keeping in mind that some languages will have flaws and you will need to be aware of them so you can avoid.
5. Make good use of source control. Smaller commits are better. Follow Git Flow.
Doing everything in smaller commits instead of bigger chunks helps others to follow what you’re doing. We use Atlassian’s Git Flow definition.
6. Always expect exceptions. Handle them with care. Treat all external services as evil and error-prone. Log your errors with details.
Don’t assume that all code that wasn’t written by you is going to be perfect. It won’t. Expect something to go wrong and don’t let it pass, as something will crash within the project. But when it does, make sure to log it as accurately as you can so everyone is aware of any issues.
7. Always think about performance and efficiency - KISS and DRY.
Remember that the project you’re building might need to run on older devices, so you need to make sure its performance is still good and doesn’t slow down. To address that, we stick to two rules: KISS - keep it simple stupid and DRY - don’t repeat yourself. All the code you write should be as simple as possible so it’s easy to maintain across different devices. If it’s possible to share code, it’s better to do it instead of writing all over again.
8. Unit testing for critical sections is not optional. Always run and test anything you’ve written.
Testing to make sure the code works for a particular function is key and you have to do it for all the important sections. For example, in gambling systems, you need to make sure that money is always calculated correctly as a failure could lead to a huge fine.
9. Code reviews are not optional.
We recommend that any code you write should be checked by someone else on your team. It’s best to have a fresh pair of eyes to look over your work and spot any errors.
10. Don’t suffer in silence. Talk through issues with your team.
It’s pretty self-explanatory - ask for help if you’re struggling with anything, that’s what the team is there for.
These commandments act as a guidance for our team. We’ve printed them on posters and hung them around the office to remind the developers what they should keep in mind when working. We hope this is useful for other developers out there!
We’re currently recruiting for several positions, including developer, technical lead and test analyst roles. Go to our Careers page to find out more!