As the push to Web-based computing gains momentum, the variety of available tools, standards, techniques and languages gets increasingly complex. In implementing a Web strategy, IS managers must make some hard decisions on issues that include: supported browsers, ISP selection, Web server platform and OS, application server platform and OS, object architecture standards, client-side component approach (HTML vs. Java vs. ActiveX), server-side component tools (VB5, C++, PowerBuilder 6, Delphi, Java), security standards, database engine selection, search engine selection, business content creation and more.
Enter SilverStream, a new company with a phantom-like image, a star-studded management team, well-tuned development staff and an extremely ambitious vision of what a Web- based development platform should be. The product is also named SilverStream and we saw it for the first time in June at SilverStream's HeadStart program. The number one question we wanted answered was: Is there substance behind all the hype? The short answer: Yes! Although it is a 1.0 product, SilverStream lives up to most of its claims and will be something that you must consider if you want to create Web applications.
What is SilverStream?
SilverStream, founded in 1996, is based in Burlington, MA. The management team is led by Chairman David Skok (founder of Watermark Software, a market leader in document imaging.) Also from the Watermark team is Peter Brumme, COO, and Arny Epstein, Chief Technology Officer (Arny was also Chief Architect at Lotus). The President and CEO is none other than former Powersoft President and visionary David Litwack. Other Powersoft heavyweights include Kim Sheffield (aka Mr. DataWindow), David Dewan and Ed Clarke. Add to this a seasoned development staff combining cross-industry talent from Powersoft, Iris, Lotus, OSF and others.
In developing the SilverStream product vision, it is evident that Skok, Litwack & Co. took a hard look at the underlying model of Web-based computing and determined that it required a new set of tools tailor-made for the Web. The new product is a fresh 3-4GL environment which addresses about 80 percent of the needs for Web-based development.
Web development is very different from traditional two-tier client/server development. Some of the major Web development concepts that SilverStream addresses include the following:
Pure Three-Tier Approach
SilverStream was designed to incorporate the three-tier approach in its purest form. The client-side objects know nothing about the database, contain no database drivers, etc. Corresponding server-side components provide all the needed database transactions and other business service resources. The two sides communicate based on powerful SilverStream Java classes. The client automatically communicates with the server and the developer doesn't have to deal with the communication between the two partitions. The approach embodies the client services/business services/data services model.
SilverStream leverages RDBMS functionality by using it to store all application metadata. Currently, five engines are supported: Oracle, Sybase SQL Server, MS SQL Server, Informix and Sybase SQL Anywhere. The application metadata is stored in five system tables which can be kept in the same database as the application data or in a separate database. In addition, SilverStream creates ten tables for internal use to store security information, logging, etc. This approach allows SilverStream to offer several key benefits right out of the box such as full text searching (via Fulcrum's search engine), replication, automated backup, scalability and security.
When using the tools included in SilverStream, you'll notice that this is not a Windows-based application. Everything is written in Java. Many of the well-known graphical metaphors are present, such as wizards, menus, tool palettes, property dialogues, drag/drop, WYSIWYG editors, etc., but they all inherit from Java classes, not Windows classes. This makes the multi-platform issue an easy one for SilverStream. Their "sandbox" appears pure and porting the development environment, as well as applications built in it, should be a no-brainer. Server-side and client-side Java class construction is extremely easy and the communication between client Java and server Java is handled automatically by the SilverStream Server.
Convergence of Structured and Unstructured Data
SilverStream cleanly combines structured data (traditional relational corporate data) with user-driven content (rich text, multimedia, backgrounds, links, sounds, etc.). Both structured and unstructured content are stored in the same database. For runtime content creations, SilverStream provides a rich text edit control that allows the user to "draw" an HTML page and store it in the database as a blob. In addition, with the User Content agent a URL can be assigned the HTML the user creates. Think of your users creating their own pages of HTML and having them automatically stored in the database related to real data while also having a URL attached to the new content. Finally, SilverStream lets you specify what type of data (in addition to HTML) is being stored. This includes sound, video and file attachments.
This idea has been around for years but never completely integrated into an application development environment on a large scale. With SilverStream, it's everywhere. Server-side, trigger-based logic comes in the form of agents-Java classes created in SilverStream triggered by an external event which performs some server-side action. Examples of agent functionality include: e-mails fired off whenever a Web site is hit (SilverStream is e-mail savvy), HTML pages created whenever new products are added to the database or any type of workflow functionality.
Java or Dynamic HTML Applications
There seems to be some debate on whether Dynamic HTML or Java is best for the client. SilverStream applications have the added benefit of presenting themselves at runtime to the client browser in either Java (richer content, fatter client) or dynamic HTML (constant page refreshing, slower, thinner client). The dynamic HTML approach is the purest application presentation to ultra thin clients for Internet applications. However, Java on the client allows a much richer user experience and more sophisticated business applications. These types of applications tend to be Extranet or Intranet in nature, require one-time downloading of a nearly 1 MB Java class file and the user's browser to support the latest Java Virtual Machine, JVM 1.1. The browsers to support 1.1 won't be released until later this year. If needed, you can run the client on the user's machine by installing JVM 1.1 on the user's machine and using SilverClient.
What is Included in SilverStream?
What areas are covered in the SilverStream development environment? The only thing it doesn't provide is a browser and an e-mail client. Here is a summary list:
- A fully functional HTTP 1.1 server which performs standard Web server duties along with connection pooling, security administration, and transaction management.
- A page designer which includes a powerful HTML editor, drag/drop functionality for images, sounds, JavaBeans and other SilverStream components.
- A Form Designer for creating container classes with database aware fields, etc. Forms can be placed within other forms.
- A Data View Designer for creating data- aware list views, hierarchical views, nested views, etc.
- An Agent Designer for creating server-side components which are triggered by some external event.
- A Database Designer for creating/modifying tables, defining and viewing foreign keys, etc.
- The Silver/Client application for running SilverStream applications without a browser.
- The Fulcrum Search Engine for providing full text search capabilities on any database field.
- A ten user version of Sybase SQL Anywhere
SilverStream Development Environment
Building an Application in
To learn and test SilverStream, we built a customer browser. We wanted a Web page that allows the user to scroll through a list of customers and edit information about them, including contacts, orders and free form notes.
Creating the Customer Form
We start by running the SilverStream Designer, which shows a hierarchical list of all SilverStream-aware databases. Remember, in SilverStream an application lives in a database. By expanding a database we see the components that make up the application, its forms, views, pages, agents, objects (JavaBeans, graphics, etc.) and security.
We used an existing database that had customers, orders, contacts and customer notes. Using the table designer, we were able to view tables and columns in the database. The table designer does not substitute for a good data modeling or DBA tool, though!
The first step was to create a customer form. When you create a form in SilverStream the designer walks you through to create the default behavior of the form. You specify a primary table and then the columns you want on the form. Finally, you specify a presentation style (many are provided and you can build your own defaults.) Styles include look and feel as well as pre-defined functionality.
Forms in SilverStream are attached to one primary table. SilverStream automatically handles the updating of data to that table. If you want to update multiple tables, you'll have to code that yourself. SilverStream gets its data into this form through something called AgData. (All SilverStream classes begin with Ag - recall your periodic table in chemistry?) The AgData class communicates with a corresponding dataset on the server to perform database transactions, etc. SilverStream automatically handles bringing the data into the client from the application server. It has written the client and server portions for us already. When the form loads, SilverStream will do an initial retrieve from the app server and then get extra rows in a background thread so the user can perform work.
Since the form and everything on the form are objects, it has events, methods and properties. The properties for the form itself include the background image, the primary table and fields, custom events and form parameters, size and the HTML help page to use for context sensitive help for the form. Properties for the field include datatype, whether the field is editable, client-side validation rules, font and background, the database column bound to the field, tool tip text, visible and enabled attributes as well as position and size.
We clicked the test icon and ran the form. The Designer sends the form to the server, the server compiles and runs the form (at release time you should be able to use the Sun compiler, Visual Café, PowerJ or Visual J++). The first row of data appeared and we were off and running, editing, scrolling and searching through data. The buttons for data navigation come free through the form wizard and allow forward and backward scrolling or scrolling to first or last row. Buttons for "find" mode allowed us to quickly search for rows matching any criteria.
The form designer tool palette includes icons for a variety of controls; these include buttons, labels, text fields, multi-line text fields, rich text fields, check boxes, radio buttons, tab controls, etc. We added a tab control and allocated three tabs. On the first tab we wanted to see contacts. On the second tab we wanted to see a list of orders (and items on each order). The third tab will contain freeform content.
In SilverStream, a view is similar to a form except that you don't put other controls on a view.
We first created the contact view. The View Designer asked us for a primary table just like the Form Designer did. We selected the contacts table and a few columns. We assigned a style and named the view. we did not define a where clause or any arguments for retrieving data.
We then went back to our form and dropped the view on the first tab page. SilverStream is data-smart enough to know that the primary table on the view is related to the primary table on the form via the foreign key: customer_id.
SilverStream automatically creates a master/detail link from the form to the view so that when the row of the form changes, the corresponding contact list changes. Not only does the form handle the embedded view's navigation but it also handles the transaction updating.
Including a Hierarchical View for Orders
Now, let's do something harder. How about master-detail-detail - with math. We want to see a list of orders. When an order is clicked, we want to see a list of items with quantity, description, price, etc. Each order should be totaled. This implies joining the orders, order_detail, and product tables with aggregate math.
We went to the view designer and selected the order table as our primary table. We chose the normal columns you'd see for an order header. Now for the cool part! SilverStream shows us other tables available for nested views by way of foreign keys (or soft' relationships). Since order_detail is related to orders it shows up on this list; we select some columns. Since SilverStream knows that orders (order_detail) is a one-to-many relationship, it automatically detects a sub-view. All order_detail columns we select are listed in the sub-view. But it doesn't stop there. SilverStream shows us the tables related to order_detail for further column selection. We chose product name from the product table and SilverStream handled the join for us.
Once our view is built, we can modify and change it at will. The View Designer is a banded report writer like Crystal Reports or PowerBuilder's DataWindow.
We saved this view, dropped it on our form and tested the form. SilverStream automatically handled the master/detail relationship between the customer on the form and the order view we just created. Remember that the server is handling the data for us; the client isn't making any access to the DBMS. Had we defined SilverStream row level security on customers or orders, the server would automatically enforce that security on everything we were running.
Adding Rich Content
On our third tab we wanted to show an HTML page. We dropped a rich text control and associated it with a blob column that is in our database. That's it! The user can now add full rich text which is saved as HTML. The rich text control is really a full-fledged HTML editor! You can add images, sounds, links, tables, etc. SilverStream handles saving the HTML and it saves each object (image, sound, etc.) the user embeds as a separate object. Finally, with the User Content Agent you can make the HTML page the user creates accessible directly via a URL.
Programming in SilverStream
So far, the application has been built without any need for programming. However, to get heavy-duty applications built, you'll need to program. When needed, there are two ways to program: Simple Script or Java.
The simple script editor is a tool for power users who want to build in specific behavior and event control without knowing Java. SilverStream provides a host of prebuilt actions and scripts which are, for the most part, plug and play. Doubleclicking on a control brings up the script/Java editor. From the editor, you can point and click to achieve conditional logic, branching, as well as choose from many prebuilt actions such as jump to Web page, next row, save, etc. SilverStream presents the logic in color-coded, indented psuedocode. We chose a simple If-Then condition, coded the city check and then embedded an action to open a message box. Wizards took us through both the conditional statement expression and the content of the
By clicking the Java button we saw the code that SilverStream had generated. Once you edit the Java, you can't go back to Simple Script. The Java editor gives point and click access to all related objects and methods, color-coded and auto-indent scripting, error checking, etc.
Areas for Improvement
One thing we couldn't leave out was areas for improvement and concerns. So what is missing? Well, here are the areas:
SilverStream is aware of these issues and many of them will be addressed in an upcoming version. The most important on their list is stored procedure support and a debugger.
- No debugger
- No automatic recovery features (if the server crashes, etc.)
- No reporting tools
- No stored procedure support (it can be done manually but what's the point?)
- No version control
- No inheritance of Ag class (you can't subclass their objects)
- No built-in way of communicating via IIOP/CORBA or COM.
- No foreign language support
- No support for ActiveX controls (unless they are wrapped in a JavaBean)
Another issue to be determined is scalability. The underlying architecture is very well defined and scalability should not be an issue. However, in the first release only Windows NT will be supported as a server platform. Shortly after the 1.0 release they plan to ship a UNIX version (probably Sun first). Because SilverStream is written in Java, porting to other platforms should be easy.
Finally, let's talk stability. The HeadStart version we have does crash occasionally but is very stable for a product that is considered pre-release. Every bug we've found they already know about. The developers tell us that Java is wonderful to program in because there aren't any memory leaks or bad memory references that you get in C++.
Both of us are very experienced in corporate application development. Within 30 seconds (literally) of walking out of our first four hour demo of this product we, along with some other people in our company, said that this was technology worth investigating.
About the Authors
Steve Benfield is Vice President of Technologies and Brad Cooley is a Branch Manager at Financial Dynamics, a consulting and development company. Steve is a well known architect and developer. Brad manages several high-profile development projects.