LifeCycle is a set of utilities to enhance the development phases of the production life cycle. As new utilities are developed, they will appear in this section called "LifeCycle".

LifeCycle - Build Phase 1.0

Automate the building of multiple projects using user-designed reusable task scripts.

Table of Contents

Download LifeCycle - Build for Free. It is now public domain. Feel free to download, and try it. Please email me on any suggestion, bugs, or problems you find while trying LifeCycle Build tool.

Introduction

During any development cycle there is point when a project needs to be built into executables. The phase is referred to as the Build Phase. There are different kinds of builds that can take place; the standard build done by the developer to build a local copy of the executables, the Debug or Test Build for the Testers, the Production Build to be distributed to the customers, and possibly many more other types between these builds. The purpose of LifeCycle - Build Phase utility is to provide a single tool where all these different types of building processes can be created, maintained, and executed each time the application is built. The purpose of this tool is to provide a central application to automated as much of the built process as possible without have to clone code, or replicate the procedure for different projects.

Overview

LifeCycle - Build Phase utility allows the developer and/or build manager to automate if all, then most of the tasks involved in building all the pieces to a run-time Solution. The utility provides a list of all the projects in the overall project, and displays them in hierarchical listing based on dependency. But the main feature of the utility is the Build Styles Scripts. Each style is related to a list of Task steps, called the Build Script. The Scripts are performed during the build process. Each of these tasks is a separate entity, like a building block, which can be either added, removed, or excluded from the build script during design-time.

By have the Tasks as separate reusable building blocks, different project can share the same tasks for different reasons. For example, if the development shop is responsible for several projects and they all adhere to similar build practices, then maintenance on the build scripts can be time consuming. When the boss decides it is time to upgrade the Source Code Control system to a new or different system, the automated portion of the build scripts for all the projects will need to be adjusted or rewritten for the new SCC system. If each project has its own build script (as PRG for example), then each will have to adjust individually. But with LifeCycle - Build Phase, only the Task for interacting with the SCC system would need to be modified. Once the modification is completed and tested, then all the projects build scripts will function the same again.

The same scenario can be applied to generating an installation setup program. In recent past, Visual FoxPro has changed the method of generating setup programs. In VFP 6.0, it used a internal method of generating a setup program, where here in VFP 9.0 it relies on InstallShield Express as the proper, generic way to create installation programs. If the development shop migrates their application from 6.0 to 9.0 then it may be required that the installation program be upgrade too. LifeCycle - Build Phase does not speed up the actual generating of such of process, but does provide a central place to interface and performing of the actual building of the installation program.

When the developer starts a build process, the utility walks down the lists of projects (actually starting with the innermost dependency and working its way outward). Each project is run through a set of task step, with one being the actual building of the run-time module. Each task is a standard Visual FoxPro base class (or inherited from one) in either a Class Kibrary file formmat (VCX) or a Program file format (PRG). There are no special PEM required to make them a task for this utility. The developer of a new task would create their task and drop it into the proper Build folder on the hard drive. The Build Cycle utility will see the new task and make it available to be included into one or more Scripts. Special header comment lines in the Tasks methods identify the methods as Tasks and describe their functionality.

Documents

To allow you to get a better understanding what LifeCycle - Build Phase utility has to offer, I am allowing you to read all the documentation available for the product. Feel free to view, print, or download these documnents.

User's Guide
Developer's Guide
Listing Script Tasks

Build Scripts and Tasks

The true key to LifeCycle - Build Phase utility is the expandability of the list of Tasks available. If the product does not have or do what is needed by you or your company, you can modify an existing Task or create a new on your own. The goal is to create a library of downloadable Tasks here on GLR Software web site to aid others in build Scripts easily. It is our hope that will using the utility, you will enahance existing Tasks and create new one, and then post to us to share with others. But, if by chance you feel that your Tasks is involved enough to require a reasonable payment, then either we or yourself can market it.

Here is a list of some of the tasks provided with LifeCycle - Build Phase.

• Fetching the latest source code from the SCC provider before the actual build occurs.
• Loop through the numberious subprojects and files within each project file.
• Perform conditional builds on the name of the sub-project, version of VFP, etc.
• Dynamically set the project settings.
• Clean up files of undesired settings; such as absolute paths to reports amd images.
• Generate installation setup files
• Copy files to a specific folder for the remainder of the team to have access to.
• Preform forms of documentation agianst the projects and files.
• Zip files and generate a self-extracting executable.
• Burn the final setup files to a CD for back storage or production.
• And many others. For a complete list of the predefined tasks currently available for LifeCycle - Build Phase Click Here

Feature List

General Feature of the utility:

• Build multiple projects at once.
• Build projects against different styles of builds (Debug, Test, Production, etc.)
• Run LifeCycle - Build Phase unattended to automate the daily builds.
• Schedule reaccuring daily builds using Windows Scheduled Task service.
• Run utility from the command line or alternate program.
• Manage unlimited number of Project Solutions, Project, or Project Styles.
• Receive automatic updates when they arrive on GLR software web site.
• Select one, more, or all projects to participate in the build run.
• Monitor the Build Logs in real-time while the build is running.

Solutions:

• List and load main project file as a Solution (like in Visual Studio).
• Add and remove from the Solution listing.
• Copy exising Solition's Build Style Scripts to new Solutions.

Project List:

• Lists all project file referenced in the project files.
• Hierarchical display of project and their dependencies.
• Double-click on a project in the list will open the Project Manager for that project. Use Third-party Projec Managers is optional.
• Displays the project's long-name description in the project listing.
• Select one, more or all projects to participate in the build process by placing a check-mark in the "Sel" column.

Build Styles:

• Create different Build Styles for different purposes
  • Standard development builds
  • Daily builds for regression testing and testers
  • Debug builds
  • Beta tester builds
  • Production builds for deployment
  • Documentation runs to gerenate documents for release notes or code review.
• Add, Remove, Edit, and Copy existing Build Styles.
• Newly added Styles are based on a Default Style or as a copy of an existing Style.
• Each Build Style is related to unique Build Script.

Script List:

• The utility come with over 120 pre-defined Tasks to start building Build Scripts.
• Add, rearrange, remove. and exclude Tasks from the Script List.
• Description is read from the Task Description comment in the source code. If not found, then the ClassLib.Class.Method (LCM) is used in its place.
• Apply up to 200 Task Parameters to any one Task.
• Display the Script List in a Tabulated fashion for ease in readability.
• Generate and view Build Log as resulting files and at build time.
• Visually trace the tasks throgh the Script listing as they are being preformed.
• Ignore classes in the Build folder by setting their Enabled property to False.
• Ignore individual task in task class by setting the method as hidden, or by Excluding them in the SCript Listing.

System Requirements

LifeCycle – LifeCycle - Build Phase was built to run in MS Visual FoxPro 6.0 and greater. But if the utility is ran in VFP 7.0 or greater, it will use some built in features of that VFP version, where in VFP 6.0 they are emulated.

Download Now

Download LifeCycle - Build