Unit I: What Is Client Server Model?

Branch: CSE/Seventh Semester
Subject: Client Server Computing Unit-I: Server types and Client Server Operating system
1

Dept. of Computer Science & Engineering, Rajiv Gandhi College of Engg. & Tech, Puducherry

UNIT I
Basic Concepts: Characteristics - File Server - Database Server - Transaction Server -
Groupware Server - Object Server Middleware - Building Blocks. Client Server Operating
System: Anatomy of server program - Server needs from OS - Server Scalability - Client
Anatomy - Client need from OS - Client OS trends - Server OS trends.
What is client server model?

The clientserver model is a distributed application structure in computing that
partitions tasks or workloads between the providers of a resource or service, called
servers, and service requesters, called clients.
Often clients and servers communicate over a computer network on separate
hardware, but both client and server may reside in the same system.
A server is a host that is running one or more server programs which share their
resources with clients. A client does not share any of its resources, but requests a
server's content or service function.
Clients therefore initiate communication sessions with servers which await incoming
requests.
What do you mean client server computing?

Client-Server computing is the logical extension of modular programming with
fundamental assumption that separation of a huge program into its constituent parts
("modules") can create the possibility for further modification, easier development
and better maintainability.
In Client-Server Computing, all large modules need not all be executed within the
same memory space.
With this architecture, the calling module becomes the client (requesting service) and
the called module becomes the server (providing service).
Clients and Servers are running separately on appropriate hardware and software
platforms for their functions.
For example, database management system servers running on platforms specially
designed and configured to perform queries, or file servers running on platforms with
special elements for managing files.
What are the characteristics of Client server?

All client/server systems have the following distinguishing characteristics:
Service: Client/server is primarily a relationship between processes running on
separate machines. The server process is a provider of services. The client is a
consumer of services. In essence, client/server provides a clean separation of
function based on the idea of service.
2


Shared resources: A server can service many clients at the same time and
regulate their access to shared resources.
Asymmetrical protocols: There is a many-to-one relationship between clients
and server. Clients always initiate the dialog by requesting a service. Servers
are passively awaiting requests from the clients. Note that in some cases a
client may pass a reference to a callback object when it invokes a service. This
lets the server call back the client. So the client becomes a server.
Transparency of location: The server is a process that can reside on the same
machine as the client or on a different machine across a network. Client/server
software usually masks the location of the server from the clients by
redirecting the service calls when needed. A program can be a client, a server,
or both.
Mix-and-match: The ideal client/server software is independent of hardware
or operating system software platforms. You should be able to mix-and-match
client and server platforms.
Message-based exchanges: Clients and servers are loosely coupled systems
that interact through a message-passing mechanism. The message is the
delivery mechanism for the service requests and replies.
Encapsulation of services: The server is a "specialist." A message tells a
server what service is requested; it is then up to the server to determine how to
get the job done. Servers can be upgraded without affecting the clients as long
as the published message interface is not changed.
Scalability: Client/server systems can be scaled horizontally or vertically.
Horizontal scaling means adding or removing client workstations with only a
slight performance impact. Vertical scaling means either migrating to a larger
and faster server machine or distributing the processing load across multiple
servers.
I ntegrity: The server code and server data is centrally managed, which results
in cheaper maintenance and the guarding of shared data integrity. At the same
time, the clients remain personal and independent.
These features also provide a framework for the design of loosely-coupled, network-
based applications.
Define the scalability of Client/Server.

Scalability is the measure of how well a computer, service, or application can grow to
meet increasing performance demands. For server clusters, it is the ability to
incrementally add one or more systems to an existing cluster when the overall load of
the cluster exceeds its capabilities.
Client/server systems can be scaled horizontally or vertically. Horizontal scaling
means adding or removing client workstations with only a slight performance impact.
Vertical scaling means either migrating to a larger and faster server machine or
distributing the processing load across multiple servers.
3


Explain file server.

With a file server, the client (typically a PC) passes requests for file records over a
network to the file server.
This is a very primitive form of data service that necessitates many message
exchanges over the network to find the requested data.
File servers are useful for sharing files across a network.
They are indispensable for creating shared repositories of documents, images,
engineering drawings, and other large data objects.

Fig: Client/Server with File Servers.
Explain database server.

With a database server, the client passes SQL requests as messages to the database
server.
The results of each SQL command are returned over the network.
The code that processes the SQL request and the data reside on the same machine.
The server uses its own processing power to find the requested data instead of passing
all the records back to a client and then letting it find its own data, as was the case for
the file server.
The result is a much more efficient use of distributed processing power. With this
approach, the DBMS server code is shrink-wrapped by the vendor.
However, you must create the SQL tables and populate them with data.
The application code resides on the client. So you must either write code for the client
application or you can buy a shrink-wrapped query tool.
Database servers provide the foundation for decision-support systems that require ad
hoc queries and flexible reports. They also play a key role in data warehousing.

Fig: Client/Server with Database Servers.

4


Explain transaction server.

With a transaction server, the client invokes remote procedures (or services) that
reside on the server with an SQL database engine.
These remote procedures on the server execute a group of SQL statements. The
network exchange consists of a single request/reply message (as opposed to the
database server's approach of one request/reply message for each SQL statement in a
transaction).
The SQL statements either all succeed or fail as a unit. These grouped SQL
statements are called transactions.

Fig: Client/Server with Transaction Servers.
With a transaction server, you create the client/server application by writing the code
for both the client and server components. The client component usually includes a
Graphical User Interface (GUI).
The server component usually consists of SQL transactions against a database. These
applications are called Online Transaction Processing, or OLTP.
They tend to be mission-critical applications that require a 13 second response time
100% of the time. OLTP applications also require tight controls over the security and
integrity of the database.
There are two forms of OLTP TP-Lite, based on the stored procedures provided by
database vendors; and TP-Heavy, based on the TP Monitors provided by OLTP
vendors.
Explain groupware server.

Groupware addresses the management of semi-structured information such as text,
image, mail, bulletin boards, and the flow of work.
These client/server systems place people in direct contact with other people.
Lotus Notes and Microsoft Exchange are the leading examples of such systems,
although a number of other applicationsincluding document management, imaging,
multiparty applications, and workfloware addressing some of the same needs.
Specialized groupware software can be built on top of a vendor's canned set of
client/server APIs. In most cases, applications are created using a scripting language
and form-based interfaces provided by the vendor.
Typically, the communication middleware between the client and the server is
vendor-specific.
5


Fig: Client/Server with Groupware Servers.
Explain object server.

With an object server, the client/server application is written as a set of
communicating objects.
Client objects communicate with server objects using an Object Request Broker
(ORB).
The client invokes a method on a remote object. The ORB locates an instance of that
object server class, invokes the requested method, and returns the results to the client
object. Server objects must provide support for concurrency and sharing.
The ORB and a new generation of CORBA application servers bring it all together.
Examples of commercial ORBs that comply with the Object Management Group's
CORBA standard include Iona's Orbix, Inprise's VisiBroker, ICL's DAIS, JavaSoft's
Java IDL, BEA's ObjectBroker, IBM's SOM, and Expersoft's PowerBroker.

Fig: Client/Server with Distributed Object.
What is middleware?

Middleware is the nervous system of the client/server infrastructure.
Middleware is key to developing client/server applications.
In N-tier environments, the middleware must also provide a platform for running
server-side components, balancing their loads, managing the integrity of transactions,
maintaining high-availability, and securing the environment.
It must also provide pipes that allow server components to communicate using a
variety of metaphors
Middleware is a software which allows an application to interoperate with other
software, without requiring the user to understand and code the low-level operations
required to achieve interoperability
Features :
Forwards client request to the network
Includes APIs (Client to Server)
Sends requested information back to client
6


Runs on both Client/Server
Competition in C/S
With Synchronous systems, the requesting system waits for a response to the request
in real time.
Asynchronous systems send a request but do not wait for a response in real time the
response is accepted whenever it is received.
Middleware is the glue that holds client/server applications together.

Fig: Middleware
Explain middleware.

Middleware is a software which allows an application to interoperate with other
software, without requiring the user to understand and code the low-level operations
required to achieve interoperability
Features:
Forwards client request to the network
Includes APIs (Client to Server)
Sends requested information back to client
Runs on both Client/Server
Competition in C/S
Client/Server for Tiny Shops and Nomadic Tribes
The nice thing about client/server is that it's infinitely malleable.
It is easy to run the client and server portion of an application on the same machine.
Vendors can easily package single-user versions of a client/server application.
For example, a client/server application for a dentist's office can be sold in a single-
user package for offices consisting of a single dentist and in a multiuser package for
offices with many dentists.
The same client/server application covers both cases. The only caveat is that you need
to use an operating system that is robust enough to run both the client and server sides
of the application.

Fig: Client/Server for Tiny Shops and Nomadic Users.

7


Client/Server for Small Shops and Departments
The client/server architecture is particularly well-suited for the LAN-based single
server establishments.
It consists of multiple clients talking to a local server.
This is the model used in small businessesfor example, a multiusers dentist office
and by the departments of large corporationsfor example, the branch office of a
bank.

Fig: Client/Server for Small Shops and Departments.
The single-server nature of the model tends to keep the middleware simple. The client
only needs to look into a configuration file to find its server's name.
Security is implemented at the machine level and kept quiet simple.
The network is usually relatively easy to administer; it's a part-time job for a member
of the group. There are no complex interactions between servers, so it is easy to
identify failuresthey're either on the client or on the local server.
For example, data (such as a price list) may be downloaded once a day to refresh the
local server. Or inventory data may be uploaded to an enterprise server using a WAN
or the public Internet.
Fax and mail can be sent or received any time through the mail server gateway.
Typically, the software that interacts with remote servers will reside on the
departmental server.
Departmental servers will continue to be popular, even in large enterprises, because
they provide a tremendous amount of user autonomy and controls.
Users feel that it is their server, and they can do anything they please with it.
A departmental server's applications typically address the specific needs of the local
clients first, which makes users very happy.
With fiber optics and high-speed ATM connections, it will be hard to detect a
performance difference between a local departmental server and an enterprise server a
continent away.
However, the psychology (and politics) of ownership will always provide a powerful
motivator for holding on to that local server.

Client/Server for I ntergalactic Enterprises
The client/server enterprise model addresses the needs of establishments with a mix of
heterogeneous servers.
When more processing power is needed for various intergalactic functions, more
servers can be added (thus creating a pool of servers), or the existing server machine
can be traded up for the latest generation of superserver machine.
8


Fig: Client/Server for I ntergalactic Enterprises.
We can partition servers based on the function they provide, the resource they control,
or the database they own.
In addition, we may choose to replicate servers for fault tolerance or to boost an
application's performance.
There can be as many server combinations as your budget will tolerate.
Multiserver capability, when properly used, can provide an awesome amount of
compute power and flexibility, in many cases rivaling that of mainframes.
To exploit the full power of multiservers, we need low-cost, high-speed bandwidth
and an awesome amount of middleware featuresincluding network directory
services, network security, remote procedure calls, and network time services.
Middleware creates a common view of all the services on the network, called a
"single-system image".
Good software architecture for intergalactic enterprise client/server implementations,
is all about creating system "ensembles" out of modular building blocks
A complex request may involve a task force of servers working together on the
request.
Preferably, the client should not be made aware of this behind-the-scenes
collaboration.
The server that the client first contacts should be in charge of orchestrating the task
force and returning its findings to the client.
Intergalactic client/server is the driving force behind middleware standards such as
distributed objects and the Internet.

Client/Server for a Post-Scarcity World
Every machine is both a client and a full-function server.
Every machine is a full-function server, we should assume it will run, at a minimum, a
file server, database server, workflow agent, Object Transaction Monitor, and Web
serverall connected via an ORB.
This is in addition to all the client software and middleware.
9


Figure 3-5: Client/Server for a Post-Scarcity World
What are the 3 building blocks of client/server?

The three basic building blocks: a client, a server, and the slash (/) that ties the client
to the server.
It should help you identify some durable structures in the design of client/server
systems.

Fig: The Three Basic Building Blocks of Client/Server.
How the building-block arrangements are used?

The building-block arrangements are used in four situations:
1. Client/server for tiny shops and nomadic tribes is a building-block implementation
that runs the client, the middleware software, and most of the business services on
the same machine. It is the suggested implementation for the one-person shops, home
offices, and mobile users with well-endowed laptops. This is a new opportunity area
for client/server technology.
2. Client/server for small shops and departments is the classic Ethernet client/single-
server building-block implementation. It is used in small shops, departments, and
branch offices. This is the predominant form of client/server today.
3. Client/server for intergalactic enterprises is the multiserver building-block
implementation of client/server. The servers present a single-system image to the
client. They can be spread throughout the enterprise, but they can be made to look
like they're part of the local desktop. This implementation meets the initial needs of
intergalactic client/server computing.
4. Client/server for a post-scarcity world transforms every machine in the world into
both a client and a server. Personal agents on every machine will handle all the
negotiations with their peer agents anywhere in the universe.
10


Explain building blocks of client/server in detail

The three building blocks of client/server: the client, the server, and the middleware
slash (/) that ties them together.

Fig: The Client/Server Software I nfrastructure.
The client building block runs the client side of the application. It runs on an
Operating System (OS) that provides a Graphical User Interface (GUI) or an Object
Oriented User Interface (OOUI) and that can access distributed services, wherever
they may be.
Thin clients require a Web browser to download JavaBeans and applets on demand.
In all cases, the operating system most often passes the buck to the middleware
building block and lets it handle the non-local services.
The client also runs a component of the Distributed System Management (DSM)
element. This could be anything from a simple agent on a managed PC to the entire
front-end of the DSM application on a managing station.
The server building block runs the server side of the application. The server
application typically runs on top of some shrink-wrapped server software package.
The five contending server platforms for creating the next generation of client/server
applications are SQL database servers, TP Monitors, groupware servers object
servers, and the Web.
The server side depends on the operating system to interface with the middleware
building block that brings in the requests for service.
The server also runs a DSM component. This could be anything from a simple agent
on a managed PC to the entire back-end of the DSM application.
The middleware building block runs on both the client and server sides of an
application.
This building block is divided into three categories: transport stacks, network
operating systems (NOSs), and service-specific middleware.
Middleware is the nervous system of the client/server infrastructure. Like the other
two building blocks, the middleware also has a DSM software component.
Pipes and Platforms
In N-tier environments, the middleware must also provide a platform for running
server-side components, balancing their loads, managing the integrity of transactions,
maintaining high-availability, and securing the environment.
11


It must also provide pipes that allow server components to communicate using a
variety of metaphors.
The middleware is still responsible for providing client/server communications pipes.
Pipes and platforms are used in describing middleware in N-tier client/server
environments.
Pipes provide the intercomponent (and inter communication services. Examples of
pipes and RPCs, MOMs, and ORBs. Pipes also include wire-level security such as
SSL, as well as directory services such as LDAP.
Platforms are the application servers that run the server-side components.
Examples of platforms are TP Monitors, Object Transaction Monitors, and Web
Application Servers.

Fig: N-Tier Middleware Consists of Pipes and Platforms.
Server-to-Server Middleware
Middleware does not include the software that provides the actual service. It does,
however, include the software that is used to coordinate inter-server interactions (see
Figure 3-8). Server-to-server interactions are usually client/server in natureservers
are clients to other servers, and vice versa. So a server can play both client and server
roles. Most modern software (even within operating system kernels) follows the
client/server paradigm.

Fig: Server-to-Server Middleware I nfrastructure.
However, some server-to-server interactions require specialized server middleware.
For example, a two-phase commit protocol may be used to coordinate a transaction
that executes on multiple servers.
Servers on a mail backbone typically use special server-to-server middleware for
doing store-and-forward type messaging.
Databases and groupware servers use daemons to automatically replicate data.
12


What are the different types of pipes?

Pipes are divided into two broad classes:
General pipes provide the substrate for most client/server interactions.
They include the communication stacks, distributed directories, authentication
services, network time, remote procedure calls, and queuing services.
This category also includes the network operating system extension such as
distributed file and print services.
Products that fall into the general middleware category include LDAP, X.500,
firewalls, certificate servers, SSL, DCE MS-RPC, Named Pipes, TCP/IP, APPC,
IPX/SPX, and NetBIOS.
It also include the Message-Oriented Middleware (also known as MOM) products
from IBM, BEA, TIBCO, Microsoft, Peerlogic, and Neon Systems.
Service-specific pipes accomplish a particular client/server type of service. They
include:
1. Database-specific middleware such as ODBC, JDBC, SQLJ, DRDA,
EDA/SQL, SAG/CLI, OLE DB, OQL, and Oracle SQL*Net.
2. OLTP-specific middleware such as Tuxedo's ATMI and /WS, Encina's
Transactional RPC, X/Open's TxRPC and XATMI, CORBA's OTS, and
Microsoft's DTC and TIP.
3. Groupware-specific middleware such as MAPI, VIM, Javamail, SMTP,
Web/NNTP, S/MIME, POP3, IMAP, Workflow, and Lotus Notes calls.
4. Object-specific middleware such as OMG's CORBA/IIOP, Microsoft's
COM+, and JavaSoft's RMI-over-IIOP.
5. I nternet-specific middlewaresuch as HTTP, CGI, XML, and SET.
6. System management-specific middleware such as SNMP, CMIP, RMON,
DMTF, WFM, JMAPI, WEBEM, and ORBs.
Explain the anatomy of a server program

The role of a server program is to serve multiple clients who have an interest in a
shared resource owned by the server.
Here's what a typical server program does:
1. Waits for client-initiated requests. The server program spends most of its time
passively waiting on client requests, in the form of messages, to arrive over a
communication session.
Some servers assign a dedicated session to every client. Others create
a dynamic pool of reusable sessions. Some provide a mix of the two
environments.
To be successful, the server must always be responsive to its clients
and be prepared for rush hour traffic when many clients will request
services at the same time.
13


2. Executes many requests at the same time. The server program must do the
work requested by the client promptly.
Clearly a client should not have to depend on a single-threaded server
process. A server program that does not provide multitasking will run
the risk of having a client hog all the system's resources and starve out
its fellow clients.
The server must be able to concurrently service multiple clients while
protecting the integrity of shared resources.
3. Takes care of VI P clients first. The server program must be able to provide
different levels of service priority to its clients.
For example, a server can service a request for a report or batch job in
low priority while maintaining OLTP-type responsiveness for high-
priority clients.
4. I nitiates and runs background-task activity. The server program must be able
to run background tasks triggered to perform chores unrelated to the main
program's thrust.
For example, it can trigger a task to download records from a host
database during non-peak hours.
5. Keeps running. The server program is typically a mission-critical application.
If the server goes down, it impacts all the clients that depend on its
services. The server program and the environment on which it runs
must be very robust.
6. Grows bigger and fatter. Server programs seem to have an insatiable appetite
for memory and processing power.
The server environment must be upwardly scalable and modular.
Explain the needs of a server from OS

In distributed computing environments, operating system functions are either base or
extended services.
The base services are part of the standard operating system, while the extended
services are add-on modular software components that are layered on top of the base
services.
Functionally equivalent extended services are usually provided by more than one
vendor.
Base Services
Server programs exhibit a high level of concurrency.
Ideally, a separate task will be assigned to each of the clients the server is designed to
concurrently support. Task management is best done by a multitasking operating
system.
Multitasking is the natural way to simplify the coding of complex applications that
can be divided into a collection of discrete and logically distinct, concurrent tasks. It
14


improves the performance, throughput, modularity, and responsiveness of server
programs.
Multitasking also implies the existence of mechanisms for intertask coordination and
information exchanges.
Servers also require a high level of concurrency within a single program. Server code
with run more efficiently if tasks are allocated to parts of the same program rather
than to separate programs (these tasks are called coroutines or threads).
Tasks within the same program are faster to create, faster to context switch, and have
easier access to shared information.

Fig: What Server Programs Expected From Their Operating System.
Task Pre-emption: An operating system with pre-emptive multitasking must allot
fixed time slots of execution to each task.
Without pre-emptive multitasking, a task must voluntarily agree to give up the
processor before another task can run. It is much safer and easier to write
multitasking server programs in environments where the operating system
automatically handles all the task switching.
Task Priority: An operating system must dispatch tasks based on their priority. This
feature allows servers to differentiate the level of service based on their clients'
priority.
Semaphores: An operating system must provide simple synchronization mechanisms
for keeping concurrent tasks from bumping into one another when accessing shared
resources.
These mechanisms, known as semaphores, are used to synchronize the actions
of independent server tasks and alert them when some significant event
occurs.
I nterprocess Communications (I PC): An operating system must provide the
mechanisms that allow independent processes to exchange and share data.
Local/Remote I nterprocess Communications: An operating system must allow the
transparent redirection of interprocess calls to a remote process over a network
without the application being aware of it.
The extension of the interprocess communications across machine boundaries
is key to the development of applications where resources and processes can
be easily moved across machines (i.e., they allow servers to grow bigger and
fatter).
Threads: These are units of concurrency provided within the program itself. Threads
are used to create very concurrent, event-driven server programs.
Each waiting event can be assigned to a thread that blocks until the event
occurs. In the meantime, other threads can use the CPU's cycles productively
15


to perform useful work.
I ntertask Protection: The operating system must protect tasks from interfering with
each other's resources. A single task must not be able to bring down the entire system.
Protection also extends to the file system and calls to the operating system.
Multiuser High-Performance File System: The file system must support multiple
tasks and provide the locks that protect the integrity of the data. Server programs
typically work on many files at the same time.
The file system must support a large number of open files without too much
deterioration in performance.
Efficient Memory Management: The memory system must efficiently support very
large programs and very large data objects. These programs and data objects must be
easily swapped to and from disk, preferably in small granular blocks.
Dynamically Linked Run-Time Extensions: The operating system services should be
extendable. A mechanism must be provided to allow services to grow at run time
without recompiling the operating system.

Extended Services
Extended services provide the advanced system software that exploits the distributed
potential of networks, provide flexible access to shared information, and make the
system easier to manage and maintain.
They also make it easier for independent software vendors (ISVs) and system
integrators to create new server applications.
Figure below shows some of the extended services server programs can expect either
from their OS or from a best-of-breed middleware package.
In intergalactic networking situations, the middleware becomes the OS.
So many corporations are standardizing on middleware (or even on a DBMS
packagelike Oracle) to provide a meta-layer of heterogeneous glue.

Fig: What Server Programs Hope To Get From Their Extended Operating Systems.
16


Ubiquitous Communications: The operating system extensions must provide a rich
set of communications protocol stacks that allow the server to communicate with the
greatest number of client platforms.
In addition, the server should be able to communicate with other server
platforms in case it needs assistance in providing services.
Network Operating System Extensions: The operating system extensions must
provide facilities for extending the file and print services over the network.
Ideally, the applications should be able to transparently access any remote
device (such as printers and files) as if they were local.
Binary Large Objects (BLOBs): Images, video, graphics, intelligent documents, and
database snapshots are about to test the capabilities of our operating systems,
databases, and networks.
These large objects require operating system extensions such as intelligent
message streams and object representation formats.
Networks must be prepared to move and transport these large BLOBs at
astronomic speeds.
Databases and file systems must be prepared to store those BLOBs and
provide access to them.
Protocols are needed for the exchange of BLOBs across systems and for
associating BLOBs with programs that know what to do when they see one.
Global Directories and Network Yellow Pages: The operating system extensions
must provide a way for clients to locate servers and their services on the network
using a global directory service.
Network resources must be found by name. Servers must be able to
dynamically register their services with the directory provider.
Authentication and Authorization Services: The operating system extensions must
provide a way for clients to prove to the server that they are who they claim to be. The
authorization system determines if the authenticated client has the permission to
obtain a remote service.
System Management: The operating system extensions must provide an integrated
network and system management platform.
The system should be managed as a single server or as multiple servers
assigned to domains. An enterprise view that covers multiple domains must be
provided for servers that play in the big leagues.
System management includes services for configuring a system and facilities
for monitoring the performance of all elements, generating alerts when things
break, distributing and managing software packages on client workstations,
checking for viruses and intruders, and metering capabilities for pay-as-you-
use server resources.
Network Time: The operating system extensions must provide a mechanism for
clients and servers to synchronize their clocks. This time should be coordinated with
some universal time authority.
17


Database and Transaction Services: The operating system extensions must provide a
robust multiuser Database Management System (DBMS). This DBMS should ideally
support SQL for decision support and server-stored procedures for transaction
services.
The server-stored procedures are created outside the operating system by
programmers. More advanced functions include a Transaction Processing
Monitor (TP Monitor) for managing stored procedures (or transactions) as
atomic units of work that execute on one or more servers.
I nternet Services: The Internet is a huge growth opportunity for servers. We expect
that over time the more common Internet services will become standard server
featuresincluding HTTP daemons, Secure Sockets Layer (SSL), firewalls, Domain
Name Service, HTML-based file systems, and electronic commerce frameworks.
Object-Oriented Services: This is an area where extended services will flourish for a
long time to come. Services are becoming more object-oriented. The operating system
will provide object broker services that allow any object to interact with any other
object across the network.
The extended operating system must also provide object interchange services
and object repositories. Client/server applications of the future will be between
communicating objects
What do you mean by multiserver ?

Multiservers (or clusters) are used in environments that require more processing
power than that provided by a single server systemeither SMP or uniprocessor.
The client/server model is upwardly scalable. When you need more processing power,
you can add more servers (thus creating a pool of servers). Or, the existing server
machine can be traded up to the latest generation of PC superserver machine.
Multiservers remove any upward limits to the growth of server power. Ordinary
servers can also provide this power by working in all kinds of ensembles using
middleware.
What is symmetric multiprocessing?

Symmetric Multiprocessing (SMP) treats all processors as equals. Any processor can
do the work of any other processor.
Applications are divided into threads that can run concurrently on any available
processor. Any processor in the pool can run the operating system kernel and execute
user-written threads.
Symmetric multiprocessing improves the performance of the application itself, as well
as the total throughput of the server system.
Ideally, the operating system should support symmetric multiprocessing by supplying
three basic functions: a re-entrant OS kernel, a global scheduler that assigns threads to
available processors, and shared I/O structures.
18


Symmetric multiprocessing requires multiprocessor hardware with some form of
shared memory and local instruction caches. Most importantly, symmetric
multiprocessing requires new applications that can exploit multithreaded parallelism.
The few applications on the market that really exploit SMP are SQL DBMSs and TP
Monitors.
SMP architecture requires cache synchronization between processors. Consequently,
it is not fault-tolerant.
What is asymmetric multiprocessing?

Asymmetric multiprocessing imposes hierarchy and a division of labor among
processors.
Only one designated processor, the master, can run the operating system at any one
time.
The master controls (in a tightly-coupled arrangement) slave processors dedicated to
specific functions such as disk I/O or network I/O.
A coprocessor is an extreme form of codependency; one processor completely
controls a slave processor through interlocked special-purpose instructions.
The coprocessor has unique special purpose hardware that is not identical to the main
processor. An example is a graphic coprocessor.
Explain Server Scalability in detail.

The limits really depend on the type of service required by their clients. One safe rule
is that clients will always want more services, so scalable servers are frequently an
issue.
Figure below shows the different levels of escalation in server power.
It starts with a single PC server that reaches its limits with the top-of-the-line
processor and I/0 power.
The next level of server power is provided by superservers populated with
multiprocessors. If that is not enough power, the client/server model allows you to
divide the work among different servers.
These multiservers know no upper limits to power. But they must know how to work
together.

Fig: The Server Scalability Story.
19


Multiservers (or clusters) are used in environments that require more processing
power than that provided by a single server systemeither SMP or uniprocessor (see
the next Briefing box).
The client/server model is upwardly scalable. When you need more processing power,
you can add more servers (thus creating a pool of servers). Or, the existing server
machine can be traded up to the latest generation of PC superserver machine.
Multiservers remove any upward limits to the growth of server power. Ordinary
servers can also provide this power by working in all kinds of ensembles using
middleware.

Multiprocessing Superservers
If you need more server power, you'll be looking at a new generation of superservers.
These are fully-loaded machines; they include multiprocessors, high-speed disk arrays
for intensive I/O, and fault-tolerant features. Operating systems can enhance the
server hardware by providing direct support for multiprocessors.
With the proper division of labor, multiprocessors should improve job throughput and
server application speeds.
A multiprocessors server is upwardly scalable. Users can get more performance out of
their server by simply adding more processors instead of additional servers.
Multiprocessing comes in two flavors: asymmetric and fully symmetric

Fig: Symmetric and Asymmetric Multiprocessing.
Asymmetric multiprocessing imposes hierarchy and a division of labor among
processors. Only one designated processor, the master, can run the operating system
at any one time.
The master controls (in a tightly-coupled arrangement) slave processors dedicated to
specific functions such as disk I/O or network I/O. A coprocessor is an extreme form
of codependency; one processor completely controls a slave processor through
interlocked special-purpose instructions.
The coprocessor has unique special purpose hardware that is not identical to the main
processor. An example is a graphic coprocessor.
Symmetric Multiprocessing (SMP) treats all processors as equals. Any processor can
do the work of any other processor. Applications are divided into threads that can run
concurrently on any available processor.
20


Any processor in the pool can run the operating system kernel and execute user-
written threads. Symmetric multiprocessing improves the performance of the
application itself, as well as the total throughput of the server system.
Ideally, the operating system should support symmetric multiprocessing by supplying
three basic functions: a reentrant OS kernel, a global scheduler that assigns threads to
available processors, and shared I/O structures.
Symmetric multiprocessing requires multiprocessor hardware with some form of
shared memory and local instruction caches.
Symmetric multiprocessing requires new applications that can exploit multithreaded
parallelism. The few applications on the market that really exploit SMP are SQL
DBMSs and TP Monitors.
SMP architecture requires cache synchronization between processors. Consequently,
it is not fault-tolerant.
The mass-market server operating systemsincluding Unix, NetWare, OS/2, and
NTall support SMP. These operating systems run on commodity superserver
platforms; the hardware vendors have been gearing up for these OSs for quite some
time.
Commodity Intel-based servers supplemented with SMP are powerful enough to
handle more than 80% of client/server application needs. These servers can run
ordinary PC software and have a strong affinity with clients.
Clusters make a group of interconnected SMP machines behave like a single system.
Typically, the interconnection is via a high-speed LAN.
Typically, clusters come in one of two flavors: shared-disk and shared-nothing .
In both cases, some form of high-speed LAN is used for intercluster communications;
it can be a simple Ethernet connection or a specialized high-speed redundant bus such
as Compaq/Tandem's ServerNet.
Clusters provide high-availability because they do not share memory or synchronized
caches. Consequently, failures are contained within a single node.
Some clustering systems use "I'm alive" messages to determine the health of each
node on the cluster.
If a node dies, messages can be re-routed to an alternate node. Of course, the alternate
must be capable of doing the job and must also have access to the shared data.
Typically, all this messaging is transparently handled on behalf of your application by
a TP Monitor or DBMS.

Fig: Clustering Architectures: Shared-Disk Versus Shared-Nothing.
21


Shared-nothing clusters like Compaq/Tandem's NonStop systems, IBM's SP2, and
Oracle's NCube provide very high levels of parallelism. Their "shared-nothing"
architectures eliminate the bottlenecks found in SMP systems, thus allowing them to
scale to hundreds or even thousands of processorsall working together.
What do you mean by clusters?

Clusters make a group of interconnected SMP machines behave like a single system.
Typically, the interconnection is via a high-speed LAN.
Typically, clusters come in one of two flavors: shared-disk and shared-nothing .
In both cases, some form of high-speed LAN is used for intercluster communications;
it can be a simple Ethernet connection or a specialized high-speed redundant bus such
as Compaq/Tandem's ServerNet.
Clusters provide high-availability because they do not share memory or synchronized
caches. Consequently, failures are contained within a single node.
Some clustering systems use "I'm alive" messages to determine the health of each
node on the cluster.
If a node dies, messages can be re-routed to an alternate node. Of course, the alternate
must be capable of doing the job and must also have access to the shared data.
Explain client anatomy in detail.

Client/server applications are client-centric. The client side provides the "look-and-
feel" for the services a system provides.
All client applications have this in common: they request the services of a server.
What makes client applications different is what triggers the requests and what GUI,
if any, is needed.
Based on these differences, we can classify clients into three categories: Non-GUI
Clients, GUI Clients, and OOUI Clients.

Fig: Three Client Types: Non-GUI , GUI , mad OOUI .
Non-GUI Clients
Non-GUI client applications generate server requests with a minimal amount of
human interaction. Non-GUI clients fall into two sub-categories:
1. Non-GUI clients that do not need multitasking. Examples include automatic
teller machines (ATMs), barcode readers, cellular phones, fax machines, smart
gas pumps, and intelligent clipboards.
22


These clients may provide a simple human interface in the request
generation loop.
2. Non-GUI clients that need multitasking. Examples include robots, testers,
and daemon programs. These clients often require very granular, real-time,
event-driven multitasking services.

Fig: The Many Faces of Non-GUI Clients.
GUI Clients
Simple GUI Clients are applications where occasional requests to the server result
from a human interacting with a GUI.
The simple GUI interface is a good fit for mainstream, OLTP-type business
applications with repetitive tasks and high volumes.
They also make good front-end clients to database servers. Simple GUI client
applications are graphical renditions of the dialogs that previously ran on dumb
terminals.
GUIs replace the "green-screen uglies" with graphic dialogs, color, menu bars, scroll
boxes, and pull-down and pop-up windows.
Simple GUI dialogs use the object/action model where users can select objects and
then select the actions to be performed on the chosen objects. Most dialogs are serial
in nature.
This model of user interaction is predominantly used in Windows 3.X, and OSF Motif
applications, as well as most of today's form-based Web pages.

Fig: A Club Med GUI Application "Look-and-Feel."
23


Object-Oriented User I nterface (OOUI ) Clients
The Object-Oriented User Interface (OOUI) metaphor provides a highly iconic,
object-oriented user interface that lets you directly manipulate objects on a screen
(typically, via drag-and-drop).
OOUIs are used by information workers doing multiple, variable tasks whose
sequence cannot be predicted. Examples include executive and decision-support
applications, multimedia-based training systems, system management consoles, and
stockbroker workstations.
OOUIs have an insatiable appetite for communications. OOUI desktop objects need to
communicate among themselves and with external servers. The communications are,
by necessity, real-time, interactive, and highly concurrent.
Examples of OOUIs are the OS/2 Workplace Shell, NextStep (now Mac OS X), Mac
OS, and, to some extent, Windows 98. In addition, you will start seeing OOUI-like
Web pages populated with Java 2 JavaBeans (these are beans that support direct
manipulation via drag-and-drop).
Current OOUIs provide a visual desktop metaphor where you can bring together
related objects and programs to perform a task.
The desktop can contain multiple workplaces running concurrently.
Each workplace may be running parallel dialogs, also, called modeless dialogs, over
parallel sessions with the server.
With advanced multimedia-type applications, you can use these parallel dialogs to
display images, video, multiobject folders, and voice-annotated mail. Information is
displayed to the user in the foreground windows, while background tasks are
constantly moving information to and from servers.
For example, the first page from a multimedia document is displayed in a window
while a background task is busy prefetching the rest of the document from the server.

Fig: A Club Med OOUI Application "Look-and-Feel."
OOUIs focus on the objects required to accomplish a task. They provide folders, work
areas, shadows (short cuts), and associations that allow users to personalize their
desktops and manage their objects.
24


OOUIs provide a common metaphor for creating, copying, moving, connecting, and
deleting any object on the desktop. One of the major features of OOUIs is the concept
of multiple views of objects.
In OOUI environments, the user interacts with objects rather than with the operating
system or with separate programs.
The interaction has the same look-and-feel across all tasks. The OOUI is a simulation
of how users interact with objects in real life. It is a computer visual of the real-life
situation.
Application Features: GUI Versus OOUI
The best way to compare GUIs and OOUIs is to put the two side-by-side and contrast
some of their features.
The OOUI Club Med is an extension of the operating system's user interface.
You can't tell where the application starts and the OS desktop ends. They appear to be
seamlessly integrated.
The OOUI Club Med invites the user to manipulate the visual Club Med objects
through drag-and-drop.
For example, a transaction may be triggered by dragging a guest object to the
shredder to delete it. Or, if we want to be kind, we'll drop it on the fax machine icon
to send a confirmation of the reservation.
The OOUI Club Med icon can be opened at any time to reveal a notebook view of the
information inside it.
The notebook control makes it possible to visually staple together many dialog
windows and let the user find the information needed. This is a giant step forward for
OLTP-type of applications.
The OOUI Club Med setup will reappear the way the user left it when the machine is
turned on again. The desktop configuration is persistent.
Kids feel quite at home with drag-and-drop, icons, and direct manipulation. The
OOUI is a simulation of reality that they can easily recognize.
The OOUI Club Med can be extended to seamlessly work with any other OOUI
object.
The GUI Club Med, on the other hand, is your typical Windows or Web interface.
The icon is just there to represent the application to the desktop. You're not invited to
play with it.
You start the application by clicking on the icon (or on a URL link). From then on,
you're in menu land. The user is quite aware that there is a running Club Med
application.
25


Table: Summary of the features that distinguish OOUI s from GUIs.

Compound Documents: OOUI s on Steroids
Compound documents frameworkslike ActiveX and JavaBeansare the latest and
greatest OOUI technology ( Figure below).
Every visual object on the screen is a live component.
Some components are also containers, which means that they can embed other
components.
You can edit the contents of any component "in-place," regardless of how deeply
embedded it is within other components.
A component is an independent piece of software that you can separately purchase on
the market. Components can play together in visual suites that mimic applications.
26


Fig: The GUI /OOUI Evolution.
In today's OOUIs, visual objects are typically rectangular icons with underlying
views. Ideally, components can take any shape, and you can move them around and
embed them at will.
You can resize components, zoom in on their contents, and visually rearrange them
within a visual container in any way you want. The components automatically share
the document's menu, clipboard, and palette.
So compound documents are a better simulation of reality than vintage OOUIs. 3-D
compound documents will provide even more realistic simulations.
The document becomes a virtual world populated with components.

Shippable Places
A place is a visual ensemble of related components.
A shippable place is a mobile container of components; it's a place that can be shipped
over the Net.
Today's user interfaces are centered around a primitive place that represents a
desktop.
In contrast, shippable places let you interact with multiple places that represent
collaborative environments based on real-world models; it's like having multiple
desktops.
So a place is a mini virtual world that servers can ship to their clients; it's a shippable
front-end for all kinds of specialized Internet services and server objects. Places allow
servers to automatically update their client's desktop.
It also gives them a visual place on the client in which to display information in real
time. So a place can be a dynamic assembly of ever-changing data, video feeds, and
other live content.
Web technology made it possible for servers to ship HTML pages to clients where
they are displayed in GUI format. The Web then evolved to support HTML-based
forms that let clients send data to their servers.
With Java, servers can now embed codein the form of appletswithin HTML
pages; Java makes the Web page active and smart.
Finally, we have shippable places. These are shippable compound documentsin the
ActiveX or JavaBeans sense.
27


Like a page, a place can contain Java components (or beans). But unlike a page, a
place does not go away after you switch pages; it can live on your desktop for as long
as you need it.
A place also has its own storage, so it can remember your preferences and maintain
active links to the outside world.

Fig: From Web Pages to Shippable Places.
What are the two types of non-GUI clients?

Non-GUI client applications generate server requests with a minimal amount of
human interaction. Non-GUI clients fall into two sub-categories:
Non-GUI clients that do not need multitasking. Examples include automatic
teller machines (ATMs), barcode readers, cellular phones, fax machines, smart
gas pumps, and intelligent clipboards.
These clients may provide a simple human interface in the request
generation loop.
Non-GUI clients that need multitasking. Examples include robots, testers,
and daemon programs. These clients often require very granular, real-time,
event-driven multitasking services.

Fig: The Many Faces of Non-GUI Clients.
What are the needs of a client from an OS?

Each of the three types of clients described here places a different set of requirements
on the operating system.
All client applications need some mechanism to communicate service requests and
files to a server.
28


All three client categories will function best in a robust, multitasking environment. It
is particularly important for the client environment to be robust because it is
impossible for system providers to test the client software on all possible
hardware/software combinations.
It is important to use an operating system that can protect programs from clashing and
crashing. No client program should cause the system to hang (requiring a reboot).

Table: What Does a Client Need From an OS?
GUI and OOUI clients work best with a thread-like mechanism for handling the
background requests.
By using separate threads for the user interface and background processing, the
program can respond to user input while a separate thread handles the interaction with
the server.
This is how GUIs avoid the notorious "hourglass" icon, a sure sign that the computing
environment is not keeping up with the human users. Threads also help clients
respond to asynchronous calls from a server (i.e., they implement callbacks).
Priority-based, pre-emptive multitasking is also required to respond to multimedia
devices and to create client applications where multiple dialogs are displayed in
parallel.
Increasingly, one of the most important requirements of a client operating system is to
host mobile code in a secure fashion.
In practice, this means the client OS must provide a Java VM. This lets servers ship
mobile code to clients on an as-needed basis.
Explain client OS trends.

The desktop is becoming more fragmented. The move to 32-bit OSs is fragmenting
the desktop. Unlike its predecessorsDOS and Windows 3.XWindows 95 does not
own the client.
In fact, the Microsoft world has five competing client OSs to choose from: Windows
CE, Windows 3.X, Windows for Workgroups, Windows 95/98, and NT
Workstationnot to mention MS-DOS.
29


In addition to Windows, OS/2 Warp is still alive on some corporate desktops, Mac OS
has its dedicated following among the Internet crowd, and Linux is becoming more
attractive every day.
Figure below shows the total client OS shipments in 1997.
As you can see, there's quite a bit of diversity. Of course, the total installed base is
even more diverseespecially on corporate desktops.
According to IDC's Dan Kusnetzky, the desktop in large corporations is most likely
running Windows 3.1, followed by a large jump down to Windows 95, and then a
dumb terminal.

Fig: 1997 Worldwide PC/Client OS Shipments (Source: I DC, 1998).
The universal client is really a Web browser. If you think about it, Microsoft does
not own the standards for the intergalactic client.
The Internet community owns these evolving standards.
In addition, the Java VM is an operating system for Web mobile code; it's an OS that
lives on top of existing OSs. Of course, Microsoft does not control Java, either.
There will be a huge demand for super-fat PCs. These are ordinary PCs that act as
both clients and servers.
These servers must be shrink-wrapped; you can't afford a system administrator with
every server.
There will be a huge demand for ultra-thin PCs. Typically, these minimalist PCs are
centrally managed via a server.
There's currently enough bandwidth behind corporate firewalls to effectively
download applets and JavaBeans on demand.
The idea here is that zero-footprint networked PCs may be easier to use, maintain, and
upgrade than our current PCs.
They can bring to the Web millions of new usersmostly people who can't afford,
comprehend, or deal with the cost of ownership of a full-blown PC.
These low-cost Web clients may become as ubiquitous as the telephone. Of course,
our current PCsas we know and love themwill continue to do very well.
Shippable places will become the new desktops. Today, you mostly live within a
Windows desktop
These are the virtual worlds that connect you with the network at large.
So you will spend your time in the virtual worlds that make you feel the most at
home.
30


The desktop is no longer a single monolithic place. Instead, you now have multiple
places to choose from.
You will be able to run these places either from your Web browser or from more
specialized place viewers. Internet Portals will serve a "home places." They will also
become dispensers of shippable places.
Embedded clients will be everywhere. This is the old Novell vision of "the billion-
node network by the year 2000."
To get to this number, millions of little network nodes will be installed in fuel
injectors, copy machines, crockpots, refrigerators, cash registers, televisions,
telephony devices, automated teller machines, and pick-up trucks. Sun estimates that
by 1999, the typical home will contain 100 microcontrollers. These nodes require an
OS with a small footprint that can also run some form of client/server middleware.
Embedded Java (with Jini) could be the perfect OS for these types of environments.

List out popular client OS and describe them

Most of today's client platforms belong to Microsoft.
The only other serious competition on the desktop comes from Mac OS and Linux.
OS/2 is no longer a serious player.
Java OS may eventually become a formidable competitorespecially in the area, of
Internet appliances, Web, TVs, and embedded clients.
In the future, the client OS (and the browser) will simply provide a player for running
Web content.
The real client is whatever you download from the Netwhether it's Web pages,
simple forms, or shippable places packed with beans. The Web (and Java) will make
us client-OS agnostic.

Fig: What the Different Operating Systems Cover.
31


Though ubiquitous, DOS and Windows 3.x do not make very good client platforms.
Their poor little computer brains are too weak to give us what it takes to build
universal clients and fulfill the vision of post-scarcity client/server computing, where
each machine is both a client and a server.
For client/server computing to unleash its potential, the industry is moving to 32-bit
client platforms with full multithreaded support, robust memory management, and
pre-emptive multitasking.

1. NT Client
Windows NT Workstation is a robust 32-bit client OS. It supports pre-emptive
multitasking, multithreading, memory protection, and a transactional file system.
Windows NT is network-ready; it supports TCP/IP, NetBEUI, IPX/SPX, PPP, and
AppleTalk. NTas an advanced client platformhas very few system upper limits.
It also provides C2-level security.
Finally, NT's Windows 95 user interface is very familiar to millions of Windows
users, which is also a big plus.
Disadvantages:
NT is a resource hog, but this may not be a problem as the price of memory
continues to drop.
Compared to Windows 95/98, NT's support for laptops is very poor; it has
limited PC card support and power management.
NT provides poor emulation of DOS and 16-bit Windows applications; it does
not support virtual device drivers (VxDs).
In addition, NT does not support plug-and-play, which makes it harder to
configure. Compared to Windows, NT has limited device driver support.
Finally, NT Workstation is an expensive client platform.

2. MAC OS X
Mac OS X combines the Mac's user-friendliness with NeXT's no-compromise object-
based frameworks.
In addition to OpenStep applications, the new OS can run existing Mac applications
(either unchanged in a compatibility environment, or natively as recompiled "Carbon"
applications).
Mac OS X also inherits from NeXT a modified Mach microkernel and BSD 4.4 Unix
layer, allowing it to run most Unix applications .
Mach provides memory protection, threading, and pre-emptive multitasking.
In addition, the new OS also comes with a fully compatible Java VM that supports
100% Pure Java and JavaBeans as well as some of the "less pure" Microsoft
extensions, so it should run most Java programs.
Disadvantages:
1. It requires new device drivers for most third-party hardware.
32


Fig: The Mac OS X Architecture in a Nutshell.
Linux
Linux is one of the fastest-growing client operating systems.
Linux is probably the most reliable version of Unix running on Intel.
Any Intel-based Unix application will run on Linux without modificationincluding
productivity suites like StarOffice and ApplixWare.
There are also suites of freeware apps that specifically target Linux.
The community of Linux technologists provides excellent free support. However,
corporations (and novice users) are still nervous about running what they perceive to
be an "unsupported OS." So the for-sale Unix distributors also include support with
their packages.
Disadvantages:
1. First, Linux does not run popular Windows applications such as Microsoft
Office. This could be a problem for corporations that have standardized on
these packages. The Linux technologists must provide a Windows-emulation
layer soon.
2. Second, Linux does not provide a single desktop environmentalthough the
K Desktop (a GUI that looks like a blend between Windows and Mac) comes
close.
3. Third, the for-sale vendors provide a very useful service, but they may also
end up splintering the Linux community.
4. Fourth, Linux needs to be bundled with client PCseven an easy CD-ROM
installation may be too hard for the mass market.
5. Finally, Linux needs some marketing help from folks like AOL/Netscape,
IBM, and Oracle.

Explain Server OS trends.

The fastest growing category is what IDC calls application servers.
These are Web, DBMS, TP Monitor, object, and groupwareservers.
Figure below, shows where application servers fit in the scheme of things.
They started out from the department and are now spreading in two directions: 1)
downward into the space held by traditional NetWare LAN servers; and 2) upward
into the space held by Unix servers running downsized mainframe applications.
33


Of course, all server OSsincluding NetWare, OS/2, NT, and all the Unixesare
going after this high-growth market.

Fig: The Application Server Market (Source: Summit Strategies).
Figure below, from IDC shows the breakdown of worldwide server OS license
shipments in 1997.
The numbers show that NT server unit shipments now outpace all Unix versions
combined. NT sold over 1.2 million server licenses.
The Unixes (and Linux) combined sold 962,000 server licenses. NetWare was a close
third with 924,000 server licenses. Finally, OS/2 sold 218,000 server licenses.

Fig: Server Shipments in Units of Millions (Source: I DC).
However, these numbers do not tell the whole story. The majority of NT, OS/2, and
NetWare shipments are for low-end server environments.
Figure below, shows hardware revenues by server OS platform.
As you can see, Unix emerges as the clear winner; it sells three times more server
hardware than NT.
Unix also emerges as the winner when the server market is measured by the total
number of clients supported by each platform.
NetWare falls into second place; NT holds the number-three spot, followed by OS/2.

Fig: Server Hardware Platform Revenues by OS Environment in 1997 (Source: I DC, 98).
Table below is also informative. It shows that Unix is primarily used as an application
server platform.
34


In contrast, over 50% of NT server licenses are used for departmental file/print
servers.
So NT is slugging it out with NetWare and OS/2 in the departmental trenches while
also trying to encroach on the traditional Unix turf in the more lucrative application
server market.
In the last few years, NT made outstanding progress against both NetWare and OS/2
as a platform for database application software.
But NT made very little progress against NetWare as a file/print server; it mostly
grew there at the expense of OS/2.
NT is currently battling Unix for the Web application server market; it also gearing up
to go after the Unix enterprise server business with NT 5.0.

Table: Server OS Platform Functional Segmentation in 1997 (Source: I DC, 1998).

List out popular Server OS and describe them.

The players in the low-to-medium end of the server market include NetWare, OS/2
Warp Server, NT Server, and Unixes on Intel such as SCO, Solaris, and Linux.
The high-end currently belongs to Unix clusters and to any mainframe or supermini
that can act as a server to PCs.
The most formidable competitors at the very high-end are the RISC mainframe
vendors that can provide massively parallel computing, scalability, and/or fault
tolerance (for example, Tandem/Compaq, Sun, IBM, and Sequent).
The parallel, MVS-based IBM mainframeswith their transaction engines,
enterprise-based system management, and large databasesare also key players.
NetWare
The largest server installed base (by far) belongs to Novell's NetWare.
NetWare is a very fast, effective, well-supported file server that seamlessly supports
OS/2, Mac, and Windows clients.
The product also includes an X.500-like global directory service and the tools that
make it usable. NetWare is a well-managed server platform; its global directory
provides a single point of network administration.
Over 5,000 applications run on NetWareincluding the major DBMSs.
NetWare has a very large support and sales infrastructureincluding over 200,000
Certified NetWare Engineers (CNEs) and 20,000 reseller partners across the world. In
1997, Novell introduced IntranetWare (a.k.a., Netware 4.5), which provided a built-in
Web server.
Disadvantages:
1. NetWare 4.X makes a poor application server. NetWare Loadable Modules
(NLMs) are the Achilles' heel of NetWare.
35


These are special namespaces set aside on the server that let
programmers provide new system services (or write new applications).
The NLM server modules you create get loaded by NetWare to
manage these namespaces.
Your NLMs, in effect, become part of the NetWare operating system
kernel.
There are many problems with NLMs that make it very difficult (if not
impossible) to use NetWare 4.x as a general-purpose, modern,
application server platform.
The three worst culprits are: 1) limited memory protection; 2) lack of
memory managementNetWare 4.x does not provide virtual memory;
and 3) no support for pre-emptive multitasking.
2. The second issue with NetWare 4.X is that it is too closely tied to a proprietary
networking protocol, IPX/SPX.
3. The third issue raised against NetWare 4.X is that it does not take full
advantage of SMP. The final criticism is that it does not provide an integrated
suite of back-end applications (a la NT's BackOffice).
The good news is that NetWare 5.0 fixes all these problems (and more).
It's a modern OS whose kernel was rewritten to provide native support for SMP, pre-
emptive multitasking, and virtual memory management.
NetWare 5.0 provides pure IP supportno more encapsulation or tunnelling of IPX
inside IP packets.
This means that standard IP products will interoperate better with NetWare. In
addition, NDS is now LDAP-enabled, which should help it get more acceptance on
the Internet.
On the application development front, Novell has embraced server-side Java with a
passion.
NetWare 5.0 provides one of the fastest and most secure Java VMs. In addition, it
allows your Java programs to be directory-enabled.
Novell will also provide native support for Enterprise JavaBeans and CORBA/IIOP
So developers will be able to use standard Java tools to create their server-side beans
on the NetWare platform.
Finally, Novell is bundling a best-of-breed suite of integrated back-end products with
NetWare 5.0.
All these products are directory-enabled and have common administration facilities.
The current suite includes Netscape's FastTrack Server, a five-user version of the
Oracle8, a certificate server, and Z.E.N.worksan NDS-centric system management
utility.

NT Server
NT Server provides the following additional features over NT Workstation: file/print
server support, built-in Internet server, disk mirroring and striping, and SMP.
36


NT Server code can be compiled to run on different microprocessor platforms
including Intel, Alpha, PowerPC, and MIPS.
NT 3.5 and the MS BackOffice server application suite release enhanced the TCP/IP
stack, provided better support for NetWare, and improved the performance.
NT 4.0 added support for the DCOM ORB, enhanced security, multiprotocol routing,
better SMP support, and ISDN communications.
NT 5.0 introduces a network directory, enterprise-level security, enhanced clustering,
a built-in Object Transaction Monitor called MTS, and a built-in message queue
facility called MSMQ.
Some of these products are already available as part of NT Server Enterprise Edition
or as add-ons via the NT Server Option Pack.
NT is a good application, database, and file/print server platform. Its tight coupling
with Windows, BackOffice, and DCOM makes it a natural server in Microsoft
environments. NT comes from the PC LAN tradition, which means that it is easy to
install, manage, and configure.
The NT programming environment and tools are familiar to programmers versed in
Microsoft tools.
Disadvantages:
1. NT does not scale well. Its SMP engines seem to top out at four processors (it
could also be an Intel bottleneck).
In addition, Wolfpack clustering does not support load balancing in its
current incarnation. So it doesn't help NT scale either. In contrast, Unix
platforms have been pushing SMP and clustering technology into
larger and larger configurations with almost linear scalability.
For example, Solaris has demonstrated linear scalability of up to 64
processors using clusters. Even if NT solves its current scaling
problem, it will always be around two years behind Unix in this area.
2. NT 4.X does not provide an enterprise directory server; its domains-based flat
directory does not even integrate with other BackOffice applications.
Of course, this problem may be solved by either running NDS on top
of NT or waiting for NT 5.0's Active Directory.
3. NT security is really a work-in-process; NT 5.0 promises to provide
intergalactic security and fill many of the holes.
4. NT add-onssuch as MTS, MSMQ, and Active Directoryare based on
Microsoft's COM+ object model.
Consequently, these services lock you into the Microsoft platform and
server component model. This may be OK if you're an all-Microsoft
shop.
The enterprise and the Internet are very heterogeneous environments
especially when it comes to servers.
So it's safer to stay with more open standardssuch as CORBA and
Enterprise JavaBeansthat are supported by multiple vendors on
multiple platforms.
37


OS/2 Warp Server
Like NT, OS/2 is also an excellent application server for departments. It is a seasoned,
32-bit operating system that has incubated some leading-edge server softwarefor
example, Lotus Notes.
In February 1996, IBM introduced OS/2 Warp Server, which combines OS/2 Warp's
application server environment with LAN Servera very fast file and print server.
Warp Server provides an OOUI user interface for easy installation, configuration, and
system management.
The installation auto detects hardware, which makes it easier to find and configure all
these strange network adapters.
Warp Server also provides disk mirroring, remote administration, remote software
distribution, a backup server, and software metering.
In 1997, IBM introduced a set of back-office and middleware offerings for OS/2, NT,
and AIX.
These are integrated families of server offerings for database management, transaction
processing, data warehousing, Web commerce, groupware, and system management.
In 1998, IBM introduced the OS/2 Warp-based WorkSpace on Demand. This is a
thin-client architecture that lets users remotely boot from an OS/2 server.
The application software and the operating system reside on the server while keeping
their unique desktop configurations.
Clients can run OS/2, DOS, Windows 3.X, and Java applications. The system comes
with a server management console.
In late 1998, IBM started to beta test a new release of OS/2 Warp Server code-named
Auroradue in the first half of 1999.
Aurora's new features include a built-in SMP engine, a journaling file, support for a
single European currency, full year-2000 compliance, a super-fast Java engine, and an
improved Web server.
Aurora will also provide a single logon capability that lets users log on to an OS/2
server and access files, printers, and applications on networked NT servers.
It will also let OS/2 Warp Server administrators create and delete NT user accounts,
passwords, and user groups.

UNI X
UNIX provides a seasoned, function-rich operating system that is scalable from the
desktop to the supercomputer.
The UNIX server industry grew out of the downsizing of mainframe applications.
UNIX was able to successfully surround the mainframe.
It then provided "a poor man's mainframe" alternative. However, in the PC LAN
environment.
UNIX is now surrounded by low-cost PC alternatives such as NT, OS/2, and
NetWare.
The latest high-growth area for UNIX servers is the Internet.
38


UNIX standards have become Internet standardsincluding mail, FTP, TCP/IP, and
the domain name service.
In a sense, the Internet is a showcase for distributed UNIX technology.
UNIX vendors have always been at the forefront of client/server middleware.
UNIX is also a well-regarded choice for database servers, especially ones that scale.
They are incredibly resilient and can automatically isolate and correct failures.
Disadvantages:
1. The main problem with UNI X has always been: Which UNI X do you
choose?
At last count, there were still dozens of UNIX variants on the market, but they appear
to be consolidating.
Because UNIX is a hardware-independent operating system, an application should be
able to run on any machine that supports Unix, from a PC to a supercomputer.
This server scalability story is very attractive, but it is not realistic. In the real world,
what keeps this from happening are two factors:
1. Lack of binary compatibility. The Unix world is different from the PC world,
where software comes in low-cost, shrink-wrapped floppy packages that can
run on any PC clone that runs MS-DOS, NT, Windows 95/98, or OS/2.
Unlike these operating systems, Unixes vary widely.
There is still no broadly supported binary standard. Unix applications,
at a minimum, must be recompiled to be ported from platform to
platform. This is a major headache and expense for software providers.
2. Functional differences among the Unixes. There will always be differences
among the Unixes: Vendors like to sell products, and functional differences
are required to avoid relentless, no-win price wars.
However, most Unix vendors have fully implemented the Unix 95
application interface formerly known as Spec 1170.
It supports over l,170 kernel APIs selected from the top 5O Unix
applications.
In June 1998, the Open Group introduced Unix 98. This latest spec
standardizes many more Unix fundamentalsincluding support for
real-time apps, DLL extensions, a common GUI, Internet profiles, and
the year 2000.
The Internet profiles will make every Unix box a full-function Web
server. On the Intel side of Unix, vendors are also collaborating on a
64-bit Unix for Merced. So the situation is improving.
The NT threat is pushing Unix vendors toward some kind of unification.
SCO has become the new guardian of the Unix standard, but not everyone is playing
by its rules.
It seems that for Unix to effectively compete, it must change its model. Instead of
each vendor reinventing the wheel with their UNIX extensions, they must learn to
cross-license each other's technology.

Unit I: What Is Client Server Model?

Uploaded by

Copyright:

Available Formats

Unit I: What Is Client Server Model?

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unit I: What Is Client Server Model?

Uploaded by

Copyright:

Available Formats

Branch: CSE/Seventh Semester

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.