1. Plan, design, implement, compile, and execute a complete 
object-oriented software solution on a target Unix environment.
2. Describe and apply fundamental programming techniques, 
including exception handling, generics, recursion, and code 
reuse.
3. Apply accepted programming practices, including documentation 
and proper code style.
4. Describe and apply object-oriented programming techniques, 
including interfaces, inheritance, and polymorphism, and apply 
combinations of each in a software solution.
5. Utilize software development tools, including tools for 
version control, build management, debugging, and unit testing.
6. Design, analyze, and implement algorithms for searching, 
sorting, and other real-world problems.
7. Reinforce course concepts using integrative examples, 
including graphical user interfaces, stream-like operations, 
and abstract data types.

Major Topics Covered

1. Unix Fundamentals 
  a) Navigate and modify files, directories, and permissions 
  in a multi-user Unix-like environment.
  b) Execute, redirect, pipe, and manage programs/processes in 
  a multi-user Unix-like environment. 
  c) Create and modify text files and source code using a 
  powerful terminal-based text editor such as Emacs or Vi. 
  NOTE: Extremely simple programs like nano, pico, etc. are 
  not sufficient. 
  d) Use shell commands to compile new and existing software 
  solutions that are organized into multi-level packages and 
  have external dependencies.
2. Programming Fundamentals 
  a) Identify redundancy in a set of classes and interfaces, 
  then refactor using inheritance and polymorphism to 
  emphasize code reuse.
  b) Define, throw, and propagate exceptions appropriately in 
  a software solution.
  c) Use recursion to solve a non-trivial problem in a 
  software solution.
  d) Implement new generic methods, interfaces, and classes in 
  a software solution.
  e) Utilize existing generic methods, interfaces, and classes 
  in a software solution.
3. Accepted Programming Practices 
  a) Create and update source code that adheres to established 
  style guidelines.
  b) Create class, interface, method, and inline documentation 
  that satisfies a set of requirements. 
  c) Generate user-facing API documentation for a software 
  solution.
  d) Apply pair-programming principles in a software-based 
  project.
4. Object-Oriented Programming 
  a) Design, create, and use interfaces in a software solution.
  b) Utilize interface-based polymorphism in a software 
  solution.
  c) Design, create, and use inheritance relationships in a 
  software solution.
  d) Utilize inheritance-based polymorphism in a software 
  solution.
  e) Use visibility modifiers to provide inheritance-based and 
  package-based access protection in a software solution.
5. Software Development Tools 
  a) Utilize a version control tool such as Git or Subversion 
  to store and update source code in a multi-programmer 
  software solution.
  b) Utilize a build tool such as Maven or Ant to create and 
  manage a complex software solution involving external 
  dependencies.
  c) Utilize a debugger to trace and identify logical errors 
  in a software solution.
  d) Create unit tests for classes, interfaces, and methods 
  using a unit testing framework like JUnit. 
6. Analysis 
  a) Given an algorithm, perform an analysis that classifies 
  the algorithm according to its best Big-O class for 
  a given unit of measurement (e.g., comparisons vs. swaps). 
  b) Design an algorithm that solves a given problem with a 
  particular Big-O class given as a constraint. 
  c) Implement, analyze, and assess combinations of 
  searching/sorting algorithms such as linear search, binary 
  search, quadratic sorts, and linearithmic sorts. 
7. Integrated Examples
  a) Design and implement a graphical user interface in a 
  software project. 
  b) Use stream-like operations (e.g., map, reduce, and 
  filter in the Java Stream API) as an alternative to 
  iteration in solving problems. Observe the difference 
  between resulting implementations.
  c) Use common abstract data types and structures, including 
  lists, queues, arrays, and stacks in solving typical 
  problems.

Unless otherwise stated, programming assignments, lab assignments, and homework
are to be strictly your own work.  Of course, you can talk over general principles
and concepts about an assignment with others but sharing of printed or electronic
media is not acceptable.  Guard your own work.  Do not write code for others, and
don't have others write code for you.  Just as the work on an essay in English 
has to be your own, assignments for CSCI 1302 have to be your own work unless
specifically stated otherwise.  Procedures for handling cases of suspected dishonesty
can be found at www.uga.edu/ovpi.