General Information about

Comp410, Software Construction Methodology

Meeting location: Symonds II MWF 1:00 PM - 1:50 PM

Description

The Computer Science curriculum at Rice University emphasizes diversity in programming languages and computing environments. To provide students with a solid understanding of .NET technology, our software engineering course, Comp 410 -Software Construction Methodology, has been based exclusively on C# and .NET for the past two years. The course leads students through the process of specifying, designing and implementing a large software project that requires advanced and intricate applications of .NET solutions.

Comp410 employs a non-traditional pedagogy based on “pure discovery learning”. Traditional software engineering courses follow the Carnegie Mellon Software Engineering Institute’s “Guidelines for Software Engineering Education Version 1” in a lecture based format that covers the suggested topics of life cycle, design, requirements and specifications, testing, etc. However, at Rice, the goal is to educate leaders in the field, so simply knowing the “book” practices is not enough. We want our students to understand the why and the how of software engineering. The students need to understand what causes the problems that the various software engineering methodologies address and what fundamentally one needs to do to correct them. This understanding is not tied to a particular methodology, but requires deep and careful reflection on real development processes and the issues that face them. The only way that students can truly understand a “real world” software development process is for them to be immersed in it themselves. They must experience all that goes wrong (and right) and figure out for themselves what it takes to correct the problems, overcome the hurdles and achieve their goals. Comp410 achieves this by having the entire class simulate the development department of a small software company faced with the daunting task of completing, in 14 weeks, a very large project involving numerous unfamiliar technologies. In addition, through discussion and weekly journals, the class reflects upon and attempts to solve the various issues and problems that arise during real-world multi-team software development.

Through "learning by doing" the class covers the following topics and more:

State-of-the-art object oriented design and programming
- Highly abstract, highly modular systems
- Highly decoupled systems
- Component-framework systems
Project management
- Team organization
- Project and task specification
- Team and individual tasking
- Human resource management
- Milestone setting and management
- Agile development (e.g. eXtreme Programming) vs. traditional up-front planning
- Bug tracking and resolution
- Deadline and crisis management
Communications
- Interpersonal and inter-team
- Volatile, high speed vs. persistent slow speed communications
- Long and short term documentation
New technologies
- New programming language (C#) under new operating framework (.NET)
- Distributed and peer-to-peer systems
- New hardware platforms: TabletPC, PocketPC
- New user interface modalities: pen/stylus, inking, gestures, handwriting recognition

Recommended Texts

Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, Design Patterns, Elements of Reusable Object-Oriented Software, Addison Wesley, 1995. ISBN 0201633612. The bible of design patterns, a must-have for anyone serious about object oriented programming.
Martin Fowler and Kendal Scott, UML Distilled: A Brief Guide to the Standard Object Modeling Language, 2nd ed., Addison Wesley, 1999. ISBN 020165783X. Useful for learning how to fully use UML diagrams.
Kent Beck, eXtreme Programming eXplained, Embrace Change , Addison-Wesley, ISBN: 0201616416. The definitive reference by the developer of XP.
Martin Fowler,Kent Beck, John Brant,William Opdyke, Don Roberts, Refactoring: Improving the Design of Existing Code, Addison-Wesley, ISBN: 0201485672. The definitive book on refactoring.

Attendance

100% class attendance is absolutely mandatory!

Assignments

As this is a project-based course, the class grade will be determined from a combination of bi-weekly project milestones, weekly journals and the final product.

Project milestones
- Each student will be responsible for at least one milestone that comes due every two weeks.
- A score of 100% will be awarded for a fully completed milestone. Incomplete milestones will be assigned a score commensurate with the level of completeness and the importance of that milestone.
Weekly journals
- Each student will turn in a journal every Friday, whether or not class meets.
- Journals must cover a specified set of topics and will be graded primarily on completeness and clarity.
Final product
- At the end of the semester, the final product will be assigned a score that will be applied equally to all students. The score will be based on the level of completeness of the product with regards to the contracted goals, the quality of the documentation, the quality of the design and the quality of its operation (i.e. how well it runs).

Grading

Journals:	45%
Milestones:	45%
Final Project:	10%

Resources