31
Page 2 of 31
Table of Contents
1. Executive Summary ............................................................................................................................ 3
2. Introduction ....................................................................................................................................... 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
3. 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
4. Summary: Creating Modular Form Componentry for Agile Enterprise Applications ........................... 31
Page 3 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 no-code 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 4 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 5 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 end-user 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 6 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 7 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 8 of 31
Illustration 6
In further support of rigorous collaborative application development procedures ClaySys AppForms implements Check-In/Check-Out 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 9 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 10 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 11 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 12 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 13 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 14 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 15 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 16 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 17 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 18 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 19 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 20 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 21 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 22 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 23 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 24 of 31
Illustration 37
The results of the search are displayed in a Result dialogue screen shown in Illustration 38 below.
Illustration 38
Page 25 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 26 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 27 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 28 of 31
Illustration 46
Illustration 47
Illustration 48
Page 29 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 30 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 31 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
