YaM provides a framework and supporting toolkit for the rapid and concurrent development of software.

While smooth, rapid, concurrent development is a much sought-after dream of software development, it is rarely achieved in practice and is certainly not for the faint-hearted. This failure stems from the lack of a framework and methodology to handle the significant challenges of rapid concurrent development. These issues are further compounded when the goal is to not simply develop software but to develop reusable software to support a software "product-line". These challenges which go well beyond the scope of traditional configuration management and include:

Instability:

By its very nature, the s/w development process involves immature code and fast and iterative changes. This mix in the context of concurrent development can cause developers to break each others' code, causing frustration and a breakdown of the development process.

Monolithic code:

Multiple s/w configurations are needed to support multi-platform, testbed, subsystem, debugging etc. development needs, but are rarely supported adequately because of the focus on the final delivered product. This lack of s/w configurability creates a drag on the development process with developers left to fend for their own day to day development needs.

Scaffolding cost:

Typically, individual developments focus on specific areas of the overall code at any given time. However, the remainder code is needed as scaffolding to support this development. As the size of the code grows, the scaffolding setup and maintenance can add significant cost and slow down the development pace, and can also lead to a forking of the development process with expensive sync up costs. As a consequence one typically ends up with code development that is time consuming, expensive, and with an end-product of marginal quality that is tuned to the specific project needs with little inherent reusability.

Modules serve as the units which can be used to assemble new systems (packages), build scaffolding, reuse across multiple systems (configurability), expand by adding new pieces (modules) and so on. The key components of YaM which include the CVS source repository, a module release area, and user sandboxes.

All development software is organized into a collection of "modules". YaM "packages" are defined as sub-collections of the available modules. Developers can set up private sandboxes for module/package development. All module/package development takes place on private CVS branches. High level YaM commands support the setup, update and release of modules and packages. Released and pre-built versions of modules are available to developers. Developers can tailor the source/link module mix for their sandboxes so that new sandboxes (even large ones) can be built up easily and quickly by pointing to pre-existing module releases. All inter-module interfaces are publicly exported via links. A minimal, but uniform, convention is used for building modules.

YaM is written in Perl and is organized as a set of utilities on top of the public domain CVS software version control package.

Key design elements of YaM are:

• YaM is written in Perl and is organized as a set of utilities on top of the public domain CVS software version control package.
• All development software is organized into a collection of "modules".
• YaM "packages" are defined as sub-collections of the available modules.
• Developers can set up private sandboxes for module/package development.
• All module/package development takes place on private CVS branches. High level YaM commands support the setup, update and release of modules and packages.
• Released and pre-built versions of modules are available to developers.
• Developers can tailor the source/link module mix for their sandboxes so that new sandboxes (even large ones) can be built up easily and quickly by pointing to pre-existing module releases.
• All inter-module interfaces are publicly exported via links.
• A minimal, but uniform, convention is used for building modules.

Problems being solved:

• By its very nature, the s/w development process involves immature code and fast and iterative changes. This mix in the context of concurrent development can cause developers to break each others' code, causing frustration and instability in the development process.
• Typically, individual developments focus on specific areas of the overall code at any given time. However, the remainder code is needed as scaffolding to support this development. As the size of the code grows, the scaffolding setup and maintenance can add significant cost and slow down the development pace, and can at times lead to a forking of the development process with expensive sync up costs.
• Multiple s/w configurations are needed to support multi-platform, testbed, subsystem, debugging etc. development needs, but are rarely supported adequately because of the focus on the final delivered product. This lack of s/w configurability creates a drag on the development process with developers left to fend for their own day to day development configurations.

Advantages:

• The use of private CVS branches allows the isolated development of immature code and helps avoid premature interactions and instability. YaM provides a higher level layer to simplify the use of branches and hides messy details from the user. The main trunk is used for releases while branches are used for development. YaM's simple interface to the management of branches helps keep them short-lived and avoids the difficulties that arise when users directly work with CVS branches.
• YaM supports a module release area so that new sandboxes (even large ones) can be built up easily and quickly by pointing to pre-built module releases. Thus the developer need only checkout source code for the modules under development, while the scaffolding can be quickly generated by pointing to pre-built released versions of the remaining modules. This saves considerable time, eases the creation of sandboxes, enforces the clear definition of inter-module interfaces and promotes code reusability.
• YaM makes co-developers into users of one's code, so that there is continual I&T during the development process rather than relying on expensive, system level I&T efforts. It promotes the "grass grows taller as it is grazed" principle or software development. It helps catch problems and bugs early in the development process.
• YaM promotes a "release early, release often" style of development without jeopardizing development stability.
• Besides supporting the day to day needs of developers, YaM also supports the versioning and configuration management needs of I&T.
• YaM encourages a clear and public declaration of inter-module interfaces and dependencies, which is essential for minimizing hidden interactions that are difficult to debug and isolate.
• The package concept inherently relies on module re-use. Thus code reusability is an essential feature of the YaM development process.
• YaM provides much greater visibility into the functional breakdown and organization of the software.
• YaM provides ways to generate quick sandboxes for testing, training and demonstration purposes.
• YaM supports multi-site, multi-platform builds, and provides a clean interface for using third party tools.
• YaM's use of Perl and CVS simplifies porting to multiple platforms (Unix and non-Unix).