CM10135 / Programming II:   Assignment 2 (2005)

Build Your Own Chat Application

Assignment Date:  Tuesday,  15 March.  Due date:  Thursday, 21 April at 4:00pm

The Basic Idea:

What to do:

1. Remember to write an informal specification / requirements statement of your application before you start.  You will probably want to draw the window(s) you want to build, and specify some classes.
2. First, you want to build a GUI application with some labels, two large text panes and at least one button.
   
1. One text pane is for typing into / sending messages, the other is for receiving messages.
2. The labels should make it clear which is which.
3. One button should let you quit the application.  You might want to add other buttons too (see below.)
4. This part is mandatory, and is worth 40 points.  You should try to get it done in one week.
3. Now choose 60 more points from the list below.
   
• Connect the two panels, so that when you enter text in one pane, it gets printed out in the other.
  
• You can do this in real-time, or after you hit return, or after you push a button, your choice.
• Make certain that your labels make it obvious how to use your GUI!
• If you are also making your program network, you will want radio buttons to turn this self-communication feature off & on.
  
• 15 points.
• Basic Networking.
• You will probably want to make your application both a `client' and a `server',
  
• You will need to add two little text boxes for the IP address & a port number.
• Make your application work across a network, e.g. use it to have a chat between two BUCS computers.
• Be sure to do good exception handling, e.g. so you can tell if the client couldn't find the server.
• 20 points.
• If you are making the same application/window be either a client or a server, then you should make it clear which your application is being at any particular time.
• Use radio buttons to choose `client' or `server' functionality.
  
• Disable the fields that aren't applicable if you are a client or a server.
• 5 points, even if the networking doesn't actually work.
• Use radio buttons, menus or combo boxes with icons or words to support displays of emotion as well as words.  You might want to use a slider to paint colours as well.
  
• 5 points to work on a non-networked version.
• 5 further points (10 total!) if this works across a network.
  
• Use a fancy layout manager and make your GUI look attractive and tasteful.
• 15 points.
• Support more people in the conversation in an elegant way, using threading & multiple panels.
  
• 20 points (requires networking works).
• Use the java.awt.Graphics package to allow personalization of users windows with drawing in a pane.
• This isn't covered at all in lecture, but is described in the java documentation online & in most java books.
• Examples of things you can do is draw shapes or change colors.
• 15 points.
• Another thing we aren't going to cover in lectures -- security.
• Think about how your application could be attacked.
• Write protocols to defeat it.
• Or just write something thoughtful in your analysis about what could happen.
• 10 points for code and analysis, or 5 points for thoughtful analysis without code.
  

What to hand in:

1. Your informal description of your classes & algorithms.
• This will almost certainly contain drawings.
• This must contain a table with which 100 points you are trying to achieve.
• The table should look like this (leave the gray squares blank!):
  

  Intended Features	points	works? (self evaluation)	works? (checker evaluation)	special instructions
  Basic GUI	40	yes		none
  Basic Networking	15	yes, pretty much		er... you have to choose the IP value in a special way here's how...
  and	so	on	...
  total points:	100

  This table will be used by the markers.
  
• Note that we expect description to have been written before you have done the coding, so it may have bugs in it!
2. A printout of your fully-commented code. 
   
• Poor program layout will lose marks.
• Poor coding will lose marks.
3. A short write-up documenting your program.
   
1. Include a screenshot of your GUI.
2. Be sure anyone (try your family!) could run your program from this documentation.
3. Some critical analysis of your program: 
   
1. What did you do right?  What did you do wrong? 
   
2. What would you do differently if you did it over?
3. Be sure to draw attention to any work that you think was particularly clever or difficult -- we are checking a lot of projects!
4. A disk containing an uncompiled version of your code.  Be certain the disk is not write protected!  The person marking your program will be compiling & running your program.

How you will be marked:

1. Description / Specification 15% 
2. Fully commented, working program implementing your design 65% 
3. Documentation and Analysis 20% 

1. Brief discussion of requirements and design. 
2. Simple program. Basic level of commenting. Code layout is mostly correct. Minimal exception handling necessary for a compile.
3. Minimal functionality: 
   
• A basic control window with buttons that let you start a conversation, end a conversation and kill the application.
• Some slight additional functionality.
  
4. Minimal documentation so that the system can be run without hacking. 

1. Specification covers all aspects of problem. Good program design at an appropriate level of detail. Clear description of how design will be implemented.
   
2. Program is a good implementation of design, or possibly better than the design. Code is concise and comprehensible.  Layout of code is correct and clear.  Some reasonable exception handling, e.g. reasonable messages or steps taken on likely exceptions.
3. GUI appearance uncluttered and clear.
   
4. Basic functionality: 
   
• Everything in the threshold pass, and
  
• Has at least 25 points worth of extra features working correctly.
5. Documentation clear, concise and helpful. Sensible criticism of your work, and good ideas for improvement. 

1. Specification covers all aspects of problem.  Detailed program design starting with a high level design and showing refinement into appropriate levels. Algorithms and implementation plan are given at an appropriate level of detail and are well explained.
2. A sophisticated program showing good use of Java, but not overly complex. Commenting is appropriate and gives sufficient information. Layout of code is correct and clear. Fully appropriate use of exception handling.
3. GUI attractive, functionality / usability apparent without much documentation.
   
4. All or nearly all of intended functionality works well.
5. Documentation clear, concise, attractive and informative. Detailed and thoughtful criticism of your work, and well-thought-out ideas for improvement, possibly including descriptions of alternative implementations.