Course Syllabus

Syllabus for

CSCI-E 97, Fall 2015

Software Design: Principles, Models, and Patterns

Last Update: 2015/08/09

Abstract

This course is an introduction to the application of software design principles to the design of applications. This course approaches software design from three perspectives: the software engineering principles that enable development of quality software, modeling of software elements using the Unified Modeling Language (UML), and the application of design patterns as a means of reusing design models that are accepted best practices.

 

Software Design in most IT organizations is a collaborative effort, involving software engineers, managers, and other stakeholders in a project.   We will simulate that with several sessions devoted to interactive design.  The assignments will apply an agile design first methodology.  

 

See the section Course Logistics for information on text books, distance education, and the course meeting schedule.

Teaching Staff

Instructor

Eric Gieseke, ALM
Software Architect
Telephone: 781-330-9835
email: egieseke@fas.harvard.edu

Teaching Assistants

Robert Zupko

Takayuki Iida

Moshtaq Ahmed

Course Description

The working assumption for this course is that registered students are proficient in programming.  Our goal is to move beyond programming-specific concerns to a point where one can think through a design for a software application without having to write code.  It might be useful for you to apply the maxim that "You can't take people from where they're not to where they don't want to go" to yourself in deciding whether you want to take this course.  In particular, if you are taking this course with minimal prerequisites, or are taking this course as one of the three courses needed before you enroll in the ALM in IT, my advice is to wait until you have more background.  You might be able to meet the requirements for the programming aspects in the course, but will struggle through the process of design.

What is Software Design?

"Design" can be used as a verb to denote the process of finding a solution to a problem in the form of drawings and plans.  "Design" can also be used as a noun to denote the results of that process.  

To keep things simple, we can categorize software design problems based on the context in which they appear and the scope of the problem to be solved.

First, the problem might have fairly narrow scope and be closely tied to programming decisions.  For instance, the problem might be about choosing the right data structure and the algorithm to manipulate it to satisfy given functional requirements.  We'll refer to this as "detailed design."

Second, the problem might be how best to implement a run-time component that is either a stand-alone application or part of a larger system.  Here the scope is larger, and one has to think about what software modules will go into the component and how to implement the interactions between this component and other run-time components in the system to meet a given set of functional requirements.  We'll refer to this as "component design."

Third, the problem might be based on a set of functional requirements and the designer's task is to define a system made up of collaborating components that conspire to satisfy the given requirements.  We'll refer to this as "application design" or "system design."  We might even refer to it as "architecture."

In this course we focus primarily on component design.  We will "do design" by applying principles and patterns and by creating appropriate UML models.

One important aspect of component design that will be an integral part of each assignment is the definition of interfaces that the component makes available so that other components can interact with the component.  The term interface here is more general than the concept of interface defined in Java.

Prerequisites

CSCI E-22 (Data Structures) and proficiency in Java (CSCI E-10a and b are not sufficient). If you do not have these prerequisites, do not take this course – take an appropriate prerequisite. Proficiency in other languages, such as C++, Ada, COBOL, FORTRAN, or LISP, is not an appropriate substitute for Java.   It would be premature for you to take this course without a more substantial background.

What I expect you to know about Java

The proficiency requirement for Java is much stronger than a brief introduction. All examples in the lecture notes and all programming assignments will be done in Java (in particular, JDK 1.8).  You should be competent in the following aspects of Java:

• Basic language syntax and semantics
• Core packages: java.lang, java.util
• Core tools: javac, java
• You should be able to define your code in packages, such as cscie97.problem1, manage the directory structure required, set your classpath for compilation and execution, and so on

The first programming assignment, to be given out in week 1 as a warm-up exercise, should help you decide whether you have satisfactorily met the Java prerequisites.

Note - While the object-oriented language used in the course is Java, this is not a course designed to teach Java.

There are numerous other packages or features of the Java platform (inner classes, threads, RMI, JNDI, JDBC, AWT, Swing, etc) that are not prerequisites. If we decide to use any of the things mentioned in this paragraph, we will cover them in class first.

Writing Requirements

Communication of a design is an important skill to be learned in this course; students are expected to demonstrate not only good analytical skills but also good writing skills. Each of the first four assignments will have a specific writing component in addition to the programming component.  The fifth assignment will require writing a design document for a specific application and will not require implementation.

Due to the focus on design and writing design documents, the course can be considered writing intensive.  The following Extension School guidelines apply:

"Writing-intensive courses at Harvard Extension offer students the opportunity to develop their writing skills in the context of a particular academic discipline, and they all feature common elements.  Students will

 

• develop core writing skills, as defined by the instructor, in the discipline of the course;
• complete multiple writing assignments of varying lengths, at least 2 of which must be revised;
• produce a minimum of 10-12 pages of writing, exclusive of the required revisions, over the course of the term;
• meet at least once in individual conference (in person, by phone, or electronically) with the instructor or TA to discuss writing in progress;
• receive detailed feedback on their drafts and revisions, on both content and expression."

Course Logistics

This section has information about where the course meets, the course website, text books for the course, and the schedule of classes.

Class Meetings

Lectures take place on Thursdays beginning on Thursday, September 3rd.  Lectures are held in Room 306 of 1 Story Street from 7:40 pm to 9:40 pm, Eastern Time.

 In class section will be held Wednesday's in Room 307 of 1 Story Street from 7:40pm to 8:40pm Eastern Time.

An additional online section will be determined.

Both the lectures and the in-class sections will be broadcast live and both will be available on demand within 24-hours.

There will be a Web conferencing section beginning in the first week of the course. The exact date and time will be announced at the first lecture. This will use the Collaborate tool for interaction.  It will be helpful if you have a microphone to facilitate conversation.

Sections provide an opportunity for you to ask questions about lecture material or assignments and also to practice the art of design with some focused exercises.  Sections are not required, but missing a large number of sections will limit your chances for mastering the material in this course.

Assignments and Grading

There are no exams in this course.  Your grade will be based on your performance on the assignments.

There will be at least one significant modeling exercise and a set of programming assignments that require the application of design principles and good programming technique. Students are expected to write a detailed description of the design for each of their programs, incorporating UML models as appropriate. Students implement their programs in the Java programming language.

There will be five assignments, each lasting about three weeks.  In four of the assignments you will have to do some implementation and some design documentation. Each of these first four assignments will have a writing component that will contribute to your grade.  In the first assignment, it will entail documenting your design after the implementation.  In the fifth assignment you will write a complete design document for an application without having implemented the application.  As you progress from the first assignment to the last, you will have more responsibility for a priori design work.  Getting clarification of requirements will be part of your responsibility in these assignments.  Ask questions when you perceive a requirement to be unclear or incomplete.

Each assignment will have a specific set of functional requirements and implementation requirements, and you will receive a grade sheet specifying the grading criteria for each assignment.

Distance Education

In addition to the classroom presentation, each lecture will be available through the Harvard Distance Learning facility. See the website http://www.extension.harvard.edu/DistanceEd/ for more details on how distance education is supported at Harvard Extension School.   The course website will have links to our course videos.

Text Books

There are two required texts:

1. Fowler, Martin, UML Distilled, Third Edition, Addison-Wesley, 2004
2. Freeman, Eric  & Robson, Elisabeth, Head First Design Patterns, First Edition, O’Reilly, 2004

Other lecture material will be in the form of notes that will be made available before the lecture.

Course Website

The URL for the course website is https://canvas.harvard.edu/courses/4078 . After the first two weeks of the semester you will need your Harvard ID and PIN to access the site.

All lecture slides, assignments, and related course material, including this syllabus, will be given out in hard-copy format in class, and will also be available in pdf format (readable via Adobe Acrobat) through the course website .

Class Schedule

Class meeting dates and assignment due dates are as follows:

9/3/2015 (thurs)	Lecture 1 - Assignment 1 handed out
9/9/2015 (wed)	First Section
9/10/2015 (thurs)	Lecture 2 - UML and Class Diagrams
9/16/2015(wed)	Assignment 1 due
9/17/2015(thurs)	Lecture 3 - Assignment 2 handed out
9/24/2015(thurs)	Lecture 4
10/1/2015(thurs)	Lecture 5
10/7/2015(wed)	Assignment 2 due
10/8/2015(thurs)	Lecture 6 - Assignment 3 handed out
10/15/2015(thurs)	Lecture 7
10/22/2015(thurs)	Lecture 8
10/28/2015(wed)	Assignment 3 due
10/29/2015(thurs)	Lecture 9 - Assignment 4 handed out
11/5/2015(thurs)	Lecture 10
11/12/2015(thurs)	Lecture 11
11/18/2015 (wed)	Assignment 4 due
11/19/2015(thurs)	Lecture 12 - Final Assignment handed out
11/26/2015(thurs)	Thanksgiving Break, no class
12/3/2015(thurs)	Last Lecture
12/9/2015(wed)	Final Assignment Due

 

Assignments must be submitted by midnight EST on due date.  

References

The books and websites listed here are optional references for your own out-of-class reading.

References on Design Patterns

• John Vlissides, Pattern Hatching - Design Patterns Applied, Addison-Wesley, 1998.

References on UML

• The most recent UML specifications can be found at http://www.omg.org
• Hans-Erik Eriksson, Magnus Penker, Brian Lyons, David Fado, UML 2 Toolkit, OMG Press, 2004

References on Java

• Ken Arnold and James Gosling, The Java Programming Language, Addison-Wesley, 1996.
• David Flanagan, Java in a Nutshell, umpteenth Edition, O'Reilly
• See http://www.oracle.com/technetwork/java/index.html for lots of documentation, articles and commentary, as well as to download JDK 1.6 (free).

Other Interesting Books

• Frederick Brooks, The Mythical Man-Month, Addison-Wesley, 1995 (includes a reprint of "No Silver Bullet: Essence and Accident in Software Engineering")
• Frederick Brooks, The Design of Design, Addison-Wesley, 2010
• Frank Buschmann et al, Pattern-Oriented Software Architecture – A System of Patterns, John Wiley, 1995.  Chapter 6 includes a good description of principles for software design.
• Paul Clements et al, Documenting Software Architectures – Views and Beyond, Addison-Wesley, 2003.  The first half of this book is a marvelous introduction to terminology and prescriptions for documenting software designs.
• James P. Womack et al, The Machine that Changed the World: The Story of Lean Production, Free Press, 2007.  This book provides a excellent overview of the importance of process in the quest for product quality.  While about the auto industry, the concepts can be applied to software development and the application of the software design methods learned in this class.