Distributed computing paradigms: traditional client server or mobile agents.

[Want to get automatic updates on ethel cofie’s blog post of Africa, technology, ecosystems and doing business in Africa sign up here ]






A Distributed system can be described as collection of independent computers who are interconnected that work together to perform a computation task. Computers in the context of this paper includes mobile devices such as PDA(Personal Digital Assistant) and mobile phone .Distributed systems stem from the need to make better and more efficient use of computing power by combining the computing power of various independent machine. It also rides literally on the backbone of the technological advancement in networking Local area Networks (LAN), Wide area networks (WAN) and the internet.

Communication among the computers involved in a Distributed System is paramount because without the ability of the computers to communicate with each other the set computation task cannot be accomplished.

The objective of the paper is to investigate the different design paradigms of developing a distributed system based on how they implement communication and which paradigm is the most efficient and cost effective.

This paper introduces a short history of distributed systems, delving into its Goals and objectives with example of different types of distributed system.

[Want to get automatic updates on ethel cofie’s blog post of Africa, technology, ecosystems and doing business in Africa sign up here ]

The two most used design paradigms the traditional client server paradigm and the newer agent based paradigm are discussed in detail stating the how they work technically.

Finally this paper’s comparism includes the relative advantages of both paradigms with research on a practical experimentation of both paradigms using a Java based client server and agent based systems to determine which a better paradigm was.





Since the modern era of computing  begun in the mid 80’s ,the need for increased and efficient use of computing power has been a constant feature .This revolution started  with development of increased power of microprocessors  at a fraction of the price of  the  main frames and mini computers .

In pushing for the greater computation power with the PC (personal computer), there was not only an increase in the microprocessor power and storage of these computers but also the push to link these computers to enable the efficient use of the resources such as memory, printers, files etc.

This brought about the invention of the high speed networks: Local Area Networks: enabling computers to be interconnected within a closed geographical area e.g. an office building then Wide Area Networks (WAN’s) interconnecting large number of computers over wide geographical area, the internet is a good example of wide area networks: This would enable a company with branches in Milan, England and Australia to share databases.

This ability to interconnect machine regardless of the geographical location is the wave on which the distributed systems paradigm emerged.

There are variety of definitions of a distributed system two is listed below:

A distributed system is one in which components located at networked computers communicate and coordinate their actions only by passing messages. [George et al 2001, p.1]

A Distributed system is defined as a collection of independent systems that appear to the users of a system as a single system. Processes and/or data can (or cannot) move from host to host, share information. (IEEE distributed systems online)

As stated in the definition A Distributed is characterized by the fact that the computers are  autonomous computers ,also the machines collaborate to work on tasks but appear to the user not as a fragmented groups of machines abut as one coherent unit .

As a further illustration of what a distributed system ,this System would be described as a distributes system: Sales representatives of an organization who may be spread over a wide geographical locations could place orders by means of laptop computers connected via telephone networks or possibly cell phones, incoming orders would then be automatically forwarded to the planning department, resulting in new internal shipping orders sent to the stock department, as well as billing orders to be handled by the accounting department. The system would then automatically forwards orders an available and appropriate and available person and all these processes would appears to the users as one centralized databases. [Anonymous]

Also Organizations with large projects to complete have attracted Internet users from across the world to donate their computer’s time. SETI@Home — by far the most popular with users — analyzes data from a telescope, searching for potential signals from extraterrestrial life. RC5-64, a project from Distributed.net, is testing out 72 quadrillion keys to unlock a 64-bit encryption code. The Great Internet Mersenne Prime Search sorts through numbers in the millions for a large prime number. [DC CENTRAL, 2000 http://library.thinkquest.org/C007645/english/0-application.htm]


1.1 The Goal/Characteristics of Distributed Systems is to:

Connecting Users and resources: The major goal of a distributed system is to enable users regardless of the geographical location of their users to connect with each other and share resources .This obviously has its security drawbacks: who should have access to which resource and how often, how the distributed system offers authentication and validation etc. Resources shared over a network could be a database, a printer, processing power etc. The internet shows examples of how resources can be shared over an electronic medium e.g. multimedia like music, movies, short clips etc

Transparency: By the very definition of a distributed system the users of a distributed system should not be able to detect that the different computation tasks are distributed across different machine .This is thus the argument where some researchers dismiss the internet as a distributed system whilst others do not because users do recognize on the internet that they are accessing different servers.

There are different types of transparency these are:

Access: Hide differences in data representation and how resource is accessed

Location: Hide where resources are located

Migration: Hide that resources may move to another location

Relocation: Hide that a resource may be moved to another location while in use

Replication: Hide that resources may be replicate (e.g. replicate websites and databases on the internet)

Concurrency: Hide that a resource may be shared by several competitive users

Failure: Hide the failure and recovery of a resource

Persistence: Hide whether a software resource is in memory or on disk

(Tanebaum et al, 2002, p.5)

Openness: An open system is a system that can interact with other systems according to certain laid down standards, meaning that even systems that are made from different manufactures and developers should be able to interact with each other according to set rules, syntax or standards. E.g. Interface Definition Language, XML, Web services protocol, Open Systems Interconnectivity (OSI) model.

Scalable: Distributes Systems ought to be infinitely scalable but due to technology advancement  it cannot fully meet its target .However a  distributed to large  degree must be scalable new machines and users should be able to be added without decrease in performance of the system

Also the geographical areas of the distributed system could be increased with no fatal decrease in the distributed system performance.

In all these increase in size and geographical area the system should still be administratively manageable.





 As the paradigm of Distributed metamorphosis’s and come of age in it self, as in any technology there is drive to increase the efficiency to provide better service and efficiency to users and developers alike. The major bottle neck of distributed systems is communication/passing of messages between computers that enable the sharing of resources across the networks .In response two this two paradigms of  how a computers passes and receives its messages have emerged.

Distributed System traditionally uses the client server paradigm in implementation where each autonomous machine become a client request a service or data from another autonomous machine (Server).

However another paradigm is emerging: This is the use of the Mobile Agents to implement a distributed system. In other words instead of the traditional invocation of a method or service from a remote machine/or computer. An Agent migrates to the Destination compute/Machine executes to retrieve the data or service it needs and returns the results to Host Machine.


This research paper is investigating these two paradigms/Architectures: the traditional client server paradigms and the newer mobile agent based paradigm.

This paper researches which is the most efficient implementation paradigm for distributed systems


2.1 Traditional Client Server Model

The traditional client server architecture of the distributed is primarily composed on two parties .The Client and the Server. These roles are interchangeable in a distributed system depending on the need of the machine at that point in time.

The Client makes a request by sending a message to the server and the Server unwraps the message, decodes it and processes the request and sends the reply in the form of a similar message back to the Client .There are some specific types of servers that serve a particular need e.g. an application server, file server, terminal servers, mail servers

Illustrating this fact a Client machine (Sales Executive) in Tokyo can make a request for sales numbers in the London Office from the London Office database server.

Tele workers can work from home based on this same principle.

Obviously in the Client Sever model there is a need for connection between the client and Server. Connection or connectionless protocols like TCP/IP may be used to as the channel to transmit, messages across the network.

In a connectionless protocol the Client sets up the connection with the Server, sends the message and cuts the communication connection .The Server receive the message processes it establishes a new connection to sends the requested reply. An Example of connectionless protocol is TCP/IP.

A transmission failure is invariably the one greatest disadvantage of the connectionless protocol. When does the system realise that the message did not arrive at its intended destination or was corrupted in the transmission process.

The connection protocol require that a connection is set and  maintained between client and server till the request message is processed by the client and reply to client is

sent. It is much more costly in terms of bandwidth usage as compared to the connectionless protocol but less prone to transmission failure.

There are many variations of the client server architecture: Thin client where almost no processing is done on the client, all processing is on the server graduating to the next extreme fat client where the most of the processing is performed on the client.

In the Client Server model or paradigm it is the  communication between machine that is the driving force but actually on the granular side it is the in the communication between processes that drive a distributed system.

A distributed program consists of multiple program units that may execute concurrently

on the nodes of a distributed system, and inter act by exchanging messages . A running program unit is a process. The distributed programming consists of implementing distributed applications. [ PATRICIA , November 1992]

In computing, a process is an instance of a computer program that is being executed. While a program itself is just a passive collection of instructions, a process is something which actually executes those instructions. Several processes can be associated with the same program – each would execute independently [http://en.wikipedia.org/wiki/Process(computing)]

In the client Server Model the communication models that are used to perform the reply request Client Server request are [Tanebaum et al .2002, p 57]  Remote call procedure, Remote Invocation and Message–Oriented Middleware (MOM) stream.

Remote Procedure Call: In a standalone computer one process calls the other by calling that function necessary to perform that function along with supplying the requisite parameters. Remote procedure call uses the same kind of principle but in much more complex way.

Basically in remote procedure calls the client remotely calls a function on another machine that it might use to perform a function. The idea is to call a remote function as if it were a local function on the client machine. Thus is to ensure transparency where the requesting client or machine cannot tell whether the request is processed locally or remotely.

The Technical aspect of Remote procedure call is explained below:

Remote procedure calls are usually embedded in client/server program which in on compilation create a client and server stub.

According to research from ANDREW S TANEBAUM and MAATEN VAN STEEN’s book  Distributed Systems Principles and paradigms :The client stubs duty is to pack the clients parameters into a message  and request that the message to be sent to the server via the network connection.

The server stub is also defined as the server side equivalent of the client stub.

The server stub is a piece of code that transforms requests coming over the network into local procedure calls. [Tanebaum et al. 2002, p.71]


According to the research from [Tanebaum et al. 2002, p.71] When the packaged message arrives at the server the operating system of the sever machine send the message to the server stub who unpacks the message and then calls the server procedure needed to be executed.


RPC increases the flexibility of architecture by allowing a client component of an application to employ a function call to access a server on a remote system. RPC allows the remote component to be accessed without knowledge of the network address or any other lower-level information. Most RPCs use a synchronous, request-reply (sometimes referred to as “call/wait”) protocol which involves blocking of the client until the server fulfills its request. Asynchronous (“call/no wait”) implementations are available but are currently the exception.

RPC is typically implemented in one of two ways:

  1. Within a broader, more encompassing propriety product e.g. distributed computing environment, Sun RPC or Open Network Computing.
  2. by a programmer using a proprietary tool to create client/server RPC stubs

 (http://www.sei.cmu.edu/str/descriptions/rpc.html )

In the research I culled an example to better explain the concept of RPC

A  program at a Stock Exchange includes a read call to get data dollar –pound from a remote  machine .The client stub on the client machine takes the parameters provided by the client packages it up into request and send it across the network to the server. The server operating system then the request and forwards it to the server stub who then unpacks the parameter and call the right read function for the request.

The client in the mean time is blocked. Once the read function is executed the server stub packages the reply and sends it back to the Client.

The Client operating machine receives the exchange rate and sends it to the client stub who then unpacks the exchange result sending it to the client for use.





Remote Object Invocation: In the programming paradigm, object-oriented programming is when an object is an individual unit of run-time data storage that is used as the basic building block of programs. These objects act on each other, as opposed to a traditional view in which a program may be seen as a collection of functions, or simply as a list of instructions to the computer. Each object is capable of receiving messages, processing data, and sending messages to other objects. Each object can be viewed as an independent little machine or actor with a distinct role or responsibility [culled from wikipedia]

 The class of Dog defines all possible dogs by listing the characteristics that they can have; the object Lassie is one particular dog, with particular versions of the characteristics. A Dog has fur; Lassie has brown-and-white fur. In programmer jargon, the object Lassie is an instance of the Dog class. The set of values of the attributes of a particular object is called its state. [Culled from wikipedia]

The object oriented concept become popular a few years over procedural programming being especially promoted by Java.

Thus as the Distributed have become diverse as some are implemented procedurally and others  using the object orientation programming .Remote procedure Calls (RPC) which is solely procedural has being modified to accommodate the Object oriented concept using

According to research culled form [Tanebaum at al, 2002].”An object by its very nature can implement multiple interfaces .This strict separation allows us to place the interface at one machine while the object itself resides on a different machine. This organization is referred to as distributed object.

When a client binds to a distributed object, an implementation of the objects interface called a proxy is loaded into the client‘s address space. A proxy is analogous to a client stub in RPC. The only thing it does is to marshal methods of invocations into messages and unmarshal reply messages to return the result of the method invocation to the client.

The actual object resides at the server machine where it offers the same interface as it does on the client machine.

Incoming invocation requests are first passed to a server stub often referred to as skeleton, which unmarshals them to proper method invocations at the objects interface at the server. The server stub is also responsible for marshaling replies and forwarding reply messages to the client –side proxy.

A characteristic but somewhat counterintuitive feature of most distributed object is that their state is not distributed: it resides at the single machine .only the interfaces implemented by the object are made available on other machines. Such objects are also referred to as remote objects”. [Tanebaum et al 2002, p.86]






2.2 Mobile Agent Model/Paradigm


Having discussed The Client server architecture/paradigms, this research paper proceeds to the Mobile Agent paradigm of Distributed System Architecture.


Cumbersome computations can often be broken into discrete units for distribution among a pool of servers or processors. Each of these discrete units can be assigned to an agent, which is then dispatched to an “agent farm,” where the work is actually performed.

Upon completion, each agent can return home and the results can be aggregated and summarized…-– Stefan Marti, MIT Media Lab. in the article. Applications for Aglets.

This quote above amply describes the mobile code/agent paradigm of Distributed system architecture.

To better explain the concept of mobile code paradigm it is imperative that this research paper delves into what a Software Mobile Agent is and how they work relating it back to the how function as a paradigm for Distributed system development.


The Definition of what a software agent is quite a contentious topic. The views are varied and wide spread. Using the broadest definition is in the article Effectiveness and Suitability of Mobile Agents for Distributed Computing Applications (Case studies on distributed sorting & searching using IBM Aglets Workbench).

It states that a software agent is process or code that that is situated within an execution environment; possesses the following mandatory properties:

  • Reactive; senses changes in the environment and acts in accordance with those changes;
  • Autonomous; has control over its own actions;
  • Goal-driven; is pro-active and  is to perform a specific task
  • Temporally continuous: executes continuously; and may possess one or more of the following orthogonal properties:
    • Communicative; can communicate with other agents;
    • Mobile; can travel from one host to another;
    • Learning; adapts in accordance with previous experience;
    • Believable; appears believable to the end user.


In other words agents are figuratively speaking the first step in the AI (Artificial Intelligence) Paradigm but with a more realistic approach and less hype.

There are wide arrays of processes that can be described as software agents within and without the distributed system environment .They perform various tasks as a single unit or in collaboration with other agents.

Borrowing an example from a paper on mobile code paradigms this real life example helps explain how the concept mobile paradigm works

Louise wants to prepare a chocolate cake. She has the right recipe and ingredients, but she has not an oven at home. However, she knows that her friend Christine has an oven at her place, and that she is very happy to lend it.

So, Louise prepares the chocolate dough ad then goes to Christine’s home, where she bakes the cake. [Carzaniga et al, 1997]


A typical role of an agent in a distributed system is a function of the type of distributed environment it operates. E.g. in an ATM (Automatic teller Machine) application consists of an account database server, with customer request agents distributed across the network submitting requests. The account server agent and the customer request agents are agents within the ATM application, but they might also serve agents residing at the financial institution’s headquarters, as part of an administrative application. Example culled from (http://www.unix.org.ua/orelly/java-ent/dist/ch01_01.htm)


There is no agreed taxonomy of categorizing the agents but agents are usually categorized by their characteristics and attributes .There are some agreed classes of Agents .These are:

Collaborative Agents: Agents in a multi agents system work to together to perform a task. This uses the characteristics of autonomy and collaboration

Mobile Agents: A prominent feature of some agents is the ability to remove them selves from one machine and execute themselves on another machine either the same of different platforms.

Interface Agents: They have learning capacity and they assist the user in the use of applications, learn user preferences and adjust accordingly.

Information Agents: Main ability of these types of Agents is to collect order sort and presents information from different sources. That tends to be a much used agents within the distributed system environment. (Tanebaum et al, 2002)


These characteristics of the of a software agent which allow to migrate to  a host machine execute itself and retrieve the data it need and migrates it self back to the Source machine and collaborate with other agent in task performance is seen as alternate design paradigm to the traditional Client Server.


2.2.1How Mobile agent paradigm works

The Mobile agent/code is mostly dependant on the how it packages its self (code) and the execution environment and the method it takes to transfer itself from the Host node to the destination machine and its platform. This could be with homogeneous platforms meaning that the machines are of the same make and hence easily compatible or Heterogeneous where the machines have different makes are therefore less easily work together or are compatible.

Migration of the Agents especially between heterogeneous environments involved in the distributed environment is a technically difficult due to the fact that it involves issues with binary compatibility of the platforms involved.

There two types of Agent migration these are weak migration and strong Migration.

The mobile agent can be migrated in two ways .it migrates it self in other word its code and then its execution state (i.e.internal state and the private data)

Thus in weak mobility the agent code and /or state is  transferred to the host machine whilst in strong mobility the agents code and execution state are sent to the host .

XML is one of the independent formats in which the agent state is saved so be transported and easily read by the host machine/node.

The agent-code is made available on both sides so that an agent process can be created on the destination platform, which is then initialized with the transferred agent state. This particular approach to weak migration is, for example, implemented in an extension of the Fipa-OS agent platform. [Groot et al, 1999]

This research identified two methods of agent migration which are used, the first being the process or code migration and code generation migration.

Process/code migration deals with migrating of the entire process (i.e. code and /or execution state) over the network to the node that the data is required from. Some Mobile agent programs employ this technique e.g. D’Agents and they seem to be the solution to the problem of migration of distributed mobile agents.

Process migration despite its best efforts lends itself better to migration within homogeneous environment. It is almost impossible to implement process migration without some level of homogeneity.

In summary the generative migration concept works by defining a structured agent behavior and functional into machine dependant syntax using a mechanism called an agent factory. This Blue print alone with the execution state of the agent is sent from the host machine to the host machine which should have its own agent factory that interprets it and transforms it using its class libraries to generate an executable code which is the distributed Agent. The Agent then reorients its self to its environment using its execution state and subsequently performs its predetermined task.


The Regenerative migration concept lend itself to many types of migration: Homogeneous migration, Cross platform migration which is migration of an agent from one agent platform to a different agent platform but with the same virtual environment , Heterogeneous migration where the agent migrates to a host with a different agent platform and different virtual environment and Agent regeneration migration which involves the migration of an agent to a different virtual target machine and hence require code regeneration maybe to a different executable[.Cofie,2006]




Having researched into the how both the of both the traditional client server design paradigm for Distributed systems and the agent migration design paradigm work ,this research paper goes on to discuss the relative weaknesses and strengths of both paradigms which is most appropriate for Distributed systems.

In this research it has being discovered that the agent migration paradigm work was developed because of the pitfalls of the Client Server paradigm.

Firstly the client server paradigm which is based on messaging uses up a lot of  network bandwidth  and causes network traffic and mobile agent paradigm solves this problem by using minimal number of messaging first message to migrate code and data and then second message to return the executed code and data to Server machine.

Secondly in the client server paradigm implementation of RPC (Remote procedure Call) in the event of a failure the client cannot distinguish between the message reply delay, a failure of the message to be retrieved or even network failure and hence cannot make an informed decision on resending the message. In instances where the request might just be retrieval of information resending a request is not a problem but in critical instances e.g. request to transfer ₤1000 from one account to another resending the request is not the best option.

The impetus for technologist and developers in developing the agent migration paradigm was primarily due to the network congestion caused by the messaging between client and server stub because in the mobile agent paradigm moves the code to the server. It has being found in this research the mobile agent paradigm decreases network traffic.

This research included a review of a research paper by D. Hagimort and L .Ismail titled A Performance Evaluation of the Mobile Agent Paradigm which uses two applications to compare the two paradigms.The experiment reviews issues of the two paradigms relating to

·         Network Latency and Round Trip Time

·         Transfer of huge data

·         Tasks that involve complex computations to be performed on huge data sets

·         Tasks that are inherently parallel and distributed in nature.

The experiment involved the use of Java runtime environment, Java based remote object invocation, Java based minimal platform to program agents and aglet()

The networks used were the:

  • Workstations under Solaris, interconnected through a 10 Mbits Ethernet.
  •  Large scale network. It is composed of two comparable workstations interconnected through the Internet. The first machine is located in France (INRIA, Grenoble) and the second is located in United Kingdom (Queen Mary and Westfield College, London).

Java development kit 1.15 was used for all the experiments.

[Hagimont et al, 1999]

The First Experiment fetching a minimal amount of data

The first set of experiments using the RMI is below:

Culled from [Hagimont et al, 1999]



The experiment involving the Agent was a simple iterative to and fro migration

 The agent size is 1475 bytes, including the code and

the data parts of the agent. The results is shown below


Culled from [Hagimont et al, 1999]

In this experiment the RMI outperforms the Agent by being faster at performing its set tasks.


The second Experiment varying the data to be retrieved

In this example in the server exports an interface that allows a client to fetch a copy of a document. The interested is in optimizing transfer for large documents using data compression [Culled from [Hagimont et al, 1999]



Culled from [Hagimont et al, 1999]

The graph below shows that with smaller document samples Remote Method Invocation is far more efficient in terms of time efficiency it then it begins to falter as the document size increases to Mobile agent paradigm.





This research has come to the conclusion though the mobile agent design paradigm was developed based on the short comings of client server design paradigm of network congestion and inability mobile agent paradigm is not the best distributed paradigm in all circumstances.

This research has brought the light the fact that there is no clear cut most efficient way of developing a distributed system.

The best paradigm has to be decided on a case by case basis that is the requirements of the distributed application to be developed .A distributed hypertext system and a data mining system have different data and network needs and hence have to be designed based on the volume of data that is to be retrieved and the volume of messaging that will be needed to retrieve the information needed. Efficiency  and effectiveness in the context of this research paper is the time involved in completion of the computation task .The Client server paradigm after having being tested against the mobile agent paradigm is much more efficient when there is a minimal number of messaging between client and server and the volume of data to be transported is over 1000kilobytes .

Client server paradigm also lends it self better for use in homogeneous environment.

Mobile Agent are however much more efficient and effective with data intensive distributed system which require greater degree of messaging between the machines involved but are less conducive for use in a time critical distributed system.

The use of the mobile code paradigm reduces network traffic in a distributed although not necessarily making it faster.

Mobile Agent also lends it self better for use in heterogeneous environment.


I n conclusion mobile agent paradigm and traditional client server have their distinct characteristics and  consequently the distributed systems they better suited for and hence there is no better paradigm but rather the best paradigm is based on the Distributed system to be developed.

Consequently this research end by pointing out the parameters that should aid any distributed system developer to choose the best paradigm for the application

Parameters to aid the choosing of the best paradigm to use.

  • The timeliness over efficient network use
  • Time critical ness of system
  • Type of system heterogonous or homogeneous
  • The volume of the Data that needs to be transferred.
  • Complexity of distributed task.































CARZANIGA ANTONIO,GIAN PIETRO  PICCO ,GIOVANNI VIGNA, Designing Distributed Applications with Mobile Code Paradigms. International Conference on Software Engineering Proceedings of the 19th international conference on Software engineering, 1997, Boston, Massachusetts, United States , ACM Press   New York, NY, USA. ACM Press   New York, NY, USA

This paper primarily discusses the different design paradigms in distributed systems. It also discusses mobile code languages. The paper compare all the different paradigms concluded that there is no single best paradigm but the best paradigm is based on Distributed application needed.



COFIE  ETHEL, 2006.Software Agents In Distributed System Environments .Brighton

This paper deals with Agents in distributed systems with particular attention to migration methods .This paper specifically compares the regenerative method and why it is a better method.


COULOURIS  GEORGE, JEAN DOLLIMORE AND TIME KINDBERG,2001.United States of America :Pearson Education limited Distributed Systems concepts and design.3rd edition Pg1-25;

The authors define state their definition of a distributed system stating the real world examples of distributes system dwelling on and especially discussing the internet and why it is termed a distributed system. They authors end the chapter by discussing the major issues/challenges arising i.e. security, openness, mobile code, scalability, concurrency and fault handling.


COULOURIS  GEORGE, JEAN DOLLIMORE AND TIME KINDBERG,2001.United States of America :Pearson Education limited Distributed Systems concepts and design.3rd edition Pg 29-62;

The authors discuss the architectural models of distributed systems starting with the software architecture/structures .Within the discussion on the software structures they described the platform and Middleware components their relation to a distributed system and their component functionality. They also enumerated the System architectures and their commonalities and differences. The chapter ended with the discussion of design requirements and interaction, failure and security


DC CENTRAL,2000. What is Distributed computing ?[online]. Thinkquest Team C007645 .Available at <URL: http://library.thinkquest.org/C007645/english/0-definition.htm > [Accessed November 2006]

 The author launches straight into the need for distributed system with an exposition on a distributed system for analysing telescope data. Illustrations are used to simply explain a distributed systems advantages and disadvantages .The article ends with a description of alternative and forms of distributed system .Though the description of the forms of distributed system is centred on terminal systems.


DC Central,2000.[online] Thinkquest Team C007645 .Available at <URL: http://library.thinkquest.org/C007645/english/1-intro.htm >[Accessed November 2006]

A technical paper explaining how a distributed system works within a network, emphatically underlying premise that a network is the lifeline of a distributed system. The first part of focuses on an introduction to networks (hardware software components and types) and how they communication .In conclusion there is  a focus on distributed communication and its methods, and information on parallel processing This article with simplified illustration simply explain the inner working of a distributed system.


TANEBAUM ANDREW S and MAATEN VAN STEEN,2002 Distributed Systems Principles and paradigms Pg 58-131

The authors describe communication in a distributed system with an exposition on the OSI model and its layers with a detailed explanation of how they work in synchronous and asynchronous modes. Using this background the authors ease into an explanation of distributed computing environment.


GODFREY  BILL,2006. A primer on distributed computing [online]Available at <URL: http://www.bacchae.co.uk/docs/dist.html>> [Accessed November 2006]

 This is a short non technical article on how distributed systems work practically and how to determine whether the task to be implemented actually requires distributed computing. The article concludes with an exposition of the securities needs of a distributed system and safeguards .An easily understandable explanation of distributed systems.


GOULD  LAWRENCE S..  Sun’s Jini: Granting the Wish of Simplified Distributed Computing?.Automative design and production[Online]Available at <URL: http://www.autofieldguide.com/articles/069903.html >[Accessed November 2006]

The author uses the free ship software to show an example of a distributed system gone wrong. He then goes on to discuss the Jini a sun Microsystems inc platform which effectively enables dynamic object allocation/spontaneous networking using a lookup service .concluding the jinni biased article  with  a discussion on other platform for distributes application development and compares it with Jini.


GROOT, D.R.A., BRAZIER, F.M.T., AND OVEREINDER, B.J. (2004) , Cross-Platform Generative Agent Migration , In: Proceedings of the Fourth European Symposium on Intelligent Technologies, Hybrid Systems and their implementation on Smart Adaptive Systems , pp. 356-363 , June (EUNITE 2004, June 10-12, 2004, Aachen, Germany,

This paper is based on David de Groot’s Master’s thesis. It discusses the need for mobile agent and then going on the explain the difficulties mobile agent face in migration and the reasons why the cross platform generative migration of a better way of migrating agent


HAGIMONT   DANIEL ,L. ISMAIL . A Performance Evaluation of the Mobile Agent Paradigm. Conference on Object Oriented Programming Systems Languages and Applications Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications. 1999 . ACM Press   New York, NY, USA . Denver, Colorado, United States .  Pages: 306 – 313  

This paper evaluates the different paradigms discusses the pitfalls and advatntages of each. The paper concluded by the observation of an experiment using java based system to test out which is the better distributed system design paradigm/


OTTE  RANDY,PAUL PATRICK,MARK ROY,1996.New Jersey USA:Prentice Hall Inc. Understanding CORBA, pg 2-1 to 2-8

The authors give a simplistic view of CORBA and how it relates to distributed Systems

They give a conceptual overview of CORBA along with descriptions of its cardinal concepts and the technical aspect of how they partake in implementing the functionality of distributed system. It helps give a simplified view of CORBA.


SOARES  PATRICIA GOMES  ,November 1992, On Remote Procedure Call, Proceedings of the 1992 conference of the Centre for Advanced Studies on Collaborative research – Volume 2 CASCON , SESSION: Distributed systems – programming and management 1992, Toronto, Ontario, Canada ,IBM Press. Pages: 215 – 267  

This paper discusses remote procedure calls dealing dealing with how they work generally and the concept behind RPC.It also discusses the pitfalls of the RPC paradigm ending with a discussion on the future of RPC.A good and insightful paper


VONDRAK CORY, 1997. Distributed Computing Environment Software Technology road map [online]. Redondo Beach CA: Carnegie Mellon University. Available at <URL:http://www.sei.cmu.edu/str/descriptions/dce.html>  [Accessed November 2006]

Though this article outdated .it gives a good overview of the origin, purpose and technical details of the a distributed computing environment (dce)

With an illustration of the dce components it describes its services portability and suitability with examples of applications using dce’s.

The article concludes by lightly touching on the evolution of the dce its limitations and costs.


WIKIPEDIA,2006. Distributed computing [online] .Wikimedia Foundation, Inc .Available at <URL: http://en.wikipedia.org/wiki/Distributed_computing> [Accessed November 2006]

This article gives a general overview of a distributed system  by defining a distributed system and how it related to parallel and cluster computing. It describes its goals stressing particularly on openness and scalability are examined .The advantages along with the drawbacks are also discussed. The author lightly touches on the architectural patterns of distributed system ending with an exposition on how distributed systems implement concurrency. The author also provides a good list of references for distributed systems.


Effectiveness and Suitability of Mobile Agents for Distributed Computing Applications

(Case studies on distributed sorting & searching using IBM . Aglets Workbench)