6.096 Fall 1996
Introduction to Interactive Programming

Laboratory 7: Client/Server

Overview

This assignment emphasizes the following topics

• Client/server architecture
• Use of java.net (sockets) and java.io (streams)
• Network design tradeoffs

You should read through this entire assignment and complete the Lab preparation section before lab on Monday. You may also wish to see the email message about this assignment sent last week.

Updates

• Added javadoc.
• Added promised additional detail:
  • Steps you may want to take
  • Documentation
  • Running the Demo

Contents

• Overview
• Updates
• Pre-Lab
  • Finger exercises
  • Lab Preparation
    • Building a Client
    • Writing a Client Application
    • Writing a Server (Optional)
    • Development Plan
• Laboratory
  • What to Bring to Lab
  • In the Lab
  • Before you leave
• Post-Lab, AKA What To Turn In

Pre-Lab

A writeup of the finger exercises should always be turned in along with your completed laboratory. You may do this together with your classmates. You need not complete the finger exercises before laboratory.

The lab preparation work should be completed before you come to lab on Monday.

A. Finger exercises

Network tradeoffs

Pick two of the following networked applications and sketch (using between a paragraph and a page for each) a design for the distribution of their functionality. You should not try to describe the actual implementation of the system; instead, you should brainstorm about the constraints imposed by the problem and the network techniques that would facilitate its solution.

1. a network of bank ATM machines
2. zephyr
3. web browsing
4. phone call
5. cable tv (and pay-per-view?)
6. airline reservations

In particular:

1. What constraints must your design meet?
2. What operations does each of the clients support?
3. What (if any) network operations does each client operation invoke?
4. What functionality does the server support?
5. For each of the networked applications, give at least one example transaction, describing which computations occur on which computers and what resources (where) are accessed.
6. How well does your design meet the constraints you specified above?

B. Lab Preparation

For this assignment, you are going to build a generic server, a generic client, and some specialized client code. You should plan to build a generic client yourself, though you may design it together with other students. You may use either a server that you design and build, one that we provide, or one built by one of your classmates.  (You should specify which you use(d) in your writeup.) You may also extend the basic client, either by yourself or together with a group of collaborators.

Building a Client

In class, we discussed the architecture of a basic client/server application and its Java implementation. Your first job is to implement one of these generic clients. It should support a public void send( String ) method that writes its argument to its socket's outputStream. It should also read strings from its socket's inputStream and call the public void handleString( String ) method of its StringHandler. (You may find it convenient to make your client a StringHandler and let it default to calling its own handleString method.)

You should build a version of the client that implements this basic functionality. You may wish to make use of the following:

• class ClientDialog, which provides a gui for user entry of hostname and port. Alternately, you may hard code these into your client code, but you may find that to be a less flexible implementation technique.
• interface StringHandler.  Remember that an interface name is a legitimate Java type.
• class java.io.DataInputStream (especially String readUTF()) and class java.io.DataOutputStream (especially writeUTF( String )).

We will provide you with the code for a server to test your client with as well as a StringHandler that provides an interface to your client's send method. Details on these will be available at lab; you should only need to be able to construct a client with a StringHandler as a parameter and to supply a send method.

Writing a Client Application

Once your basic client works, you should hook it up to your scribble application, making a shared whiteboard.

In order to prepare for making the transition from a one-user Whiteboard to a networked one, you should answer the following questions (and bring the answers to lab):

• When you wrote your Scribble application, how did you keep track of the lines you were drawing? Describe any methods and classes you used, as well as how you incorporated them. Please be brief.
• Describe what changes you need to make to allow lines drawn on your whiteboard to be shared with others. Specifically, take your answers to the previous question and describe what role each class/method plays in the shared whiteboard(s), and how these differ from the standalone scribble application.
• Describe how the Client and Server are going to interact by answering the following questions:
  • How does your client know what to draw? When?
  • What is the server's role? That is, what is the server going to be doing most of the time and how?
  • When you write your client, how are you gong to notify the server that you want to add a new line to the collection?
  • What could go wrong when you are trying to communicate between Client and Server? How are you going to handle that?
• Outline the code that you feel will be necessary.

Writing a Server (Optional)

After your basic client works, you may optionally wish to design a compatible server. This server should accept multiple connections and handle inputs from each by sending the String received to all of the other connected clients (but not back to the client from which the String came).

You will probably want to use java.util.Vector and java.util.Enumeration to handle multiple client connections. You may also want to use the ServerDialog class that we've provided.

Development Plan

The final stage of pre-lab preparation is to write up a step-by-step description of your incremental development plan.

In particular: What is the minimum self-contained (i.e., testable) functionality that you can implement? How will you test it? What can you add to make a slightly more complex and still fully testable version? How would you test this? Continue listing added features and tests until you scale up to your complete design. This technique, incremental refinement, is an extremely useful and practical way to write code. You may want to read through the suggestions in the In the Lab section, below.

Laboratory

What to Bring to Lab

When you arrive at lab, you should have answers to the questions in the lab preparation a copy of your code design and development plan (on-line or on paper) ready so that we can check you into lab.

In the Lab

In lab, you should write and test the code that you designed.

As always, you should implement your code in simple, testable stages, building on your code only as each stage works robustly. In this case, it should be as simple as following your development plan.

Additional detail, as promised:

1. Steps you may want to take
2. Documentation
3. Running the Demo

Steps you may want to take:

1. Look at the (new) documentation.
2. Decide whether you're going to write a client first or to connect your scribble to our client first. (The pre-lab above suggests the second, but you may not have time to do both today.) If you are going to connect the scribble to our client, skip the next step.
3. Write your client code. You can test it with our server (see running the server, below) and even with one or more of our clients (using ClientTester or ClientMonitor).
4. Write code to connect the client to the scribbler. This code will presumably extend ScribbleData and implement StringHandler. Your main function will need to set up the classes appropriately. Make sure that something also starts up a client!
   1. You will need to start the server running before you can test your code.
   2. You can monitor the activity of your networked whiteboard by running a ClientMonitor.
   3. If you are using Line's pack and extract methods, you can also run your Whiteboard with one of ours. Start up our demo, then connect to the same server.
5. If you want to write a server, you can test it with our client.

There's now lots of javadoc. See especially:

• Dialog boxes and interfaces for constructing your client (and server):
  • cs101.util.ClientDialog.
  • cs101.util.ServerDialog.
  • cs101.util.StringHandler.
• Testing utilities for running our server and client:
  • cs101.util.RunServer. This runs and complains about all of the activity on the server. Run it in the background (i.e., java cs101.util.RunServer &).
  • cs101.util.ClientTester. This is a simple text-based main program interface to our client. You can use it to run our client program (java cs101.util.ClientTester), or you can copy it and modify it to build your own test program. The code is in /mit/6.096/share/classes/cs101/util/ClientTester.java. Type to it when you see the >>. Warning: it doesn't currently tell you what it has heard from the server until you give it some more input.
  • cs101.util.ClientMonitor. This is a simple read-only main program to monitor the activity of a client. You can use it to run and monitor our client program (java cs101.util.ClientMonitor), or you can copy it and modify it to build your own test program. The code is in /mit/6.096/share/classes/cs101/util/ClientMonitor.java.
• The cs101.util.Line class, which has utilities to make it easier to ship over the network. See especially the static methods packLine and extractLine. These translate between cs101.util.Lines and java.lang.Strings suitable for sending across the network with java.io.DataInputStream.readUTF() and java.io.DataOutputStream.writeUTF( String ).

To run the demo, first start up the server:

java cs101.util.RunServer &

(You may actually want to do this in its own xterm, since it will report on its activity regularly!) Then, start up one or more scribblers by typing

java SharedWhiteboardDemo &

You can run these on any machine, but they must be connected to the hostname and port where the server is running. After you supply the machine name and port number, you should see some messages indicating that the client is connecting to the server and that it is starting its read loop.

Before you leave

Before you leave lab, you will need to have your work checked off by a course staff member.

At a minimum, you should expect to demonstrate a client application connecting to a server and communicating with it. This can be a simple string-based interface, and you may connect to (an instance of) the server that we provide.

If you built a server, you should demonstrate your client connecting with it and/or let us connect to your server.

If you interfaced applications to either the client or the server, you should be prepared to demonstrate these.

You should be prepared to answer questions about all of the code that you implemented as well as the ways in which this code made use of the pre-defined interfaces.

If your code does not behave as expected, you should be prepared to explain why or to describe what you have done to try to figure out why.

It is always more important that you write clean, modular, well-documented and easy-to-understand code than that you go on to advanced features.

Post-Lab, AKA What To Turn In

Your completed assignment should include:

• your pre-lab assignment, including the finger exercises.
• your development plan, along with a description of how (if at all) it corresponds to what you actually did in lab.
• your code or a pointer to it, and a description of its functionality.
• your observations concerning
  • the coding/debugging process,
  • the behavior and reliability of your code.
  • the relationship between the interfaces that we provided, any additional interfaces that you designed, and the implementations that you produced.
• the name of the staff member(s) who checked you into and out of lab, a brief description of the check-out interaction, and answers to any specific issues s/he may have asked you to address.
• the names and roles of any collaborators in any parts of the project.

You should do your writeup individually.

Lab assignments are due on Thursdays at the beginning of class. They may, of course, be turned in earlier.

This course is a part of Lynn Andrea Stein's Rethinking CS101 project at the MIT AI Lab and the Department of Electrical Engineering and Computer Science at the Massachusetts Institute of Technology.

Last modified: Mon Nov 18 12:46:16 1996