Guidance to the CSE132 Reading Assignments

Choose between the following two recommended texts. Choose the first text (Liskov and Guttag) if you prefer to concentrate on the philosophy and practice of good design. Choose the second text (Horstmann and Cornell Volumes 1 and 2) if you prefer to learn more technical details. You can choose both if you want.

  1. Barbara Liskov and John Guttag, Program Development in Java: Abstraction, Specification, and Object-Oriented Design will support our discussion of programming methodology. The book contains much useful advice and should be read slowly and thoughtfully. If you choose to read this text, you will be responsible for knowing the details in these reading assignments, except for application-specific details in the code examples.

  2. Cay S. Horstmann and Gary Cornell, Core Java, Volumes I and II (Seventh Edition), contain many implementation examples and are a useful reference for specific technical topics. Read these texts for familiarity of content. Unless you are captivated, avoid scrutinizing the details in the examples at first. Refer back to them later as needed in completing your lab assignments or other projects in the future. You are responsible only for the general concepts covered in these readings. You are not responsible for details in details code examples. In the list below, I will provide guidance on the specific sections you should concentrate on. Beyond that, you are not responsible for knowing technical details unless they are also discussed in lecture.

Quizzes over Reading Assignments:
Reading assignments are listed on the calendar. Do each week's reading before the Tuesday of the following week, when there will be a brief quiz over the reading assignment. The quiz will have a section for each book. You can answer either section, depending the book you have chosen to read. (Note that the Core Java Volumes I and II are together considered as one book.)

If you are having trouble figuring out how to approach the readings, here are some thoughts that may help: Reading technical material is very different from reading a novel, because you need to allow your pace to increase or decrease depending on the content. You may need to reread some sections, or stop and think about certain sentences, in order to fully comprehend the ideas. Your best bet is to try to relate what you are reading to your implementation experience and/or think about how you might use the ideas in a project you are working on. It's helpful to stop and think about these things while reading, rather than just plowing through the text. Thinking about technical material from a practical perspective --- that is, how you would apply it concretely --- will help you focus on the most relevant details. Avoid spending a lot of time reading code examples line for line. Instead, focus in on the parts of an implementation that are most relevant to the ideas.

If you want to talk about the readings, or how to approach them, feel free to stop in during office hours or make an appointment.

Week of 1/15 (Quiz on 1/22):
  • If you read Liskov, read the preface and Chapters 1-3 carefully. Feel free to ignore the lambda notation on page 7, but in case you want to know, the lambda just defines a function. In this example, it's a function that takes two parameters x and y, and returns an int whose value is the sum of the squares of x and y.
  • If you read Horstmann and Cornell, read Chapters 5 and 6 in Volume I. Some of this is review. Pay close attention to pages 159-160. You can SKIP pages 173-209 completely, and don't put too much emphasis on cloning (pages 218 to 223).

    • Week of 1/22 (Quiz on 1/29):
  • Liskov: Read Chapter 5 carefully. However, you are not responsible for the details of the implementation of the Poly class.
  • Horstmann and Cornell: Read Chapters 7 through 9. However, you can SKIP (or skim if you want) the following sections: 257-271, 296-299, 303-304, 306-308, 362-376, and 424-454. In general (for all readings from the Core Java books), you are not responsible for details in the code examples. Also in general, you can skim the API method lists, but you are certainly not ever responsible for memorizing what these do. You can look them up when you need them, and some you will learn through use, but if you skim the list, at least it gives you a sense of the possibilities.

    • Week of 1/29 (Quiz on 2/5):
  • Liskov: Read Chapter 4 carefully.
  • Horstmann and Cornell Volume I: Read Chapter 11, but you should concentrate on 557-579 and 594-596. For the remaining parts: skim the intro paragraphs so you know what the topics are and where to find them if you need them, but don't worry about the details unless you are interested or see an immediate use for them in your project.

    • Week of 2/5 (Quiz on 2/12):
  • Liskov: Read Chapters 7 and 8. Chapter 7 includes some review of class hierarchies, and provides some very useful design principles in Section 7.9. Chapter 8 is worth reading, but is somewhat dated, particularly 8.2, since the book was written prior to Java generics. Section 8.3 provides a deeper understanding of equality.
  • Horstmann and Cornell Volume I: Read Chapter 12 focusing on pages 619-622, 626-627, 633, 640-642, 662-674, 698-699. You might skim other parts if you are interested.

    • Week of 2/12 (Quiz on 2/19):
  • Liskov: Read Chapter 6. It's a short chapter, but makes use of representation invariants and abstraction functions that you may need to take some time to review. In the current lab assignment (variation 2), you may want to think about creating a generator that produces a random sequence of characters. Its hasNext() method would always return true. By the way, although the book refers to these objects as generators, most people refer to them as iterators. The book refers to the iterator as the method that returns the generator, but I will generally refer to that method as the iterator method.
  • Horstmann and Cornell: Read Chapter 13 from Volume I and Chapter 2 from Volume II. Concentrate on pages 707-724 in Volume I (skimming the example code). In Volume II, concentrate on pages 118-136. If you need a review of how iterators work, the early part of Chapter 2 will help.

    • Week of 2/19 (Quiz on 2/26):
  • In Liskov, read Chapter 9. It's a very short chapter, but should help you be more careful in writing specifications. If you can get your hands on a copy of Core Java Vol. II, you may want to read in there about threads...
  • In Core Java Vol. II, pages 1-48: Your goals should be to (1) learn how Java threads are created, started, blocked, and terminated, (2) understand why it's important to coordinate the work of interacting threads, for example to avoid race conditions, and (3) become acquainted with locking mechanisms for thread synchronization. You can skip the following if you want: thread groups, and why suspend and stop are deprecated.

    • Week of 2/26 (Quiz on 3/18):
  • In Liskov, Chapter 10 provides good advice for testing and debugging. The principles are good to know, but the main thing I'd suggest here is pick out a few things that are new to you and try to apply them in your project. We've already done a lot with test-driven development in CSE131, so probably a lot of Chapter 10 will just be a formalization of things that you already know from experience.
  • In Core Java Vol. II, pages 48-83: Concentrate on abstractions and mechanisms that support thread synchronization, including (1) Thread-safe collections, (2) Callables and Futures, and (3) the purpose and use of the different synchronizers listed on page 65.

    • Week of 3/18 (but no quiz):
    The readings (Liskov Ch. 11 and Core Java Volume II Chapters 6 and 7) do not lend themselves to a quiz, since they are not conceptually deep. However, both contain ideas that you might find helpful in your design and implementation work.

    Week of 3/25 (quiz on 4/1):
  • In Liskov, Chapter 12, focus on the main ideas of the chapter, and don't worry about details of the stock ticker application.
  • In Core Java Vol. II, Chapter 3, concentrate on pages 143-153 and 157-167.

    Week of 4/1 (quiz on 4/8):
  • Read Ch. 13 in Liskov, thinking about how the designs you did this semester relate to the methodology that is presented in the book.
  • In Core Java Vol. II, Chapter 8, concentrate on pages 617-637, skipping the part about packaging beans in jars. Think about how the concept of java beans relates to (and is supported by) the model/view/controller architecture.
    Week of 4/8 (quiz on 4/15):
  • Read Ch. 14 in Liskov in the context of the designs you did this semester, and reflect on how the methodology described could help you improve the way you carry out design and implementation.
  • In Core Java Vol. II, Chapter 5, concentrate on the introduction to remote method invocation (pp. 257-267), passing remote objects (pp. 289-291), CORBA (pp. 297-302), and SOAP (pp. 314-317).

    • Week of 4/15 (quiz on 4/22):
  • In Liskov, read Ch. 15 and identify design patterns that you have used in your project. It might help make the reading more meaningful if you rewrite the general description of the design pattern with your actual classes substituting for the examples given in the text. Also think about the way these patterns might influence a hypothetical redesign of your CSE132 project design.
  • In Core Java Vol. II, Chapter 9, concentrate on pages 693-695, 706-709, 715-718, and 741-756.