Adopt Git and CI's in your company

Objectives of the case study

  • Implement a versioning control solution to ensure the efficiency and reliability of applications with a large number of source code files.
  • Propose automated tools for compiling and executing tests on all software projects to generate reports.
  • Obtain the best quality of software contributing to maintaining the stable versions without being harmed, using agile methodologies.

Case Study Public

  • Companies with or without a development team
  • Banks
  • Governmental institutions

Introduction

Git tools are a good ally for managing software projects involving a team of 2 or more people. Manage versions not only applies to new software but for applications that are already being used and require an update.

On the other hand, we have the tools of CI, these have a specific objective, to make tests constantly on the code that is working, throwing reports on failures that can arise before uploading or updating an application.

Many times when this type of tool is not taken into consideration, this can happen:

  • A lot of time is wasted recovering source code that has already been executed.
  • One by one code tests should be performed.
  • The software is left inoperative during an update.

To optimize the performance and availability of an application it is important to manage these types of processes that will help you adopt a smarter and faster process.

What do we know about Git?

Git: is a version control system that allows better management of the project. The version control system records changes made to a file or set of files over time.

Types of version control systems.

  • Local: Lives on the computer. If some failure occurs to the equipment we are going to lose all the work, also that the combination of keys Ctrl + Z of the computer has certain limitations.
  • Centralized: It depends on a super server where the repository is stored if the server is burned, like in a local system all the work is lost.
  • Distributed (Git): Each participant of the repository has a local copy of it and the work of the rest of the team is not affected. The work is not lost if our computer is damaged, the copy that resided in it is lost locally and we can recover a copy of it on the server where it is stored.

Good practices Each developer or development team can use Git in whatever way they see fit. However, a good practice is the following, using 4 types of branches: Master (principal), Development, Features, and Hotfix (patches).

  • Master: It's the main branch. It contains the repository that is published in production, so it must always be stable.
  • Development: It's a branch taken from Master. It is the integration branch, all new functionalities must be integrated into this branch. After the integration is done and the errors are corrected (if there are any), that is to say, that the branch is stable, you can make a merge of development on the Master branch.
  • Features: Each new functionality must be performed on a new branch, specific to that functionality. These must be taken from Development. Once the functionality is developed, a merge of the branch is made on Development, where it will be integrated with the other functionalities.
  • Hotfix: They are software errors that arise in production, so they must be fixed and published urgently. That is why they are branches taken from the Master. Once the error has been corrected, the branch must be unified on Master. In the end, so that it is not out of date, the unification of the Master on Development must be carried out.

What do we know about CI?

Continuous Integration is a software development practice in which members of an agile team integrate their work frequently, usually, each person is integrated at least once a day, leading to multiple integrations per day.

Each integration is verified by an automated construction (including testing) to detect integration errors as quickly as possible.

Many teams find that this approach leads to a significant reduction in integration problems and allows a team to develop cohesive software more quickly.

This eliminates the headaches produced by the integrated compilation process when managing your builds for you. It is designed to constantly monitor all your source code and automatically start integrating your compilations one by one.

Using platforms like Jenkins, Hudson, CruiseControl or TeamCity and Bamboo.

  • Monitor your code for changes
  • Runs a build if the code has changed
  • Compile and deploy your application.

Project development

These projects begin with a study or consultancy of the capabilities of incorporating tools of this type to a work team, taking into account all the aspects that may arise as a slow adaptation to these methodologies, the lack of knowledge of the tickets to create a testing request, or not using the tool.

Usually, this consultancy is a step from the beginning of the project and do not have such repercussions, other than to import all your projects to the tool to use. To make all the improvements from the new platform.

Also, we want everything that is going to be done from now on to be of benefit to the team and saves them time by executing the tasks as they should be.

Short-term/long-term advantages.

After implementing these types of solutions, there will be an impact on the agility in which a project is done. So much so that we can say that when you finish your team will be:

  • Improves the quality of the Code
  • Faster and easier error detection
  • Reduces repetitive and manual tasks
  • You can create trial versions at any time
  • Greater trust and security of the work team:
  • Collaborative work.
  • Upload multiple files in a very large project
  • Easy code sharing.

Conclusion.

Implement Git and CI in your projects will help them to improve in different aspects, if you have not done it you will have realized long ago that they have small delays in the delivery of their projects, which must be a big headache.

They could get a big advantage over controlling the projects they want to do with a mechanism that will work for many years.