Catalog description:
    This course introduces a set of fundamental design principles and problem-solving techniques for the development of computer algorithms and their implementation as programs. Problem solutions are developed with the help of an appropriate modeling language and then coded in an object-oriented programming language. (Consult the Computer Science Department for the languages and tools currently in use.) Topics such as problem specification, object-oriented analysis and design, standard data types, control structures, methods and parameter passing, and design for reuse are presented through a study of specific example problems and solutions. Style, documentation, solution robustness, and conformance with specifications are emphasized throughout. Three lecture hours and three hours of scheduled laboratory per week plus extensive programming work outside of class.
    Prerequisites: High school algebra I & II; experience with a window-based operating system and the use of email and a word processor.

• CG1: analyze a problem statement for completeness and clarity;
• CG2: use the methodology of object-oriented design to develop class diagrams (data descriptions and methods) for a problem solution;
• CG3: convert this solution into source code in the designated high-level programming language in accordance with a well-defined set of style rules;
• CG4: debug and test the program;
• CG5: provide clear documentation for the result.

• CO1: demonstrated knowledge of the syntax elements of an object-oriented programming language
• CO2: gained experience in abalyzing problem statements for completeness and consistency;
• CO3: practiced standard techniques of problem analysis;
• CO4: applied the fundamentals of object-oriented design methodology;
• CO5: learned and utilized simple techniques for validation and verification of programs;
• CO6: created full documentation for several completed projects.

• the "problem-solving universe"
  • operational definition of computer (specifically, electronic digital stored-program computer)
  • components of a typical computer
  • fundamental computer capabilities (read, write, store, compute, compare)
• strategies and tools for problem-solving
  • formulating precise specifications for a problem and its solution
  • algorithms
  • modular design of problem solutions
  • preconditions and postconditions
  • specification of user requirements in measurable terms
• programming languages and programming language paradigms
• brief history and overview of the Java programming language
• data types
  • basic data types: integer, real, character, boolean
  • literals of each type
• variables and constants
• reference types (including String and pre-defined wrapper classes)
• console output
• console input
• simplified graphical user interfaces (GUIs)
  • JOptionPane
• object-centered problem analysis
• object-centered design and implementation
• introduction to UML (Unified Modeling Language)
• classes
  • overview
  • attributes
  • methods
        »  parameter and argument lists, return values, signatures
        »  use of modular design in creating methods
        »  visibility rules (scope, context)
  • objects (instances)
        »  handles
        »  copying objects (shallow vs. deep copies, clones)
• selection control structures
  • review of boolean expressions
  • single and double alternative structures
  • multiple-choice (switch) structure
• testing and verification
• debugging
• repetition control structures (loops)
  • while and do while structures
  • for structure
• object-oriented program design techniques
  • objects as self-contained entities
  • objects as entities that act upon themselves
        »  contrast to other design methodologies in which external agents
            act upon objects
  • programming for reusability
• collections (conceptual discussion)
• arrays of one dimension
  • syntax rules
  • static nature of arrays; physical vs. logical size of an array
  • common algorithms: storing a value into an array, removing a value from an array, linear traversal, linear search

Note: Programming language features, techniques, and aspects of object-orientation not mentioned above (for example: sorting, binary search, multidimensional arrays, stream and file I/O, inheritance, derivation) are normally deferred to the second course in the sequence, CSC 202J.

   Programming assignments: Ten to twelve programming assignments are given. One or more of these may be group projects. Each programming assignment normally involves the design, writing, testing and debugging of a program and the submission of an appropriate laboratory report. Each assignment has a specific due date, with a short grace period during which the assignment may be submitted for reduced credit. When the grace period has expired, the assignment will no longer be accepted.
   All programs must be coded in the programming language currently used for instruction in the CSC201J/202J sequence — no exeptions will be allowed. The version of the language being used will be the currently accepted standard version: any extensions or variations in student-owned compilers must be approved in advance by the instructor, who may choose to forbid their use.

   Laboratory Exercises: There will be short programming exercises to be completed during regularly scheduled laboratory sessions. Each exercise focuses on a specific language feature or programming technique presented in recent lectures. Performance on these exercises will be a contributing factor in the course grade.

   Exams and quizzes: There will be two examonations, two shorter quizzes, and a comprehensive written two-hour final examination.

   Final grades will be determined on the basis of the following approximate weights: examinations and quizzes - 40%, programming assignments and lab exercises - 60%.

Bibliography:

• Adams, Joel; Nyhoff, Larry; Nyhoff, Jeffrey. Java: An Introduction to Computing. Prentice Hall, 2001
• Dale, Nell; Weems, Chip; Headington, Mark. Introduction to Java and Software Design. Jones and Bartlett, 2001.
• Flanagan, David. Java in a Nutshell: A Desktop Quick Reference. Third Edition. O'Reilly, November 1999.
• Horstmann, Cay. Big Java. John Wiley 7 Sons, 2002.
• Horstmann, Cay; Cornell, Gary. Core Java 2. Volume I - Fundamentals. Sun Microsystems Press/Prentice Hall, 2001.
• Hosch, Frederick A.; Nino, Jaime. An Introduction to Programming and Object-Oriented Design Using Java. Wiley, 2001.
• Lewis, John; Loftus, William. Java Software Solutions: Foundations of Program Design. Second Edition. Addison-Wesley, 2001.
• Pohl, Ira; McDowell, Charlie. Java by Dissection. Addison-Wesley, 2000.
• Riley, David D. The Object of Java. Introduction to Programming Using Software Engineering Principles. Addison-Wesley, 2002.
• Schildt, Herbert. Java2: A Beginner's Guide. Osborne/McGraw-Hill, 2001.
• Schildt, Herbert. Java2: The Complete Reference. Fourth Edition. Osborne/McGraw-Hill, 2001.