Projects 

I. Overview


The overall goal of these projects is to gain insight into the algorithms
and models involved in grid computing and into the inner workings of
middleware.
 
You are expected to have a working knowledge of Java ,
the programming language for your projects.

The projects have a fair weight in the overall class grade
and each  student is expected to work by himself/herself.
Acts of academic dishonesty lead to an unconditional
failure of the class.

For your projects you will:

   - a. Design and implement a grid service and the kernel of a PN simulator.
         Evaluate and justify your design choices.
   - b. Document the project. Your documentation should be well organized
          and touch every aspect of your project including:
                    - goal and objectives,
                    - measures of success,
                    - related work,
                    - algorithms,
                    - design alternatives and design choices,
                    - implementation,
                    - performance measurements and subsystem evaluation,
                    - user guide.

 The documentation should be written in Word; the drawings should
be done using Visio.
At the due date of each project you have to provide a Zip file
including the following directories:
  - literature
  - documentation (see the structure of the documentation,
     point (b) above)
   - source code

Programing style:

   i.)  Each sub-program should have a header describing:
       - the name of the subprogram and its function,
       - the author ,    
        - the modification history.
   ii.) The code should have enough comments to make it easy to read.
   iii.)  The names should be descriptive and reflect the function of the object.
   



II.  Project  1  -  Design and implement a grid auction service.

  Due date: Monday, September 16, 8 AM (hard deadline - no extensions)
   Grading guidelines :
                    - a.  Simple minded but working project - maximum  40 points
                              Simple minded means:
                                                (1) trivial bidding and auctioning algorithms, 
                                                          (2) single threaded server,
                                                          (3) simple client GUI,
                                                          (4) no bidder and seler services support (e.g, bidders
                                                      not required to register , sellers unable to stop the
                                                      auction, etc.),
                                                          (5)  no security (authenticaten, encyption) .
                    -b.  Sophisticated project maximum 100 points.
                                                   
 Hints:
       - Familiarize yourself with the concept of an auction .
       - Connect to Ebay , Sothebys and other auctioning sites and
                see what services they offer.
          -  Familiarize yourself with bidding agents and algorithms .
          -   Write and test a simple multi-threaded Java server.
          -  Add functionality to your server.

III.  Project  2  -  Design and implement a Petri Net simulator.

 Due date: Monday, November 25, 7 PM. No extensions.  

                    Step 1. Given a Petri Net generate its textual description in PNML.
                          Use the PN for the candy machine presented in class as an example.

                    Step 2. Parse the PNML description and generate an internal representation. For
                          example, this internal representation may consist of a list of all transitions,
                          for each transition you specify its pre-set and post-set. You maintain also
                          the current marking.

             Step 3. Create a PN Virtual Machine (PNVM) that takes as input the internal representation
                          and simulates the token game. In other words, it examines the current marking and
                         identifyies all enabled transitions; then it randomly pickes up one of the transitions
                         enabled in that state (marking), fires that transition and generates a new marking.

             The parser and the PNVM should be written in Java.

             Your program should be able to list: the orginal making, the final marking, the firing
             sequence (the list of transitions fired while the system moves from the intial to the final
             marking) and the individual marking reached after firing each transition.

            Extra credit will be given for:
                 - a well designed GUI
                 -  generation of the reachability graph
                 - generation of the coverability graph
                 - ability to diagnose liveness
                 - abilty to diagnose if a PN is a state machine or a markeked graph
                 - ability to diagnose if a PN is a free-choice net.

            You will turn in:
               - your parser
               - your PN virtual machine
               - the required test case (the candy machine)
               - another test case of your choice
             For each test case you will supply the PNML description and the output of the
                     simulator.

             We will test your simulator with a test case of our own.