Home
Managing change and releases
Learn how to manage change and release in the product.
Guide to building software on Linux and UNIX
HCL VersionVault build concepts
HCL VersionVault supports makefile based building of software systems and provides a software build environment closely resembling that of the make program.
Overview of the HCL VersionVault build scheme
Learn about the build scheme of VersionVault.

Managing change and releases
Learn how to manage change and release in the product.
- Managing software projects
- Workflow for creating projects
- Workflow for making baselines
- Workflow for recommending baselines
- Guide to building software on Linux and UNIX
  - HCL VersionVault build concepts
    HCL VersionVault supports makefile based building of software systems and provides a software build environment closely resembling that of the make program.
    - Overview of the HCL VersionVault build scheme
      Learn about the build scheme of VersionVault.
      - View context required
        For a build that uses the data in one or more VOBs, the shell or command interpreter from which you invoke clearmake must have a view context.
      - How builds work
        Learn how HCL VersionVault build works.
      - Build reference time and build sessions
        Understand the build reference time and build sessions.
      - Build time environment variables
        Learn about environment variables of build time.
      - Exit status
        clearmake returns a zero exit status if all goal targets are successfully processed.
    - Dependency tracking of MVFS and non-MVFS files
      You can track MVFS and non-MVFS files.
    - Derived objects and configuration records
      When it finishes executing a build script, clearmake records the results, including build audit information, in the form of derived objects and configuration records.
    - Build avoidance
      Learn how clearmake attempts to avoid rebuilding derived objects.
    - Express builds
      Learn features of express builds.
    - Build auditing with clearaudit
      Learn about build auditing with clearaudit.
    - Compatibility with other make programs
      Many make utilities are available in the multiple-architecture, multiple-vendor world of open systems. The HCL VersionVault clearmake program share features with many of them and has some unique features.
    - Parallel building
      clearmake includes support for parallel building (concurrent execution of a set of build scripts on one or most hosts).
    - Building on a non-HCL VersionVault host
      Learn how to build product variants on a non-VersionVault host.
  - Derived objects and configuration records
    Learn about derived objects and configuration records.
  - Pointers on using HCL VersionVault build tools
    Learn how to use VersionVault build tools.
  - Working with DOs and configuration records
    You can perform operations on derived objects and configuration records.
  - clearmake makefiles and BOS files
    The HCL VersionVault build program, clearmake can process makefiles.
  - Using clearmake compatibility modes
    clearmake is designed for compatibility with existing make programs, which minimizes the changes you need to make to your makefiles.
  - Using HCL VersionVault to build C++ programs
    Use clearmake effectively with C++ programs built with various compilers.
  - Using HCL VersionVault build tools with Java
    The build behavior of Java tools causes various problems for clearmake. Understand the problems and some possible solutions to resolve them.
  - Setting up a parallel build
    Learn the process to set up and run builds that use several hosts in the local area network.
  - Building software for multiple platforms
    Learn how to address the challenge of using a single source tree to develop an application for a variety of hardware and software platforms.
  - Setting up a build on a non-VersionVault host
    There is a technique to create configuration records for a build that involves HCL VersionVault data, but is performed on a non-VersionVault host.
- Guide to building software on Windows

Overview of the HCL VersionVault build scheme

Learn about the build scheme of VersionVault.

Developers perform builds, along with all other work related to VersionVault, in views. Typically, developers work in separate, private views. Sometimes, a team shares a single view (for example, during a software integration period).

As described in Developing Software, each view provides a complete environment for building software that includes a particular configuration of source versions and a private work area in which you can modify source files, and use build tools to create object modules, executables, and so on.

As a build environment, each view is partially isolated from other views. Building software in one view never disturbs the work in another view, even another build of the same program at the same time. However, when working in a dynamic view, you can examine and benefit from work done previously in another dynamic view. A new build shares files created by previous builds, when appropriate. This sharing saves the time and disk space involved in building new objects that duplicate existing ones.

You can (but need not) determine what other builds have taken place in a directory, across all dynamic views. VersionVault includes tools for listing and comparing past builds.

The key to this scheme is that the VOBs of the project team constitute a globally accessible repository for files created by builds, in the same way that they provide a repository for the source files that go into builds. A file produced by a software build is a derived object (DO). Associated with each derived object is a configuration record (CR), which clearmake uses during subsequent builds to determine whether the DO can be reused or shared (see the following figure).

build software — Figure 1. Building software with VersionVault: isolation and sharing

For more information on how VersionVault keeps track of the objects produced by software builds, see Dependency tracking of MVFS and non-MVFS files. Additionally, for more information about the mechanism that enables such objects to be shared among views, see Build avoidance.