Build Decision Making when Building Multiple Solutions

In larger enterprise efforts, where it is necessary to manage large applications, multiple Visual Studio solution files are frequently used to create a single application.  For this effort, developers must write their own MSBuild XML scripts.  This is where OpenMake Meister enhances the process. 

OpenMake Meister allows you to generate a build.xml file, called a Build Control File, that builds an application that uses multiple Visual Studio solution files with dependency linking.  During the build process, Meister's deep dependency scanning links all of the dependent parts together.  For a major retailer, this solution management feature allowed the development team to separate  application components into unique VS solution files, creating smaller solution files, without losing the ability to build all of the solutions as a single unit.

When applications become more complex, it is often not possible to manage the entire application as a single VS solution.  OpenMake Meister allows for teams to use as many VS solutions as needed, and not lose critical build functionality. OpenMake Meister can accurately determine the order in which objects between solution files should be built.  We call this good build "decision making."   

Accelerated Parallelized builds with Build Avoidance

Building faster is critical for large projects.  Meister accelerates builds by managing the compiler calls, sorting out dependencies and leveraging the power of multi-core processing machinces to build the objects in parallel.  This is by far the most efficient method of speeding your builds.

In addition, Meister uses build avoidance for supporting accurate incremental build processing.  Build avoidance simply means that your builds will be done incrementally, re-compiling only the objects that are out of date. With MSBuild you can define "Transform" relationships between objects and MSBuild will check the time and date of the relationships to determine if on object is out of date.  To do this, you must code the "Transform" statements manually in the MSBuild script to define how you want to handle the date/time checking process.

OpenMake Meister uses machine intelligence to automatically track these dependencies and perform the date/time checking for you without the manual coding of "transform" statements.

Improved builds for the Visual Studio Web Project

A common build challenge for VS developers is the Web Project.  The web project involves not only source and assemblies, but also a requirement to interact with the IIS web server.  MSBuild can call the process that creates the Web Project, but developers must manually create the MSBuild scripts.  In some cases, developers choose Nant, an Apache open source language, to create the build logic for VS 2005 Web Projects.  Meister provides an alternative.  It supports the building VS 2005 Web Projects by automatically generating they build scripts, similarly to the way VS generates MSBuild scripts for C# and J#. 

Scheduled, Automated and Continuous Integration Builds and Workflows

As applications written using the Visual Studio Framework mature, so does the need to manage the build process outside of the VS IDE.  With Meister, your builds can be executed the same way inside the IDE as outside the IDE allowing for Continuous Integration Builds, scheduled builds and builds automated through other called activities.

You can also coordinate your pre and post build  activities using Meister's workflow engine.  Activities can be executed across multiple machines using Remote Agents to help speed up the activities needed to support your lifecycle process.  

Dependency Management for .Net 

Sorting out the dependency hierarchy between different solutions and language types (C# vs C++, vs assemblies and COM objects) so builds can be done in the correct order can be a big challenge when writing build scripts so the build can be performed outside of the .Net IDE.  Without OpenMake Meister the choices are to write static Nant scritps and manually sort out the dependencies, or call .Net in headless mode and build each solution in some order.  Neither of these soltuions resolve solution to solution dependencies or circular dependencies within a solution. 

Meister performs source code scanning and uses the .Net project information to solve this problem. It also allows you to build multiple workspaces (projects and solutions) at a time. With Meister, you no longer need to build them separetely.

Standardizing the Calls to the Microsoft Compilers

There is no standard or easy way of invoking the different Microsoft compilers for projects that use different versions of Visual Studio.  Some Microsoft compilers are called using DevEnv (VS 2003), others use MSBuild (VS 2005/2008/2010) and older ones still rely on directly accessing the compiler through Nmake (VS 6.0). This makes is difficult to standardize on builds running outside of each Microsoft IDE version. 

Meister addresses this problem directly by standardizing on the way in which the different Visual Studio compilers are called. It also manages the dependent relationships between different Visual Studio projects and solutions.