James T. Rayfield

Web-application development using the Model/View/Controller design pattern

The Model/View/Controller design pattern is very useful for architecting interactive software systems. This design pattern is partition-independent, because it is expressed in terms of an interactive application running in a single address space. Applying the Model/View/Controller design pattern to web-applications is therefore complicated by the fact that current technologies encourage developers to partition the application as early as in the design phase. Subsequent changes to that partitioning require considerable changes to the applications implementation-despite the fact that the application logic has not changed. This paper introduces the concept of Flexible Web-Application Partitioning, a programming model and implementation infrastructure, that allows developers to apply the Model/View/Controller design pattern in a partition-independent manner Applications are developed and tested in a single address-space; they can then be deployed to various client/server architectures without changing the applications source code. In addition, partitioning decisions can be changed without modifying the application.

Service-level agreements and commercial grids

Service-level agreements impose unique requirements on commercial grid infrastructures - specifically, they emphasize the need for a dynamic offload infrastructure.

Alternative edge-server architectures for enterprise JavaBeans applications

Edge-server architectures are widely used to improve web-application performance for non-transactional data. However, their use with transactional data is complicated by the need to maintain a common database that is shared among different edge-servers. In this paper we examine the performance characteristics of alternative edge-server architectures for transactional Enterprise JavaBeans (EJBs) applications. In one architecture, a remote database is shared among a number of edge-servers; in another, edge-servers maintain cached copies of transactionally-consistent EJBs. Importantly, the caching function is transparent to applications that use it.

Improving application throughput with enterprise JavaBeans Caching

We present the design of an Enterprise JavaBeans (EJBs) caching architecture, and show that EJB caching can greatly improve application throughput. Throughput is improved because data serving is offloaded from the database server to the cache-enabled application server. An important feature of our architecture is that the caching function is transparent to applications that use it. The cache-enabled application server uses the same (EJB) programming model, and the same transactional semantics, as provided by non-caching architectures.

Programming model alternatives for disconnected business applications

In connected environments, various programming models exist to facilitate the development of business applications with critical properties such as persistence, data sharing, transactions, and security. In disconnected environments, the programming models must address other issues as well, such as how to merge the work performed while disconnected from other concurrent work. Among existing programming models, a transparent model that uses a method-replay approach is particularly promising. A comparison of programming model semantics suggests that method replay is superior to other approaches. We evaluate via three criteria: conflict footprint size, client-server application divergence, and transactional semantics

E-commerce interoperability with IBM's WebSphere commerce products

With the growth of the Internet, business-to-business procurement and other processes are being moved to the World Wide Web, for increased efficiency and reach. Procurement systems from different vendors use various protocols, and additional protocols are being defined by several industry consortia. As a consequence, suppliers are faced with the difficult task of supporting a large number of protocols in order to interoperate with various procurement systems and private marketplaces. In this paper, we outline the connectivity requirements for suppliers and private marketplaces, and we describe how suppliers and marketplaces based on IBMs WebSphere® Commerce Business Edition and WebSphere Commerce Suite, Marketplace Edition can interoperate with diverse procurement systems and electronic marketplaces. We first describe simple connectivity based on punchout processes for fixed and contract-based pricing. We then describe how asynchronous processes, such as requests for quote, auctions, and exchanges can be distributed for interoperability across suppliers and marketplaces. Finally, we describe B2B/M2M Protocol Exchange, a prototype we have implemented that maps between different, but analogous, protocols used in procurement systems, and thus alleviates some of the interoperability difficulties.

Enterprise JavaBeans and Microsoft Transaction Server: Frameworks for distributed enterprise components

Abstract Software components were introduced to fulfill the promise of code reuse that “pure” objects were unable to deliver. This chapter examines a specific type of component, namely, distributed enterprise components, that provides “business” functions across an enterprise. Distributed enterprise components require special functions such as distribution, persistence, and transactions; these functions are typically achieved by deploying the components in an object transaction monitor. Recently, distributed enterprise components and object transaction monitor technology have standardized into two competing frameworks: Suns Enterprise JavaBeans and Microsofts Microsoft Transaction Server. The first half of this chapter discusses the concept of distributed enterprise components in some detail and shows how they have evolved in response to the need for code reuse in business environments. This evolution is closely related to developments in other areas of software technology such as databases and transaction monitors. The second half of the chapter focuses specifically on the Enterprise JavaBeans (EJB) and Microsoft Transaction Server (MTS) technologies and explains how they relate to earlier component technologies. We show that EJBs and MTS are remarkably similar and yet differ in some important ways. We illustrate this discussion through an example developed on both frameworks.

Zazen: A Mediating SOA between Ajax Applications and Enterprise Data

One reason that enterprises are adopting service-oriented architectures (SOA) is to develop applications more quickly by packaging - and then reusing - applications and data assets as services. Service encapsulation of implementation details is an important feature, and contributes to the loosely-coupled nature of a SOA. From this perspective, SOA data-services seem incompatible with AJAX frameworks which presume a great degree of client-side control of an applications data. For their part, AJAX frameworks promise to increase web-application performance by reducing the number of interactions between the browser and server. Caching server data on the web-client is a well known technique for achieving this goal, but implies that enterprise data is exposed to client-side developers. This paper presents ZAZEN, a SOA that mediates between the need to encapsulate enterprise data as a service and the needs of AJAX developers who want more control of their applications data. We describe ZAZENs server-side architecture and discuss two APIs to the data-service: a REST API, and an implementation of the DOJO data APIs for relational databases.

Chapter 11 Issues and Approaches for Web 2.0 Client Access to Enterprise Data

Abstract A new generation of Web technologies and programming styles, known collectively as “Web 2.0,” is increasingly used in non-enterprise applications. Many businesses, however, continue to use “Web 1.0” applications to give users access to enterprise data. This chapter outlines the main issues that confront enterprises as they consider allowing Web 2.0 access to enterprise data. These include data security, programming style, performance tradeoffs, and deployment infrastructure. We motivate these issues and their solutions in the context of several examples.

WebRB: A Different Way to Write Web Applications

Relational Blocks (RBIocks) is a visual dataflow language for writing multipage interactive applications that access, transform, and display relational data in a GUI. The authors present WebRB, an implementation of RBIocks for a Web application environment. Its deployed as a software service; developers run the WebRB visual editor in a standard Firefox Web browser and store their page designs and data on the WebRB server. WebRB is a different way to write Web applications because it uses visual page designs, lacks imperative code, and uses relational semantics.