I'm pleased with the result. Lost all the points in general considerations, but not sure why as they don't give details.
Thank you to the posters on this forum and Monkhouse's book. All very helpful. I've never had a paid programming job before and have been doing the
java certification process (
scjp,
scjd) to learn the language and set myself up for a career shift into programming. I found Monkhouse's book an excellent learning tool all around. The fact that it goes beyond (way beyond in some cases) the requirements of the project I had was useful- this is what made it a great learning tool and a reference for projects I may encounter in the future. Overall I think the sun project in combination with this forum and book is somewhat similar to real world development in a team setting.
I started the scjd in Jan 08 and submitted in July. It took 4 weeks to get the grade back.
Here are my notes and thoughts:
rmi networking - seemed the obvious choice. Could convert to a web service fairly easily as a learning step
gui - did not implement unbooking in the UI. My UI was minimal with two search fields.
locking - followed the book's design on this. I tried some other mechanisms (not using reentrantlocks, but ultimately came back to it after I started
testing).
Implemented all the methods in the interface.
- used java.util.logger for everything. This was super valuable in testing and exceptions I needed to display would bubble up to the UI, throw a dialog, write to the log.
- built a command line tool for testing the db class. Ultimately, it would have been faster to implement all the features into the GUI to speed final testing (delete, unbook).
- passed records back and forth as
string arrays.
- to productize the app, I'd need to make the clients observers, and implement a way to unbook, and manage the db better (like delete records in the ui, or an administrative ui).
testing: found the test harness for testing locking and multi-threadedness (Monkhouse) to be very good advice. I implemented something like it to test the locking in the app. Until I spent a day on this, I didn't truly understand what was going on with the locking and it was valuable to watch synchronization in action.
Environment: Netbeans 6 and Windows XP. Tested on Linux and it worked great. I found Netbeans and it's debugger to be very nice.
Challenges:
- how to handle rmi exceptions and implement the required interface. Ended up making a new interface that wrapped all exceptions in to "exception". The books design of rolling everything up to a gui exception really helped think this one through. I wrapped IO exceptions into runtime exceptions. It's possible that these areas are where I lost points.
- figuring out swing. Once I got the hang of it, I was impressed though. Nice technology.
- rmi- even though it's a simple concept, it just took a while to get the rmi factory, what was running on the client and server and how it all worked.
All in all, this was a good time and a great confidence builder.
-Pat