This project is available for Honors adjunct credit. But other interested, highly motivated and highly performing students are welcome to join.
Note 1 added April 7: I've added a link to the Sun RMI tutorial on the DB resources page. This is a good example to start with. I've also fired up the mailing list for the Honors section. Everyone in the class interested in the project should have got notified about their membership.
Note 2 added April 7: There are two distinct projects worth pursuing. Project A. Use RMI to explore client/server architecture such that the "presentation server" can simply be code on the client that converts a few command line request to server calls and the server does something simple, returns it and it's converted to command line feedback. Or Project B. Use threads in a single, non-networked application to explore locking, e.g., two operations on the same account won't interfere but simultaneous operations on distinct accounts are allowed. (No disk-based data is needed in projects A or B, just have the "accounts" stored as objects in your running system.)
The project is designed to allow small teams to work directly with client/server software technology by building their own transaction systems. The technology used will be Java RMI (Remote Method Invocation). This work will be somewhat more difficult than the standard assignments, which do not involve programming. But the projects will be more rewarding for some. The project work will replace the normal homework assignments, but the tests will be based on the homework, so students participating in the project will need to understand how to solve the homework problems in any event.
RMI is a Java-specific object-oriented extension of RPC, the remote procedure call. With it you can build client-server and peer-to-peer systems, without doing socket-level programming. RMI automatically serializes and unserializes objects that are sent as arguments to remote methods or returned as values (marshaling).
The basic goal of the adjunct is to build your own transaction-based system. The servers you build will be analogous to database servers. The systems can involve a single server with multiple clients or even a set of servers running a distributed transaction protocol. You will keep logs of the types and times of the transaction requests to monitor system activity. Some clients will contend with one another for services (attempted writes to the same data item) and others can run in parallel (reads of the same data item). You will not have to build a disk-based database to do this work. That's beyond the scope of this project, which focuses on transactions, not DBs per se. Complex logging that would allow database recovery is also not a requirement in this project.
The organization of the project will require that you write well-commented code, including Javadoc documentation. Additional README files should explain the overall architecture of your system as well as give detailed instructions as to how another person, primarily me (RPF), can run and test the system. You will also need to document the system operation by generating files of the logs of system activities when it's running. Your systems will need to compile and execute on the College's Sun Solaris systems (Java2 v1.3). You may develop elsewhere on Linux or Windows, but your system must be compiled and run on our Sun systems and handed in in that form, as source and compiled files plus Javadoc, on the Sun systems. Each person on a team will be required to send me private comments as to how the other team members are contributing. This should help assure that everyone does their fair share of work.
Students or teams of two or three members (no more!) should speak to me, Professor Futrelle, as early as possible in the quarter about working on the project. I will try to set up a regular weekly meeting to discuss the project and email discussions are also possible.
There are links to RMI resources on the Resource Links page.