PowerVista Software is used to build database applications using popular commercial database platforms, the included single-user PowerVista database or your proprietary database. PowerVista's most unique feature is using Regeneratable Styles for application development. An application built with PowerVista may be deployed over a wide range of configurations, from single user to client/server and over the Internet. 

PowerVista builds excellent database applications by combining the processing power of 3GL languages with the clarity of markup languages and adding the development efficiency found in rapid application development environments.

Philosophy
PowerVista is to developing database applications what Internet development tools are to publishing on the World Wide Web. To deliver a complete web site, a programmer needs authoring tools, browsers, HTML and a web server. PowerVista has identical components, but is focused on database application development. PowerVista is based on the belief that the building blocks required for successful database applications can be distilled into an abstract language. This language is similar in concept to HTML but rather than altering text, PowerVista's language specifies the appearance and the behavior of user interfaces that interact with database information. 

This philosophy is extended through Regeneratable Styles. Applications normally have between five and eight standard window types. PowerVista uses a Style to create these standard application windows using any database view. Each window is custom generated with desired behavior and window appearance using the developer's selections. Manual changes using traditional programming techniques are preserved during Regeneration to add additional fields, schema changes or other enhancements. Regeneratable Styles dramatically reduce the learning curve, resulting in rapid delivery of consistent, customized and complex applications. These applications meet the most rigid criteria for cost effective deployment, maintainability and extensibility.

Technical Background
PowerVista has two main components: 
PowerVista Bridge is used to create database applications using a set of authoring tools (BridgeBuilder), PowerVista Markup Language and PowerVista Application Browser.
PowerVista Application Server is used to transform PowerVista applications into Internet database applications.

PowerVista Bridge's technology results in five outstanding benefits:

1. Productivity Gains: Developers realize 3 to 10 fold gains in productivity with PowerVista Bridge. Using Regeneratable Styles and its purpose-built language, PowerVista delivers the efficiency found in creating text web pages to traditional client/server application development. PowerVista is an interpreted environment, allowing iterative development and testing without pausing for compiling the code. 

2. Customizable Environment: PowerVista Bridge is a comprehensive database development environment. It includes full featured List (spreadsheet) and Tree controls, basic window controls, report writer and graphing library. PowerVista offers a flexible and powerful array of support mechanisms for integrating third-party software. The Style Library can be customized to support a particular application style, a specific database schema structure, application purpose or development organization. 

3. Database Independence: PowerVista Bridge is designed around a database independence layer, which allows connecting the same application to any commercial database. This architecture supports our own, included single-user database and makes it simple to add support for proprietary/legacy database or other databases as needed. PowerVista even supports simultaneous connection to databases from different vendors. The database independence layer is responsible for creating all the low level SQL statements using the proper syntax. The developer does not have to alter any code to transfer an application from one environment to another.

4. Flexible Application Deployment: The same application can be deployed as a standalone application, on a LAN on a WAN or over the Internet... unchanged. Once your application is created, you can deliver to your customers in any method that suits their particular needs.

5. Reduced Maintenance: PowerVista Bridge encapsulates our expert knowledge of building database applications to enable a very short learning curve and a high degree of flexibility. This allows your expert developers to effectively leverage their experience across development teams with a high percentage of entry-level programmers. It results in teams that rapidly deliver applications that solve business issues and easily evolve to meet new challenges.

PowerVista is focused on making the developer - whether novice or experienced - successful in building database applications. Regeneratable Styles enhance every developer's success rate. Each Style generates an entire interface  - from edit field label color to record insert actions - as a  complete, working window.  Then, any manual changes needed to customize the window can be made. Regenerate the window at any time to add or subtract style elements. A specialized comparison/merge routine ensures that generated changes are applied without ever losing a single manual alteration. The developer can even make choices on a change-by-change basis. In our own Shareware applications, we typically generate complex windows in between 10 and 15 minutes. The same window would take between 8 and 20 hours to code manually.

Comparison with Other Development Choices
The business justification for better application development tools has its foundation in the economic realities of the marketplace. Many tools have already been commercially released, but PowerVista Bridge is different than anything else. 

• Procedural languages are superior for writing the algorithmic parts of applications. C++, Java, and Visual Basic are in this category. Procedural languages are best at "doing things", they lack non-procedural  constructs that allow describing applications - "showing things". Each language has a limited non-procedural capability delivered through property sheets and layout editors to describe user interface components. PowerVista is unique in supporting specification of visual presentation and behavior in the same context.
  Procedural languages have a limited built-in ability to connect to commercial databases. PowerVista automates the process of connecting database information to the application seamlessly.
  Procedural languages are development-time intensive and require highly trained (expensive) resources. The learning curve for PowerVista Bridge is much shorter than for procedural languages. It is more accessible to journeyman developers, while allowing experienced developers to realize a level of productivity not previously possible.
  PowerVista Bridge contains a fully featured, object-oriented procedural language that integrates invisibly with the layout and presentation of the application.

• Descriptive languages such as SQL or HTML focus on describing entities. Each is limited to a specific purpose, and must be extended using other tools to deliver a complete application. For instance, you must add CGI, ASP or other server-side components to HTML to obtain a sound front-end combined with processing capability. 
  Applications written with HTML are less useful in transaction-based, or high volume editing/evaluation situations. PowerVista Bridge applications provide a user experience equal to a traditional 'fat client' (including over the Internet) with a single set of tools.
  The procedural functionality in PowerVista Bridge combined with the rich set of user-interface controls easily solves problems that are impossible to resolve using HTML.

• RAD (Rapid Application Development) environments are designed for prototyping and developing complete applications. They attempt to solve the drawbacks of procedural or descriptive languages. There are a number of RAD solutions - it is a very diverse category. However, in one way or another, each falls short of the mark. Some dictate, with very little flexibility, how the application will look and behave. Some have a limited set of controls and don’t offer the ability to add new controls or behaviors. Some generate C code or HTML, with the attendant issues of maintenance. Code generation also requires compile time. Most have issues with scalability and some only offer connectivity to a single database.
  PowerVista is flexible, has a complete set of user interface controls, supports rapid development without compilation time and supports connectivity to a wide variety of databases. Regeneratable Styles extend these benefits into the realm of completely customized development environments for an enterprise, a business unit or a single application. 

PowerVista Bridge is the optimal choice for businesses that need to rapidly create graphical database applications that capture the essence of their domain expertise for their end-users. PowerVista Bridge is a different approach to developing database applications. It combines the processing power of procedural languages with the clarity of descriptive languages and the speed and efficiency of RAD environments.

Components of PowerVista Bridge

PowerVista BridgeBuilder is used to write PowerVista applications. It combines a visual layout editor and a text resource editor. This allows simultaneously programming in a procedural manner (by typing text) and a non-procedural manner (by placing widgets on the window). Each editor updates the other, so that placing an EditField control in the layout window updates the text representation in the resource editor. Regeneratable Styles are a PowerVista innovation for allowing application architects to focus attention on the process of distilling their knowledge into new applications. A Style set becomes a customized development environment for for an application or organization. When a window is generated using a Style, it automatically becomes editable in both the layout editor and the text resource editor. Changes can be made to the generated window using either approach. The altered window can be redisplayed in its Style, elements added, then regenerated while preserving the manual changes made in the layout and resource editor.

PowerVista Application Browser is similar in concept to an Internet browser reading HTML code and presenting published material. Internet browsers are designed to publish documents whereas PowerVista Bridge is designed to create database applications. There is another similarity between browsers and PowerVista Application Browser: their generic nature. The browser does not depend on any particular HTML description and PowerVista Bridge does not depend on any particular set of PowerVista Markup Language (PVML) scripts. One installation of PowerVista Application Browser can be used to operate any number of PowerVista applications.

PowerVista Markup Language (PVML) is a descriptive language designed specifically for building database applications. A "declarative" language with very little syntactical noise, PVML is unlike anything else available today. The descriptive part of the language is a list of statements about characteristics of the thing described. For example, "Bill's car is red. It has a 210 horse power engine. It has a wheel base of 96 inches." As shown in this example, PVML models the real world process of description.

Car {
  Owner( Bill )
  Color( Red )
  HorsePower( 210 )
  WheelBase( 96 inches )
}

Database applications readily lend themselves to this type of description. The database schema, menus, toolbars, windows, controls and import/export formats are described clearly, concisely and completely using PVML. The procedural part of the PVML language is similarly structured. Using specialized 'Actions' properties along with standard programming constructs such as looping, switching and branching commands, the behavior of the application in response to user input is coded at the same context level as the appearance of the application.

PowerVista Bridge applications lend themselves to expansion. If you know how long it takes to make changes to a text web page using HTML, you have a very close estimate of the time and effort involved in maintaining applications built with PVML. PowerVista Bridge has the same kind of prototyping capability built into it that you find with writing text web pages. Changes made to the application can be viewed and tested without  closing the live application. Not only can you develop quickly and deploy efficiently, you also reduce the largest single cost of commercial applications: maintenance and enhancement.

Database Independence is a core feature of PowerVista Bridge. Internally, PowerVista Bridge uses a database independence (DBI) layer. The DBI allows support for a variety of database engines, including ODBC, Microsoft SQL Server, Oracle, Sybase, IBM's DB2, Pervasive.SQL 2000, CaseMaker's DBMaker and our own internal single-user format. The DBI delivers the database independence promised by SQL and ODBC. With PowerVista Bridge the developer changes one property when describing the database, and the application moves seamlessly from one database engine to another.

The DBI layer also allows PowerVista Bridge to meet your special needs because it can be implemented economically on top of proprietary database engines. For companies with legacy products, this feature provides a means of building hybrid applications. The DBI supports moving key portions of an application to a graphical interface in an evolutionary manner.

PowerVista Bridge user-interface controls are tightly connected to the application's data. The DBI serves data to each control and provides the conduit back to the database to store changes. This design allows PowerVista Bridge to offer features that applications written in other languages must ignore. For example, there is no 'stale data' in PowerVista applications. If a particular record is displayed simultaneously in a form, a list, a tree, and a graph, changing that record anywhere causes all other views of that data to be updated. The developer does no extra work to include this feature; it is part of the DBI. Another advantage is that small syntactical differences between vendor's SQL implementations are invisible to the developer. Translation is automatically taken care of internally. This also means that SQL statements are automatically translated - without developer intervention - if the application is operated on a different database platform.

PowerVista is written in C++

Object-oriented programming is absolutely essential to developing a system as big as PowerVista. The Application Browser is a large C++ program that reads and interprets the hierarchical PVML language. The PVML language itself contains the ability to declare classes,  has a limited pointer implementation and inheritance mechanism. The Styles are written using the object oriented aspects of the PVML language. The BridgeBuilder itself is written largely in PVML.

Designing PowerVista Markup Language 

When designing a tool to implement abstractions, we first ask what the abstraction must do. What behavior must it implement? What does the abstraction need to do? What is the underlying generalization of the abstraction?

After we have completely defined the behavior of an abstraction, we ask what information needs to be specified so that the abstraction can implement the desired behavior. What does the abstraction need to know in order to do what it needs to do?

This answer dictates the design of the PVML properties that implement the abstraction. When running the application, as these abstractions are used, specific C++ objects are instantiated that carry out the specified behavior. The C++ objects are driven by the data supplied by PVML. Another way of thinking about the PowerVista abstractions is that they are similar to persistent objects. The PVML code causes C++ objects to be instantiated with the desired behavior. When the application is 'compiled' or packed, the text form of the PVML is turned into a binary resource. The binary form of the language processes very quickly and is not alterable by the end-user. Since the rendering engine is separate from the application's binary file, a single installation of PowerVista Application Browser can operate a number PowerVista applications.

PowerVista is used to develop PowerVista

One of the fundamental premises of PowerVista is that it is better to define abstractions in the PowerVista Markup Language (PVML). PowerVista itself is driven by our markup language. This the "script definition", which is written in PVML. The script definition defines what the properties are, what order the properties should be processed, whether the property is optional or required, whether the property may be repeated, and the link to on-line help for the property. The BridgeBuilder and all the Styles are entirely written in PVML. 

When any PVML script is processed, the ApplicationBrowser or development engine parses the resources against the script definition. This general purpose engine care of such things as internally putting the properties in the correct order and error processing. When implementing an abstraction, the C++ developer who is using the engine doesn't need to worry about error processing for any scripting syntax errors.