I was interested in learning more about Netscape Application Server (NAS) and Netscape Application Builder (NAB), and I'd heard good things about Netscape's Codestock technical seminar series for developers, hosted by Netscape's Technology Evangelism team. I nevertheless approached the October 7 Codestock on NAS and NAB with trepidation. Would the speakers be knowledgeable and the content engaging, or would I need a triple latté to stay awake?

In fact, my fears weren't realized: even the high-level, business-oriented discussion held my interest and taught me a few things, and the technical presentations were substantive yet easily comprehensible. Anyone interested in developing sophisticated web-based applications on the Netscape platform would have benefited from attending this seminar. So, for those of you who missed it, we'll take a look here at the presentations made that day, to give you a better sense of NAS and NAB as well as an idea of how Codestock can help in the future with your Internet development efforts.

The Codestock speakers assumed the audience was already familiar with the concept of an application server and its thin-client, multitiered architecture; this article assumes the same.

Technology Evangelism Manager (and View Source editor) Paul Dreyfus kicked things off with opening remarks about the measures Netscape is taking to help developers (Codestock being only one of them). Three presentations followed:

• A high-level business perspective of NAS by Keng Lim, formerly of Kiva Software (the original creators of NAS)
• A technical discussion of one company's experience using NAS to build a sophisticated web application, without using NAB
• A preview and demo of the soon-to-be-released 3.0 version of NAB

Feel free to skip to whichever topics interest you the most. If you'd like, you can download a zip file containing slides from the first and third presentations, which can be viewed using PowerPoint. (An article covering the contents of the second presentation - the company's experience building a NAS application - will be published in an upcoming issue of View Source.)

NET TECHNOLOGIES FOR YOU

Paul Dreyfus noted that his group's mission is to enable developers to create great Internet software based on the Netscape platform. This mission centers around your needs as a developer: anticipating your questions by producing the materials you need to be successful, and collecting your feedback and passing it on to Netscape's product groups. This critical link between you and Netscape's development efforts takes the form of the Netscape Technologies web site, and of course View Source magazine. In addition, Netscape hosts a variety of seminars and conferences, including Codestock about once a month and DevCon (the Netscape Developer Conference) every year or so; the DevEdge Online web site will keep you posted on all such events.

Paul pointed out that to succeed in the world of the Internet today, companies need to become enterprise service providers, delivering services to large communities of partners, suppliers, and customers. To help make this possible and economical, Netscape offers the development platform (Netscape Enterprise Server and NAS), infrastructure technologies (directory, security, and messaging), and applications (CommerceXpert ecommerce products) that you can use to connect people and businesses through the Internet. Enterprise business applications on the web must be able to scale to very large numbers of users, be centrally managed, and be customized to fit individual customer requirements; NAS and NAB, along with other Netscape and third-party products, make these goals easily achievable.

NAS FROM A BUSINESS PERSPECTIVE

It's hard to imagine a speaker more excited or knowledgeable about his subject than Keng Lim is about NAS - and it's no wonder: Keng was the founder of Kiva Software, the company that originally created the technology upon which NAS is built. Keng was one of the first people to begin thinking about an application server; back in the web's "infancy" in 1995, Keng already understood that developers would soon need a development and runtime platform for sophisticated, high-performance, web-based applications. That vision became the Kiva Enterprise Server; when Netscape acquired Kiva Software in late 1997, this server became Netscape Application Server, and Keng became vice president and manager of Netscape's Application Platform and Managed Content group. Here we'll review what Keng had to say at Codestock about application servers in general, and NAS in particular, from a business perspective: how the market has changed, where it's going, and how NAS fits in.

Only a few years ago, the concept of an application server was unheard of, whereas now application servers play a key role in business transacted by companies like Citibank, MCI, General Motors, Toshiba, and many more. We're in a new, network-centered era, the difference being not so much that there are new technologies but rather in how existing technologies are being applied. It's analogous to DBMS for the traditional client/server architecture: DBMS was the cornerstone, and other tools evolved around it. Likewise, the application server is the cornerstone of web application architecture today.

Web business for 1998, which was estimated to be a $100 million market, will actually triple those expectations. The market doubles every year, and the estimate for the year 2001 is $2 billion, Keng said. Being successful in the "net economy" requires a new way of thinking about extending business - supplementing (or perhaps even replacing) traditional operations with online services to meet new customer demands. Businesses need to focus on what services to set up and how to draw customers into using them, rather than on low-level implementation details.

Times have changed. Whereas a couple of years ago the standard user interface platform was Windows, today it's browsers. And the scale has changed: in the old client/server world, 200 was a large number of clients, but now businesses need to think in terms of hundreds of thousands - or even millions - of clients. Clearly the need for central management and reliability is critical when the numbers become this large.

The Application Server Solution

Application servers provide the infrastructure that's needed for the quick creation of reliable large-scale business applications on the web. The multitiered architecture enables the appropriate skills to be applied at each tier: presentation logic resides on the client, application logic on the application server, and data validation rules on the database server. In particular, having application logic on the server side rather than in the clients results in an efficient client-independent programming model, with easily reusable, centrally located business objects. Security and performance are optimized. As the number of users increases, servers can be added and the load distributed through dynamic load balancing.

So, all signs point to the application server architecture as the solution for doing business on the web. But since time to market is a critical factor, building your own application server isn't practical. Here, of course, is where Netscape Application Server fits in. It provides the means to perform these three vital functions:

• Developing applications, using Netscape Application Builder's intuitive interface to build applications quickly (or using third-party tools to meet more sophisticated development needs)
• Integrating with legacy applications as necessary, through extensions that are either prebuilt or custom-built with Netscape Extension Builder
• Deploying applications, through NAS's powerful deployment environment, which enables web applications to be installed and updated globally at the touch of a button

Unique features of NAS's development environment include its HTML template facility for defining the user interface (whereby UI elements are inserted into templates at run time) and a results-caching mechanism for improved performance. However, Netscape doesn't claim to have the best development tools in the industry. It sees the basic server product as being separate from tools and has chosen to focus on having the best deployment platform rather than the best development tools. Netscape espouses the "open tool" philosophy, believing that all application servers will need to open up to working with a variety of tools.

For the future of application servers, Keng sees standardization around the Enterprise JavaBeans (EJB) architecture - and NAS is a proven infrastructure that can provide robust support of EJB. In closing, he summarized the three major product areas in the application server market: development tools; low-end application servers, which are sufficient for small- to medium-scale applications; and enterprise-class application servers, where NAS is the clear leader.

IMPLEMENTING OBJECT-MODELED APPLICATIONS WITH NAS

Corby Page is the manager of engineering at Net Explorer, Inc., a Houston-based company that specializes in custom application design and development. He began his Codestock talk with a quick review of the technical highlights of NAS, first the development environment and then the runtime environment. (While some of these remarks repeat those made earlier by Keng Lim, it's interesting to see where they overlap, considering the different perspectives of the speakers.) Corby went on to explain what aspects of this model worked - and did not work - for Net Explorer when they were faced with the task of building a sophisticated web application (Oakley's O Store) in a very short time.

The Good News

On the development side, as already noted, the multitiered architecture provides benefits at each tier: HTML interface templates into which dynamic data can be plugged; reusable application logic components (AppLogics) in the application server; and database connectivity and extensions at the back end. Having a server-side component model means that the server takes care of managing object life cycles - creating and getting rid of object instances as needed. In addition, the server handles all the interprocess communication between objects, which otherwise would require you to program directly to CORBA. This model frees up developers to program at a higher level, enabling them to focus more on the application's business rules.

Corby says that one of the greatest strengths of NAS in the area of development is its sophisticated caching abilities, rare in other application server products. At the UI level, the HTML response to user actions can be cached, so that the HTML is ready if the same user request is made. Caching at the AppLogic level makes it unnecessary to recalculate frequently computed results. Furthermore, NAS offers a fine degree of control over caching - for example, the ability to cache for only a specified range of values.

But the deployment side is where NAS really excels compared to other application servers. The variety and robustness of its deployment features reflect Netscape's (and before that, Kiva's) years of experience in this area. Applications can easily scale to a large number of users: NAS can handle heavy transaction loads and partition an application over multiple servers - and if one machine goes down, NAS's failover capabilities keep things running. Thanks to NAS's excellent administrative tools, including system performance monitors and remote startup and shutdown, Net Explorer is confident that maintenance won't be a problem when they turn an application over to a client; customer service and support will be minimal. (For more information about NAS performance, see the View Source article Why Application Servers Outperform Web Servers.)

The Bad News

This all sounds great, but in fact Net Explorer experienced a problem that Corby described as "discordance": whereas NAS's deployment environment is well suited to sophisticated, high-usage web applications, its development environment is best for building simpler, smaller-scale applications, which can't fully exploit the deployment features that NAS offers. Net Explorer envisioned a server architecture that would essentially separate business objects from other components that interact with them - that is, from interface/workflow components at the front end and data managers at the back end. Ideally, shared access to business object instances would be possible. However, NAS AppLogics have certain characteristics that work against this ideal: they can't be indexed for easy later access, and they can pass only values and not object references "over the wire" to other AppLogics.

Net Explorer tried a couple of different ways of working around this problem. First, they tried object serialization: since object references can't be passed over the wire but values can, an object can be serialized and the result passed as a BLOb (binary large object). However, this was found to have several disadvantages: it degraded performance; it wasn't always clear what to serialize (that is, how far down to go in the object hierarchy); and it was still basically a pass-by-value scheme. They also tried having specialized objects called "factory objects" that provide support for object references, passing object method invocations and results over the wire, but this also proved to be too slow and difficult to implement.

The Solution - Object Pooling

The solution that worked was object pooling, conceived of by Mike Abney of Net Explorer. Under this scheme, only the interface/workflow components are implemented as AppLogics. The business objects are placed in a shared memory space accessible by the AppLogics; a Pool Manager acts as a gatekeeper to this object pool and provides services to the business objects such as life cycle management, locking support for read/write objects, and index request handling. The interface to the Pool Manager is isolated to data manager methods and so is invisible to the AppLogics and business objects. AppLogics behave as if objects are instantiated on demand. The result is a clean interface and high performance.

Time did not permit Corby to get into the details of how object pooling is implemented; we'll likewise gloss over the subject here. A more detailed discussion is planned for a future View Source article.

Object pooling uses a two-level indexing scheme: a hashtable of hashtables of instantiated objects. Business objects implement an IPoolObject interface with the methods addPoolObjectListener(), removePoolObjectListener(), getObjectId(), lock(), and unlock(). Three public Pool Manager methods are usually all the data manager methods need to call: getInstance(), getObject(), and putObject(). A LockManager AppLogic synchronizes access to multiple copies of a single object instance (this is where lock() and unlock() come into play). The administration tools include a straightforward Pool Monitor and Pool Editor.

Net Explorer managed to successfully implement object pooling in production applications. This solved the discordance problem: they enjoyed all the benefits of using NAS to deliver a stable, scalable application, but were also able to use sophisticated design methodologies that extended NAS's basic AppLogic framework.

NETSCAPE APPLICATION BUILDER 3.0

In the final Codestock presentation, Netscape product manager Hubert Chou previewed and demonstrated version 3.0 of Netscape Application Builder, which is expected to be released by the end of 1998. (The server platform for this new version, NAS 2.1 SP3, is due for release in late November.) Version 3.0 can easily import 2.1 projects, but to best take advantage of the features of 3.0 you should import your 2.1 components into a new 3.0 project.

Hubert began by noting that NAB is designed to help new developers come up to speed fast, and it's meant to be used in conjunction with other tools (such as Visual Café), not replace them. NAB helps with the creation of all three levels of application logic - presentation, business, and data logic - as can be seen from these key features of the new version:

• A WYSIWYG editor for creating HTML pages and templates, complete with dynamic data
• A project map - a graphical view of how projects are laid out, showing the relationships between AppLogics
• A data modeling tool for creating data logic components
• New wizards for automating common tasks, including data access wizards
• Limited client-side JavaScript support, primarily for doing validation (for example, of U.S. phone numbers)
• Enhanced debugging support, including integrated features for setting breakpoints, viewing variables, and stepping through code
• Source code control, such as file check-in and check-out
• Richer documentation - an extended tutorial and context-sensitive help

In his NAB 3.0 demo, Hubert went through the process of creating a simple application, which consisted of four basic steps:

1. Build the data model, adding tables from the database to the model.
2. Build the pages, specifying the database connection, whether fields should be editable, how to link between pages, and so on. NAB generates all the necessary code, templates, AppLogics, and query files.
3. Look at the project map to see what was done (including a view that shows what the customer sees).
4. Test.

NAB's intuitive graphical interface for accomplishing these tasks makes this process surprisingly simple - and at deployment time, a "point-and-click" distributed deployment capability is available.

WRAPPING IT UP

Even with the accompanying slides, we can't convey as much as you'd learn by attending Codestock yourself, hearing the presentations first hand and seeing the demos in person. The October 7 Codestock ended with a long, animated Q&A session - an excellent way to get your product- and development-related questions answered by the experts.

For future reference on NAS and NAB in particular, take a look at NAS Developer Central. And be sure to watch DevEdge Online for news of upcoming Codestock events, which are held approximately every month at Netscape's Mountain View, California, headquarters.

Caroline Rose was one of the original authors of Apple's Inside Macintosh series of developer documentation about the Mac OS. Now, after stints with NeXT and Apple (again), she does technical writing and editing on a contract basis; for more information, check out her web site.

---

Related Readings:

• Integrating NAS, Netscape Extensions and CORBA
• State Tracker: Using Netscape Application Server
• Designing First Auction with Netscape Application Server
• Using Web Server Attribute with NAS
• Using LDAP with Netscape Application Server for User Authentication

Any sample code included above is provided for your use on an "AS IS" basis, under the Netscape License Agreement - Terms of Use