8 key points to master and optimize your software’s lifecycle. [Part 2/3]

In my last article, I have introduced you to the first two key points to master and optimize your software lifecycle. 

?? The definition of clear guidelines will help you to lead the project forward in a more carefree way, and avoid the setbacks. Involving the team in the process will make it more efficient!

?? To handle the client’s demands, you can use a centralized system, which will allow you to reference and classify them, as well as appoint the right people to treat them!

The next three key points are central to lead the project to the end and ensure a good understanding of the customer needs.

3. Leave the needs mature

Before beginning to develop a solution, you need to make sure the customer’s needs are well-understood. This will require exchanges between both parts to highlight the downside.

1. Approve a solution with the client.

This is the final goal of the dialog with the customer: you have to work side by side to guarantee the client will be pleased by the solution.

Few ways, from the more to the less efficient, are available:

?? Meetings face to face with the client to clarify the needs.

?? Phone calls, when meetings are not possible.

?? Tickets exchanges, thanks to the centralized system.

The solution should be written by the supplier and approved by the client. This way, you ensure your answer meets the client’s conditions and needs.

?? Rely on the labels, you can identify which tickets have been validated by the client and are ready to be developed.

At the end of the maturation phase, you should have identified the functional and technical requirements, as well as the test scenarios.

2. Approximated the workload

It is highly recommended asking the team to approximate the workload necessary for each ticket. This assessment can take into account the time or the number of points to:

?? Get acquainted with the subject,

?? Follow training courses on new technologies (when identified),

?? Set up the work environment,

?? Code the solution,

?? Add unitary tests on the code developed,

?? Update the user, as well as technical documentation,

?? Execute test launch during the development,

?? Write specifications and test’s scenarios,

?? Transmit knowledge, in the case the ticket is a mean to train a recruit. 

Depending on the project, you can also estimate some time or points for unexpected risks, calculated in proportion of the global workload.

?? Points are a way to estimate a task in Agile methodology. The harder the task is, the higher the point gets. Using point instead of price or person-day helps to plan the sprints and releases. It also highlights the fact that those points are just an estimation.

4. Write and capitalize your solution’s requirement in a specification file

This step is often forgotten, yet its aim is important: writing what does, does not and should be doing the software will help you during the development.

?? Some examples of questions you might have regarding your software:

?? How do we know that the bug seen by the client really is one?

?? How do I answer the question “What should be happening if I click on this button?”?

?? How to analyze the impacts of a new development demand on the existing functionalities?

If you have not centralized and maintained up to date those requirements, it will be difficult and time-consuming to answer all those basic questions following the software changes. Every time your software evolves, the specifications should be updated, validated and used as a new reference.

?? If you have the abilities, you can edit a full specification’s file, with all the models created, traceability and rules of each job. Do not worry, even a simple file would reveal itself very helpful! You can use Markdown or AsciiDoc to begin with.

5. Develop the solution

Finally, the core of the subject!

1. Use a system to handle the releases

For your team work to be efficient and manage without incidents your releases, you must work with a system that handles the releases. 

??  For my part, I recommend Git with Gitlab You can set up workflows via branches, with merge requests and approvals to ensure the efficiency and safety of your development.

2. Identify, implement, and use a development infrastructure

The developer must possess an adapted environment to carry out the solutions.

If your product is composed of 3 units – backend, frontend, and database – you need to build an infrastructure adapted, in order to avoid too much dependency between the units.

There is no universal solution, but there is an optimal answer for your team and project configuration.

3. Set up Continuous Integration (CI) to produce in a performant and safe way

During a software development, the developer needs, at least, to make sure that the code:

?? Does not devalue the existing solution,

?? Can be tested via routines (jobs, Unit test, Non-regression…),

?? Contains enough documentation,

?? Was tested before being shared to his team’s mate,

?? Answer functional and nonfunctional requirements.

All the previous points should be mentioned in your guidelines, and automatically implemented through Continuous Integration.

Those treatments (also called jobs) should be executed near to the developer, if possible, on his environment but also on an integrated environment shared by the team.

?? Working this way, we can check as soon as possible that the safety and validation steps were handled properly!

?? Those 3 key points require methodology and investment from the team but will facilitate the whole project. In the next article, I will write about the three last key points, ensuring a full and complete software lifecycle. See you next week!