- Generate application
- Install (no coding)
- Review & customize:
- Update data model, regenerate
- Update meta-data, regenerate
- Add mockups
- Obtain client feedback
- Repeat previous two steps
- Meta-data is pre-generated to minimize customization
- Recursively customize
- Refine data model
- Update meta-data
- Modify templates
- Develope custom functionality
- Re-generation must never overwrite custom code
- Upon completion
- updated templates may be shared with user community to maximize reuse
The JAG Methodology
Automated Architecture, Inc. proposes the Just-In-Time Application Generation (JAG) software development methodology in order to take advantage of application generation technology for the purpose of dramatically increasing development productivity, and delivering applications that more accurately fit client needs. The JAG methodology extends on the Rapid Application Development software development process created by James Martin in the late 1980's. This paper describes the JAG methodology and how Automated Architecture’s Blue Ink product implements and enables JAG.
JAG is generally the process of building an application instantly and iteratively customizing and regenerating the application during the design and development lifecycle stages. JAG is summarized in the JAG Methodology Overview sidebar at right and can be downloaded for review. The remainder of this paper describes how JAG relates to the traditional lifecycle stages, how to implement JAG's fist step of initially creating a web application using Blue Ink, how to iteratively customize a generated application according to JAG, and finally how Blue Ink allows users to share modified template solutions with the Blue Ink Net user community.
The following six software development lifecycle stages are common to most methodologies (waterfall in particular): analysis, requirements, design, development, test, and deploy. Most lifecycles stages are performed as with previous methodologies, however JAG affects the design and development stages as described below.
The JAG methodology specifies that an implementer create "functional mockups" for the purpose of gathering feedback from the client and solidifying project size and scope. The implementer first creates a rough draft of the data model and database and then instantly generates an application from the database. The implementer installs the application and customizes it through data model and meta-data updates (described below), and the addition of screen mockups representing custom functionality. The implementer reviews the resulting application with the client who can now respond to a functional, nearly complete application that clearly represents the solution an implementer has in mind. With Blue Ink "functional mockups" can be generated and customized in at most a few days.
The process of iteratively receiving client feedback from functional mockups, refining the data model, re-generating the application and updating the mockups will result in a solution that more accurately fits the client needs, improves implementer-client communication, and provides an enormous jump-start into development while minimizing the amount of time spend in the design phase.
Using the JAG methodology the solution implementer begins the development phase with a nearly complete application. The tasks that remain for the solution implementer consist primarily of modifying existing code rather than starting with a blank slate as with traditional methodologies. The type of custom functionality that the implementer must develop include modifying generated security code to integrate with a database or LDAP server, updating pages for business workflows, and building out custom mockups. At any time during development the implementer may update meta-data, the data model, or templates and regenerate the application and no custom code should be lost.
Generating Applications Instantly with Blue Ink
The JAG methodology specifies that an implementer should initially generate an application during the design lifecycle stage. The following sections describe how an implementer would initially generate an application using Blue Ink. Specifically the following sections describe: how a user would create a new project, select a template solution for that project, and generate the application.
Creating a Blue Ink Project
A Blue Ink Project (.bip file) contains all of the information Blue Ink needs to generate an application. Prior to creating a Blue Ink Project file one needs to download, install, open and log into Blue Ink. One can download Blue Ink from the community section of this website, which will first require creating a Blue Ink Net account. After installation one can log in with the username and password that was created prior to downloading.
After opening Blue Ink and logging in, a user can create a new Blue Ink Project by connecting to the desired database and purchasing a license for use with that database (more information is available in the Blue Ink help files). Some licenses have limits on the number of database tables they support, more details are available at: Blue Ink Licenses Summary.
Choosing a Blue Ink Template Solution
After creating a Blue Ink Project but before generating an application, a user must select the Blue Ink Template Solution that the project will use. Template Solutions (which contain Template Projects which in turn contain Templates) are the instruction for what to build. By clicking "Select Templates" a user may download Template Solutions from The Blue Ink Net, which holds a searchable repository of Blue Ink Template Solutions, some of which are user submitted, some of which are provided by Automated Architecture. The default Template Solution provided by Automated Architecture builds a .Net n-tier web application which is described in more detail in Application Architecture.
Generating the Application
After downloading a template solution a user must click the "Generate Application" button to have Blue Ink create the code for an application. A user installs Automated Architecture's default .Net generated application by installing stored procedures into the database, compiling typed datasets, and compiling the code either with Microsoft Visual Studio or via a generated batch file (more detail is provided in the generated Post Generation Instructions file).
The JAG Methodology specifies that an implementer should refine a generated application during the design and development stages through the following four methods described below: data model refinement, meta-data updates, template modifications, and development of custom functionality.
Data Model Refinement
JAG specifies that an implementer may change the data model and regenerate the application with minimal work and without loosing any custom developed code. During design this specification allows the client to immediately visualize data model changes, while during development this allows the client to add last minute changes such as new fields or even new tables with extremely little effort compared to traditional development methods.
With Blue Ink an implementer may update a generated application to immediately reflect data model changes by selecting "Update Project from Database" and regenerating the application. No custom code will be overwritten due to the object oriented design described in Application Architecture.
The JAG methodology specifies that an implementer may change a project’s meta-data to accomplish course-grained changes in an application such as specifying which fields are searchable or which tables should be displayed as dropdowns. According to JAG the meta-data should be pre-generated with a best guess approach to minimize the amount of work required of an implementer in customizing meta-data. During design the implementer should examine the generated application page by page and make meta-data changes as appropriate. The implementer may continue to make these course-grained changes through development.
Blue Ink supports the meta-data approach specified in the JAG methodology through meta-data questions and answers. All Template Solutions contain meta-data questions, whose answers are used by templates to customize aspects of the generated application. Questions have the ability to pre-generate their answers, so that upon first generation an application is as close to complete as possible. The implementer can then provide meta-data answers for specific parts of the database by clicking "Update Meta-Data" in Blue Ink, then browsing for questions by table and/or column, then providing answers.
For example, to allow the end user to search for employees by city a Blue Ink user would click "Update Meta-Data" to enable editing meta-data answers, expand the Employees table, expand the City field, select the SearchableField question and check the checkbox under answer. The types of meta-data that can be modified with Automated Architecture's default template solution are: field names, validation rules, columns displayed in search results and searchable fields (to name only a few).
The JAG methodology specifies that an implementer has complete control of an outputted application on a character by character basis through modification of templates. This specification allows the implementer to make significant architecture changes (such as adding a new architectural tier) or make detailed changes not supported by the meta-data (such as adding a colon after column names). Blue Ink supports the JAG template specification through the Blue Ink Templates in the Blue Ink Template Solution.
The JAG methodology specifies that an implementer has the ability to customize generated code on an unlimited basis. Generated code should in no way be dependent on the tool that generated it, and must furthermore provide a facility that guarantees customizations will never be overwritten upon regeneration. These specifications are intended to maintain all the flexibility that one expects from a custom application such as custom business rules, workflows, user interface and security. Blue Ink generated code never contains dependencies and the default template solution fully supports writing custom code and regenerating an application without overwriting custom functionality through the object oriented approach described in Application Architecture.
Sharing Modified Templates
The final specification of the JAG methodology is to allow implementers to optionally share their customized templates with other implementers. Blue Ink supports sharing Template Solutions to the Blue Ink Net user community. Published template solutions may then be re-used during the template solution selection process of future projects.