Open Web Studio - Standard Practices

By Kevin M Schreiner

November 27, 2008

As the network centric and internet based technologies have grown and become globally adopted, organizations seeking to integrated their systems across departments and organizational boundaries have made painfully evident that the traditional development model and life cycle needs shifting. The development process for Open Web Studio is similar in concept and functionality to all other standard development efforts. The architecture and workflow of the platform have already taken into consideration the standard goals of Distributed Application Design, providing a more short-circuited and direct formula for creation and delivery of technology solutions, therefore breaking the mold of traditional development, expanding the capability and development capacity across all types of users.


Figure 1. Open Web Studio data flow and runtime logic


The beginning and end of every solution is the presentation layer. Like the common cliché regarding first impressions, the end users opinion of the solution will be positive or negative from the beginning based on the interface. The main interface, built by careful design practices is essential for maintaining a good and fruitful relationship with the target audience. Because all the data collected for the solution is harvested by the presentation layer, it is imperative that the interface is clean and easy to use. There are few specific requirements for a good design; however the following five rules are highly reliable for distinguishing and producing a better interface.

Be Consistent

Users, including the designers themselves will always be drawn to enticing looking applications. But beyond the look and feel of the design, be ever vigilant about the thought process of the user base. When establishing the base flow of the solution, maintain certainty that the position and appearance of all interactive components remain the same. After a brief glance and review of the solution, every user should be quickly able to identify the relative look and feel of the functional aspects. This applies to navigation, validation, requirements, help and assistance. In summary, the end-user should not need to think in order to complete any behavior.

Be Simplistic

While it is often a great idea to have a very flashy presentation with all the bells and whistles of the competition, keep in mind that quite often users are more apt to return to an application - NOT when it is pretty, but rather when it is simple and easy to use. This, at times, will mean limiting the interface to "text-only" to remove complexity of the design. The key point is to five the user an interface that they can understand without referring to any general help. This makes it more likely that they will use the solution, and increases the odds of their frequent return.

Be Fast

Many applications suffer due to inappropriately long wait times. Obviously at times the slow downs are unavoidable due to process intensive workflows. However, it is often difficult to convey this to the end user who dreads the all to frequent, "Please Wait..." message. Delay is nothing something people will often do voluntarily and on many occasions this will instantly lose the user base.

To reduce or eliminate this as a possibility, there are a few simple ways to move forward:

#1 - utilize callbacks, today commonly in the form of AJAX requests. Reduction of full trips to the server to only update specific information within the page is a large waste of time.

#2 - Optimize the data interaction technique. This means making appropriate use of the data indexing and construction from the beginning of the project, with performance being the key focus. This also means taking advantage of retaining previously retrieved information, or caching, whenever possible. As a rule of thumb, it is generally more efficient to use memory or file space rather than burning CPU cycles.

#3 - Reduce the size of your request and response. Tools like Firebug and Fiddler are very useful for evaluating the specific size and timing of the application interfaces.

#4 - Don't blame the host. In most situations, the problems addressed by the previous three possibilities will aid in a resolution. Always be proactive with the performance plan. Purchasing the lowest end site hosting option may be cost effective on your wallet, but it will performance prohibitive for the users.

Be Reliable

When a user is utilizing the application is often a concern that the reliability of the server comes into question. Quite frequently the reliability of the application itself is a major culprit of user loss. The user should always feel safe that their time and energy will not go to waste. This means that the solution should not only be bullet proof, but also provide "warm and fuzzy" feedback confirming each of the actions the user has performed.

Be Pessimistic

It is imperative that developers stay vigilant and forever persistent regarding the data each end user is providing. This is for the reason the users don’t always fulfill the information requirements that were anticipated. Or, in a more severe thought, the requests being made against the application are malicious in nature, attempting to manipulate or destroy the solution. Always perform validation of the required data on the presentation interface, and NEVER trust the data received by the server. Security and Data consistency must always remain the primary focus of the approach. 

Business Layer

Providing the functionality that is required for the target audience and solution is the primary goal of Open Web Studio. Once the required data has been collected by the front-end the data can then be used to fulfill the business process. The workflow environment of the tool, in the form of Actions, supports both the standard presentation aspect as well as the data source requirements. The functional structure business layer handled by the utilization of server based logic including:

  • Template: Query, Header, Footer, Detail, No Query, No Result
  • Branching: Region, Conditions, Looping, Events, Goto
  • Variables: Assignment, Query Variables, Filter
  • Actions: Query, Delay, Email, File, Input, Output, Log, Redirect
  • Interfaces: Search

Each action within the execution plan of the Open Web Studio configuration is provided with a simple property driven administration. This lets the builder complete the development by using, not by memorization. The fundamental constructs of the runtime are all easy to manipulate, organize and flow into one logical output structure. Because the core concepts of the functionality are handled behind the scene, and the attributes are friendly and limited, the complexity of the application for most business solutions is radically simple.


In terms of return on investment, the investment being the opportunity cost of the employment period for each developer, compared to the physical productivity level achieved by each developer during the life cycle of a development effort is huge. Since much of the ground work is already in place for creating rich, fast, and interactive applications by the Open Web Studio framework, developers can begin full scale development during the discovery phase. In essence, the developers are already developing the final application during the period in which designers and developers in the initial prototype for the client. This "mock-up" is completely translated into a working application by simply extending any missing functionality and rounding out the quality assurance and any short-cuts.

The change a developer makes during the construction phase of the model is immediately available and publishable to the presentation. Because the developers are not experiencing any down-time waiting for compilations, builds and web server startup during the "write, check, repeat" practice - there is very little lost effort. Therefore, maintaining considerably higher productivity levels.

The production system is rolled out quickly and easily from this system, because it is simply exported and imported between target servers (regardless of the platform). The developers don't need to work through logistics of installations, changes and scheduled updates (again, because the server won't require a restart). Also, final changes requested by the client can be made instantly on the server (either production or staging), and no development loop is necessary.

Finally, the on-going maintenance of the target solution is made quickly and easily, since the workflow and data processing of the systems are all uniform and simple to ready and manipulate. The productivity level of any developer on the target production system will remain high through the life span of the product, and not directly dependant on the association of the original developers to the product.

Data Sources

Open Web Studio provides the ability, through Queries and Input actions, to contact both traditional and modern data sources. The versatility of the tool itself is demonstrated by how quickly it can be adapted to one or more data environment simultaneously, with very little direction from the developer. The provided tools support this capability seamlessly.

Traditional - Data Access

Data connectivity, including high performance and high impact data sources, is supported for nearly any data source which supports oleDB or ODBC. The "Traditional" sources are generally thought of as local database systems like SQL Server, Oracle and mySQL. Connecting to these sources is simple and well-known, because they are typically referenced within the local server environment. Open Web Studio supports the ODBC, oleDB, and SQL Client interfaces inherently, so setting the connection to the target database is the only requirement. Once the data connection is made, all data can be consumed and used as if they were all native to the environment.

Modern - Service Agents

As the future has droned on, new sources, concepts, protocols and features have been introduced globally for data consumption. These sources are generally referred to as "Data Services" and are accessible using a variety of different formats. The most common of these are: Web Services using SOAP, JSON services, Restful and XML Services, but many others using different types of protocols are also widely available. Retrieving data from these sources is just as simple as the Traditional Data access models; however more understanding of the target source is required for appropriate functionality.

Additionally, the extension model of Open Web Studio allows .Net developers the flexibility of creating Actions, Tokens, Formats, and Query Types that will provide a "best of both worlds" approach to their development efforts.



Much like other development patterns, and the approach of object-oriented design, the presentation layer and business layers are separated. The essential concept of the runtime for Open Web Studio, however, is fundamentally different. It is unique in that its built from the ground up to attach to a data source, and bind a template to its result. This template is the Presentation that is generated during the Workflow. This adaptation makes the environment of Open Web Studio capable as both a standalone entity, without specific data sources, as well as a fully integrated data centric component.

The template itself uses a Wiki style language token structure that is familiar and simple to utilize. This token logic allows for direct placement of values within the layout templates without requiring any further effort. When a query contains a column called "myColumn" for example, using this column within the template is as easy as typing [myColumn]. Thats it!

Finally, it is important to state that the Open Web Studio engine is not meant to only return HTML. The engine can return any content, with any format. It has been used in thousands of situations with different target types like XML services, data feeds, RSS feeds, Image processors, Media galleries, Document Repositories, etc. It's truly limitless.

Average (0 Ratings):
Want to help out?

New York, NY • Baltimore, MD • Vienna, VA • St. Louis, MO • Seattle, WA •

Bookmark & Share Bookmark and Share