Wherever possible, the B&T process should use industry-standard tools, and their associated standard conventions.
The e2e process should be sufficiently well documented that handover of support and maintenance from one B&T engineer to another should be relatively straightforward.
The process should be able to routinely produce functioning, self-contained packages for all supported platforms.
The process should allow for the easy inclusion of new, additionally supported platforms.
The CASA team shall use an industry-standard issue tracking system to track progress on bugs, new feature requests, etc.
The issue tracking system should support various standard fields and established (good practice) CASA workflows. These include ticket number, the addition of ticket watchers, a configurable ticket state workflow, relative prioritization, sub-tasks, etc.
The issue tracking system should support a plug-in infrastructure that can be leveraged by the other components of the B&T toolchain
Code Commits & Version Control
All code commits will be managed via an industry-standard Version Control System (VCS).
It should be simple for a developer to roll back any change committed to a previous version.
The commit history should be readily available to the CASA development team, in an automated report form.
It should be possible for developers and user testers to easily determine if any given code commit has been included in any given published package.
There should be one established build process used in the production of all packages.
A single unified codebase should be used for routine user (tester)-facing CASA builds. Temporary development branches, etc. are acceptable (and sometimes necessary), but circumstances such as the NRAO/Google Code casacore bifurcation should be avoided.
It should be possible to build CASA in one disk storage location, move it to another and the package should still function.
Code merging between branches should be a straightforward process, and should never be a cause for delays in the deployment of standard CASA packages.
Regular (e.g. nightly) package builds should be run and deployed automatically in both Charlottesville and Socorro. These should ideally be clean end-to-end builds, and also be accessible to developers in Europe, Japan, etc.
As CASAs internal architecture permits, it should be possible to build the various components/modules of CASA individually.
The build process should automatically generate summary reports on the progress and success/failure of the build. These reports should be available to all members of the development team.
The build process should automatically generate reports summarizing the contents of each package built. These reports should be easily accessible to all CASA developers and user testers.
In the event that a build is broken, the system should be able to give clear indications as to the cause of the build failure, and automatically notify the appropriate individual.
When appropriate, a code commit intended to specifically address a particular tracked issue should trigger a notification to the involved parties (e.g. the developer and user tester) that the committed code is now available for use/testing in a given CASA package. This notification process should end when the issue been resolved.
The build system should natively support the use of a standardized package version numbering scheme.
A standard suite of automated unit tests, integration tests and system regression tests will be automatically run on all routine automated builds (as time permits).
Unit tests will be provided by developers using a common framework as an integral part of the CASA development process.
Andy Hales testing group will be responsible for converting CASA Guides examples into automated regression tests, but these shall be run routinely as part of the B&T Group work.
The distinction between test, stable, pre-release and release-level packages should be established on the basis of a given package passing a set of standardized hurdles, based on increasingly-stringent requirements for passing tests.
All developer machines should have shared access to a standard library of realistic test data for development and automated testing purposes. Whenever possible, these test data should be representative of real science data.
Where possible, automated testing of GUI components should be conducted using industry-standard tools prior to human user testing.
In general, automated unit and integration testing should focus on verification. Regression testing and (human user) acceptance testing should focus on validation.
The testing regime should be designed in such a way that human user testing is naturally the final stage of testing.
The actual mechanism for producing CASA packages should be a standardized and clearly-documented process.
Clear policies, procedures and a timeline requirement should be established for handling requests for changes to included third party packages.
A standard process for documenting third party package changes should be implemented. (This might be addressed by appropriate VCS usage).
The packaging process should facilitate the early detection of any dependency issues and (ideally) aid in addressing them.
The packaging process should be able to generate packages for one/several/all supported platforms on request.
All packages generated by the new process should be as portable as realistically possible.
All packages produced should be built primarily for end-user environments. Any in-house idiosyncrasies (e.g. NRAO Managed Software deployment systems) should be regarded as special cases.
The process by which CASA packages are published should be automated, ideally in accordance with standard industry practices and tools. Ideally, this should ultimately normally be a pushbutton or entirely automated process.
The process by which CASA packages are published should support a simple and immediate process for version roll-back.
The process by which CASA packages are publicly published should conform to the IT security requirements of all NRAO and associated sites.
The computer systems used for routine CASA package builds should be powerful enough to support a continuous build strategy. At the very least, they should be able to provide automated builds on a frequent, agreed-upon cadence (e.g. nightly).
There should be a sufficient number of computer systems available that are capable of running the necessary standard test suites described above, ideally on a similar cadence to that of the automated routine builds.
There must be sufficient availability of CASA developer computers that the project is not delayed due to a lack of available developer hardware.
Suitable hardware with appropriate OS versions for all currently-supported versions of CASA should be available to developers.
Additional development, build and test hardware should be made available on an as-needed basis, whenever CASA support for additional platforms is advertised.
Other (Additional documentation, Pipeline, ATCA/SA/other considerations, other things I havent thought of )
The system design should not preclude the future introduction of code review tools to the CASA development workflow.
In-line documentation should be regarded as an integral part of the CASA package, and retained in version control along with the associated code.