CSE 142 Homework 6 – Grand Finale

May 23, 2003

Update! Please download new hand-out code. It contains the JukeBox class which was not distributed with the original hand-out code. Please read the discussion board for more information. Thanks!

Purpose: To learn about programming with interfaces, practice reading and understanding more complex code than before, and take a brief look at concepts beyond the scope of CSE 142 – particularly graphical user interfaces.

Procedure: We've prepared a graphical user interface (GUI) and audio rendering code for the jukebox, along with sample play lists and a few audio files. The sample code is complete other than it is missing the crucial JukeBox class which holds everything together. Your task is to read the sample code, integrate it with your own JukeBox class to make it work, write two reports explaining parts of the sample code, and provide code comments for a part of the jukebox GUI.

Turn-in and due date: The due date for part 1 is Wednesday May 28 at 9 pm, and the turn-in for part 1 consists of a report as described below. The due date for part 2 is Tuesday June 3 at 9 pm and the turn-in consists of screenshots, a report as described below, plus your complete jukebox source code with your own comments.

You can complete the entire assignment working in pairs, including both reports – no individual turn-in is required. If you want to hand-draw diagrams to accompany your reports, please explain the diagrams in the text you turn in using the web form, and bring the diagrams to lecture Wednesday June 4.

Apply common sense when deciding how long your reports should be. Too short and you won't be able to convey the material. Too long and the reader will give up.

Grading: Part 1 is worth 4 points for the report. Part 2 is worth a total of 16 points – 8 for the report, 1 for the screenshots, 3 for the code modifications and 4 for the code comments.

This is a difficult assignment and very few of you will be able to complete it perfectly. Your goal should be to do it as well as you can given the time you have. If you know the course material and put care into your solution then you should expect a good grade – even if the solution is not complete.

Time: By Parkinson's Law (1, 2), and as usual, you will sink yourselves entirely into completing this homework. But at least you won't have to debug any loops.

Part 1 – Interfaces

Purpose: Practice using interfaces in Java code, and prepare for part 2.

Procedure: Write a report containing short sections addressing the following questions. Please use file names and line numbers as much as you can when referring to code. Concentrate on JukeBoxInterface.

1. Interface usage: Where are interfaces implemented in the sample code? Where are they used?
2. Code integration: What code modifications are necessary to integrate your JukeBox class into the sample code?
3. Interface benefits: What are the high-level benefits of JukeBoxInterface? You may want to refer to your lecture notes.
4. Code improvements: Can you point out other places where similar benefits could be derived from the introduction of other interface classes? Write up one such interface and include in your report.

If you have more time it is a good idea to do the code modifications of part 2 next.

Hints:

• It helps to use file names and line numbers when referring to code, e.g. JukeBoxInterface.java:30-35.
• DrJava can be configured to show line numbers in the left margin of the code editor. Select Edit -> Preferences and check the box in the display/editor preferences section.
• You can save a lot of time by using DrJava's string search functionality. Searching for JukeBoxInterface is a good place to start. Take notes about what you discover, to help you in writing the report.
• All the questions can be answered by removing the five files comprising the old jukebox code and compiling the rest, then analyzing the compiler output. How is JukeBoxInterface relevant when you do this? Why is the compile not successful? How would you fix that, using only interfaces? What if there were a TrackInterface?

Grading: Your TA will base your grade on how well your report conveys your understanding of Java interfaces and their use in the final jukebox implementation.

Turn-in: Turn in the report, using the turn-in web form for part 1.

Part 2 - Code Comprehension

Purpose: To practice your code comprehension skills on a more complex application, and introduce yourself to concepts beyond the scope of CSE 142.

Procedure: You need to make code modifications to get the GUI to work, then select one of the three main parts of the GUI and both provide code comments and write a report explaining how that part works.

First, make the necessary code modifications to integrate your JukeBox class into the sample code. This involves ensuring that your jukebox code correctly implements JukeBoxInterface. You need to get each of the three parts of the GUI (the contents, search and player tabs) to work, and turn in three corresponding screenshots along with the code. Note that you are free to modify any aspect of the sample code as well as your JukeBox class, in any way you please. However, we strongly recommend you attempt to keep your changes minimal, and of course any changes should make things work better...

Second, select one of the three GUI aspects to write a report about. We recommend you select either the contents or the search tab but you can write about the player tab if you want a greater challenge (don't say we didn't warn you though). The report should describe the functionality, design and implementation of the GUI aspect you chose, paying particular attention to the interaction with the jukebox implementation (the five classes from homework 4).

Here are some issues you may wish to discuss in the report, listed in order of decreasing importance:

• Features: What are the features (functionality) provided?
• Classes: What are the various classes involved, and what purposes do they serve? Diagrams may be useful here.
• Interaction: How do the classes interact to implement the features? What are the most important methods in each class? Again, diagrams may be useful.
• Libraries: Can you categorize the most important library classes used? Analyzing the import statements at the top of the tab file may help.
• Testing: When integrating your jukebox code with the GUI, what tests did you use to check whether things were working right?
• Bugs: What bugs did you find? (There are plenty.) Can you think of a way to fix one of them? (Hard.)

If you write about the contents or search tab you can assume that the reader already possesses a reasonable understanding of the jukebox code, e.g. all the non-GUI code. The player tab is more difficult to write about because it interacts with the media player class. That class has changed considerably, is now by far the most complex of all the classes of the jukebox and GUI code, and makes use of concepts that are far beyond the scope of 142. However, it is largely irrelevant to the contents and search tabs.

Finally, you need to write comments for the GUI tab you discuss in your report, e.g. one of the files ContentsTab.java, SearchTab.java or PlayerTab.java. Of course it makes most sense to work on this as you prepare the report.

Hints:

• The JukeBoxGUI class has a main method, that's a great place to start.
• Imagine you are junior developers who just started a new job. Your new boss (let's call him Alon Martin) has assigned the two of you the management and continued development of the GUI aspect you chose to write about. The code was pulled together somewhat hastily, is undocumented and the developer who worked on it before has left the company and vanished without a trace (let's call him Stefan). Your first task is to document the code and write a report about it for your boss. He wants a functional specification (features), design description (classes and interactions), dependency list (libraries), ideas for building a test suite and a roadmap for bug fixes. Of course he hardly gives you any time to do all this, so you may need to select areas to concentrate on first. To compound the difficulties, he can also be an impatient reader.
• When working with unfamiliar code and libraries web resources are often highly useful. In addition to the Sun Java API documentation and tutorials, you should also use the class discussion board as much as you can. The GUI code is quite complex and you may need significant help from each other, the lab consultants and the TAs.

Grading: Your TA will base your report and code comments grades on how well you understand and explain how the sample code works. The clarity of your writing is very important – pay attention to how you structure the report. It helps to use short paragraphs and bulleted or numbered lists for improved legibility.

Turn-in: Turn in the entire jukebox and GUI implementation, your report and the three screenshots using the web turn-in form for part 2.