Table of Contents

1.

Executive Summary ............................................................................................................................ 3

2.

Introduction ....................................................................................................................................... 4

3.

4.

2.1.

Building Composite Applications in ClaySys AppForms ................................................................. 4

2.2.

AppForms Integration with SharePoint ....................................................................................... 5

2.3.

SharePoint List Forms ................................................................................................................ 10

2.4.

SharePoint Form Web Parts....................................................................................................... 11

2.5.

SharePoint Form Applications.................................................................................................... 11

Working with ClaySys AppForms....................................................................................................... 12

3.1.

Form Controls in ClaySys AppForms ........................................................................................... 17

3.2.

The Dynamic Grid Control.......................................................................................................... 18

3.3.

Sub Form Control ...................................................................................................................... 20

3.4.

External Form Control ............................................................................................................... 21

3.5.

The Tab Control ......................................................................................................................... 22

3.6.

Lookup and Search Controls ...................................................................................................... 23

3.7.

Menu and Tree View Controls for Linking and Navigating Multiple Forms in a Process ............... 26

3.8.

The ClaySys AppForms Expression Builder and Functions ........................................................... 29

Summary: Creating Modular Form Componentry for Agile Enterprise Applications ........................... 31

Page 2 of 31

1. Executive Summary
Forms are essential application components that enable users to access, create and manipulate structured information in order
to execute their work functions and activities. InfoPath is Microsofts declarative, no-code rapid application development tool,
integrated within SharePoint, for creating sophisticated form applications. However InfoPaths capabilities have not been
advanced since the release of the 2010 version, and Microsoft recently announced that it has been officially deprecated and will
be phased out. Furthermore, Microsoft has not indicated what will ultimately replace InfoPath. Consequently many
organizations have stopped developing form applications in InfoPath resulting in halted projects and hesitation to use
SharePoint as a platform for building important applications.
ClaySys AppForms is the pre-eminent successor to InfoPath for form application development. It substantially advances the nocode form development paradigm enabling power users and developers alike to efficiently create sophisticated form
applications that are fully integrated within SharePoint and go beyond what was possible with InfoPath. It is entirely web based,
using current web standards technologies, and incorporates the extensive wish-list of functionality that users and developers
have wanted from InfoPath, such as:

Check in/check out capabilities allowing multiple developers to work on a form

Versioning of forms with single click rollback
Application Lifecycle Management (ALM) support process for development, testing and production deployment
The ability to create and update information in multiple data sources (Lists, Libraries, SQL, Web Services) from a single
form simultaneously without writing code
Generating and submitting repeating item information (e.g. master/detail) without requiring code
A robust visual point and click Expression Builder for creating complex rule statements
Support for Tab structured forms and Sub forms.
Linking and passing of data parameters between forms at runtime
Built in functions for calling external processes (e.g. workflows) and opening or embedding other forms
Error handling and debugging facilities
The ability to embed and invoke JavaScript in forms
Embedded Search capabilities
Capabilities for embedding hierarchical menus and tree views within forms
Metadata architecture to insure full compatibility with future versions of SharePoint and Office365
The ability to export forms deployed on premises to online environments with no modification
Browser based spell checking

In the same manner as InfoPath, ClaySys AppForms is based on the XML declarative model, and it presents its functional
capabilities in highly accessible ways enabling the creation of sophisticated and complex Enterprise class applications in a
fraction of the time it would require to do so writing code.

Page 3 of 31

2. Introduction
This document identifies, illustrates and describes the numerous capabilities of ClaySys AppForms that makes it the natural
successor to InfoPath for developing form based applications in the Enterprise.
ClaySys has been building custom applications for Fortune 1000 companies for over 5 years. In support of developer efficiency
and the creation of applications that are easily extensible, configurable, self-documenting and future proof, ClaySys built its own
web-based declarative rapid application development (RAD) platform. This platform was designed to support both a standalone
Windows Server Forms platform and a Forms engine embedded in SharePoint. The services business at ClaySys has been
engaged in custom SharePoint development since SharePoint 2003, assisting large organizations such as Unilever with
enterprise wide SharePoint projects and deployments. Many of these engagements involved building custom SharePoint
applications and subsequently migrating them to later versions of SharePoint. The difficulties in deploying these custom
applications to later versions of SharePoint inspired the design and architecture of the ClaySys AppForms platform to support
the creation of future proof applications that would work readily on any version of SharePoint as well Office365 in the cloud.
The ClaySys AppForms architecture is designed for the shared infrastructure and Multi-tenant model of cloud computing.
Multi-tenant cloud services like Office365 do not allow customers to deploy custom code within the shared infrastructure.
Because the ClaySys AppForms metadata driven architecture allows customers to create form applications in the cloud without
having to write any custom code, it is fully compliant with the deployment constraints of services like Office365. The Office365
version of ClaySys AppForms is planned for release in the SharePoint App Store by the end of 2014.

2.1. Building Composite Applications in ClaySys AppForms

It is well understood that the best approach to application development is to design and create reusable and configurable
functional components that implement the recurring patterns of functionality that are commonly required. The benefits of such
a building block methodology are the elimination of redundant development effort, the adoption of consistent functional
methods, and the ability to better support the lifecycle maintenance of applications. Component reuse, composition,
extensibility and interchangeability have been the holy grail of system architects and software developers for as long as there
has been software. What has prevented truly modular development frameworks from being truly actualized is the abstraction
level of the components. They have existed on too low a level, usually in the form of opaque procedural code that is typically not
well documented. Consequently, it is more prudent for a developer to create application functionality from scratch that they
understand and trust then use something that already exists but is not completely transparent to them. What makes ClaySys
AppForms a viable platform for functional reuse and application composition is that the tools it provides and the artifacts
created are functionally exposed and self-documenting. It is highly accessible to developers and non-developers alike, capable of
being able to create sophisticated web-based applications that have the following characteristics:

End-to-end visibility of process activities, components and functions

Process components and functionality that are exposed and self-describing
Any process component can be loosely coupled with any other component.
The ability to integrate any information source and application functionality, no matter where it resides, into a process
Any process activity or component can be added, removed or re-configured readily and with a high degree of
confidence that existing functionality will not be compromised
Any process can be easily replicated, extended and scaled

Page 4 of 31

Illustration 1 below shows examples of multiple forms that are connected and working together as a composite application. No
code was required to implement the sophisticated functionality indicated here.

Illustration 1

2.2. AppForms Integration with SharePoint - A Mature and Robust SharePoint Hosted Development Environment
SharePoint 2010 and 2013 are the host environments for both the ClaySys AppForms development environment and the enduser interaction with those forms. Like InfoPath, ClaySys AppForms can generate SharePoint List forms as well as stand-alone
Document-type forms. Document-type forms can be used outside of SharePoint and both List forms and Document forms can be
embedded as a Web Part in any SharePoint page.
In line with the cloud computing paradigm and device independence, the ClaySys AppForms development environment is
entirely browser based and hosted within SharePoint, both online and on premise. This is a significant value as there is no
additional requirement to purchase and install a client application on each development computer, as is required with InfoPath.
Furthermore, ClaySys AppForms is not simply a client development tool; it is a robust, centralized declarative development
platform providing lifecycle and component management capabilities in support of creating, testing, and deploying complex
applications comprised of multiple interdependent forms, data sources, and supporting artifacts. Illustration 2 below shows the
ClaySys AppForms Form Explorer page. Folders are used to store and organize forms that have a logical association or
relationship.

Page 5 of 31

Illustration 2

Right-clicking on a form displays the drop-down selection options available for forms as shown in Illustration 3 below.

Illustration 3

Page 6 of 31

Selecting View History will display the Form History List as shown in Illustration 4 below.

Illustration 4
Right-clicking on a version allows the user to View it. Selecting two or more versions allows the user to compare the different
versions in either Design or Rules mode as shown in Illustration 5 below.

Illustration 5

Clicking the Details button on the top right in Illustration 5 above will display all the specific changes in the form that were made
from the earlier selected version to the later selected version as shown in Illustration 6 below.

Page 7 of 31

Illustration 6
In further support of rigorous collaborative application development procedures ClaySys AppForms implements Check-In/CheckOut and Draft version publishing capabilities as shown in Illustration 7 below. A form must be checked-out to make
modifications while all aspects of the form can be examined while checked-in. In addition, Draft versions cannot be deployed to
a production environment, and can be reviewed and tested only by the user creating the draft.

Illustration 7

Page 8 of 31

The Data Source Settings page displays all of the Data Source connections that have been created as shown in Illustration 8
below. Maintaining the data source connections in a centralized repository allows any Data Source connection to be readily
utilized in any form created in the host environment, based on the developer having the appropriate permissions to use them.
This facilitates the efficient management, control and reuse of Data Source connections.

Illustration 8

Performance characteristics, logging of SQL and Web Services transactions executed within ClaySys AppForms can be captured
from the ClaySys AppForms Transaction Settings page shown in Illustration 9 below, providing auditing and performance
management control. ClaySys AppForms also captures run-time exception events at a detailed level, facilitating form debugging
and troubleshooting when necessary.

Illustration 9

As these illustrations indicate ClaySys AppForms incorporates a mature and comprehensive environment for forms application
development. In addition there are Backup and Restore capabilities and other data management settings.

Page 9 of 31

2.3. SharePoint List Forms

InfoPath List Forms were introduced in SharePoint 2010 allowing users to substitute an InfoPath form for the default ASPX forms
used to create, modify or view list items. Because InfoPath list forms are easily modifiable and provide enhanced form controls
and rule logic, they were implemented widely. ClaySys AppForms supports the same list form functionality and more.
Illustration 10 below shows the ClaySys AppForms Ribbon button for a List.

Illustration 10
Illustration 11 below shows a form automatically generated by ClaySys AppForms for a SharePoint list. Once generated, the
form can be fully customized by modifying the design layout, changing the field controls and adding rule logic.

Illustration 11
A distinct feature of ClaySys AppForms is the ability to create multiple and different forms for the Create, Modify or View
functions of a list, as shown in the AppForms Settings Page in Illustration 12 below; a capability not available in InfoPath.

Page 10 of 31

Illustration 12
2.4. SharePoint Form Web Parts
Both list forms and document based application forms can be embedded on any SharePoint page by using the ClaySys AppForms
Web Part as shown in Illustration 13 below. This works just like the InfoPath Form Web Part.

Illustration 13

2.5. SharePoint Form Applications

Where InfoPath and ClaySys AppForms share a great deal of commonality is in their support for sophisticated form applications
that have the following characteristics:

Can represent and work with complex information structures such as repeating sections, optional sections, Tabs and
Wizards, dynamic conditional formatting and visibility, custom dialog boxes, and multiple views of information.
Capable of complex behavior based on the implementation of rule sets
Supports multiple Views, Sub Forms and the dynamic interaction of multiple forms
Can have behavior based on user, role and rule contingencies
Each form can read from, manipulate, write to and update an arbitrary number of data sources
Support to call external functions or data using Web Services through configuration Implement embedded JavaScript
where necessary Provides error handling and debugging capabilities

Page 11 of 31

While InfoPath implements some of these functional capabilities it does not address them all. ClaySys AppForms is capable of
implementing all of these as well as other significant capabilities that will be described in detail in the sections that follow.

3.

Working with ClaySys AppForms

ClaySys AppForms has the comprehensive functionality needed to create the most demanding applications. But unless a
development paradigm is easily accessible, organized and presented logically, and most importantly, efficient to work with, it
will never be used effectively and actualized. A guiding principle in the design of the ClaySys AppForms platform was to provide
the user, whether it is a sophisticated end-user or a traditional developer, with a readily understandable toolset and
methodology that is elegant and highly productive.
In ClaySys AppForms users work with three primary development components: Form Controls, Data Sources and Rules. Users of
InfoPath will be immediately comfortable with this paradigm as it is essentially the same one used by InfoPath. However it is
been simultaneously simplified and extended in ClaySys AppForms.
Illustration 14 below shows the development environment of the ClaySys AppForms Platform.

Illustration 14
Illustration 15 below on the left shows the Control Toolbox with the alternate expandable panels for Datasources and Rules. The
Datasources panel is shown in the middle and the expanded Rules panel is shown on the right.

Page 12 of 31

Illustration 15
As shown in Illustration 14 above the central section of the development environment is the design grid for laying out controls
by simply dragging and dropping them. Every control has a set of properties that can be readily set and configured from its
Properties Panel as shown in Illustration 16 below left. An optional pop-up Properties box can be set to display when a control is
selected as shown in Illustration 16 below right.

Illustration 16
Illustration 17 below shows the Datasource Mapping page for a Datasource operation, in this case a Select (Read) operation.
The Select operation is given a name to identify it (Select Employee Information).The values obtained from the Datasource
shown in the Data Source Columns on the left will be bound to and displayed in the controls shown under the Mapping Value
column. A Query based on the identity of the user, identical to the InfoPath username function, selects the unique record in the
Datasource that matches the user identity criteria in the Datasource as shown on the right and additional and/or Query clauses
can be added.

Page 13 of 31

Illustration 17
Datasource operations can be defined for Select, Insert, Update and Delete. The support for all functional dataset operations
from almost any Datasource SQL, Oracle, Web Services, SharePoint Lists, REST, JSON and other data access methods, uniquely
distinguishes ClaySys AppForms as an Enterprise-class application development platform and surpasses InfoPaths capabilities.
Again, it is important to note that this Datasource functionality is readily understood and easily implemented or modified.
Once the Datasource operation is defined, it is bound to a control or event that triggers its execution. This is shown in the
Manage Commands for Datasource screen as shown in Illustration 18 below.

Illustration 18
Clicking on the Create Execute Rule displays the form controls and events. Selecting the FormLoad event as shown in Illustration
19 below will trigger the execution of the Select Employee Information Datasource operation.

Page 14 of 31

Illustration 19
Note that this Datasource function is named Create Execute Rule, because that is literally what is being created automatically.
Illustration 20 below displays the ClaySys AppForms Rules tab showing the rule created for this Datasource operation. The Rule
is named FormLoad EmployeeInfo, just like the Datasource Select operation. The two actions shown are the auto population of
the Employee Information controls on form load, and setting the value of the EmployeeName TextBox control to the
GlobalVariable(User) identity; which were created using a point and click process to bind controls to Datasources and configure
their behavior. That process is converted into concise, yet readily understood rule expression statements that represent the
underlying execution logic of the form.

Illustration 20

Page 15 of 31

Rules can be individually defined and structured as shown in Illustration 20 above or hierarchically combined with nested
branching as shown in Illustration 21 below.

Illustration 21
Rule expression statements are comprised of conditions (Decisions in ClaySys AppForms) and Actions representing form logic
created automatically from Designer functions, or composed directly from ClaySys AppForms Expression Builder. Clicking on the
function icon to the right of any Decision or Action in the Rule Tab will open the Expression Builder as shown in Illustration 22
below.
The Expression Builder can be used in two ways: pointing and clicking on categorically organized form objects, functions,
operators and variables to construct an expression statement, or by using IntelliSense-like prompts to directly enter the
expression logic; or a combination of both. Form developers can work both at a high level of abstraction using the Designer tools
or create form logic directly using the Expression Builder. Complex form logic can be effectively and efficiently created and
tested in this way.

Illustration 22
In further support of exposing and documenting functionality and logic in a clearly understandable manner ClaySys AppForms
provides a Report tab that dynamically shows the mapping and contingent interactions between Controls, Datasources and
Rules as shown in Illustration 23 below. The comprehensive and accessible representation of a forms all-up functionality and
logic is a necessary and defining characteristic of a mature declarative development platform.

Page 16 of 31

Illustration 23

Now that the salient capabilities, overall organization and conceptual design of the ClaySys AppForms platform has been
described, in the following sections specific features will be examined in detail to indicate the unique and advanced application
development capabilities available from the ClaySys AppForms platform.

3.1. Form Controls in ClaySys AppForms

In InfoPath a great deal of the sophisticated form functionality was derived from XML Schema. To build a form application the
user had to first create an information set based on XML Schema whose behavioral characteristics were reflected in the forms
controls. While this was conceptually interesting, it was rarely implemented effectively because it was not well understood by
most people. The more intuitive approach to form development that most people are comfortable with is to begin by laying out
the Controls on a design surface and configuring their behavior, and this is the approach taken by ClaySys AppForms.
ClaySys AppForms distinguishes itself both by the breadth of Controls available and the depth of functionality that the Controls
can implement. All of the most commonly used standard Controls are available in ClaySys AppForms as shown in Illustration
24 below.

Page 17 of 31

Illustration 24
As can be seen in Illustration 24 above there are additional Standard Controls for MultiList Box, Password Box,
RadioButtonGroup and Timer. The MultiListBox is a form feature that is available in SharePoint ASPX List Forms but not in
InfoPath. As shown in Illustration 25 below it is used to indicate the selection of items by moving them from one item box to
another.

Illustration 25
To address the more sophisticated requirements of real-world applications ClaySys Appforms provides a set of Controls that
readily implement commonly required pattern based functionality. In this section we will demonstrate how some of these
Controls, which are shown in Illustration 26, facilitate the efficient development of complex applications.

Illustration 26

3.2. The Dynamic Grid Control

The Dynamic Grid Control is designed to support repeating item matrices. An example of such a matrix is the order items shown
in Illustration 27 below where each grid item is comprised of a Product Category, a Product, and a Quantity per unit, unit price,
quantity, discount and amount. Note that this repeating item matrix implements a cascading look-up for the Product by
Category. Any type of control can be used in a Dynamic Grid and interactively configured to implement this type of common,
complex functional behavior.

Illustration 27
The Dynamic Grid Control enables users to implement these complex data structures and behavior easily. Simply drag and drop
the Dynamic Grid onto the Designer surface and select the ellipses button () for Columns on the corresponding Properties
Panel as shown in Illustration 28 below.

Page 18 of 31

Illustration 28

The Dynamic Grid Configuration Wizard will then take the user through the steps of defining the Controls used in the grid,
including their placement, visibility and other settings as shown in Illustration 29 below.

Illustration 29

Page 19 of 31

Once mapped and configured using the wizard the Dynamic Grid will display the Data Source columns specified as shown in
Illustration 30 below.

Illustration 30

Dynamic Grids handily support cascading lookups as was shown for this example in Illustration 27 above. In addition Rules can
be added to facilitate any type of information logic or form behavior.

3.3. Sub Form Control

A common form application use case is the requirement to display information conditionally; that is, displaying or hiding a group
of controls based on some action or rule contingency, such as values entered into a Control, the identity or role of the person
opening a form, or clicking a button. This is easily addressed using the ClaySys Sub Form Control which embeds a form within a
form. This control behaves like InfoPath Sections. Illustration 31 below shows a form containing multiple Sub Forms.

Illustration 31

Page 20 of 31

3.4. External Form Control

While a Sub Form is not independent of the parent form that contains it, the External Form Control provides the ability to
embed a completely independent external form into another form. This capability facilitates using forms as reusable
components. An example of a reusable form is a currency conversion calculator that accesses a Web Service for current rates as
shown in Illustration 32 below.

Illustration 32

This utility form could be embedded in any form where International transactions need to be calculated. This capability also
supports the scenario where multiple LOB systems need to be accessed simultaneously in support of a complex process as
shown in Illustration 33 below where clicking on a link in one form opens up another form in dialogue mode within the context
of the original form. In most cases it is more efficient and easier to maintain separate forms for each system and build a
composite application by linking them as needed. In addition, ClaySys AppForms provides a Rule action for opening one form
from another.

Page 21 of 31

Illustration 33
3.5. The Tab Control
Organizing information within Tabs is a common design pattern that people are very comfortable with. Microsoft OneNote has
used this paradigm for years. ClaySys AppForms readily supports this design option with the Tab Control. Simply, Tabs are added
or removed using the Tab Items Collection dialogue screen that creates a Sub Form for each Tab as shown in Illustration 34
below.

Illustration 34

Page 22 of 31

Illustration 35 below shows a Tab structured form that is designed to provide instructions to a form developer. This form can be
embedded in, or invoked from any other form.

Illustration 35
3.6. Lookup and Search Controls
Almost all ClaySys AppForms Controls can be connected to Data Sources with Query lookups configured to return criteria based
results for the purpose of populating the Control. However, often there is a need to perform a lookup of information for
reference or identification purposes only, and in many cases obtaining that reference information requires the ability to join and
query multiple tables or lists, as in looking up the order details for a customer. Again, this is a common functional pattern found
in Enterprise class applications. To facilitate this requirement ClaySys AppForms provides the Lookup and Search Controls.

On a form the Lookup Control presents an entry box for the entry of a search string as shown in Illustration 36 below.

Illustration 36

The Lookup Search Wizard screen in Illustration 37 below shows how the query and results for the Lookup Control are
configured.

Page 23 of 31

Illustration 37

The results of the search are displayed in a Result dialogue screen shown in Illustration 38 below.

Illustration 38

Page 24 of 31

The Search Control is designed to submit and return multiple field values from multiple records as shown in Illustration 39
below.

Illustration 39
This Control is like the Dynamic Grid in reverse as shown in Illustration 40 below. Instead of creating a row of data for inserting
or updating, the Search Control returns rows of information based on search criteria and can display Master/Detail information
from multiple Datasources.

Illustration 40

Page 25 of 31

The Relation and the Search Results Wizard screens shown in Illustrations 41 and 42 below is where Master/Detail relationships
are defined and configured. As can be seen the settings for the result set returned are highly sophisticated but readily accessible.

Illustration 41

Illustration 42
3.7. Menu and Tree View Controls for Linking and Navigating Multiple Forms in a Process
While the Tab Control provides an elegant structure for organizing and presenting form fields to facilitate a sequential process
experience within a single form, very often an application or process requires working with multiple forms in a defined or ad-hoc
sequence in order to execute or support a series of tasks. These processes typically rely on complex information sets, have
complicated workflow contingencies, and require access to multiple Datasources. The ability to invoke and open multiple forms
from within any form is an Enterprise application scenario that ClaySys AppForms can address that distinguishes it from the
capabilities of InfoPath.
While forms can be invoked and opened from within any form, or directly embedded in a form, ClaySys AppForms provides two
navigation Controls designed specifically for the organization and orchestration of a multi-form process the Menu and Tree
View Controls. Both provide similar capabilities in slightly different ways.
The Menu Control allows the user to build a single level menu structure with fly-outs for opening linked forms as shown in
Illustration 43 below.

Page 26 of 31

Illustration 43

The Tree View Control generates a nested, hierarchical menu structure as shown in Illustrations 44 below.

Illustration 44
A standard design pattern is to create a top level form using the Menu or Tree View Controls that serves as the starting point of
a process where any number of forms needed can be accessed in a contingency based sequence. As with any ClaySys AppForms
Control, rules can be applied to impose conditional display and validation requirements. Menu and Tree View Controls can be
copied and placed in any form in order to create a breadcrumb like navigational trail in support of a continuous and coherent
process experience.
Illustrations 45 through 48 below show the easy and straightforward configuration and editing steps available for implementing
these Navigational Controls

Illustration 45

Page 27 of 31

Illustration 46

Illustration 47

Illustration 48

Page 28 of 31

3.8. The ClaySys AppForms Expression Builder and Functions

The best declarative, rapid application development platforms balance the requirement for making complex functionality
available at a high level of abstraction so that people who are not formal application developers can access that functionality
easily and quickly, and also providing direct access to the underlying execution mechanisms so that formal developers can have
more granular control over the development process and the features and functionality of the applications created.
The ClaySys AppForms development platform addresses these dual requirements in the following ways:
As demonstrated throughout this document a point and click methodology is the primary user interface for creating and
configuring form objects, attributes, relationships and events.
These objects, attributes, relationships and events are represented as Rule logic, directly accessible from the Rule screen as
shown in Illustration 49 below. Rules in turn are comprised of expression statements that are syntactically concise but readily
and clearly understood semantically.

Illustration 49
Rule logic can be created and edited in flexible and versatile ways as well. Clicking on the function icon to the left of any Decision
or Action will open the Expression Builder where the expression can be constructed or edited directly using IntelliSense-like auto
completion support as shown in Illustration 50 below. In addition, the Syntax for constructing any form objects or function as an
expression is clearly described so that even people who are not formal developers can understand the functional grammar.

Illustration 50
Expressions can be generated directly in the Expression Builder using a point and click methodology. In Illustration 51 below the
Controls category is selected and ds is entered into the search box for all Controls, which includes the forms Datasources. Any
object with ds as the prefix, here the Datasources created in the form, will display and by selecting a specific Datasource the
respective operations and rule logic defined for it will be displayed in the third box. In this way it is straightforward to access any
form functionality directly as an expression.

Page 29 of 31

Illustration 51
For developers and power users who become conversant and comfortable composing expressions natively, they can be entered
directly in the Rule screen, again with the support of IntelliSense-like auto completion as shown in Illustration 52 below.

Illustration 52
Furthermore, forms can be extended and enhanced by invoking JavaScript functionality as shown in Illustration 53 below.

Illustration 53

Page 30 of 31

4. Summary: Creating Modular Form Componentry for Agile Enterprise Applications

Business processes are comprised of the operating procedures, institutional working knowledge, and information technology
resources of an organization. In an efficient environment any of these functional components can be readily identified, adapted
and deployed to address dynamic business requirements; it is an organizations systemic ability to fluidly marshal and
reconfigure resources in response to business opportunities and necessities.
The ClaySys AppForms platform, in conjunction with SharePoint can enable the rapid application development and application
lifecycle management efficiencies needed to actualize agility in organizations. It accomplishes this by providing the development
methodology and operational support for creating and managing modular, reusable application components that are
declarative, self-documenting, and conform to the rigorous operational standards that IT organizations require.
Organizations that have deployed InfoPath for their form applications will be very comfortable with the declarative development
methodology used by ClaySys AppForms. In addition, the substantial additional capabilities of ClaySys AppForms significantly
expand the use case scenarios that can be addressed in a declarative way. Furthermore, because ClaySys AppForms is a robust
and mature platform, not just a development tool, formal and collaborative development procedures and discipline can be
implemented effectively.
For more information about the ClaySys AppForms platform please go to www.claysys.com

Page 31 of 31