Your company is about to embark on a new project. Everyone seems excited by the idea, and you’re ready to start fleshing out the details.
However, a few important decisions should be made before the project is set in motion.
How should you share information? Which version control system is suitable for the project? How will you manage technical debt?
It’s a good idea to answer these questions beforehand so that later you don’t find yourself scrambling to figure them out.
Let’s dive in!
Table of Contents
Automate information sharing
When many developers work together on a project, it goes without saying they should be able to exchange information effortlessly in order to be effective.
However, in practice, sharing information is an aspect of doing business that employees struggle with the most.
Let’s put it into perspective. If you’re a software developer, it’s like you are working for 2-3 hours every day without actually getting any work done.
But how can you avoid this?
Bug and crash reporting tool for your mobile app.
The best way is to harness the power of automation.
There are many ways to automate sharing information, but one of the most effective is to use a project management tool that integrates with other applications.
This way, you can automatically receive notifications about events in Jira from these applications and take action on them instantly.
For example, you can use it to integrate Jira with Slack so that whenever a new issue is created in Jira, or an existing issue is updated, a message about this event will be posted on your Slack channel and vice versa.
For example, at Content Snare, a company that helps businesses collect content from clients, they use Zapier to automate their information sharing between Jira and Slack on a daily basis—with great results.
Establish proper version control
A version control system is an important part of being able to work on a software project with other developers.
In a nutshell, its purpose is to keep track of who made what change and when it was done.
As such, it allows multiple developers to work on the same code at the same time without losing their own changes, or worse, accidentally overwriting someone else’s.
Rachel Jia, a marketing manager at Dynamsoft, explains that it’s essential for a team to be able to commit changes, revert to previous milestones (in case something goes wrong), review comments from other developers, and access the latest version.
However, before choosing a version control system for your team, let’s take a look at the three types available, so that you can make an informed decision.
A local version control system is a program that runs on your own computer and allows you to create multiple versions of files, store them locally on your hard drive or network, and later access them.
While it might seem like a good idea to keep your project on your computer or local network, this method can make it harder for others to access the project.
On the other hand, a centralized version control system is the opposite.
It involves a centralized repository that all team members have access to and can commit changes from their computers by pushing them up to the server.
However, it requires a remote server that can handle the load of all the different versions of files being committed at once.
Still, centralized version control is the most common type and is used by many companies.
Finally, there’s distributed version control, which is a hybrid of the other two.
It involves multiple repositories hosted on different remote servers and accessed by developers through a network.
This type of version control allows users to work on their own local copy of the project while still being able to access changes made by other developers.
Changes in a file are highlighted, with what was available in the original document shown in red and the new text displayed as green.
This allows you to easily revert back to an older version if something goes wrong or if you need to see how the file was changed.
No matter which type of version control system you choose, it will ensure that your team is well-equipped to manage the project and keep it on track.
Make sure responsibilities are clearly defined
If you want to get a new product or feature out the door quickly, it’s very important to ensure that responsibilities are assigned, and that team members understand what they’re expected to do.
First, you need to make sure that everyone understands their role.
“Software development teams are not just developers and a CTO–they can be defined as tight knots of various skills crucial for a given phase of a project, possessed by various specialists.”
Here is a picture that depicts what kind of roles are usually present in a software development team:
Each role has its own set of responsibilities that are vital to the project’s success.
That basically means that if you have software developers who are writing code, they shouldn’t also be expected to be testing it.
Those are separate responsibilities with their own skills requirements.
Once the roles are defined, and developers know their responsibilities, it becomes easier to determine the tasks that need to be done.
The most efficient way to achieve this is with a project management tool, and, luckily, a myriad of such tools are available.
For example, Trello is an excellent choice as it enables developers to create product roadmaps, define tasks for specific developers, and set due dates.
Then, all you have to do is review the results and make sure everything is on track.
By making sure responsibilities are clearly established, you’ll be able to better manage your team members and provide them with the support they need to successfully complete the project.
Define coding standards
Telling a developer that they need to follow a coding standard may sound like needless bureaucracy, but it can be a lifesaver when it comes to maintaining a software project.
Without it, the codebase can become a confusing mess, and it can be much harder to add features or make changes in the future.
Essentially, he likens it to a situation where writers write in both contemporary English and Early Modern English at the same time—which would be impossible for most people to comprehend.
The same principle applies to code. If developers don’t have a standard that they can follow, it can be difficult to understand what is going on in the codebase.
This can lead to bugs, crashes, and other problems that make it more time-consuming and costly for developers to maintain the project.
Coding rules usually address the following points:
- Naming conventions
- Formatting and indentation
- Commenting and documenting
- Classes and functions
Naming conventions, for instance, specify how variables and constants are declared.
An example of a piece of code that follows the coding conventions is shown below, followed by another that does not.
It’s clear from this example that just a simple convention like this one can make a big difference in keeping the code readable and maintainable.
However, defining coding standards may seem like quite an undertaking at first.
Luckily, you don’t have to create them from scratch, as there are plenty of resources available online that you and your team can use as a reference.
You can draw inspiration from one of these coding standards, adopt some parts of it or come up with something completely new.
The most important thing is that you and your team agree on the conventions and follow them consistently.
Invest in DevOps
The concept of DevOps is extremely attractive to the software industry because it suggests a way to eliminate the wall between software developers and IT operations.
The concept is based on viewing software as a continuous delivery pipeline, and it means that every change to the code base is automated and tested before it’s deployed into production.
This process is illustrated in the image below.
As you can imagine, this is a much more efficient way of building software than the traditional model, where developers would write code and then hand it over to IT operations for deployment.
It also has a number of other benefits, including fast time-to-market for new features and eliminating the silos between developers and IT operation teams—as the chart below clearly depicts.
Moreover, Patrick Debois, the man widely credited with launching the DevOps movement, says that the biggest benefit of DevOps is that it compels companies to “optimize for the whole system.” According to him, this ultimately helps them improve their overall productivity.
Given all these benefits, it’s no surprise that a Stack Overflow survey has found that 80% of respondents believe DevOps is at least somewhat important to their organization, and 44% think it is extremely important.
It’s clear that DevOps is here to stay. In fact, software development teams who don’t embrace the movement risk being left behind.
However, there is no magic formula for becoming a DevOps team, and the path to success is not always straightforward.
At first, implementing that approach may require some heavy changes to your team structure, processes, projects, and culture.
But once it’s up and running, the benefits will far outweigh the costs.
Prevent technical debt buildup
Technical debt is a metaphor for the consequences of fixing a piece of software when it becomes necessary.
This isn’t always a bad thing since sometimes there just isn’t time to make the change, or perhaps it’s an improvement that isn’t really needed right away.
The problem is that when there is too much accumulated debt, the code becomes unmanageable and difficult to work with.
The image above illustrates the principle of technical debt in action—the more you ignore it, the harder it will be to implement new features.
Over time, just like with financial debt, the burden of increasing interest accumulates.
Any software development company that’s been in business for a while has accrued some technical debt—it’s unavoidable.
But, you need to be aware of how much you have and how much your individual projects are contributing to the total.
When you start approaching critical mass, you should make changes and adjustments to address the situation.
Therefore, in order to avoid technical debt buildup, it’s important to monitor your team’s progress and ensure that you have a plan in place for addressing issues as they arise.
There are also tools that can offer you a helping hand, such as SonarQube, SonarGraph, and Klockwork, that can identify areas where refactoring or improvements are needed, as well as provide suggestions on how to resolve those issues.
Another tool that can come in handy when it comes to fixing bugs is our very own software, Shake.
Shake is a mobile app testing tool that makes it easier to catch bugs in your apps and improve their quality.
All you need to do is shake your phone while the app is running, and it will take a screenshot along with some other metadata that indicates why something went wrong.
This will contribute to the reduction of technical debt by providing you with a clear, visual record of the steps that lead to a bug.
Remember, technical debt is a common problem that affects all software projects.
However, by taking care of your code on time, you can avoid building up too much technical debt while still delivering new features quickly.
If you want the best possible outcome for your project, there’s no getting around it—you need to collaborate properly during the development phase.
In order to do so, you first have to meet certain prerequisites—such as clearly defining responsibilities, defining coding standards, investing in DevOps, and managing technical debt.