This course will explore in detail the design and implementation of large software systems using modern software engineering principles.   Topics include: software life cycle models, tools and techniques for software engineering, the software development life cycle, testing/evaluation techniques, and evaluation metrics.   An ongoing group design project will be used to gain practical experience with course topics and CASE tools.   Three lecture hours and three hours of scheduled laboratory per week, plus programming work outside of class.   Not open to students who have received credit for CSC 265.
Prerequisite: CSC 260.

• CG1: to develop an appreciation for the process of large-scale software development;
• CG2: to develop the skills and knowledge necessary to analyze, design and verify large software systems;
• CG3: to give students experience in making and critiquing presentations;
• CG4: to give students experience in team software development.

• CO1: demonstrated knowledge of the software development life cycle and its phases;
• CO2: demonstrated knowledge of the major models used in the development of large-scale software;
• CO3: demonstrated an appreciation of the factors affecting team selection and performance;
• CO4: demonstrated knowledge of the tools and techniques of software development, specifically including UML;
• CO5: demonstrated knowledge of modern design paradigms;
• CO6: properly utilized a modern CASE tool environment, specifically including UML modeling;
• CO7: developed and executed a plan for product testing and evaluation;
• CO8: participated in the development and presentation of group projects.

• cross life cycle software engineering concepts and techniques
  • historical and economic aspects of Software Engineering
  • professional code of conduct
  • social context of software development
  • overview of the software development process
    • requirements, specification, design, implementation, integration, maintenance and retirement
  • software life cycle models
    • classical: ad hoc ("build and fix"), waterfall, rapid prototyping, incremental, extreme programming, spiral
    • object-oriented: fountain
  • development teams
    • organizational options
    • team roles
  • basic tools and techniques
    • stepwise refinement, cost-benefit analysis, metrics, CASE, version control, configuration control
    • Unified Modeling Language (UML)
  • product testing
    • pre-execution testing: walkthroughs, inspections, peer review
    • execution-based testing
    • test objectives: evaluate the utility, reliability, robustness, performance and correctness of the product
    • correctness proofs
  • modular design
    • cohesion
    • coupling
    • encapsulation
    • abstract data types (ADTs)
    • information hiding
    • objects
      • inheritance and polymorphism
    • dynamic binding
  • reusability
    • concepts, design guidelines, potential issues
  • portability
    • concepts, impediments, basic techniques
  • interprocess communication / interoperability
    • COM, CORBA
  • planning
    • time and cost estimation
    • management plans
    • development of a test plan
    • training as an aspect of planning
• information system models
  • role of database systems
• requirements phase activities
  • determining requirements
  • analyzing requirements
  • human factors
  • prototyping
  • testing, tools and metrics
• classical specification (analysis) phase activities
  • the specification document
  • structured systems analysis
  • entity-relationship modeling
  • finite state machines
  • other formal techniques (petri nets, Z)
  • comparison of techniques
  • testing, tools and metrics
• object-oriented analysis (specification) phase activities
  • object-oriented analysis concepts
  • use-case modeling
  • class modeling
  • dynamic (activity) modeling
  • testing, tools and metrics
• design phase activities
  • design and abstraction
  • action (process) oriented design
  • data-oriented design
  • object-oriented design
  • testing, tools and metrics
• implementation phase activities
  • choosing a programming language
  • good programming practices
  • coding standards
  • module reuse
  • integration
  • test case set generation
    • testing to code
    • testing to specifications
  • black-box testing
  • glass-box testing
  • code walkthroughs and inspections
  • tools
• implementation and integration phase activities
  • an alternative to implementation, then integration
  • basic concepts
  • top-down implementation and integration
  • bottom-up implementation and integration
  • implementation and integration in an object-oriented product
  • testing
    • graphical user interface (GUI) integration testing
    • product testing
    • acceptance testing
  • tools, metrics
• maintenance phase activities
  • reasons why maintenance is necessary
  • management of maintenance
    • fault reporting and resolution
    • change authorization
  • effect of repeated maintenance
  • reverse engineering
  • testing, tools and metrics
• retirement phase activities
  • factors influencing system retirement
  • management of the retirement process

      The emphasis of the course is on the proper design of a software system from initial conception to final product maintenance.   There will be an ongoing case study presented in depth, paralleled by a semester-long design project leading to the design and implementation of a moderate-sized system by groups within the class.   Extensive laboratory work, group discussion time and group presentations conducted as part of the scheduled laboratory sessions are an integral component of the course, serving to reinforce the concepts and techniques presented in lecture.

      All programs must conform to departmental guidelines for program design and implementation, and all lab reports must conform to guidelines announced in class.   Regardless of numeric average, a student will not be eligible for a passing grade unless he or she has submitted a lab report for every programming assignment.

      The course grade will be determined using the following approximate weights: project reports and deliverables: 25%;   presentations: 10%; midterm and final exam: 40%; homework: 15%; quizzes and/or papers: 10%.

• Dennis & Wixom.   Systems Analysis and Design.   John Wiley & Sons, 2000.
• Dikel, David M.; Kane, David; Wilson, James R.   Software Architecture: Organizational Principles and Patterns.   Prentice-Hall, 2001.
• Fowler, Martin, with Kenneth Scott. UML Distilled: A Brief Guide to the Standard Object Modeling Language.   Second Edition. Addison-Wesley, 2000.
• Gamma, Helm, Johnson & Vlissides.   Design Patterns.   Addison-Wesley, 1995.
• Hoffer, et. al.   Modern Systems Analysis & Design. Second Edition. Addison-Wesley, 1999.
• Peters & Pedrycz. Software Engineering: An Engineering Approach.   John Wiley & Sons, 2000.
• Pfleeger, Shari Lawrence.   Software Engineering: Theory and Practice.   Second Edition. Prentice-Hall, 2001.
• Pressman, Roger S. Software Engineering: A Practitioner's Approach. Fifth Edition. McGraw-Hill, 2001.
• Schach, Stephen R.   Classical and Object-Oriented Software Engineering.   Fifth Edition.   McGraw-Hill, 2002.