MDST 585:  Development of Information Systems in Humanities Computing

 

Course Description:

 

The course will examine topics from programming, software engineering, and interaction design and how they impact the development of computer information systems in the domain of humanities computing. It will focus on developing large software systems that require well-defined development processes, team organization and management, and a user-centered approach. Students will work on new and existing systems to further develop their software skills in the context of large-system development

 

Required Background:

 

Prerequisite: Completion of the Computer Programming Competency Exam

Students will have software development skills such that they will be able to develop small- to medium-sized programs in an object-oriented language like Java or Ruby. These skills will include using existing class libraries (especially container classes) and defining new classes. Students will have some exposure to database systems.

 

Students will be knowledgeable about humanities computing, including topics covered in the first year of the Masters in Digital Humanities program. This will include exposure to existing software systems and projects in humanities computing.

 

Primary Text:

 

  1. Object-oriented and Classical Software Engineering, 5th ed.  Stephen R. Schach (McGraw-Hill, 2002).

 

Readings from:

 

  1. Interaction Design: Beyond Human-Computer Interaction. Yvonne Rogers et. al. (John Wiley & Sons, 2002).
  2. Software Project Survival Guide.  Steve McConnell (Microsoft Press, 1998).
  3. UML Distilled, 2nd ed.  Martin Fowler with Kendall Scott (Addison-Wesley, 2000).
  4. The Mythical Man-Month, 2nd ed. Frederick P. Brooks, Jr. (Addison-Wesley, 1995).
  5. Various journal publications etc.

 

Topics:

 

  1. Introduction:
    1. The problem: issues related to developing large systems; stakeholders; planning and managing team development; impact of requirements- and maintenance-related issues for large systems.
    2. Definitions of software engineering, interaction design, human-computer interaction (HCI), interaction design

 

  1. Software Development Process:
    1. Phases in software development, e.g. requirements analysis, design, implementation, integration, maintenance
    2. Models for software development, e.g. waterfall, spiral, incremental release, etc.
    3. Team organization for a project
    4. Other topics, e.g. Extreme Programming (XP).

 

  1. Requirements Analysis:
    1. Role of requirements in software development, e.g. for design, testing, maintenance.
    2. Elicitation methods, e.g. interviews, questionnaires, storyboards, prototypes.
    3. User-interface issues, including conceptual models and software interaction styles
    4. Functional requirements and task analysis. Use of scenario-based methods to define these.
    5. Use of prototyping and iteration to establish requirements for user-interface, functional requirements, and information design.

 

  1. Documenting and Modeling Requirements:
    1. Approaches to documentation, including software requirements specification (SRS) documents, XP's stories, etc.
    2. Object-oriented analysis modeling.  Unified Modeling Language (UML). Class and object models.  Interaction models.
    3. Database modeling and definition.
    4. Use-case and scenarios for modeling functional requirements.

 

  1. Software System Design:
    1. Software architecture and design.  High-level vs. low-level.  Architectural styles, e.g. client/server, pipe-and-filter, layered architectures.  Describing and modeling a high-level design.
    2. Low-level design. UML class models and sequence models. Implementing these in object-oriented programs.
    3. Design patterns.
    4. Database issues, e.g. connecting an OO design to a specific database system.

 

  1. Testing, Integration, and Quality:
    1. Debugging software components during implementation.  Test drivers. Unit testing. Black box testing. XP's approach and tool support.
    2. Walkthroughs and reviews.
    3. Approaches to integrating large systems from components.
    4. Acceptance testing.
    5. Evaluating quality through user testing methods.

 

  1. Software Maintenance:
    1. Importance of software maintenance
    2. Types of maintenance: adaptive, perfective, corrective
    3. Management of change and maintenance to software systems

 

Student Practical Assignments and Projects:

 

Many assignments may be built on top of case studies, where existing software systems are used to illustrate concepts. Such systems might include those created or under development at the University of Virginia, or possibly the Virtual Lightbox system developed at the University of Kentucky (http://www.rch.uky.edu/~mgk/lightbox/)

 

Project 1: Requirements elicitation and documentation.

Given a description of proposed software system, students will gather and document requirements information for that system from real or "pretend" users. Students determine and document the system boundary (i.e exactly what the system's responsibilities will be), as well as functional requirements and information items to be processed. Students will carry out interviews, study existing similar systems, etc. to gather requirements, and will document the results using scenarios, class models, etc.

 

Project 2: Prototyping for Requirements Analysis.

Given some basic requirements for a new system or an enhancement to an existing system, students will create low-fidelity prototypes (i.e. storyboards, paper prototypes, etc.) of the user interactions. These will be evaluated with a user testing process with potential users (possibly other students in the class) according to goals for functionality and usability. Iterative design using the prototypes will be employed to produce a better design. High-fidelity prototyping of one part of the system using Visual Basic or another rapid-application development environment will be carried out and used in an evaluation session.

 

Project 3: Design

Students will be asked to study the code for an existing system and recover the high-level architectural design of that system. They will document this design using the UML modeling techniques learned in class. A proposed modification to the system will be given, and students will be asked to assess how this modification might affect the design.  Also, students will be asked to document how a particular low-level interaction with the system (say, in response to one user action) is carried out by modeling this using low-level design representations (e.g. UML interaction diagrams).

 

Project 4: Implementation

Given a set of requirements for a proposed software system, students will develop software that will represent either a first-iteration of the system with basic functionality, or a proof-of-concept prototype. This project will emphasize development of software multiple software components or subsystems that would be developed by multiple-groups of students and integrated. An appropriate system for such a project might be a client-server system with database connectivity.

 

Project 5: Maintenance

Students will carry out a "mini" development cycle in which they will define requirements for modification to an existing system, then re-design the existing system, implement that change, and verify that they have correctly implemented this change. This project will involve a wide-range of topics learned in the course.

 

 

Back | Index

This page was created on 10 August 2002.