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.
(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.
* indicates upper division science credit.