CISC 475
Advanced Software Engineering
Fall 2008
Lecture: 220 Smith Hall (SMI), Mon 1900–2200
Lab: 051 McKinly Laboratory (MKL), Wed 1640–1730 or 1800–1850
|
Instructor:
Walt Leipold E-mail: leipold@udel.edu Office: 111 EWG (Ewing Hall) Office hours: Mon 1730–1845 Web: http://www.cis.udel.edu/~leipold |
Teaching Assistant:
Charlie Greenbacker E-mail: charlieg@udel.edu Office: 102 SMI Office hours: Tue 1300–1400 & Thur 1400–1500 |
About the course
Textbook
Schedule
Semester project
Final presentation
Final submission
Exams
Grading
Policies
Resources
Lecture materials
This is the Web page for CISC475, “Advanced Software Engineering”. It contains announcements, policies, and other pertinent material for the course. The page will be updated frequently—plan on checking for new or updated material at least twice a week.
Announcements
2008-09-30: The project wiki, the punchlist, and the Subversion repository are all up and running. Use 'em!
About the course
CISC475 presents an introduction to object-oriented software engineering concepts, methodologies and tools. It covers the analysis, specification, design, and implementation of software systems using object-oriented development processes including the Unified Process and UML. The course includes a semester-long team development project using the techniques discussed in class.
Prerequisites: A minimum grade of C− in CISC280. (Program Development Techniques) and Senior status. CISC361 (Operating Systems) is recommended.
Textbook
|
Applying UML and Patterns: |
Class schedule
The following class schedule is preliminary—it will almost certainly change as the semester progreses.
| Class | Date | Topics | Activities | Reading |
|---|---|---|---|---|
| 1 | 8 Sep | Introduction Software engineering OOA/D Iterative development Life cycle models |
Project teams formed | Chaps 1–3 |
| 2 | 15 Sep | Requirements analysis Use Cases Programming style Inception phase artifacts |
Chaps 4–7 | |
| 3 | 22 Sep | Inception phase artifacts (cont'd) Sequence diagrams |
Mini presentation | Chaps 8–11 |
| 4 | 29 Sep | Domain models Collaboration diagrams Operation contracts Software testing Vanguard presentation |
First submission | Chaps 12–16 |
| 5 | 6 Oct | Software architecture | First presentation | Chaps 17–20 |
| 6 | 13 Oct | CMM (Capability Maturity Model) Maintenance Coupling & cohesion Review for exam |
Second submission Honors presentation 1 |
Chaps 21–24 |
| 7 | 20 Oct | Midterm exam | ||
| 8 | 27 Oct | Exam post-mortem System Architecture Document Design patterns |
Honors presentation 2 | Chaps 25–29 |
| 9 | 3 Nov | Second presentation | Chaps 30–33 | |
| 10 | 10 Nov | Deployment diagrams State machines Software architecture OO design principles Antipatterns |
Chaps 34–37 | |
| 11 | 17 Nov | Persistence & O-R mapping Refactoring |
Third submission | Chaps 38–40 |
| 12 | 24 Nov | Distributed applications Planning & estimating | Honors presentation 3 | |
| 13 | 1 Dec | Project reviews Review for final exam |
||
| 14 | 8 Dec | Final submission Final presentation |
||
| 15 | 15 Dec | Final exam |
Semester project
A major part of this course consists of a semester-long team project. The class will be divided into teams, and each team will analyze, design, document, and build part of a significant software application. This application is JKinetics, a desktop application for modeling chemical reaction kinetics.
Project tools: Your grade will be influenced by how well you adopt and use real software engineering tools, such as:
- Subversion for version control of both source code and artifacts.
- Ant to automate building, testing and deployment.
- JUnit to unit test your code.
- Javadoc to document your classes.
- A punchlist/issue tracking system (Mantis) to track bugs, missing features, potential refactorings, and other issues.
- A Wiki for collaborative document editing.
Presentations: Each team will make a formal presentation of its progress to the class at three points through the semester. At the second presentation, you will be expected to demonstrate major parts of your code. At the final presentation, you will demonstrate your complete application, and allow the instructor to “test drive” its functionality.
Submissions: Each team will submit a set of UP artifacts at four milestones through the semester. In all four submissions, you will submit all of your UP artifacts on paper. This will allow the TA and instructor to mark up the submissions when grading. At the second and third milestones, you will also submit all UP artifacts via e-mail as a ZIP file. At the fourth milestone, you will submit all UP artifacts, source code, build/test/install scripts, README files, installation instructions, and other documents on CD-ROM. The organization and professionalism of these submissions, and the ease with which the instructor can get your code running, will affect your grade.
3rd-party components: With the approval of the instructor, teams may use third-party libraries (for example, the Rhino JavaScript engine, the Hibernate object/relational persistence framework, the XStream XML serializer, the ANTLR parser generator, or the JFreeChart plotting package) as components in their projects. Except for such approved components, the code and documentation developed in this course must be the new, original work of the project team members.
Final Presentation
Final project presentations will be held in 104 Gore Hall on Monday, December 8th, with the first presentation starting at 1900. The classroom will be open starting at 1830 to allow you to stage and test your equipment. Attendance at all presentations is mandatory for all students in all teams.
There will be NO Internet connection available; you must bring all of the hardware you need for your presentation, including your server if you have implemented a client/server application. (The instructor will provide a power strip, a network hub or switch, and several network cables.) If your project is a networked application, the instructor and/or TA may connect a laptop to your server and test-drive your system, so make sure that your network drivers are up and that any firewall permissions are set to permit this.
Each member of each team must introduce himself (not just be introduced by the team leader), and should make some part of the presentation. The instructor will take a photograph of each team.
Each presentation should take about 30 minutes, including setup/teardown and question/answer. Do at least one dress rehearsal of your presentation to make sure that everyone knows his part and that it will take about that amount of time.
Here are some examples of the things a good presentation will cover:
- Overview: Describe what the system does, and why you think it's a good idea.
- Architecture: How is your system organized? What processes run, where do they run, and how do they communicate? Where is data stored, and how is it accessed?
- Infrastructure: Show off your source code, build scripts, Wiki, punchlist, and version control system.
- Functionality: Demonstrate all of the main Use Cases for your system.
- Error handling: Describe how you handle error conditions.
- Pattern usage: Describe which design patterns you used in your code, and why you used each.
- Refactoring: What parts of your system did you refactor, and why you did it. Did it help?
- Automated testing: This will be especially impressive.
- Lessons learned: What went wrong during the project, and how would you prevent it next time?
You can't cover all of these areas thoroughly in 30 minutes, so you'll have to choose the areas to emphasize that are most likely to impress the instructor, the TA, and other faculty observers.
Final Submission
Final project submissions are due at the beginning of class (7:00PM) on 8th December. The submission will consist of both printed and machine-readable versions.
You must turn in two copies of the printed submission and two copies of the electronic submission.
The printed submission must contain all project artifacts plus a table of contents, arranged as a single document with sequential page numbers. Do not include source or Javadoc printouts. The submission should be bound or stapled together (no loose pages), should be printed single-sided, and should not contain any hand-drawn pictures.
Each artifact should include its primary author's name, along with a revision history.
The machine-readable version should be submitted on CD-ROM. It must contain:
- readme.txt (see below).
- An electronic version of the printed submission, along with the raw files (e.g., Visio files) for all UP/UML artifacts.
- All your source code (including test and scaffolding code), Javadocs, and build and test scripts.
- A compiled version of the Javadocs, in their own directory. It should be possible to browse the Javadocs by double-clicking on index.html.
- Copies of all of your presentation materials from all three presentations, in PowerPoint or OpenOffice format.
The readme.txt file should be at the root of the disk. It should describe the organization of the submission, and should contain instructions for building and running your system, including detailed instructions for downloading, installing, and configuring any 3rd-party components necessary.
Organize the files into a reasonable and functional directory hierarchy. The instructor should be able simply to copy the CD contents to hard disk, update CLASSPATH, and run Ant to rebuild your application.
If the submission includes any Microsoft Office documents, they must be readable in Office 97 or OpenOffice.org 2.0.
Exams
The midterm exam will cover all lectures, all reading assignments, and anything else discussed in any class prior to the exam date. It will probably include an extra-credit problem.
The final examination will cover all lectures, all chapters from the textbook, and anything else discussed in any class. It will probably include an extra-credit problem.
Grading
Grades for the semester will be based on:
| Midterm exam: | 20% of final grade | |
| Final exam: | 25% of final grade | |
| Semester project: | 50% of final grade | |
| Attendance and participation: | 5% of final grade |
Each student's project grade will be a combination of the group grade and an individual grade.
Policies
Exams: The course will include two exams, a midterm and a final. The lectures will introduce material not covered in the textbook, and this additional material will be on the exams. Exams will be closed-book.
Late assignments: There are no homework assignments (other than the project) in this course. There are four delivery milestones for components of the project, which must be met. No credit will be given for project materials turned in late.
Academic integrity: You will be expected to conform to the University's policy on academic integrity.
Grades by e-mail: The University has a strong policy on protecting PNPI (Personal Non-Public Information), and treats your grades as private, sensitive data. You may request that your grades for work in this class be sent to you via e-mail, but you are hereby warned that e-mail transmission is not secure and your grades may be visible to third parties.
Resources
- Violet, a simple open-source UML drawing tool
- ArgoUML, a free UML-based CASE tool
- UMLet, another UML drawing tool.
- Visual Paradigm offers a community edition of their UML modelling tool.
- Visio templates for drawing UML diagrams.
- UML 101, a basic introduction to UML notation and UML's history. (950k PEF)
- The UML Specification is available on the Object Management Group's Web site.
- Alistair Cockburn's usecases.org site.
- The periodic table of design patterns.
- A catalog of antipatterns.
- Subversion is a version-control system, the modern successor to CVS.
- TortoiseSVN is a Windows client for Subversion.
- Findbugs is an excellent bug detector for Java.
- How to write effective JavaDocs.
- How to track bugs.
- Sometimes not using a database is a good idea.
- An excellent article about character sets and Unicode.
- Teach Yourself Programming in Ten Years!
- How to write unmaintainable code.
- How to write maintainable code.
- Are IDEs evil? Charles Petzold wonders whether Visual Studio rots the mind.
- Joel Spolsky's advice to CS majors.
Here are some recommended books:
 Effective Java Programming Language Guide Joshua Bloch ISBN: 0201310058 |
 Unit Testing In Java: How Tests Drive the Code Johannes Link ISBN: 1558608680 |
|
 The Pragmatic Programmer: From Journeyman to Master Andrew Hunt & David Thomas ISBN: 020161622X |
 The PC is Not a Typewriter Robin Williams ISBN: 0938151495 |
Lecture materials
This section contains some of the PowerPoint slides and other materials from the lectures. Slides which duplicate material in the textbook may not be included—you should read the book instead. Many topics covered in the lectures are not on the slides but will be on the exams. Also, material in the textbook (at least in the chapters we're covering in lectures) can potentially be on the exams, whether discussed in class or not.
Remember that lecture slides are not a substitute for either attending the lectures or reading the textbook—see this version of the Gettysburg Address, this Wired article by Edward Tufte, and this Robert Cringely article for some reasons why.
| 8 Sept | — | Powerpoint slides |
| 15 Sept | — | Powerpoint slides |
| 22 Sept | — | Powerpoint slides |
| 29 Sept | — | Powerpoint slides Vanguard presentation |
| 6 Oct | — | Powerpoint slides |
| 13 Oct | — | Powerpoint slides |
| 27 Oct | — | Powerpoint slides |
| 10 Nov | — | Powerpoint slides |
| 17 Nov | — | Powerpoint slides |
| 24 Nov | — | Powerpoint slides |
Last modified: Friday, 28 Nov 2008