EE 461L Software Engineering and Design Laboratory

Instructor: Professor Miryung Kim

Lecture (#17050). TTH 12:30PM to 2PM in ENS 116.
Labs: Tue 6:30-9:30 PM in ENS 307 or Wed 6:30-9:30PM in ENS 307
Office Hours: T 9:00 AM-11:00 AM in ACES 5.118
Teaching Assistant: Ray Qiu

Course Description

This course focuses on providing hands-on experience in designing and developing large-scale software systems with emphasis on the use of automated analysis tools and techniques that enable large-scale software development. Students will generate concrete software engineering artifacts at all stages of the software life-cycle. Design principles and methods for large-scale software system development; design and modeling tools; collaborative development environment; object-oriented design and analysis; design patterns and refactoring; integration and testing tools; debugger and bug-finder; program comprehension; unit testing & regression testing; program verification; static and dynamic program analysis.

Three lecture hours and three laboratory hours a week for one semester.

Pre-requisite: EE422C (or EE322C) or Computer Science 336 with a grade of at least C-; credit with a grade of at least C- or registration for EE 360C or Computer Science 357. (Students may take 360C concurrently with 461L)

Course Objectives

The goal of this course is to teach practical software development methods and tools in the context of developing a software system with other students in collaboration. Practical development tools include

Analysis tools (e.g., debuggers, profilers, automated bug-finders, style-checkers, program differencing tools, program investigation tools)
Construction tools (e.g., compilation managers and build scripts)
Tool support for collaboration (e.g., version control systems and problem report databases)
Design tools (e.g. UML-based modeling tool)
GNU/Linux operating system environment, command-line utilities, bash shell scripting

Practical software design, construction, and evolution methods include

Object-oriented design techniques such as design patterns
Refactoring
Unit testing and regression testing, test coverage and test generation
Hoare logic, preconditions, post-conditions, and loop invariants
Basic static and dynamic program analysis: data flow analysis, program slicing, delta debugging, change impact analysis, regression test selection etc

Course Organization

As a four credit laboratory course, the class time will be organized around three hours of lecture per week, used to introduce the software engineering techniques and tools central to the course. An additional three hours of laboratory time per week will be used for tool tutorials, assignments, and projects. Quizzes will be done in lectures.

	Lectures (T/TH)	Laboratory
		Tool Tutorials	Assignments, Readings, Quizzes, and Projects
Week 1 (8/30)	Lecture 1. Overview
Week 2 (9/4, 9/6)	Lecture 2. Collaborative Software Development Lecture 3. UML Diagrams Part 1. Requirements Analysis, Use Case and Statecharts	Tutorial 1a: Subversion Version Control System Tutorial 1b: Project - Saros (Distributed Pair Programming)
Week 3 (9/11, 9/13)	Lecture 3. UML Diagrams Part 2. Object Oriented Design, Class Diagrams Lecture 3. UML Diagrams Part 3. Sequence Diagrams	Tutorial 2: UML	Quiz 1. Subversion and Version Merging (Thursday)
Week 4 (9/18, 9/20)	Lecture 4. Unix Part 1. Unix Commands Lecture 4. Unix Part 2. Shell Scripting	Tutorial 3: Unix Environment and Command-line Utilities and Shell Scripting	Quiz 2. Unix Commands and UML (Thursday)
Week 5 (9/25, 9/27)	Class Presentations.	Project Part A. New Feature Proposal. (Due: Tuesday, 12:29PM) Motivation and User Benefits, Feature Description and Requirements, Identification of Relevant Classes, Mock-Up Screenshots. Use Case Diagram in UML Preliminary Class Diagram in UML
Week 6 (10/2, 10/4)	Lecture 5. Information Hiding Principle Lecture 6. Design Patterns Part 1. Abstract Factory, Factory Method	Tutorial/Exercise 4: UML	Reading Assignment 1. Paper Review Report Due in class on Tuesday 12:29PM. On the criteria to be used in decomposing systems into modules, DL Parnas
Week 7 (10/9, 10/11)	Lecture 6. Design Patterns Part 2. Singleton, Adapter, Flyweight, Bridge Lecture 6. Design Patterns Part 3. Observer, Mediator, Strategy, Visitor	Tutorial 5: Improving Design Design Pattern and Refactoring	Quiz 3. Information Hiding Principle and Design Patterns (Thursday)
Week 8 (10/16, 10/18)	Lecture 7. Refactoring Lecture 8. Testing Part 1. Statement, Branch, and Path Coverage, JUNIT	Tutorial/Exercise: Design Patterns	Assignment I. Analysis of Design Patterns (Report due in class Thursday 12:29PM) To be released on 10/2 on blackboard.
Week 9 (10/23, 10/25)	Lecture 8. Testing Part 2. Coverage, Bounded Iteration, and Infeasible Paths Lecture 8. Testing Part 3. Symbolic Execution, Test Generation, and Regression Test Selection	Tutorial 6: JUnit Testing	Reading Assignment 2. Paper Review Report Due in class on Thursday 12:29 PM. Regression test selection for Java software, M.J. Harrold et al.
Week 10 (10/30, 11/1)	Lecture 9. Build Management and Documentation ANT, JAVADOC Lecture 10. Debugging Part 1. Eclipse Debugger and GDB commands	Tutorial 7: Build Management	Reading Assignment 3. Paper Review Report Due in class on Thursday 12:29 PM. Yesterday, my program worked. Today, it does not. Why?
Week 11 (11/6, 11/8)	Lecture 10. Debugging Part 2. Delta Debugging: Isolation of Failure-Inducing Inputs/ Program States Lecture 11. Software Inspection Part 1. Code Reviews and Pair Programming	Tutorial 8: Eclipse Debugger Tutorial 9: Bug Finding & FindBug	Quiz 4. Testing/ Build Management (Thursday)
Week 12 (11/13, 11/15)	Class Presentations and Demo	Project Part B. New Feature Implementation Progress. (Due: Tuesday, 12:29PM) Design Extension in terms of UML Description of Important APIs User Interfaces: Current Snapshots Test Scenarios and Test cases in JUnit
Week 13 (11/20, 11/22)	Lecture 11. Software Inspection Part 2. Hoare Logic and Weakest Preconditions Thanksgiving	(Work on Project Part C)
Week 14 (11/27, 11/29)	Lecture 11. Software Inspection Part 3. Loop Invariants Lecture 12. Program Analysis Data Flow Analysis and Program Slicing, Memory Safety, Profiler, Style Checker	Tutorial 10: Program Understanding Exercise: Hoare Logic	Quiz 5. Bug Finding and Software Inspection (Thursday)
Week 15 (12/4, 12/6)	Class Presentations and Demo	Project Part C. New Feature Implementation Final Demonstration. (Due: Tuesday, 12:29PM) Motivation and User Benefits, Feature Description and Requirements User Manual, User Interfaces, Screen Snapshots Design Extension in UML and Description of Important APIs Test Scenarios and Test cases in JUnit Assignment II. Testing and Assertions (Report and JUnit code due in class Thursday 12:29PM) To be released on 11/8 on blackboard

Grading

50% Laboratory

25% projects

a new feature proposal and presentation 7%
a midpoint implementation and testing progress report and presentation 8%
a final demonstration and presentation 10%

10% programming/report assignments
10% tool tutorials
5% reading assignments

20% Quiz
25% Exam (Monday, December 17, 2:00-5:00 pm/ regular scheduled final exam time)
5% Attendance (taken at random 5 days)

Grading Scheme

programming assignment, project report, and presentation grading scheme

3 pt (excellent design, complete implementation, selection of a task that is highly intellectually challenging, creative, concise yet comprehensive writing, nearly perfect answers, beautifully written and verbally communicated, eloquent presentation within a time limit)
2 pt (demonstrating understanding of the key concepts, mostly correct answers, i.e., >70%, selection of a intellectually challenging project topic, well written, good verbal presentation, well practiced presentation within a time limit)
1 pt (shallow, minimally sufficient, or needlessly wordy, key concepts misunderstood or missing, selection of easy project tasks, poor written and verbal communication, presentation over time, not following specified formats)
0 pt (late, incomplete, or never submitted at all.)

Reading assignment grading scheme

3 pt (excellent writing, clear and concise, demonstrating understanding of the key concepts of the paper, within a word limit, ideas presented in your own words, and some evidence that the paper has been considered in the context of larger issues and themes of the course.)
2 pt (demonstrating understanding of the key concepts of the paper, and ideas presented in your own words.)
1 pt (shallow, minimally-sufficient, or needlessly wordy. Key concepts misunderstood or missing. Author’s words echoed back to me with little effort to reinterpret or paraphrase.)
0 pt (late, incomplete, or never submitted at all.)
Here is a guideline on how to read research papers and write paper reviews by Bill Griswold.

Tool tutorial grading scheme

2 pt (demonstrating understanding of the key concepts of the tool, and completion of the specified tasks)
0 pt (late, incomplete, never submitted at all, shallow, minimally-sufficient).
Note: each week's tool tutorial will have a different weight depending on its difficulty level.

Your letter grade assignment is not based on an absolute score. It is based on the performance of an individual in relation to the entire class. For example, getting a total score of 80 does not guarantee B in this class and getting a total score of 70 could still provide B in this class. Generally speaking, the top 30% of the class may receive A or A-, the next 40% of the class may receive B+, B0, or B-, and the bottom 30% of the class may receive C+, C0, C-, D or F. The instructor reserves a right to modify the grading scheme.

Laboratory Assignments and Quizzes

The main focus of the laboratory assignments and projects will be exercising the concepts, techniques, and tools covered in class and labs. Quizzes are to test the concepts, techniques, and tools covered in both class and labs. All assignments are done individually. Collaboration is not permitted under any circumstance.

Laboratory Projects

The main focus of the project is to learn how to extend a large scale system. Students will propose a new feature, identify relevant parts of the system for extension through reverse engineering and extend its current design, implement and test the changes, and demo their working implementation in class. The project assignments are done in teams of four students. If a team implements a feature that already exists or is very similar to an existing feature in any past or later version of SAROS, it will be considered as plagiarism. It is each team's responsibility to demonstrate that the proposed feature is new, does not exist in any version of the project base, and a unique creation of the team. The team must produce a working, testable implementation of the proposed feature to receive any score for Part B and C. Thus, when proposing a feature to implement, the team must investigate whether the feature is feasible to implement and whether the team has capability to implement and test the feature. The team may receive no grade when the implementation is incomplete or fails to perform a live demonstration of the feature in class.

Class Policy

There is no late policy for assignments, projects, quizzes, tool tutorials, and exams. There's one immunity for missing tool tutorials. No credit for late submissions, with the exception of extremely exceptional circumstances (e.g.your medical emergency or death in near family, evidenced by letter from doctor or obituary notice) but only if you contact the instructor before the penalty is incurred.
All assignments are due in the beginning of the class. If the student does not hand in his or her assignment to a TA or an instructor by 12:29PM, the assignments will NOT be accepted and the student will receive no credit. When an assignment involves multiple submissions, all hard copy and electronic submissions must be received by the deadline.
Class starts 12:30 pm sharp. If a student is more than 5 minutes late (12:35pm), the student may not enter the class room. Students who have sent at least 24 hours of advance notice to an instructor via email and have received an explicit approval may be exempt from this rule.
Quizzes start in the beginning of the class at 12:30 pm sharp.
Class announcements will be made through Piazza. Not every class announcement will be made available via electronic means. If a student misses a class, it is the student's responsibility to catch up with announcements and materials covered in the class.
Students may use Assembla for version control and project management. Students must provide a read permission to their Assembla project websites.

Software Environment

Students are encouraged to use their personal laptops. It is a student's responsibility to install required software and ensure that it is working correctly. Students are strongly encouraged to install all necessary software systems and environments in the beginning of the class to ensure timely progress of weekly tool tutorials, assignments, and projects. While students are not restricted to using tools approved by the teaching team, it is the student's responsibility to include additional documentation, tool tutorials, manuals, etc., if a student decides to use a different tool. If a student chooses to use tools and environments that are not endorsed by the teaching team and, and as a result, if this makes it inconvenient or unable for the teaching team to grade his or her assignments, the student may not receive any score for the assignments.

Unix or Linux installation for BASH shell scripting and running Unix commands, or MacOS with X11 or Terminal, or Cygwin installation for Windows OS; Subversion Client installation or Subclipse Eclipse plug-in; Account creation in Assembla and Piazza; Eclipse Classic 3.7.1 or later versions of Eclipse for Plug-In development; ArgoUML or other UML diagram software systems; JUnit; Ant; Eclipse debugger; gdb; FindBug and Java 6 or later versions.

Intended Benefits for Students

(1) Students will gain knowledge in objective-oriented design, analysis, and testing techniques.
(2) Students will gain hands-on learning experience in collaborative software design and development and also become familiar with practical tools that enable them to construct and evolve a large-scale software system; this course will make our undergraduate students attractive to software engineering industry.
(3) Students will learn about and gain experience in generating software engineering artifacts that can clearly and concisely communicate design intent and realization.
(4) Students will be naturally introduced to software engineering research, in particular automated analyses and development tools. This class will also discuss advances in development tools and analyses from a software engineering researcher's perspective.

Textbooks

(Required) Essential Open Source Toolset (ISBN-10: 0470844450, ISBN-13: 978-0470844458)
(Required) Design Patterns: Elements of Reusable Object-Oriented Software

Useful References:
Code Complete: A Practical Handbook of Software Construction (ISBN-10: 0735619670, ISBN-13: 978-0735619678)
Linux Pocket Guide (ISBN-10: 0596006284, ISBN-13: 978-0596006280)
UML 2.0 Pocket Reference (ISBN-10: 0596102089, ISBN-13: 978-0596102081)

Frequently Asked Questions

Q: How is this different from EE 360F (Introduction to Software Engineering)?
EE360F is an introduction to software engineering with focus on software engineering life cycle and process. This lab-based course extends these concepts to include instruction in practical design techniques and artifacts and hands-on experience in applying the tools and techniques discussed in other courses.

Q: Why do we need to teach development tools in universities? Don't students already learn these methods and tools through an internship?
Students may encounter software development tools through an internship; however, when they do not understand how these tools work internally and what are strengths and limitations of these tools, they cannot use these tools effectively.

Q: Don't we already have a senior capstone course? Why can't students take EE 464 instead?
EE464 is a capstone course designed for all students in electrical engineering and computer engineering. Thus, EE464 does not provide an opportunity to introduce software developments tools systematically in the context of collaborative software development. In fact, the introduction of this advanced software engineering laboratory will better prepare our students for serious software engineering 464 projects.