MODULE 1

Client - server computing is an exciting technology with real- world benefits to computer users. Client-server promises to define a new mechanism of computing in the nineties. It will redefine how computer programs are written, executed, and maintained. While client- server technology itself is very basic, the power, leverage and flexibility that can be derived from its use are amazing.

Traditionally, computer programs were run on a single machine. Application might have been mainframe applications, where all of the computing is done at the central mainframe computer, or stand- alone application, where all of the processing takes place at a personal computer or work station. Client- server application are different because they run on both a client and a server and they meld the best parts of stand- alone and mainframe technologist a cohesive environment.

TRAPPING THE POTENTIAL OF CLIENT SERVER COMPUTING

Client- server technology has recently become popular, but it has actually been around for many years. As the evolution of today’s computing market-place moves toward low-cost, high processing PCs, the time has arrived for Client- server computing. Increasingly, the new PCs are being networked together to form interconnected local area network (LAN) environment. By fully utilizing the LAN and all to its processing components, Client- server technology has become a viable alternative to centralized mainframe computing. This doesn’t mean, however, that mainframes are dead or will become obsolete.
Client- server computing promises to leverage the enormous potential of the ever-increasing inter connected LAN environments. By having a program execute on more them one machine, there is the potential for increased performance and scalability. Client- server is not a panacea for all aspects or ills of computing , however improperly designing and poorly implementing the technology will not decrease performance, it will introduce management jeadaches of hightmarish proportions.

As with any computing technology there are wonderful advantages to be leveraged and awful drawbacks to be avoided with client- server computing. Carefully implementing the technology – during application development, deployment, management and training- is essential. It is very important to note that, as with any emerging technology, the initial exposure can be overwhelming. Client - server skills are not easy to obtain. In fact , a great deal of the effort in migration to client server competing consists of the training issues involved. Training involves all aspects of the corporation, from the actual Client- server programmer to the MIS department. It involves users as well.
It is therefore wise to learn as you leap. Normally, one would learn before one leaps, but Client-server technology is advancing very quickly, so unfortunately the learning often occurs at the same time as, or occurs because of, the leaping. As with any major new technology, the learning curve is sure to diminish over time as the computing population learns more about client server technology.
This work navigates the minefield of client-server. Even though definitions and uses of Client-server are changing every day, the same basic fundaments for the technology hold true. This book explores these fundamentals on many different levels. It addresses the concerns of information Systems personal and their information technology (IT) infrastructure, application developers, and users. The work all explore in great depth how to create and design Client- server application. Those considering such an effort will benefit most.

CLIENT-SERVER COMPUTING AND ITS USES

Numerous definitions of” Client - server” can be found today. Many are the result of the technology itself and its promising potential, but others come from an unclear understanding of Client - server uses. This book defines “Client- server” in very simple terms. By technical definition, Client- server is the distribution of an application program into two logically separate components, each perform some

 work on its behalf. It is the server’s job to process the requests of the client and return the results. This process most often occurs between two physically separate computers over some type physical LAN infrastructure. Typically, so ever computers are much larger and faster and are thus better equipped to handle work from other systems.

Client- server technology is composed of client, or front-end programs that coordinate application logic with a server, or back-end application using the LAN as the mechanism of communication. This application distribution allows to computers to process the work instead of one. In fact with the evolution towards distributed computing many servers may be involved in the back-end processing of application logic. The combination of these systems offers tremendous opportunity for high-performance applications and a high degree of scalability.

Computing where it is most efficient to do so Client- server offer the flexibility to compute where it is most effieient to do so. It is very beneficial to allow application logic components to be hosted on either the client or the server. By migrating portions of the Client- server application program between client and server, the development products allow the location of execution to be a run – time decision.

Balancing the load between client and server Because processing can be located anywhere on a network, Client- server offer the opportunity to scale very efficiently. To achieve the proper balance of client and server, an application component should be executed on a server only when it is most efficient to centrally process the work. For instance, hosting portions of an application on a server where some central data resides is a very good idea. Network requirements may be lessened because the application logic that interfaces with central data would be located on the machine with the data, and thus the data would’t be transmitted over the LAN.

HOW CLIENT-SERVER TECHNOLOGY EVOLVED

Client- server computing is very different mainframe computing. Logically they are very different, but they have some similar characteristics. Both centrally process application logic on behalf of remote users. In additions, those remote users are usually connected via some means of physical network connection. Architecturally, the most important difference between the Client- server and the centralized mainframe approach is as follows: with Client- server computing, the client is intelligent, where mainframe terminal are generally dumb. Mainframe terminals merely act as input/output to a mainframe computer (that centrally processes all application logic), while client in Client- server computing actually have a CPU and are capable of processing real information.The inherent limitations of the centralized mainframe approach are causing many organizations to consider downsizing their applications to Client- server environments.
It is important to note, however, that as the amount of server work increases, the system becomes more mainframe- like. Since the technology is usually implemented on smaller machines, an application can actually perform worse if the server computer becomes overused or its resources are constrained. It is very important to balance the load of the server computer and offer some means of scalability to larger systems.
Historically, there has been a trend towards Client- server computing. First operating systems were broken up into components and their interaction was managed as client and sever processes running on the same machine. Later, network file system were introduced, and request for data or files were fulfilled by a remote machine. In such environments requests for data were routed over the network and serviced by a network file server. Centralized file deriver network software such as Novell’s Netware have used Client- server technology for over a decade. These systems became very popular in the eighties with the introduction and rapid growth of the LAN.
Many applications have been implemented as Client- server computing technology in recent history. Client- server computing has been transformed from system-level components performing duties such

as the sharing of files to the application space itself becoming Client- server computing. In fact, the most common Client- server application today is the relational database. Most database vendors have a Client- server implementation of their product. With such product, general queries (usually , but not limited to SQL) are made of server database. Requests are formulated at the client and shipped to the server for execution. The server processes the queries against the locally stored database and returns results over the network to the client. Interaction of the client and server components is managed by the database management system.

Current Trend: Distributing Application Logic

The current movement in Client- server is to distribute application logic as well. It has been proven that Client- server offers tremendous performance gains for file and database service. Now other applications are being targeted for distributed deployment. This work will document in detail the effort required to develop such applications.
Today most computer operating systems are capable of reforming Client- server computing. Core characteristics must include robust systems and application- level support as well as networking components. Some operating systems perform much better at being client, some at being servers. Some do both very well. Companies such as Novell first provided network server capabilities and later added true application services. UNIX and now Windows NT provided both services concurrently and were born ready for client- server. IBM, with OS/2, first provided core operating systems are still unfairly linked with their past, however, and it is important to note that today each provides a very sound platform for client- server applications. We will explore each system’s unique benefits and drawbacks throughout this book.

Methods for Creating Client-Server Applications

Client- server has many uses in today’s corporations, but creating client- server applications can be a tricky business. The technology itself inherently adds complexity to application programs, their use, and their manageability. Migration to client- serve requires a great deal from an application developer, including new skills, development tools, and development/ deployment environments. Whether designing new applications, modifying old ones, or downsizing from mainframe environments, client- server technologies can be applied to these efforts. There are a wide range of ways to produce client- serve applications using many different development methods as shown in the following list:

3 GL C,C++,COBO, Psal, etc 4GL
CASE
5GL or visual development environments
It is possible to produce client- server applications in low-level programming languages such as C as well as much higher level languages such as 4GL, CASE, or 5 GL visual development environments.

Whatever method is chosen, the migration to client- server will be accelerated or severely inhibited by the availability of tools to help produce the applications. In fact, much has been written about client- server development tools and the need for them to be “industrial strength”. International Data Corporation ( IDC), for instance, has published a tools relating to client- server. I believe that client- server will prosper greatly due to the advent of new and creative tools for application development.

WHAT IS A CLIENT-SERVER APPLICATION

                                     In  this  book,  I  will  differentiate    between  a  real  client-  serve  developer  and  the  mass  of application  programmers.  A  client-  server  application  developer  is  one  who  creates  an  application whose unique components run both the client and server. For instance, a 4GL developer using a client-server database is not really a client- server developer, but the developer who created the client and server components for the underlying database is a true client- server  application developer. Users of that  database  (via  explicit  SQL  calls   from C  or  visual  4GL  development)  are  extremely  necessary programmers, however , and will leverage the underlying client- server technology for some incredible applications. The difference between the client- server application developer and the 4GL programmer is this: the 4GL programmer didn’t actually have to create code that runs at the server. Why? Because

the underlying database provided the client- serve mechanism.
However, 4GL products are undergoing a migration. New products are being introduced that allow 4GL developers to logically distribute their own code between client and server. Once there is a logical knowledge of both client and server components, 4GL programmers will be classified as client-server application developers.
These definitions are not mean to alienate or diminish anyone’s effort. In fact, the majority of vendors creating client- server applications are using 4GL components. We draw the distinction because a client- server developer needs to obtain a number of unique skills, including specific knowledge about how to separate application components to make them communicate and effectively serve client users. We will discuss these issues in further detail in Chapter 3.

TOOLS FOR CLIENT SERVER DEVELOPERS

A large number of development tools are available to client- server developers today, and many more are in the works. These tools promise to ease the migration from stand – alone or mainframe applications to client- server. They will be provided on many levels, from low level framework tools to high- level CASE tools. The selection of a tool ( or the choice to go it a alone) is an extremely important one for the application developer and the corporation. Tools should provide the ability to rapidly prototype applications and, more importantly, to scale them to large size deployments.

3GL programming languages Developers creating client-server applications using 3GL programming languages will have a challenging experience. client-server offers a new look to application development and requires developers to learn new skills. Some help is offered in development frameworks. This book attempts to document client- server application development at the 3GL programming level and should provide insight for programmers undertaking such an effort. Chpter 3 documents the logical process necessary to convert stand- alone to client- serve applications. All subsequent chapters deal with specific issues relating to server application development and portability issues for such applications.

4GL Graphical builders 4GL graphical builders are by far the most popular tool used to create client-server applications. Numerous products are available today, including SQL – Windows from Gupta, PowerBuilder from Power soft, as well as product from Progress and Oracle, that provide excellent access to back- end databases. These products promise to leverage the data – centric nature of client- serve computing. As such, they are a fundamental tool for creating client- server applications. The majority of near- term client- server solutions will be based on these data – centric, ad hoc query products.

In addition , many of these 4GL tools mask the underlying complexity of both the OS and data base to the extent that applications created with them may become portable across systems or databases. Some vendors, such as Fort Software and dynasty Technologies, are even extending the 4GL paradigm to include logically creating both client server components.

 CASE products Computer -aided software engineering ( CASE) has been extremely popular on mainframe environments for years. CASE products attempt to model process or business logic in graphica form to create real applications. The good news for developers using such products is that many of them have been ported to PC or workstation platform.Now they provide similar working environments for those developers migrating from host environment. In addition, these CASE products are now producing client- server application with graphical interfaces as output. That is employing a similar design methodology, they will produce components that actually run on both client and server machines. Vendors such as Andersen Consulting, Easel, Knowledge are, and Bachman have or are producing such products today.

5GL visual builders 5GL visual building products such as Novell’s Visual AppBuilders promise to offer amazing technology for creating applications,including client-server ones. Visual AppBuilder allows developers to code very sophisticated application without writing source code of any kind. Such products logically present large- grain application components and allow the developer to visually combine them into functioning applications. These applications can offer connection to many services, such as database, video, imaging and messaging, providing prebuilt components for the application developer to assemble. Thanks to the power of the application components , and by modeling client and server interaction into these products, developers can create real client- server applications with little effort. Such environments mask the intrinsic of client- server from the application creator very well. As such, they will be a very popular environment for development.

CLEARING UP MISCONCEPTIONS ABOUT CLIENT SERVER COMPUTING

“client- server” is one of the most overused buzzwords in the industry. It is also one of the most misunderstood. This n confusion comes from many sources, the most prominent being the application vendors themselves. It sees that every product nowadays is labeled “client - server”. Because there is so much excitement about the technology, this trend will continue and more and more vendors will want to hitch themselves to the client- serve bandwagon.

Here are some common misnomers about client- server technology: It requires a graphical user interface for presentation. It is database- centric It will increase development productivity It helps increase code reuse. It is event – driven.

Client- serve does not require a graphical user interface It is incorrect to say that client-server technology implies that a graphical user interface must be used for presentation. Client-server application logic remains independent of its presentation to the user. The cause of this confusion is threefold.

Front-ends for applications being downsized from the mainframe are commonly being deployed on today’s popular GUI operating systems. Client-server technology is thus wrongly associated with the operating platform for its deployment.
Many new client-server development tools, such as 4GLs and CASE tools, are being instrumented with graphical interfaces. These interfaces are being mistaken as client-server technology, while the actual client and server components are merely represented in graphical form.
The X Windows graphical user interface traditionally found on UNIX computers is inherently client-server. The X Windows implementation comprises both client and server components that may run on the same or different physical computers. X Windows use client-server as an architecture. It does not imply, however, that client-server must use a graphical user Interface.

 Client is not always database-centric Another common misconception of client-server technology is that it is database-centric. Many tools and products are available for providing client-server access to databases and their data, but client- server technology does not require a database. Applications using client-server technology don’t define the technology’s characteristics. By far the most popular client-server application is the relational database, however. As such, in many circles of today’s computing environment client-server is synonymous with databases.

This is one definition of client-server that is sure not to change. One of the tremendous benefits of client-server technologies is that they can be data-centric. Many vendors have exploited these capabilities in their SQL databases and even more in their SQL access tools.

Client-server will not help developers be more productive Another common delusion of some proponents of client -server computing is that it will help developers be more productive. Client-server (the distribution of an application program between two machines) will definitely not help a developer be more productive. Developer efficiency is gained through proper programming practices and techniques that may be applied to any technology, including client-server.

While the technology itself won’t increase developer productivity, the development tools used to produce client-server applications just might. Many client-server development environments-3GL,4GL, or object-based-may greatly increase developer productivity. These products promise multiple platform deployment, multiple database support, and code reuse .

Client-server will not increase code reuse Client-server design in no way provides or helps In the process of code reuse. Tools that help create client-server applications, on the other hand, may provide this benefit, For instance, object-oriented design (either client-server or not) promises to offer Reusability of code. Objects that are created to perform logical application functions should be targeted for reuse.

In addition, good programming fundamentals increase the likelihood of code reusability. Since practices such as component-based design better prepare applications for client-server, it could be said that code reuse is enhanced with client-server. It is the tools or practices, not client-server technology, that may provide for code reusability.

Client -server is not event- driven Another common mistake applied to client-server technology is that it is event-driven, While client-server logically models very well to event driven systems, the technology is in no way limited to such environments. Remote procedure calls (RPCs), For example, provide a very synchronous, procedural interface for client-server developers. Again, client-server technology is being associated with the platforms on which it runs. While modeling very Well to these event-oriented systems, they are not a requirement for client-server.

Client-Server Technology and  Heterogeneous Computing

One factor facing information systems personnel and application developers alike is today’s Diverse computing environment. Widespread technology platforms such as PCs, minicomputers, and Mainframe computers and more diverse operating systems as well, pose interesting problems for MIS (management information systems) personnel and opportunities for application developers. Large organizations such as Fortune 100 companies, and even significantly smaller companies, have many different computer systems installed at single or multiple sites. For MIS, the pressing issue is how to make all the systems communicate and interoperate with each other. For application developers, the issue is to provide their software on as many platforms as possible and allow their applications to communicate with each other.
Heterogeneous computing is the term used to describe this diverse computing environment. Each application vendor must strive to support key platforms for its target software consumer. Many

 times, organizations decide whether to purchase a software system based on these criteria: Is it compat-ible with our existing software and hardware? Will it integrate with our current platform? Will it integrate with platforms we intend to use in the future? Developers are faced with the dilemma of how to make application software port form platform to platform with as little difficulty, expense, and problems as possible.

There are many issues regarding heterogeneous computing that face both programmers and MIS personnel. The three main components of any system are its hardware, operating system, and software programs. Issues regarding how to support each of the three components are different for management information systems. For example, hardware platforms must be able to support multiple operating systems, networks, and protocols. Operating systems must deal with logical connections not only between their peer components, but with other operating systems as well. Application developers have perhaps the most to be concerned with. They must make code work over diverse hardware, operating systems, and networks.

Hardware-independent operating systems Many of our evaluated operating systems work independently od hardware. UNIX has been the most recognizable operating system for platform independence in the history of computing. From high-end minicomputers to low-end PCs, and seemingly everything in between, UNIX has dominated hardware independence. Microsoft Windows NT was architected from the beginning to be hardware-independent. It promises to run not only on Intel platforms but MIPS and DEC Alpha as well. Recently, Novell has achieved hardware independence with NetWare via Processor Independent NetWare (PIN). PIN allows NetWare 4.0 to be executed not only on Intel, but on other platforms, such as HP,SUN, Power PC, and DEC. OS/2 2.X currently only runs on Intel-based platforms, but promises to run on others in the future.

For operating systems, heterogeneous computing means the ability to communicate with other dissimilar operating systems and protocols. Heterogeneous computing was popularized in the late eighties and early nineties by Novell’s notion that any computer system should connect over any network to NetWare. Novell achieved this milestone by natively communicating with many client operating systems, including DOS, Windows, UNIX, Macintosh, OS/2, OSI,SNA, and DEC

.
NetWare’s support of native connections With the introduction of NetWare 3.11, Novell supported native connections via IPX/SPX, TCP/IP Apple Talk, OSI, and SNA. In addition to these protocols, Novell also supported each associated file service as well: NetWare Core Protocol (NCP), Network Files System (NFS). Apple Filling Protocol (AFP), File Transfer Access Method (FTAM). This allowed the clients of these respective network and file service protocols to connect to NetWare seamlessly without additional software or training at the client.
The major difference in this philosophy (now common among many systems, including UNIX, OS/2, and Windows NT) was that each client environment was to be supported natively. Rather than use gateways or enforce new protocols, each client platform with well-defined networking software was supported natively without change. Application developers were faced with new opportunities because now they could write applications that supported native communications to multiple platform form a single server-NetWare. Today, this technology is fairly common on our other platforms and thus the challenges and opportunities for the developer to leverage this technology abound.
There is an increasing need for networks and segments of computer users to become better integrated. Client-server computing offers an answer for MIS and its communications-integration issues. The solutions, however, must be simple, easy to integrate, and easy to maintain. In addition to connecting many diverse networks, operating systems also must provide a platform for applications to use these services. Development APIs and methodologies were needed so that these services could be accessed individually or concurrently in an application program. Part of this book covers the architecture and implementation of client-server on these operating systems and their APIs. Part Three

 also covers heterogeneous topics, such as multiple operating systems and multiple protocol issues, and how a developer should architect applications in that environment.

Cross-Platform Computing

Cross-platform computing is defined simply as the implantation of technologies across heterogeneous environments. Today it has become imperative for an application to run on more than a single platform. There is a diversity of systems, and it is the job of the application developer to support each one. While doing so requires an increased amount of effort, the benefits far outweigh the sacrifice and costs on the developer’s part.
When creating cross-platform applications, developers are saddled with many issues. Providing the following capabilities is imperative for the application developer.
The application must run on multiple platforms. It must have the same look and feel as on other platforms. It must integrate with the native operating environment. It must behave the same on all platforms.
It must be maintained simply and consistently.

Running on multiple platforms First off, the application must be deployed on many computer systems. As we learned earlier, a proliferation of computer hardware and operating system makes up the current computing climate. Applications must support this environment to give users freedom of choice for development. Many corporations are making their investment decisions based on application support of platforms. By architecting properly and ahead of time, the application engineer can significantly reduce the difficulty of applications being built for multiple platforms. Advanced client-serve development environments may help in this process as well.

Maintaining the same look and feel on all platforms Second and most important, the applications should maintain the same look and feel on all platforms. This is very crucial, as application users shouldn’t be unfamiliar with a product because it is implemented on a different system. Each operating system platform has similar graphical interface capabilities, and the majority of application programs could provide similar interfaces to the user over these GUIs. This doesn’t mean, for example that a developer must implement Macintosh-style controls on a Widows or other GUI system. It simply means that the functions and general feel of the application should be consistent between platforms, including features such as the layout, menu items, dialog information, and other general usage characteristics. The style should remain native to the underlying operating system, but the information presented to the user should remain as consistent as possible across platforms.

Corporations spend a great deal of resources training personnel on application programs. If its personnel have to train independently for each platform, corporations are less likely to purchase the software. Training is rapidly becoming the single most important purchasing criterion for today’s systems. By following simple guidelines, applications can be developed independent of operating systems while maintaining similar interfaces.

Supporting the native operating environment Third, the applications must utilize native features of the target platform. By supporting the native environment, the developer doesn’t force any additional constraints or software on the user. The MIS department has a difficult enough job as it is with out requiring it to reconfigure currently working systems for a particular application. For instance, if an application only supports TCP/IP for its client-serve communications, additional prerequisite products might need to be purchased, installed, and/or managed before the developer’s software is installed. This may be a prohibitive factor in the development of a system, especially if there are a large number of nodes requiring the prerequisite software. It is difficult to convince a MIS staff to change the configuration of a thousand or more workstations for any application program.

Behaving the same on all platforms Fourth, the software must be have similarly on all systems. It is very important for applications to provide consistency to users. If a feature or function is implemented on one platform, it should be on another as well. Users may feel that their implementation is inferior if components or features are not present. This may force users to change (something they don’t like to do) or convert to a competitor’s product (something developer don’t like to have happen). It may not always be possible to implement all functions on all platforms, but it should remain a design goal.

Simple and consistent maintenance Fifth and finally, developers should ease the integration of their software into new environments by providing similar maintenance of application programs. Installation and update facilities vary from platform to platform, but the feature and mechanics shouldn’t change from the developer’s application code. Management interfaces may change from system to system (i.e., SNMP, Net View, etc.), but the maintainability of the program shouldn’t place more burdens on this process.

USING THE PROPPER APPLICATION ARCHITECTURE

Application developers can meet the above design criteria for client-server computing through proper application architecture. From thorough investigation, the majority of application code native to any given platform can be removed with proper architecture. Choice of development tools and abstract level of programming language may hide the intrinsic of client-server application development. In the case of 3GL programmers portability can be achieved much more cost effectively by providing software layers (or walls) between general application code and operating system-specific code generally, there is about an 80-20 percent split of portable/specific application code available

in most programs today Development, debugging , and testing can be greatly reduced if the proper layers or walls are constructed.
Applications developed using these techniques are better prepared for the process of porting between operating system. Because the platform specific code is limited to independent modules for each system, the application is mostly portable. The portable code usually requires only a recompile-thus no significant changes are made. This is a great benefit when the applications have already been through rigorous testing from the original platforms. Any unique behavior (bugs) is usually found in the platform specific code. This fact cannot be emphasized enough. As application complexity increases, so does the likelihood of application bugs. Anything to alleviate or reduce buggy behavior is an invaluable asset.
On the surface, cross-platform development may seem like a major undertaking. While more effort is required, proper architecture of applications can alleviate most of the difficulty in porting code between platforms. One  intent of this book is to provide many helpful techniques and real-world examples of porting applications between platforms.

MULTIPLATFORM CLIENT-SERVER FRAMEWORKS

Application developer faces numerous issues when it comes to providing applications that execute on the many diverse operating environments. This is a significant task and is more easily achieved with proper architecture of applications and their components. As discussed in the previous section, many important issues face programmers as they develop cross-platform code.
The difficulty supporting heterologeneous environments is only magnified with client-server applications. Because client-server applications are running on more than one machine (maybe even different operating systems), the amount of effort to support the heterogeneous environments is

Client – server applications will have a major impact on the computing enterprise for many years to come. Client – server technology and the accompanying tools for its development provide the fundamental building blocks for high performance, highly leveraged and highly accessible information systems. Systems generated with Client – server computing have the potential to increase the productivity with Client – server computing has the potential to increase the productivity of end users. End users will have broader access to data and the ability to model it quickly for business solutions.

These pressures along with many other factors are forcing corporations to consider an implementation of the technology. Producing Client – server solutions for the enterprises environment is a major task, however. In fact the productivity of programmers and IS personel at least during initial experience with the technology may decrease.

` This chapter not only evaluates the benefits and drawback of Client – server computing, it explores its impact on the corporation, including the overall system, its performance, costs and manageability. With Client – server technology each benefit may also have an inherent detriment to the overall system. The ultimate goal is to provide a basis of knowledge for both IS personnel and application developers so they can make proper decision when creating, deploying and maintaining Client – server applications.

Creating a system that leverages the tremendous benefits of Client – server technology but avoids its pitfalls is sometimes a difficult process. As with any system people who are experienced with Client – server would probably say they learned more from their actual implementation than from their preparation for the project. Unfortunately, most corporations don’t have the luxury of learning as they go along. As we discuss the associated costs of Client – server, it will become apparent that making the migration to Client – server must be undertaken with care and foresight.
Designing a Client – server technology solution requires the developers to consider many aspects of system deployment as well. Due to lower cost per MIPS, many of today’s solution are being deployed on microprocessor platforms. As this trend increases, systems will become resource- constrained and will have to have the ability to scale well. This includes scalability of the microprocessor hardware, the operating systems running on the hardware, and the Client – server application. Many times the most scalable solutions are created within the application by the Client – server developer.

The Costs of Client – server Computing

Recently, much has been written and much research has been done concerning the costs of Client – server computing. With the introduction of the technology, it was assumed that implementations would not only provide intangible benefits, but real cost savings. Early implementers of the technology and many research firms have dispelled the notion that today’s Client – server computing is a chapter alternative to mainframe or minicomputers. In fact, Client – server implementations are on par or even more expensive in some scenarios than traditional systems. While the overall system is comparative, the underlying costs vary widely.

The numbers used as a comparison for Client – server costs come from a February 1993 research report entitled “Client – server’s Price tag” from Forrester Research. This report compares associated costs of Client – server computing with mini computer solutions.

Figure 2.1 shows a breakdown of the costs of Client – server computing by functional area. It is interesting to note the high percentage of costs attributed to system support,maintenance and training – in other words, to labor cots. Labor costs comprise almost half of the total costs of a Client – server information system. Early excitement about the tremendous potential for cost savings were vanquished when research discovered these large associated costs.

The bottom line for corporations considering Client – server implementations and costs is this: Don’t expect Client – server to be cheaper in the short term. While there are tremendous benefits and advantages to the technology, it is not economically advantageous in a first implementation. Many hidden labor costs are driving the price of Client – server upward. It is important to have realistic expectations for what the technology has to offer and what the finished Client – server system will provide. By the mid to late 1990s, all aspects of Client – server costs will become markedly reduced.

THE COSTS OF IMPLEMENTING A NEW SYSTEM

Implementing a new Client–server system will prove to be a challenging yet rewarding process. Knowledge, experience, initial costs, and exposure to Client – server computing will provide a tremendous base for leveraging subsequent projects. The initial exposure, however will probably not yield a bottom line saving or make IS or application developers more productive. If applications are properly crafted, however, the user benefits should far outweigh the struggles of the Client – server staff. In addition, subsequent implementation of Client – server will be significantly reduced on a cost basis.
As I mentioned earlier, the costs of creating a new Client – server system from the ground up are on par with the cost of traditional systems. The statistics are even more telling when individual components are compared, as Table 2.1 shows.

COST COMPONENT	CLIENT - SERVER	MINI COMPUTER	
			
Application development	28	40	
Systems Support / maintenance	25	27	
Training	40	30	
	7	3	

The largest cost differential is mostly attributed to labor costs such as training and maintenance. Early estimates of the costs of Client – server technology did not take into account the expensive initial and ongoing costs associated with labor. However compared to traditional systems, Client – server systems are much more expensive in this area. As one would expect, hardware costs( including network and infrastructure) are less for a Client – server solution, although only modestly. And even in Client – server infancy, application development costs are cheaper as well,. This is a major justification of the technology itself and the tools for its development.

Hardware and Infrastructure Costs

As one would expect, the infrastructure costs of client-server computing were less than those of a comparative minicomputer-based solution. However, the difference was very slim in terms of the cost differential, due to the fact that PCs , networks, gateways, bridges, and routers needed to be purchased for the initial installation. Comparable minicomputer hardware did not have those associated costs. Subsequent implementations of client server systems wouldn’t require such an enormous initial cost outlay.
PCs are generally very low in cost and are always getting cheaper. In fact, this downward price trend, which is sure to be maintained into the future, even further. In addition, the component costs in microprocessor-based environments are sure to decrease as well, effectively lowering the costs of operating system for the client, the server, and for associated peripheral hardware.
Software Development Costs

One of the greatest promises of client-server computing is its development technology, methodologies, and tools. Comparative application development costs were 29 percent less expensive for client-server implementations than for the minicomputer technologies. The cost
Differences are due to many factors, including the development tools available and the inherent comparative ease of developing applications using those tools.

Client-server development with a 4GL component greatly reduces the amount of work necessary to create client-server applications. As a result, there is a shorted development time associated with these technologies. Client-server tools, however, are only entering their second generation. Future releases of client-server tools will drastically reduce the amount of effort needed for coding, for scaling the finished product, and for overall development.
Labor Costs: Training, Administration, Support
The labor costs attributed to a client-server technology development are numerous and high. As with any new technology, the initial and ongoing training of programmers, IS staff, and users is to be expected. Total labor costs are 34 percent less for a minicomputer system deployment than they are for a client-server one, according to Forrester. Labor costs themselves account for almost 50 percent of the total cost of a client-server implementation. Skilled labor comes at a high premium, especially in the initial phase of the new technology.

The ongoing maintenance and support of client-server networks is a major cost factor facing corporations today. In fact, management costs are magnified with client-server because of the inherent manageability problems associated with distributed networks. Traditional mainframe and minicomputers provide for a central management strategy with a central machine whose tools are time-tested and proven. Client-server management tools, on the other hand, are just beginning to become robust enough to support large, disperse deployments. Managing distributed networks is a difficult task made worse by today’s heterogeneous networks. Management solutions must be far-reaching and well integrated for client –server technology to proliferate.

In fact, the consulting firm John Chisholm Group has analyzed the costs of centralized vs. distributed network implementations of client-server technology. The heavy cost factors associated with manageability are directly related to the degree of distribution of the network. As a result, both hidden and planned ongoing costs of the more heavily distributed client-server networks will be significantly higher.
WAY OF PRESERVING EXISTING INVESTMENTS
Economic constraints very often force companies to limit their spending on new computer resources and fully utilize existing ones. Weighing users’ productivity on outdated systems against the cost of replacing those systems is a delicate balancing act. Client-server promises both to preserve existing investments in computer systems and ease the pain of transition to newer systems. To do this, client hardware requirements are reduced(thus extending their usefulness) and expensive server machines and peripherals are effectively shared. Client-server computing may benefit the bottom line for corporations.
Reducing Client Hardware  requirements

Client-server architecture, which is designed to distribute functionally between two or more machines, reduce the client’s hardware requirements. The introduction of the serve plays a significant role by decreasing the amount of client processing. Resource utilization is thus reduced at these client machines and, as a result, less powerful existing machines may have their life extended.

Reductions in Client Processing

Many applications that use client-server technology spend a significant amount of execution time idling and waiting for the server. Studies sow that a notable change in client processing power makes only a slight improvement in client execution times. The client, in effect, has become less dependent on machine capabilities when off-loading work to the server computers.
The significant reduction in client processing can be used of two ways.

Systems with extra CPU cycles can be used to used to run other programs or process Other work at the client computer. Systems not capable of running multitasking operating systems can be preserved. These systems might not be able to participate in some areas without the use of client-server, as they aren’t capable of processing the required amount of work in a client-only solution.  Performance improvements may be more pronounced or less pronounced, depending on the application on the application utilizing client-server technology.

MEASURING THE VALUE OF A CLIENT-SERVER SYSTEM
Overall, client-server computing offers excellent value to today’s corporations. This value, while not necessarily a bottom-line function, is accelerating the move towards client-server. However, it is important to note that the biggest impact of client-server technology is on the end-user. Applications are created faster (often by years), data is modeled more flexibly for immediate use, and changes can be made more easily, guaranteeing effective user input on the application itself. User interaction with client-server technology, or any other technology for that matter, is extremely important.

As more input is given to developers, as developers provide more flexibility, the more satisfied and productive users become.

While the initial costs of the technology are significant, exposure to the technology should begin as soon as possible, because the cost of client-server technology is sure to decrease in the future. Hardware and associated infrastructure costs will decrease. Development tools will provide increased productivity, thus lowering development costs. In addition, good fundamental programming techniques can aid in shorter development, testing and maintenance. Labor costs are sure to decrease too as the computing population becomes familiar with the technology. All of these factors, coupled with the inevitability of the technology itself, make client-server computing a must for corporate America.

The Benefits of Client-Server Computing

Client-server computing benefits all participants in a corporate information system. Users benefit from flexibility, performance, and the full utilization of all resources. Provides for the interoperability of data. IS manager’s benefit from the ability to quickly craft applications, a significant reduction in network traffic, and the interoperability of systems.

How Client-server Benefits Users
Client-server aids users because the technology performs data-intensive tasks on multiple computers. The client is relieved of intensive computing tasks and can perform other duties. Applications thus execute more quickly from the clients perspective, because many processes are executing the workload concurrently. Users benefit because they are capable of performing more work in the same amount of time.

How client-Server Benefits Corporations

Client-Server computing has many benefits for corporations as well. Expensive computers with more processing power can be shared among many clients, which maximize the use of the most costly systems and fully utilize their available resources. In addition since the server is performing work on behalf of many clients, existing client computing power is extended as the processing requirements of the user stations are lowered. Effectively this means that corporations can preserve their investment in existing client technology and incorporate more expensive high –performance server computers to process additional workload.

Increased. Recently, some integrated development	environments- also called frameworks-have been	
Announced or made available to support such an effort. Environments such as Microsoft’s Windows Open Systems Architecture (WOSA) and Win32, the UNIX COSE initiative, and Novell’s App Ware Foundation have made significant strides in reducing the amount of effort required for applications to be migrated between platforms.
This book describes many ways for application vendors to ease the migration for server applications between new computing platforms. In addition, it discusses the architecture and re-architecture of applications to support these heterogeneous environments and evolving framework technologies. Chapter 9 discusses the foundation for multiplatform frameworks in more details.

Distributed Computing

Distributing computing is a technology architecture with wonderfully promising benefits and advantages. As with client-server computing, distributed computing involves the distribution of work among more than one machine. Distributed computing is more broad, however, in that many machines may be processing work on behalf of client machines. Think of distributed as client-server computing with one client and many servers.

The  benefits  of  distributed	computing	Distributed	computing  benefits  users  and	
corporations alike. Since distributed	computing is a form of	client-server computing, users benefit	
from most of the same things. Increase of overall application throughput and the ability to multitask are tremendous benefits for the user. Corporations benefit from the integration of discrete network components and their functioning as a whole to increase efficiency and reduce costs.
Distributed computing promises to revolutionize the computing industry. Heterogeneous computing allowed any all systems to communicate with each other. Distributed computing promises to allow these systems and networks to efficiently operate as a whole. As new applications are developed and deployed, many will be cooperating to achieve the desired results. This ability will maximize the use of existing equipment and fully optimize the heterogeneous environment.

Distributed computing promises to revolutionize the computing industry. Heterogeneous computing allowed any and all systems to communicate with each other. Distributed computing promises to allow these systems and networks to efficiently operate as a whole. As new applications are developed and deployed, many will be cooperating to achieve the desired results. This ability will maximize the use of existing equipment and fully optimize the heterogeneous environment.
Distributed computing is a complex architecture, however. It involves the re-architecture of applications, redeployment of systems, and increased difficulty in managing the network as a whole. While the benefits are outstanding, the above issues will rest an already taxed information systems office. For the technology to become effective and revolutionary, developer of distributed applications must do everything possible to minimize the complexity of deployment and maintenance.

Servers in distributed computing When used in distributed computing, the term “server” merely signifies a program responding to requests and providing computation to a requesting client unit. While some may argue that distributed computing is not client-server computing, but peer-to-peer computing, I dismiss this definition. Distributed computing might not be the client –server relationship in which a single server machine processes multiple client requests, yet each application processing requests on behalf of a client machine is a server application.

Distributed machines (or nodes) process work by exactly the same means as client-server servers. Requests are sent to these machines, computation is performed, and the results are usually returned to the client requester. Many distributed nodes may be working on behalf of one requesting client, and it is the client’s responsibility to manage information requests and receipt of results. In actuality, many nodes or processes may be coordinating data to and from distributed computers.

 Distributed systems may be designed so that management is also distributed, or so that central servers manage coordination of data and processes.

Balancing the load of distributed computing If the management of the distribution is performed at a central server, the network can very effectively provide load balancing. By knowing the current load of available distributed nodes, more logical dispatching can occur. In addition, work may be dispatched to specific nodes, such as those geographically nearest the requesting client. For example, when a client issues a request for a piece work to be performed, the distributed server could then route the request to the most idle or nearest distributed node (any algorithm can be used).The processing node could either return results to the dispatching station or to the original client (any algorithm can be used).

Component development for distributed applications For application developers, the scenario is the same as for client-server. Applications and their functions must be modularized so as to operate as discrete components. These discrete components must be bounded only by encapsulated data and functions that may be moved between systems. To be distributable, these components must have knowledge only of themselves and the data passed to them. Any extraneous references are not applicable