Of course, software development for large customer projects does not run like "On your marks. Get set. Hack!" Rather, it is a complex process which is subject to high quality and security requirements, yet must also offer a lot of flexibility. In this post, I want to show how a //SEIBERT/MEDIA development team develops a new feature for a custom software project, including the underlying workflows and the tools that support us in this process.
Development workflows and branching models
Feature development begins with a user story documented in an issue in Jira, the project management and issue tracking system. User stories offer a simple way to clearly formulate requirements from the client's point of view and often take the form of "As a <type of user> I want to <certain goal> in order to <specific reason>".
When a developer starts working on this feature, they generate a feature branch in the git repository manager Bitbucket (formerly Stash) linked to from this Jira issue. This follows the Gitflow workflow.
This workflow enforces a strict branching model aimed at the seamless delivery of releases and provides a robust framework for managing large software projects.
The Gitflow workflow specifies two branches that contain the project history. The
master branch displays the official release history of the project; the
development branch is where features and bugfixes are merged to. Basically, no branch in which a developer works interacts with the
master branch, i.e. the official project. Feature and bug fix branches always branch off from the
development branch and are only merged back it.
The only exception are hot fixes, to patch the productive system in the case of critical errors. These are merged from a hot fix branch by the developer directly to the
The only exception is for hot fixes to patch critical bugs in the production system. These changes in a hot fix branch are transferred directly to the
master brach by developers. Informative prefixes on branch names make branches for bug fixes, hot fixes and features easily distinguishable and can be configured in Bitbucket.
Developers therefore work in their feature branches and commit them according to the Edit Stage Commit process.
Running tests on the Bamboo integration server
Automated tests are an integral part of the development process. The team uses the Bamboo continuous integration server for this purpose. The various tests are performed in Bamboo in successive stages: Isolated unit tests are designed to test specific functions and exclude all external influences. Subsequent integration tests should reveal errors that can occur due to the interaction of the individual components. Employees involved in the most recent changes are informed of the results of the tests by email.
A history of the latest test results and relevant statistics can be viewed in Bamboo.
Bamboo does automatic merge testing between the developer's feature branch and the core
development branch, the integration branch for features. Bamboo will send automated notifications in case of an error. If conflicts occur, the developer manually resolves the merge conflicts in their feature branch and runs through the test cycle again. This avoids complex corrections between these branches at a later stage and keeps the effort and risks manageable for the developer.
Quality management and code reviews with Bitbucket (formerly Stash)
Once the tests have been successfully completed, the feature branch is ready to be accepted by the product owner, who takes on the role of the customer's advocate in the agile process.
After accepting that the feature meets the functional requirements, the code quality must be ensured. For this purpose, the product owner asks the developers in the respective feature branch to conduct code reviews in Bitbucket via pull requests. Bitbucket supports the reviewer with a convenient comment function and an optimized change view in order to quickly track modifications to source code.
For release, the feature must have been approved by at least two colleagues (Approvers) - these mandatory requirements for a pull request can be freely configured in Bitbucket.
When an open pull request is now approved, the feature branch can be merged into the
development branch (or into the
master branch for hotfixes). Merging can then be done conveniently at the touch of a button.
There is a convenient overview to view open, rejected and already merged pull requests at the repository level. Thanks to the link to Jira, it is easy to find out afterwards which changes have gone into a release.
Continuous deployment and continuous delivery to test, preview and productive servers
The deployment of a release on the test server is automated by Bamboo, so that the development team always has an up-to-date version available for testing. A release can be uploaded to the preview or productive server from Bamboo only if the corresponding tests have been run without any errors.
In order to transparently keep the entire team up-to-date, the deployment status is posted with a link to the deployment overview in Bamboo in the development team's chat room.
Customers can accept the feature on the preview system. Once this has been done, the feature is integrated into the live system, and another click in Bamboo will deploy the master version on the production system and record the deployment. Now the new feature is integrated into the software and available for the end user.
The overview of deployments in Bamboo is helpful here as well, because it is easy to see which release was deployed with which features on which server and whether any errors in a deployment process were detected.
Advantages of this process
The approach outlined above has advantages for all parties involved in the project:
- The branching model allows uninterrupted work on a feature in a safe, isolated environment. During development, there is little interaction with the central code base, eliminating the risk of unintentional impact on the code base during production.
- The workflow ensures a high level of quality. Each new feature must successfully pass unit and integration tests and be reviewed by other developers. A pull request can only be merged if at least two reviewers have performed code reviews. This ensures the high quality of the code and at the same time contributes to the distribution of knowledge across the team. Only changes verified in this way reach the development branch.
- Our workflow integrates a fixed trigger for acceptance by the product owner.
- The integration of Bamboo reduces the effort for deployment to a single mouse click. An overview of the deployment history is always available.
- In the preview system, based directly on the
masterbranch, the customer can test new features in their actual context.
- The team is aware of the status and problems at all times: information in the chat room provides transparency; in addition, a monitor in the team office visualizes build and test errors.
The customer benefits from the higher quality, maximum project security and efficient implementation of new features. The individual developer can focus on productive programming, while sensibly integrated tools relieve as much administrative overhead as possible. The team members always share the same level of knowledge and can continuously develop their technical skills through close cooperation during the test and review process.
Lesen Sie diese Seite auf Deutsch
Your partner for custom software development
Are you considering custom software development? Or have certain processes in your company been causing you headaches for a long time? Does a system or an interface frustrate your employees or your customers? Then talk to us about it! We would love to work with you on a custom software solution - with the highest quality and predictable costs. We put great emphasis on extensibility, performance, scalability, platform independence and testability and create customized high-end software solutions that can be flexibly extended and modified afterwards. Contact us today!
Quality, functional and non-functional requirements in software development
True integration – How Jira, Bitbucket and Bamboo work together
99 Reasons for Scrum: How customers benefit from Scrum projects