As embedded systems become increasingly complex and incorporate new features and components with each generation, it is no longer possible for teams of two or three engineers to meet their demanding design schedules.
Large software development teams are required whose members may be spread throughout several buildings or sites, and coordinating source code from all of these individuals becomes difficult to manage, especially if the system is an incremental delivery.
Instead of spending their time writing application code, developers can find themselves overwhelmed by the overhead to track even simple changes to program code and product requirements across a team.
Development teams can automate much of the complexity of tracking code changes in a systematic manner through the use of a Version Control System.
Integrating version control functionality within the software development environment makes it possible for an organization to regulate even the most complex build processes in an orderly manner and ensure timely deployment to market.
The intricate dependencies within an embedded system can be difficult to predict and anticipate. For example, a simple code change can cause an unexpected failure in another, seemingly unrelated part of the system. Alternatively, a new function may not be completed in time for the current release.
In each of these cases, developers need to have the ability to rollback changes. A VCS makes this possible by taking a “snapshot” of the code base every time a new build is made. All current and previous versions of code source files are available in the VCS’s database, enabling developers to restore the system to a stable version quickly and easily.
Coordination of Code
A VCS is invaluable when coordinating source code changes among members of a project. For example, several developers may be working on the same section of code simultaneously.
Whenever one of them checks in changes to the code, the VCS will not only merge the changes with what other team members have previously submitted but also alert each developer involved to approve or deny the suggested merging of code.
This level of coordination makes a developer’s job easier and more efficient by preventing multiple changes to the same code from arbitrarily overwriting each other.
When modifying code, developers actually work with a local copy of the source code files for the system saved to their hard drive. The VCS can optionally alert developers when a new version of code has been checked in by another team member.
In addition, the VCS can automatically synchronize these changes with local copies of source code so that developers can be assured they are working with the most up-to-date version of the system at all times.
Freedom to Experiment
The ability to rollback code gives developers complete flexibility to test different approaches to solving a problem, improving performance, or adding a new feature.
Because developers can always revert back to a stable version of the code if an approach doesn’t work out as planned, there is no risk in exploring a potentially powerful but unproven idea.
Given that software is where most of a system’s functionality is implemented and often represents the single most expensive component of a system, it is critical that program code be backed up regularly.
When code is managed by individuals and spread across multiple systems, it is difficult to ensure that the proper procedures are in place to ensure that all pertinent files are backed up in the case of equipment failure or environmental disaster.
A VCS simplifies system backup by collecting one of a company’s most critical assets – its code base –in a central repository. Disaster recovery becomes a matter of restoring the VCS and its database to recover all of the functionality the system had before the disaster occurred.
Depending upon an organization’s budget and need to mitigate risk, the use of a VCS can preclude the need to back up individual developer’s computers since their work is effectively always backed up.
Good Programming Practices
The review and approval features of a VCS introduce peer review and oversight into the design process. By making developers aware of changes to key components on which their own code depends, each team member can evaluate and verify the impact to their modules before the system enters the testing phase, thereby avoiding time-consuming troubleshooting of problems that are otherwise easily recognized and addressed.
This process has the additional benefit of encouraging developers to focus on writing better and cleaner code since they know it will be reviewed by their fellow team members. In this way, a VCS shortens product time-to-market by promoting and supporting better development practices.
In addition to tracking all successful changes, a VCS can manage changes which either didn’t work or are for features whose implementation has been delayed. This allows developers to come back to uncompleted work at a later date without having to begin again from scratch.
Version Control Software implements these features in the most intuitive way when it is integrated directly into the development environment. Rather than have to manage code using a separate tool, version control can be managed within the same tool suite used for writing, compiling, and debugging code.
Once a development team has their chosen VCS client installed on all development machines, (e.g. Tortoise for Subversion), each team member can easily connect to the VCS server from the Project-Version Control System menu.
From this menu, developers can access VCS features, including checking code in and out from the repository, as well as synchronize the local project with the latest files from the server.
As embedded system design continues to become more complex, companies need larger design teams to meet tighter design schedules. Rather than let the challenge of source code management reduce individual developer efficiency, Version Control Software integrated into the development environment automates systematic tracking of code changes and system requirements.By extending full version control of code to developers, a VCS facilitates the rapid flow of ideas and changes across a team to shorten test-and-fix cycles and significantly speed time-to-market.
Shawn Prestridge has served as IAR Systems Senior Field Applications Engineer since 2008. Shawn’s degree work includes a BS in Electrical Engineering, a BS in Mathematics, an MS in Electrical Engineering, an MS in Software Engineering and a PhD in Electrical Engineering specializing in Quantum Cryptography, all with Southern Methodist University in Dallas.>/i>