Overview of the Programming Assignments
We will use the programming assignments to implement an application framework
that we will later use in the design and implementation of an application suite.
1 About Application Frameworks
The easiest way to think about application frameworks is in the
context of an example. To that end, imagine that you had to
implement an office suite consisting of a word processing
application, a spreadsheet application, and a presentation
application. The different applications have some functionality in
common (e.g., the ability to create a new file, open a file, save a
file, quit, etc.) and some unique functionality (e.g., the ability
to perform a mail merge in the word processing application, the
ability perform calculation on a column of numbers in the
spreadsheet application, the ability to animate bullet points in the
presentation application). The role of the application framework is to
provide the functionality that is common across all of the applications.
2 The Software Process
We will be using a traditional/heavyweight (as opposed to agile)
software development process during this part of the course.
I have already completed the planning, product design, and
engineering design actions/tasks. Your job will be to implement the
design that I have created.
I will also serve as the project manager. In that role, I have scheduled
all of the programming assignments. You must adhere to the schedule
that I have created.
Each programming assignment constitutes a single milestone and will
have specific deliverables. Since we will not be using an
incremental process, we will not have a working product at the end
of each programming assignment. That is, we will not have a working
product until all of the programming assignments have been
completed. However, you will be able to (and required to) run unit
tests and integration tests for each set of deliverables. To
facilitate integration testing, I have designed, and you will
implement, a demonstration application called "The Big Pixel".
We will be using a parallel development process. That is, each of
you will implement the same product. However, unlike in a
traditional parallel development process (in which the developers
work independently), you will periodically share information with
the other developers (for pedagogical reasons).
3 Learning Objectives
Remember that this course is about design, not implementation. So,
the primary purpose of the programming assignments is to get you to
think critically about the design that has been given to you. As a
side benefit, you will probably become a better programmer, but that
is not the purpose of the programming assignments. After you
complete each programming assignment, we will have an in-class
discussion of the design (not the implementation).
It is important that you think critically about the design of the
application framework during the first half of the course because,
during the second half of the course, you will be responsible for
designing (and implementing) a product. In other words,
during the first half of the course you need to become a better
designer so that you can create a good design during the second half
of the course.
4 Document Formats
We will be using several different document formats this semester.
- The academic aspects of the programming assignments (e.g.,
submission requirements, due dates, etc.) will be in HTML files.
- The products themselves will be described/specified in two
different kinds of files. Textual descriptions/specifications
will be in PDF files. UML diagrams will be in SVG files so that
you can "zoom in" without loss of detail (since some of them
are quite large).
5 The Specific Application Framework
The specific application framework that you will be implementing
contains only the basic functionality that must be included in
GUI-based, desktop applications. Specifically, it includes the
ability to: open documents, close documents, create new documents,
save documents (including both "save" and "save as"), print
documents, and quit the application. This includes functionality
that enables/disables these operations based on the current state of
the system. For example, the "save" functionality is disabled until
there is something to save (i.e., until a change has been made).
The framework enforces a somewhat non-traditional work flow that
would probably upset interaction designers. This was done to
simplify the design and implementation. The work flow that it enforces
is discussed in the following PDF document:
An abstract UML class diagram for the framework is available in the
following SVG file:
6 The Demonstration Application
The demonstration application called "The Big Pixel" can be used to
draw rectangles of different sizes and colors. In and of itself it
is of no value. However it will have enough functionality to allow
you to run integration tests.
An abstract UML class diagram for the demonstration application
is available in the following SVG file:
7 Best Practices
Though this is a design course, we will use "best practices" when it
comes to implementation. Two are particularly important to mention
at this point.
7.1 Packaging for Unique Identification of Classes
You must package your code in a way that the classes you implement
can be identified uniquely. Specifically, you must use the
convention that all of the packages you create are inside of
the package edu.jmu.cs.academics
.
7.2 Using a Testing Package
To facilitate deployment and to limit the visibility/accessibility
of methods that must be unit tested, it is common to have one
project for the deployable code and another project (with an
identical package structure) for the unit tests.
Unfortunately, doing so will make it hard for you to submit your
code to Autolab (i.e., it will make it hard for you to create a
single .zip
file that contains both the deployable
code and the unit tests). Hence, you will not be required to
follow this practice for the programming assignments (though
you will be required to do so for the project).