Student
Originated Software
Writing software is
hard, and the best efforts of computer users and software engineers have not
alleviated software development problems:
most software is late and over-budget, does not meet user needs or
expectations, or is socially irresponsible. Evergreen's Student Originated Software program addressed these issues and
prepares students to face these problems.
The full time, year-long program provided both in-depth practical
experience in software engineering and a deeper understanding of the issues
behind writing responsible, effective software. The program’s curricular design is based on the premise that
writing software systems (or software engineering) is intrinsically
a multi-disciplinary team effort involving not only programmers but also users
of the proposed software, human-computer interface design experts
(psychologists and artists), experts in the application domain and computer
scientists. We believe that successful
software engineers will work effectively with all stakeholders. The major
components of the program were a year-long project, seminar, and a variety of
disciplinary study contributing to students’ ability to contribute to a
software project. Not every student
took every program component, but each student’s evaluation explicitly lists
equivalencies that indicate the components he or she completed.
Year-long Project. The program’s vehicle for learning how to
write software was a year-long software project for an identified real-world
need or market. In the fall, students
organized into teams, and each team identified a viable project and performed a
preliminary systems analysis and feasibility study that was presented to the
class. In winter and spring, students
turned to design and implementation. They worked in teams to produce a software
prototype and activities including requirements refinement, user profiles,
analysis and design. Students were asked to submit individual weekly status reports,
and teams to submit weekly progress reports.
Teams met weekly with their faculty advisor, and were encouraged to keep
external sponsors apprised of progress or issues. They prepared a project notebook with relevant documents and
presented project status to the entire program once each quarter. Each team
demonstrated their product at a trade-show-like “software fair”. Guest speakers from industry and state
government, and a field trip to Seattle contributed to students' understanding
of software development.
Software Engineering – Object-Oriented Analysis and Design
(Fall). The
objective of this part of the program was for students to learn software
engineering concepts, to apply software development methods and to assess the
use of modern tools. Since many
software errors can be traced to requirements specification and design, we
emphasized those topics. Software
engineering concepts and some currently articulated “best practices” were
taught using the Rational Unified Process and the Unified Modeling Language
(UML). Students attended twice-weekly
lectures and a weekly workshop, and were expected to complete a weekly
assignment in pairs or teams of four depending on the assignment. They were encouraged to complete the
assignments in Rational Rose, a tool that implements the UML and organizes the
Rational Process development artifacts.
Specific topics included:
project organization, feasibility study, domain model, use case
analysis, user interface design with paper prototyping, collaboration diagrams,
and sequence diagrams. Concepts of risk
analysis and software testing were also introduced. Individual students
demonstrated their understanding of the material through mid term and final
examinations. Texts: Martin Fowler’s UML Distilled and Terry Quatrani’s Visual Modeling with Rational Rose 2000 and UML.
Introduction to Object-Oriented Programming in Java
(Fall). Here students were introduced to concepts of
object-oriented programming through the study and practice of the Java language. A major goal was to give students an
opportunity to answer claims that object-oriented programming (OOP) will change
the nature of programming and system construction. To that end, we covered the fundamental concepts of OOP (e.g.,
objects, messages, methods, and classes), and explored data abstraction,
encapsulation, typing, inheritance, and polymorphism. Students also were introduced to a graphical user interface
generator and integrated development environment with IBM's Visual Age Java,
and used that tool to implement the case study (see below). Students did weekly programming assignments
using Visual Age with a partner, and demonstrated their understanding of the
language through a written midterm, an individual programming midterm
assignment, and a written final exam. The text was Budd's Understanding Object Oriented Programming
with JAVA.
Case Study Integrating Software Engineering and
Object-Oriented Programming (Fall). This part of the program aimed to help
students integrate their study of software engineering with what they had
learned in object-oriented programming, and to give them first hand experience
in a software development team that they could use as an exemplar for their
year-long project. To those ends,
students consolidated homework assignments for the OOAD with another two person
team to produce one set of specifications and design. They then implemented the system in Java. They were asked to organize their
deliverables into a notebook and demonstrate the implementation to faculty.
Introduction to Database Systems (Winter). This
component aimed to give students an understanding of the fundamental concepts
of database systems, including database design, languages and system
implementation. Topics covered were: conceptual, logical and physical design
(including entity relationship modeling); the relational data model; SQL;
integrity constraints and enforcement; domain constraints and functional
dependencies; query processing, transaction management. Because we assumed familiarity with basic
data structures, computer organization, operating systems, and a high-level
programming language, the material was presented at an advanced undergraduate
level. Students demonstrated their
knowledge of the material by participation in class discussions and labs, six
homework assignments, two examinations, and a significant project involving the
design, implementation, population and querying of a database of the student’s
own choosing (staged as six project assignments). The text was Ullman’s Database Systems, Chapters 1-10; the
DBMS used in labs was MS SQL Server, and Java was the sample application user
interface.
Students who took only the
first half of this course completed four each homework and project assignments,
took the two exams, attended class the first five weeks, and completed a
database design.
Project Management (Winter). This part of the
program endeavored to introduce students to aspects of project management
relevant to software engineering that could be immediately applied in their
year-long projects. Topics included the
software development life cycle, work breakdown structures, milestones,
critical path analysis, risk management, schedules, conflict resolution, and
quality assurance. Students completed
weekly assignments using their year-long project as a case study. Assignments included project documentation,
decomposition, work breakdown structures, and project schedules. They participated in two workshops on team
dynamics and communication and two laboratories in MS Project and Bugzilla’s
bug tracking software. Finally, students took a comprehensive in-class
examination. The text was On Time Within Budget: Software Project
Management Practices and Techniques, (3rd Edition ) by E. M. Bennatan.
Information Architecture (Winter). Because current software applications
typically disseminate or manage information, students were given an option of
studying information architecture.
Peter Morville and Louis Rosenfeld define information architecture as “
… the design of organization, labeling, navigation, and searching systems to
help people find and manage information more successfully. “ Topics included user definition, task
analysis, site structures, home page design, usability testing, navigation
systems, search, accessibility, globalization and wireless devices. Students completed weekly assignments
individually or in two-person teams and turned in a final project portfolio on
a site or application design. The text
was Information Architecture for the
World Wide Web, by Louis Rosenfeld
& Peter Morville, with additional online readings by Jacob Nielson.
Advanced Topics in Object-Oriented System Design: Design Patterns (Spring).
This advanced topics course assumed a mature understanding of object-oriented
programming and design, and provided an opportunity to explore applying
recurring solutions (patterns) to problems of software design. Students demonstrated their understanding of
the material by facilitating one or more discussions, their participation in
discussion, and applying a pattern to a design problem of their own
choice. The text was Erich Gamma's Design Patterns.
Program Seminar. A
weekly seminar aimed to connect the students’ notions of the software industry
and culture to their understanding of its technology. This cornerstone of the
program integrated the concept- and technique- building components and anchored
the study of software engineering to the cultural context in which we live and
work. The fall quarter seminar focused on the Computing Culture and
software industry. Students demonstrated their understanding of the material by
writing a weekly one-page paper either on a predefined topic, or their own
reactions to the reading, and sporadic pop quizzes on the assignments. The seminar readings were: Ullman’s Close
to the Machine; Norman’s Things That
Make Us Smart; Brooks’ Mythical Man
Month; McConnell’s Code Complete;
Levy’s Insanely Great; Bick’s The Microsoft Edge: Insider Strategies for
Building Success; and Raymond’s Cathedral
and the Bazaar.
Winter
quarter’s seminar focused on contemporary computing
technology – prediction, research and development. Readings included: Lydia
Morehouse’s Archangel Protocol, Brooks’ Silver Bullet and
other retrospective essays on software engineering from Mythical Man Month, Beck’s Extreme
Programming Explained; Constantine’s Beyond
Chaos: The Expert Edge in Managing Software Development, Hafner and Lyon’s Where Wizards Stay Up Late, as
well as articles on wireless technology, information architecture, data
warehousing and XML. Students were
expected to read the weekly assignments, participate in seminar discussions,
post and respond to a web-discussion, and write a 5-7 page paper on a topic of their
own choice related to the seminar theme (drafts staged over the last 5 weeks of
the quarter). Students who opted for a
2 credits option wrote a 3-5 page paper.
In
spring, the seminar focused on contemporary, but
classic, issues of computer science. In
the high tech computing world, change seems constant – and it is sometimes said
that a programmer needs to relearn everything every five years. The lecture series aimed to dispel this
myth, pointing out that an education in computer science involves learning
principles in which to ground « technology du jour » such as
technical training in programming, system administration or web development
(which do evaporate and must be relearned).
Some problems (often the most interesting ones) appear again and again
but often manifesting themselves differently as the context changes. Weekly
lecturers of national repute presented material from a wide variety of
topics: Cyrus Durgin, Amazon.com
(security); Teri Roberts, Los Alamos National Laboratory (modernizing legacy
code); Brian Harvey, University of California Berkeley (how programming
languages relate to computer science education); Mark Tullsen, Oregon Graduate
Institute (domain specific languages); Steve Tanimoto, University of Washington
(image processing and online learning environments); John DeOliveira, Cycorp (artificial intelligence and
common sense); Mike Wolfe,
STMicroelectronics (computer architecture); Craig Hickman, University of
Oregon (graphics and interactivity in software development); and (Caroline
Wardle, National Science Foundation (under-representation of women in computer science). Each lecturer recommended reading to
accompany his or her lecture, and we also read Margolis and Fisher’s Unlocking
the Clubhouse. Seminars met weekly
to discuss reading and lecture.
Credit Distribution:
(Students’ credit distribution is drawn from the following,
for up to 48 units of credit)
*18: Year-long Software Development Project (2 fall, 8 winter, 8 spring)
*2 4: Winter Quarter
Team-Initiated Technical Component
*4: Spring Quarter Team-Initiated Technical
Component
*4: Software Engineering: Object-oriented Requirements Specification,
Analysis and Design
*4: Object-Oriented Programming in Java
*2: Integrative Case Study: Software Engineering and Object-Oriented
Programming
*2 4: Introduction to Database Systems
*2:
Project Management
*2: Information Architecture
*4: Design Patterns for Software
*4: Seminar (fall): Computing Culture and Software Industry
*2 4: Seminar (winter): Contemporary Computing Technology.
*4: Seminar (spring): Contemporary Issues in Computer Science.
----------------------------------------------------------------------------------------------------------------
*48: total
* indicates upper
division science credit.