CM10135 / Programming II:   Assignment 2 (2007)

Build Your Own Chat Application

Assignment Date:  Friday,  2 March.  

Due dates:     First Increment:     Monday,  12 March at 4:00pm

                      Final:                     Friday,    23 March at 4:00pm

                      Late Final (only 10% off):             Tuesday,    17 April at 12:00pm

The Basic Idea & Objectives:

What to do:

First Increment: Basic Networking

1. Make two command line applications, a server and a client.
   
2. These should take a command line argument of  a port number.  The client also needs an argument for the IP address.
   
3. Make your application work across a network, e.g. use it to have a chat between two BUCS computers.  Make sure it will also work in two windows on one computer as well though --- that's how it will probably be tested.
   
4. Be sure to do good exception handling, e.g. so you can tell if the client couldn't find the server.
5. Once the applications are both running & connected to each other, make sure you can type text into one of the applications and it will print out in the other
• it doesn't matter which is which --- in the real chat program you will be talking both ways, but that's inconvenient from the command line.

What to hand in (incremental)

1. Your well-formated, fully commented code.
2. That's it! 
   
3. Submit it through moodle.  

How the incremental assignment will be marked:

1. Marking will happen in lab during your next lab after the 12th March.
2. You must attend your lab session or you will lose points.
1. People who have Monday labs will be marked on the Wednesday lab on 14 March to make sure they get their code working on time!  We will have an extra tutor available to handle the extra number of people.
   
3. You will get to witness the marking process, so you can see why we ask for well formated code!
4. If your code doesn't work, hopefully the TAs will be able help you so this doesn't cause problems with your main project.

Main Assignment

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 30 points.  You should try to get it done in one week.
3. The networking is also mandatory, and worth 30 points.
1. 20 points are from the incremental assignment, above; 10 are for making this work in the GUI.
   
2. Make certain that your GUI has panes for entering the port into both the client & the server, and the IP address into the client.
   
3. You probably want your server to have a pane showing its IP address, that will make it easier to use.
   
4. Now choose 40 more points from the list below.
   
• Connect the two panels on your GUI, 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 to use labels to make it obvious how to use your GUI!
• Because your program will be networked, you will want radio buttons to turn this self-communication feature off & on.  This is mostly for testing the GUI part of your program before you implement the networking in it.
  
• 15 points.
• 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 to do this as well.
  
• 10 points if this information gets passed between both (or all) windows, or 5 points if it only works locally.
• 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.
• 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.
• Using the same package, implement a shared drawing area.
• 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.
• 15 points for code and analysis, or 5 points for thoughtful analysis without code.
• Write a formal protocol spec for the protocol you use (another thing you will have to look up!)
• 5 points.

What to hand in:

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

  Intended Features	points	works? (self evaluation)	works? (checker evaluation)	special instructions
  Basic GUI	40	yes		none
  Basic Networking	20	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 the description to have been written before you have done the coding, so it may have bugs in it!
• One page of text, up to one more for the table and up to one more for drawings.  Max 3 pages total.
  
2. Your fully-commented code. 
   
• Poor program layout will lose marks.
• Poor coding will lose marks.
3. A short (2 to 4 pages) write-up documenting your program.
   
1. Include a screenshot of your GUI.
2. Be sure anyone (try your non-CS friends, or family if they are online!) 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. Zip (or tar) everything, including uncompiled versions of your code, and post it on Moodle. The person marking your program will be compiling & running your program.
5. Please also put a printed out copy of your code & documents in the box by the department office.  If you do this, we will give you more feedback.  But you must still submit moodle, that is your real submission.
   

How you will be marked:

1. Informal Specification 10% 
2. Fully commented, working program implementing your design 70% 
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 making the marker hack it. 

1. Specification covers all aspects of the problem at an appropriate level of detail. Good program design and plan for implementation.
   
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 20 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.  Design description starts with a high level design and showing refinement to 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, but is not overly verbose. Layout of code is correct and clear. Fully appropriate use of exception handling.
3. GUI attractive, functionality / usability is apparent without much documentation.
   
4. All or nearly all 40 points of chosen 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.

Marks Table: