ISEUC Course Catalog

COURSE CATALOG
PROSPECTIVE MEMBERS
THE INTERNATIONAL SOFTWARE ENGINEERING UNIVERSITY CONSORTIUM
ISEUC: "I SEE, YOU SEE"
UNIVERSITY CODE
Butler University [Undergraduate + Graduate] BUT
California Polytechnic University at San Luis Obispo CALPOLY
[Undergraduate + Graduate]
Carnegie-Mellon University [Graduate] CMU
Embry-Riddle Aeronautical University [Graduate] ERAU
Indiana University-Purdue University at Indianapolis IUPUI
[Undergraduate + Graduate]
Mercer University MER
[Graduate]
Monmouth University [Undergraduate+Graduate] MON
Murdoch University [Undergraduate] MUR
Purdue University PUR
[Undergraduate + Graduate]
Rochester Institute of Technology [Undergraduate] RIT
Stevens Institute of Technology [Graduate] SIT
Texas Tech University [Graduate] TTU
University of Michigan-Dearborn UMD
[Undergraduate + Graduate]
University of Ottawa OTTAWA

VERSION 0.26
LOTS OF CRITIQUING REQUIRED!!!
PLEASE CORRECT: MISSING COURSES
+: CURRENTLY AVAILABLE VIA DISTANCE LEARNING
*: PLANNED TO BE AVAILABLE VIA DISTANCE LEARNING
-: NO PLANS TO PROVIDE VIA DISTANCE LEARNING
MARCH 5, 2001
KEN MODESITT
UNIVERSITY OF MICHIGAN-DEARBORN
DISTRIBUTION OF COURSES BY LEVEL
NEED
UNIVERSITY UNDERGRAD GRAD TOTAL DETAIL
BUTLER 1 1 1
CALPOLY 5 2 7 3
CMU 12 12
ERAU 10 10 10
IUPUI
MER 18 18
MON 15 20 30 15
MUR 11 11 29
PURDUE 2 1 3
RIT 12 2 14
SIT 11 11
TTU 9 9
UMD 3 16 19
OTTAWA 14(Eng)+14(Fr) 8(Eng)+4(Fr)
TOTAL 63(Eng)+14(Fr) 109 (Eng)+4(Fr) 172(Eng)+18(Fr)

Butler University [Undergraduate] (BUTLER)
[www.butler.edu/csse]
CS XXX: Software Maintenance, taught by Panagiotis (Panos) K. Linos
California Polytechnic University at San Luis Obispo [Undergraduate] (CALPOLY]
[www.csc.calpoly.edu]
CSC 205 Software Engineering I (4) (Also listed as CPE 205)
Introduction to the software lifecycle. Methods and tools for the analysis, design, and specification of large, complex software systems. Project documentation, organization and control, communication, and time and cost estimates. Group laboratory project. Graphical User Interface Design. Technical presentation methods and practice. Software design case studies and practices. Ethical and societal issues in software engineering. Miscellaneous course fee may be required- see Class Schedule. 3 lectures, 1 laboratory. Prerequisite: CSC 103.
CSC 206 Software Engineering II (4) (Also listed as CPE 206)
Continuation of the software lifecycle. Methods and tools for the implementation, integration, testing and maintenance of large, complex software systems. Program development and test environments. Group laboratory project. Technical presentation methods and practice. Ethical and societal issues in software engineering. 3 lectures, 1 laboratory. Prerequisite: CSC 205.
CSC 402 Software Requirements Engineering
In approval process
CSC 405 Software Design and Construction
In approval process
CSC 406 Software Deployment
In approval process
CSC 508 Software Engineering I (4)
In-depth study of requirements engineering, software project management, formal specifications and object-oriented analysis. 4 seminars. Prerequisite: CSC 205 and graduate standing, or consent of instructor.
CSC 509 Software Engineering II (4)
In-depth study of software modeling and design. Formal design methodologies. Design patterns. Detailed case studies of existing projects. Tools and methods for designing large software systems. 4 seminars. Prerequisite: CSC 508 and graduate standing, or consent of instructor.
Carnegie-Mellon University (CMU)
[www.distance.cmu.edu]
The Distance Education Program does not supply textbooks as part of the course support. Textbooks required for Software Engineering courses may be purchase from your favorite bookseller.
651. +Models of Software Systems
Scientific foundations for software engineering depend on the use of precise, abstract models for characterizing and reasoning about properties of software systems. This course considers many of the standard models for representing sequential and concurrent systems, such as state machines, algebras, and traces. It shows how different logics can be used to specify properties of software systems, such as functional correctness, deadlock freedom, and internal consistency. Concepts such as composition mechanisms, abstraction relations, invariants, non-determinism, inductive definitions and denotational descriptions are recurrent themes throughout the course.
This course provides the formal foundations for the other core courses. Notations are not emphasized, although some are introduced for concreteness. Examples are drawn from software applications.
After completing this course, students will:
• understand the strengths and weaknesses of certain models and logics including state machines, algebraic and process models, and temporal logic
• be able to select and describe appropriate abstract formal models for certain classes of systems, describe abstraction relations between different levels of description, and
• reason about the correctness of refinements
• be able to prove elementary properties about systems described by the models introduced in the course
Prerequisite: Undergraduate discrete math including first-order logic, sets, functions, relations, proof techniques (such as induction).
If possible, Methods of Software Development should be taken concurrently.
[ASYN]
651. +Methods of Software Development
Practical development of software requires an understanding of successful methods for bridging the gap between a problem to be solved and a working software system. This course focuses specifically on methods that guide the software engineer from requirements to code. The course will provide students with both a broad understanding of the space of current methods, and specific skills in using these methods.
After completing this course, students will:
• be able to use at least two software engineering methods effectively and make a critical assessment of the strengths and weaknesses of a broad range of methods
• understand the dimensions along which methods differ
• understand the tradeoffs in making choices along those dimensions.
Prerequisite: Experience with at least one large software system, either through industrial software development experience or an undergraduate course in software engineering, compilers, operating systems, or the like.
If possible, this course should be taken either concurrently or after Models of Software Systems and Management of Software Development.
[ASYN]
651.
652. +Managing Software Development
Large scale software development requires the ability to manage resources - both human and computational - through control of the development process. This course provides the knowledge and skills necessary to lead a project team, understand the relationship of software development to overall product engineering, estimate time and costs, and understand the software process. Topics include life cycle models, requirements elicitation, configuration control, environments, and quality assurance, all of which are used broadly in other core courses and the Studio.
After completing this course, students will:
• be able to write a software project management plan, addressing issues of risk analysis, schedule, costs, team organization, resources, and technical approach
• be able to define the key process areas of the Capability Maturity Model and the technology and practices associated with each and a variety of software development life cycle models and explain the strengths, weaknesses, and applicability of each
• understand the relationship between software products and overall products (if embedded), or the role of the product in the organizational product line
• understand the legal issues involved in liability, warranty, patentability, and copyright
• understand the purpose and limitations of software development standards and be able to apply sensible tailoring where needed
• be able to use software development standards for documentation and implementation
• be able to apply leadership principles
• be able to perform requirements elicitation
Prerequisite: Students must have had industrial software engineering experience with a large project, or a comprehensive undergraduate course in software engineering.
[ASYN]
671. Software Development Studio I
A Sample of Past Studio Projects
The Studio provides students with a laboratory for direct application of concepts learned in coursework. It has produced a variety of software products. Clients have included Boeing, NASA, Westinghouse, Innovative Systems, Inc. and the United States Air Force. Here is a sample of the Studio projects.
Medusa
A software engineering team at Boeing Defense and Space Group was working on a distributed operating system for a new helicopter. Most of the engineers still used VT100-class terminals. They needed a way to seamlessly boot up and synchronize multiple target processors in order to perform system testing. The Studio team implemented a form of windowing for the terminals that ran transparently under VMS, including using VMS Help and other operating system facilities.
Architectural Visualization Projects
Two different systems were implemented to assist architects and their contractors to have different "views" of buildings in a coordinated way. Usually plumbers, HVAC engineers, electricians, and architects have to reconcile their different needs in building construction by manual and awkward means. The systems implemented by the Studio teams assisted in automating and intelligently reconciling cable runs, piping, HVAC, etc.
Computer Assisted Instruction (CAI)
A Studio team re-engineered a CAI system that teaches logic. The old system was assembled from various sources and its interfaces had become unmaintainable. The Studio team re-implemented the underlying knowledge base and part of the user interface.
Tessellator
Before the Space Shuttle flies, its thermal protection system has to be waterproofed by injecting a toxic chemical into each of the thousands of individual tiles. A perfect job for a robot. Two Studio teams implemented the software to move and position the robot, move and position its arm, and do planning of its work.
APEX
This project is a robot to explore the moon and Mars. It has some requirements for autonomous operation. The Studio worked on navigation software and the system specification. It also re-engineered part of the existing "standard" robot message passing system, Task Control Architecture.
TCAMS
The Tape Copy and Management System (TCAMS) is one of the most successful Studio projects in terms of producing high quality code by following a defined process. TCAMS is 7,000 lines of C that controls a robotic tape mounting system and associated computers for the Air Force's B-2 test program. The
product had a total of three defects detected in unit and itegration test combined [0.44 defects/KLOC]. Tour more defects were found by the client in acceptance test, none major. After six months of operations, no additional defects were found.
654. +Analysis of Software Artifacts
Our ability to build, maintain, and reuse software systems relies on our ability to analyze effectively the products of software development. This course will address all kinds of software artifacts - specifications, designs, code, etc. - and will cover both traditional analyses, such as verification and testing, and promising new approaches, such as model checking, abstract execution and new type systems. The focus will be the analysis of function (for finding errors in artifacts and to support maintenance and reverse engineering), but the course will also address other kinds of analysis (such as performance and security).
Various kinds of abstraction (such as program slicing) that can be applied to artifacts to obtain simpler views for analysis will play a pivotal role. Concern for realistic and economical application of analysis will also be evident in a bias towards analyses that can be applied incrementally. The course emphasizes the fundamental similarities between analyses (in their mechanism and power) to teach the students the limitations and scope of the analyses, rather than the distinctions that arose historically (static vs. dynamic, code vs. spec). The course will balance theoretical discussions with lab exercises in which students will apply the ideas they are learning to real artifacts.
After completing this course, students will:
• know what kinds of analyses are available and how to use them
• understand their scope and power, when they can be applied and what conclusions can be drawn from their results
• have a grasp of fundamental notions sufficient to evaluate new kinds of analysis when they are developed
• have some experience selecting analyses for a real piece of software, applying them and interpreting the results
Prerequisite: Models of Software Systems plus experience programming a large software system.
[ASYN]
654. +Architecture of Software Systems
Successful design of complex software systems requires the ability to describe, evaluate, and create systems at an architectural level of abstraction. This course introduces architectural design of complex software systems. The course considers commonly-used software system structures, techniques for designing and implementing these structures, models and formal notations for characterizing and reasoning about architectures, tools for generating specific instances of an architecture, and case studies of actual system architectures. It teaches the skills and background students need to evaluate the architectures of existing systems and to design new systems in principled ways using well-founded architectural paradigms.
After completing this course, students will be able to:
• describe an architecture accurately
• recognize major architectural styles in existing software systems
• generate architectural alternatives for a problem and choose among them
• construct a medium-sized software system that satisfies anarchitectural specification
• use existing definitions and development tools to expedite such tasks
• understand the formal definition of a number of architectures and be able to reason about the propertiesof those architectures
• use domain knowledge to specialize an architecture for a particular family of applications
Prerequisite: Experience with at least one large software system, either through industrial software development experience or an undergraduate course in software engineering, compilers, operating systems, or the like.
[ASYN]
672. Software Development Studio II
673. Software Development Studio III
615. +Software Process Definition
A software process definition is the cornerstone of implementing and improving a software process. Although this course is primarily intended for students in the Process Track of the Masters of Software Engineering, others interested in learning how to define a process are welcome and could benefit as well.
The objective of this course is to prepare students to define software processes. The approach to software process definition to be taught will be an incremental methodology that covers:
• guidelines for early success and building a sound foundation
• organizing the process definition as it develops
• approaches to avoid unnecessarily elaborate or formal using organizational goals and constraints in the development approach
• environmental context that the process resides within and builds upon it
Prerequisite
This course is intended for individuals who have industrial software engineering experience with a large project, or a comprehensive undergraduate course in software engineering.
Assignments & Assessment
The course provides a dynamic learning experience. As you move through the course, you will reflect on the material covered in lectures and readings, and apply theory learned to your assignments. Your progress in the course will be assessed using the following methods.
Twice during the course, you will participate in debates—as a member of a debate team for one debate and as a questioner for the other debate. Debate topics will be determined by the course instructor. Your participation in the debates will constitute 20% of the assessment.
Your participation in chatroom sessions and on-line discussions will constitute 10% of the assessment.
Requirements and specification documents for the course project will be developed by you and based on your job related activities. The course project will constitute 30% of the assessment.
The final examination will test your understanding of thecourse material and will constitute 40% of the assessment.
[ASYN]
619. +Introduction to Real-Time Software and Systems
In the typical industrial setting, traditional engineering professionals (mechanical, electrical, civil) are recruited as software developers and managers because of their domain expertise. This is especially true for embedded systems development. As a result, these professional often lack specific training in the software development domain. Many undergraduate computer scientists have never had specific training
in real-time systems development and asprofessionals, are now faced with the challenge of developing software or managing development efforts for real-time systems. This course was designed with these practicing developers and managers in mind.
This course is designed to provide a thorough background in the development of real-time systems. Traditional software development issues are presented. In addition, we explore how the added constraint of real-time processing affect the analysis, design, and development of real-time systems.
Topics include:
• the software development process
• requirements and requirements analysis for real-time systems
• real-time software architectures
• real-time software design
• language for real-time system development
• real-time systems timing issues
• hardware and operating systems for real-time applications
• real-time data storage
Prerequisites
Proficiency in at least one high-level programming language used to develop real-time software (e.g., C, C++, or Ada).
Proficiency in a software design notation.
Knowledge of operating system concepts taught in an undergraduate operating system course.
A student may acquire the prerequisite knowledge via an undergraduate course, on-the-job training, or an independent study.
Course Materials
Course materials include CD ROMS of lectures, a companion guide, and access to the course website with class bulletin board and chat room.
[ASYN]
635. +Software Measurement
This course will introduce students to applying software measurement—from need identification through analysis and feedback—into the process. Much of the course material used to demonstrate the concepts are based on how software measurement is used by managers and practitioners in industry today. The content of the course is taught within the framework of the software engineering process.
After completing this course, students will:
• have learned basic and advanced measurement concepts as applied to software engineering
• be prepared to apply measurement concepts and make decisions based on the data in a software engineering environment
• understand the relationship between software products and overall products (if embedded), or the role of the product in the organizational product line.
Prerequisite
Students must have industrial software engineering experience with a large project, or a comprehensiveundergraduate course in software engineering.
Assignments & Assessment
The course provides a dynamic learning experience. As you move through the course, you will reflect on the material covered in lectures and readings, and apply theory learned to your assignments. Your progress in the course will be assessed using the following methods.
You will be responsible for three major assignments. The purpose of the assignments is to give you practice in applying software measurement. The assignments will constitute 20% of the assessment.
For the final project, you will expand on the output of your assignments by developing a project that is representative of a complete instantiation using the measurement process framework for a measurement goal. The project will constitute 20% of the assessment.
Twice during the course, you will participate in debates—as a member of a debate team for one debate and as a questioner for the other debate. Debate topics will be determined by the course instructor. Your participation in the debates will constitute 20% of the assessment.
Your participation in chatroom sessions and on-line discussions will constitute 10% of the assessment.
The final examination will test your understanding of the course material and will constitute 30% of the assessment.
Course Materials
Course materials include 14 videotaped lectures, the Companion Guide, and access to the course Website and Forums (bulletin board and chatroom). The course has no required text.
[ASYN]
NON-CREDIT
+Personal Software Process
The purpose of this course is to introduce the highest-leverage metrics of the Personal Software Process (PSP), specifically the ones associated with improving time estimation and reducing defects. Students will watch eight lectures, solve seven programming problems, complete four reports, and read selected chapters from Watts Humphrey’s A Discipline for Software Engineering (Addison-Wesley, 1995). These exercises will help the students to immediately apply PSP principles to their daily work.
This course is intended for practicing software engineers and their managers. The measures introduced can serve as the basis for software development process improvement in the organization, as well as for helping individuals. Students who advance to a more comprehensive course in the PSP will be able to concentrate more completely on advanced metrics.
Prerequisite
Since this is a development oriented class and involves writing code, all the normal tools one may use to develop code in their language of choice are required. Course requirements are not solely grounded in theory.
Students will need access to a compiler for the programming language they have chosen to complete their course assignments. Additionally, students will need a spreadsheet program for data analysis, preferably Microsoft Excel.
Assignments & Assessment
You are expected to complete the assignments as outlined on the website, participate in class discussions, an receive an assessment of "pass" or better on each of the four reports.
Course Materials
Course materials include Just-In-Time-Lecture CDs, a companion guide, and access to the course web site with a class bulletin board and chatroom.
[ASYN]
+Documenting the Idea: A Communication Course for Software Engineers
Communication is an integral part of software engineering. To be successful, software engineers must communicate their ideas, document their work, and interact with a wide variety of people. This course will enable you to become more effective and efficient in your written and oral communication. You will lean how to plan and revise your work, give and get useful document reviews, and give presentations that impress audiences. In addition, you will mature as a professional through reflection, exposure to the reflections of other professionals, and practice in expressing ideas related to software engineering.
After completing this course, you will be able to:
• save time and minimize rework when you write
• write documents and presentations that get you the results you want
• make choices—from document format to word choice—that suit your audience and purpose
• review drafts and make suggestions that result in clear, effective documents
Assignment & Assessment
This course provides a unique opportunity to enhance your writing skills, particularly as they relate to software engineering. As you move through the course, you are expected to complete the assignments as outlined in the course companion guide, participate in class chatroom discussions, and receive an assessment of "pass" or better on each of the written papers. Upon satisfactory completion of the course, you will receive a continuing education certificate attesting to the 12 units earned.
Course Materials
Course materials include CD ROMS of lectures, a companion guide, and access to the course website with class bulletin board and chat room.
[ASYN]
Embry-Riddle Aeronautical University (ERAU)
[www.computing.db.erau.edu]
MSE 500 Software Engineering Concepts
MSE 530 Software Requirements Engineering
MSE 510 Software Project Management
MSE 610 Software Architecture and Design
MSE 555 Object-Oriented Software Construction
MSE 545 Specification and Design of Real-Time Systems
MSE 640 Concurrent and Distributed Systems
MSE 655 Performance Analysis of Real-Time Systems
MSE 585 Metrics and Statistical Methods of Software Engineering
MSE 660 Formal Methods for Concurrent and Real-Time Systems
Indiana University Purdue University-Indianapolis (IUPUI)
[klingon.cs.iupui.edu]
CS 450 Principles of Software Engineering
(3 cr.) P: CSCI 355 and CSCI 362. Tools and techniques used in software development. Life-cycle concepts applied to program specification, development and maintenance. Topics include: overall design principles in software development; the use of structured programming techniques in writing large programs; formal methods of program verification; techniques and software tools for program testing, maintenance and documentation.
[ASYN]
+CS 452 Object-Oriented Analysis and Design
(3 cr.) P: CSCI 355 and CSCI 362. Introduction to the object-oriented paradigm in software development. Basic concepts: objects, classes, messaging, inheritance, methodologies. Analysis: defining objects, structures, attributes, services. Design: transforming the analytic model into the design model. Implementation: comparison of the support features provided by languages such as Smalltalk, C++, Eiffel, and CLOS. A significant design project.
[ASYN]
CS 506 Management of Software Development Process
[ASYN]
CS 507 Object-oriented Design and Programming
[ASYN]
* CS 5XX Interactive System Design
[ASYN]
Mercer University (MER)
[http://www.mercer.edu/engineering/GRAD_PROGRAMS/grad.htm]
"+" = already available in DL (none)
"*" = available in DL in 2001 – 02
"-" = not feasible for or planned for DL at this time
(no prefix) = planned for DL, but not in 2001 - 02
SSE 552. Object Oriented Design I (3-0-3)
Prerequisite: SSE graduate standing or permission of the program director.
An in depth treatment of software development with a modern language such as C++. UML is used to document designs. This course may cover both object-oriented and procedural software development. Introduction to a modern system modeling language such as Unified Modeling Language (UML).
[ASYN]
*SSE 556. Java Design I (3 0 3)
Prerequisite: SSE graduate standing or permission of the program director.
The use of a modern object-oriented programming (OOP) language (Java) to develop software including applications and applets, object oriented programming, basic data types and control structures, methods, interfaces to HTML, graphic displays, and simple graphic user interfaces. Introduction to software testing. Introduction to a modern system modeling language such as Unified Modeling Language (UML). May include topics such as simple exception handling and file I/O.
[ASYN] {T1}
SSE 572. Disciplined Software Development (3-0-3)
Prerequisite: SSE 552 or SSE 556
Individual software development practices for estimating, measuring, and controlling process schedule and product quality. May include the Personal Software Process (PSP).
[ASYN]
SSE 581. Structures, Algorithms and Timing (3 0 3)
Prerequisite: SSE 556
Object oriented data structures and algorithms for processing them. Timing considerations and timing specification in UML. May include programming with relevant APIs.
[ASYN]
SPECIAL COURSES: 591, 592, 593 for variable credit. May be repeated for credit with permission of the advisor.
* SSE 591. Software Engineering (3 0 3)
Software engineering overview, including software processes and software project management. Software requirements, requirements engineering processes, system models, prototyping, and formal specification. Software design, distributed systems architectures, object-oriented design, real-time software design, reuse and user interface design. Critical systems, dependability, specification, and development. Verification and validation, software testing, and critical systems validation. Software management, cost estimation, quality management, and process improvment. Software evolution, change, re-engineering, and configuration management.
[ASYN] {T3}
591, 592, 593 Special Topics 1-6
SSE 633. Advanced Computational Techniques I (3-0-3)
Prerequisite: SSE 652 or SSE 656
Topics covered may include genetic algorithms, artificial intelligence, neural networks, fractals and applications of chaos theory.
[ASYN]
SSE 634. Advanced Computational Techniques II (3-0-3)
Prerequisite: SSE 633
A continuation of SSE 631. Additional topics are covered, and topic areas may be synthesized, for example by combining genetic algorithms with neural networks.
[ASYN]
- SSE 641. Computer Graphics I (3-0-3)
Prerequisite: SSE 552 or permission of the professor
Introduction to graphics systems; basic raster graphics algorithms for 2D primitives; geometrical transformations, viewing transformations, windowing, clipping and shielding for 2D graphics.
[SYN] (not DL)
- SSE 642. Computer Graphics II (3-0-3)
Prerequisite SSE 641
Geometrical and viewing transformations for 3D graphics; representation of 3D curves and surfaces; solid modeling; color; illumination, and shading in the rendering pipeline.
[SYN] (not DL)
SSE 652. Object Oriented Design II (3-0-3)
Prerequisite: SSE 552
A continuation of SSE 552. This course may cover both object-oriented and procedural software development. Use of peer reviews such as software inspections. Extended use of UML. Topics may include the Standard Templete Library, C legacy code, string stream processing, and bit manipulation. Introduction to design patterns using C++.
[ASYN]
* SSE 656. Java Design II (3-0-3)
Prerequisite: SSE 556.
A continuation of SSE 556, with greater breadth and depth. Additional Java APIs are introduced. Use of peer reviews such as software inspections. Extended use of UML. Topics may include advanced graphic user interfaces, network programming, and Java Beans. . Introduction to design patterns using Java.
[ASYN] {T2}
* SSE 657. Object Oriented Methods (3-0-3)
Prerequisite: SSE 652 or SSE 656
Covers the software development life cycle. General object oriented analysis techniques (OOA) for software and system specifications are presented and applied to develop application domain models and requirements specifications. Techniques for transforming the requirements specifications into designs are presented and applied to develop language independent object oriented designs (OOD). A modern specification language such as UML will be used. Generation and selection of test cases.
[ASYN] {T1}
* SSE 658. Design Patterns (3-0-3)
Prerequisite: SSE 652 or SSE 656
Advanced topics in object oriented design (OOD), emphasizing the reuse of successful designs via design patterns.
[ASYN] {T2}
SSE 673. Software Processes (3-0-3)
Prerequisite: SSE graduate standing or permission of the program director.
This course explores the nature of the software development process and means for controlling the process so as to improve the product and control development costs and risks. Issues including development organization, project planning, configuration management, quality assurance, standards, validation and verification, and process monitoring and process improvement are presented and explored. Techniques for improving the level of maturity of the software development process are considered. Standards such as ISO or CMM may be used
[ASYN]
SSE 674 Software Risk Management (3-0-3)
Prerequisite: Permission of the program director.
Risk is inherent in virtually every software engineering project. Two kinds of risk are opportunity risk, which is the loss from avoiding risk, and failure risk, which is the loss from taking a risk, but failing to achieve the corresponding goal. The loss may be financial, or it may be competitiveness in a market, or the development and acquisition of reusable software components, or many other valuable things. This course covers topics such as people, process, infrastructure, and implementation in software risk management.
[ASYN]
- SSE 681 Real Time Embedded Software (3 0 3)
Prerequisites: SSE 581 and SSE 656.
Topics may include object-oriented design techniques for real-time systems, use of a specification language such as UML for real-time systems, and implementation in an embedded systems language such as Embedded Java or Real Time Java, and JINI technology.
[SYN] (not DL)
SPECIAL COURSES: 691, 692, 693, 698, 699 for variable credit. May be repeated for credit with permission of the advisor.
691, 692, 693. Special Topics 1-6
* SSE SSE 691 Refactoring
Prerequisite: Permission of the program director.
Software maintenance and the improvement of the design of existing code.
[ASYN] {T3}
SSE 698. Professional Seminar 1-6
(TBD) SSE 699. Thesis Research 1-6
A maximum of 6 hours of research may be counted toward the degree. Only grades of satisfactory or unsatisfactory will be assigned.
[TBD]
Monmouth University (MON)
[www.monmouth.edu/~seed]
SE 104 Introduction to Software Engineering (with PSP)
SE 205 Requirements Engineering and Specifications
SE 207 Software Design and Architectures
SE 312 Software Construction and Components
SE 418 Software Project Management
SE 485 Practicum
SE 306 Formal Methods
SE 403 Software Process Improvement
SE 402 Human-computer Interaction
SE 425 Software Experimentation and Measurement
SE 223 Product-line Development
SE 221 Software Tools Development
SE 321 Real-time Systems Design
SE 421 Information Systems Design
SE 423 Telecommunication Systems Design
SE 500 The Process of Engineering Software
This course introduces the need for an engineering approach to software, through a motivational discussion of the so called "software crisis," and a presentation of software development processes at the various degrees of granularity; this ranges from organizational processes to team and individual engineer's processes. Details of the SEI Capability Maturity Model and ISO 9000 certification standards are given and comparisons drawn as to how one influences the other. The course provides practical experiences with the Personal Software Process, and team-oriented development. A software process is defined as a set of guidelines, activities, and methods that engineers use to develop and maintain software. Without a software process, most projects are over budget and behind schedule, since successful efforts cannot be guaranteed. The success of a project depends greatly upon the experience and discipline of the engineers. Prerequisite: SE504 or equivalent.
SE 505 - Software Systems Design
The software design process and its activities. Design Fundamentals: Abstraction, Modularity, Information Hiding, Refinement, Software Architecture. Design Strategies: Function-Oriented design, Object-Oriented design, combination of both. Design application Domains: Real-time Systems, Information systems for the centralized and distributed environment, Graphical User Interfaces. Prerequisite: SE500 and SE 507.
SE 506 - Formal Methods in Software
Mathematical and logical foundations for formal methods in programming; notations and conventions for arrays; a formal programming language; proof rules for the statements of the language; the formal development of programs; formal methods in design and in design verification. Prerequisite: SE501 or equivalent.
SE 507 - Software Systems Requirements
Requirements analysis and specifications will be explored. Requirements definition and requirements specification documents. Types of requirements. The validation process of requirements specifications. Software prototyping as a technique for establishing system requirements. The use of formal methods for the specification of software systems. The interviewing process and feedback with the customer in order to formulate correct requirements. Prerequisite: SE500.
SE 512 - Software Testing and Quality
Explores techniques employed to ensure quality in a software product developed in a controlled and disciplined environment. Detailed examination of software testing principles and methodologies. Provides specific methods for test case selection and development leading to optimization of resource management in software testing environment. Prerequisite: SE507.
SE585A-SE585B The Software Engineering Practicum
This is a two-semester course sequence with major emphasis on hands-on, team-oriented large software development projects. Students will be asked to form groups of 3-5 persons, that will work as a software team whose purpose will be to develop a software product. The particular product will be chosen through negotiation with the instructor. Teams will operate in accordance with a well-defined set of policies and procedures (documented in a SE Handbook) that governs the entire development process. This documented process addresses work products, roles, activities, entry & exit criteria, reviews and audits, documented procedures, and training. The practicum will also include the use of a set of approved tools. Additional software project management topics such as planning, estimation and tracking will be covered. Project Management techniques and their application to the management of software projects. How to define a software development plan its associated tasks, milestones and deliverables. Software project scheduling and the establishment of relationships among the different tasks. Tasks dependencies and conflict resolution. Resources management and allocation. Software project cost estimation. Algorithmic models for estimating costs: the COCOMO model and its derivatives. Risk assessment and its impact in the planning and scheduling of software projects. Software project measurement and tracking. Comparative review of software tools for software project management. Software configuration management and its importance in the management of large software projects. The students will be asked to serve in team roles, hold oral reviews, and prepare documentation appropriate to their project. In addition, the students in the class will participate in the reviews of other teams in the class. At the end of the second semester, each team will give a formal presentation on the project. Prerequisites: All Core courses.
ELECTIVE COURSES
SE 508 - Software Implementation and Reuse
The purpose of this course is to explore contemporary topics in systematic software implementation and reuse. This includes the impact of Object-Based and Object-Oriented Design and Programming with Ada83, Ada95, and C++ along with Domain Engineering on the software development process. The course will concentrate on the practical aspects of applying architecture-centric, domain-specific, library-based reuse methodologies integrated with the software development process to create software systems in an efficient, cost-effective manner. The course will illustrate how object-oriented and domain engineering techniques coupled with domain-specific libraries can be used to effectively develop significant software systems in a short period of time, frequently realizing reuse on the order of 70% or more. Libraries of object-based reusable software components will be used to design and implement solutions to problems. Prerequisite: SE505.
SE 513 - Software Systems Security
Threats, vulnerabilities, and attacks to network-based systems. Heuristic procedures for breaking systems. UNIX and Internet case studies. Security modeling techniques including Bell-LaPadula, Biba, and Clark-Wilson. Composition of nondeducibility and noninterference security. Safeguard techniques including cryptographic protocols, on-line auditing and intrusion detection, access control, Internet firewalls, authentication, security kernel design, and trusted software development. Case studies in database security and secure network design. Prerequisite: SE507.
SE 526 - Networked Software Systems I
Network Computing Models, Concepts and Requirement Specification; Techniques for Interprocess Communication; Message Passing; Remote Procedure Calls; Directory Service; Synchronization; Task Partition and Allocation; Threads; Security and Authentication; Time Management. Prerequisite: SE507.
SE 527 - Networked Software Systems II
Distributed File Systems, Replication, Shared Data, Transactions, Distributed Operating Systems, Micro Kernels, Network Operating Systems, Computing Environments and Toolkits: ONC, DCE, ISIS, Languages. Prerequisite: SE526.
SE 531 - Software Organization Management
Management issues regarding the software process. Authority and delegation. Leadership and leadership paradigms. Software team management: organization, staffing and evaluation. Organizational alternatives. Centralized vs. decentralized organizations. Managing design, development and testing teams. Managing software support organizations. Strategies for staffing: minimal vs. redundant staffing. Combining generalists and specialists to achieve an optimal staff configuration. Staff development and growth. Fostering professional growth within the organization. Evaluation strategies and techniques. Compensation and reward issues. Prerequisite: SE504 or equivalent.
SE 532 - Software Quality Management
Management issues regarding the software process. This course is centered around the concept of management for quality in software processes. It covers the three fundamental elements in the management of software processes: policies, procedures and tools. It examines how software processes are defined, established, monitored and controlled in a continuous cycle of planning, doing, checking and acting to improve its quality and therefore the quality of the resulting product. The ISO 9001 and SEI's Capability Maturity Models (CMM) are discussed. Prerequisite: SE531.
SE 541 - Information Systems Architecture
Theoretical and practical issues related to the modeling and design of information systems to support medium to large organizations. The target architecture and its role in building enterprise-wide information systems. Operational, warehouse, departmental and individual level data. Data modeling levels and their associated constructs: Entity-Relationship Diagrams, Data Item Sets, Physical Data Models. Process modeling levels and their associated constructs: Functional decomposition, Context diagrams, Data Flow Diagrams, State Transition Diagrams, HIPO charts, Pseudo-code and programming specs. Relationship with Object-based modeling. Prerequisite: SE507
SE 542 - Information Systems Engineering
Theoretical and practical issues related to the implementation of information systems to support medium to large organizations. Databases within the target architecture and their role in building enterprise-wide information systems. Logical vs. Physical database design. Transaction Processing (TPS) and Decision Support systems (DSS): similarities and differences. Knowledge-based systems. Implementation issues: reliability, integrity, security, performance, scalability and maintainability. Review of existing commercial tools and environments for building, using and maintaining information Systems for the enterprise. Prerequisite: SE541.
SE 551 - Real-Time Software Analysis and Specificatio
Scheduling policies and mechanisms. Classification of Real-Time Systems: hard, soft; uniprocessor, multiprocessor, distributed. Kernels and executives. Real-time programming languages and their tasking systems. Real-time distributed systems: processor and communication scheduling domains, priority inversions and mappings, global time synchronization. Real-Time Structured Analysis (RTSA). CASE tools for RTSA. Real-Time Object Oriented Analysis methods. Comparison to RTSA. Prototyping real-time software systems. Using prototyping tools like CAPS (Computer Aided Prototyping System) to establish and validate system requirements. Prerequisite: SE507.
SE 552 - Real-Time Software Design and Implementation
Criteria and trade-offs for partitioning the functions of an real-time system among the hardware, firmware, and software. The interfaces of a real-time system to the external environment such as sensors and actuators. Designing real-time systems: structured and object-oriented methods. Case studies and comparison between the two. Design verification and validation. Implementation of Real-Time systems. Development environments and tools: Simulators, Emulators and Debuggers. Testing Real-Time systems. Test coverage and regression testing. Special approaches for Real-Time software testing. Engineering and organizational issues in real-time software development. Performance testing and its importance in real-time systems. Prerequisite: SE551 and SE505.
SE 590 - Thesis Research
Independent research in software engineering, spanning a period of 2 consecutive semesters, in an area not substantially treated in a regular course offering, under the supervision of a software engineering faculty member. A formal thesis is required. An oral defense of the thesis before a committee of two faculty members, plus the advising professor is required. Depending on the topic, a reviewer from outside the software engineering department may be asked to serve as a committee member. Prerequisites: completion of all core courses, and prior permission of the advising professor and program director.
Murdoch University [Undergraduate] (MUR)
[eng.murdoch.edu.au]
G2607 Requirements Engineering
Objectives: To provide an introduction to the software development life cyclewith an emphasis on requirements engineering.
Prerequisites: Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content:
• General systems theory and a discussion of life cycle models.
• Modelling methods and techniques for the analysis of the data, process and behavioural aspects of systems.
• People issues including interpersonal skills and techniques (eg, for teamwork), common roles and responsibilities (eg, stakeholder, analyst).
• The emphasis of the unit is on Object-Oriented concepts and analysis through the application of object-oriented information gathering techniques and modelling notation.
Outcomes:
1. To be able to describe the concepts and application of a range of software development models.
2. To be able to describe and discuss the concepts of object oriented modelling.
3. To be able to complete an analysis for a simple software product.
4. To be able to apply an object-oriented notation within a requirements engineering task.
[ASYN]
G3757 Advanced Software Design I
Objectives:
To apply the principles of software design and introduce alternative software architectures in order to study their implications for system design and implementation. In addition, Formal Methods and in particular the Z specification language are introduced as a mechanism for specifying software and software architectures.
Prerequisites:
Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content:
Formal Methods topics including: the place of Formal Methods in Software Engineering and an introduction to Z.
Software architecture topics focus on architectural style, including: filters, layered architectures, abstract machine architectures, various concurrent and real-time software architectures and process control architectures.
Outcomes:
1. To be able to describe the concepts and application of a range of software architectures.
2. To be able to complete a design for a complex software product.
3. To be able to implement a complex software product meeting all the necessary requirements for
specification, analysis and performance.
4. To be able to specify a range of software architectures.
[ASYN]
-G3767 Embedded and Industrial Computer Systems
Objectives:
To provide a broad understanding and practical experience in using a wide range of computing systems typical of industrial environments.
Prerequisites
Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content:
The unit deals with a broad spectrum of embedded and industrial computer systems, from SBCs, through PCs and PLCs to SCADA and DCS systems. The strong laboratory component provides students with practical experience in using these systems. Additionally, a wide variety of application domains are considered. This enables students to appreciate the range of different sensor types, actuators and system response times (from microseconds to minutes) found in the industrial environment together with the type of computer systems which are associated with measurement and control.
Outcomes:
1. Implement and test software in a typical embedded system environment.
2. Understand the hardware and implement software for a single computer based measurement and control system.
3. Analyse and design sequential and discrete state systems.
4. Configure and maintain a small automation and process control system.
5. Configure and maintain a small system using a supervisory control package as is typical in DCS and SCADA systems.
[Requires lab – currently under investigation]
G3807 User Interface Design
Objectives
To cover the concepts, principles and practice of user interface design.
Pre-requisites
Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content
This course will cover the theories and practice of the design of interactive user interfaces. The units will include: the elements of human-computer interaction; interaction styles; interaction design and the evaluation of interaction. Also included is the use of design environments and toolkits to implement user interface environments.
Outcomes:
1. To be able to design an operational user interface from a requirements specification.
2. To have an appreciation of the issues involved in the design and performance of a user interface.
3. To be able to fully implement a user interface conforming to design standards, styles and performance requirements.
[ASYN]
G3837 Software Engineering I
Objectives:
To provide an overview of the issues concerned with the development of large-scale software systems with an emphasis on the software process.
Prerequisites
Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content:
The Software Development Process
Topics include: a discussion of the need for an engineering approach; software process models (including the Software Development Life Cycle plus various evolutionary and prototyping concepts); project management – estimating, planning, tools, team organisation and roles; inspections and an introduction to validation, verification and testing; an introduction to quality and reliability issues in software.
Outcomes:
1. To be able to explain the software development lifecycle, and its integration with project and team planning and management and the various tools required to support this process.
2. To be able to describe and design a software development process for a design task which includes planning, scheduling, control, verification and testing.
3. To be able to implement and demonstrate the application of a software development process in example design tasks.
[ASYN]
G3847 Software Engineering II
Objectives:
To further develop the concepts introduced in the part I unit in greater detail and introduce formal aspects of the construction of software systems with an emphasis on software quality assurance.
Prerequisites:
Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content:
Software Quality Management
Topics include: applying software process management – various commercial and social issues; software quality assurance; use of ISO 9001 and AS3905.8; manuals, procedures and plans; configuration management and change control inspection; test planning and defect analysis; process descriptions and enactment; data integrity; Cleanroom Engineering introduction to process improvement.
Outcomes:
1. To be able to explain and demonstrate the use of inspections, testing and configuration management in large scale projects.
2. To be able to explain and demonstrate the implementation of quality assurance techniques.
3. To be able to apply those techniques as a part of an ISO 9000 compliant quality management system.
[ASYN]
G4XXX Engineering Design
Objectives
To provide an opportunity for students to put into practice all aspects of Software Engineering in the design of a modest scale, but complete, software project.
Pre-requisites
Normal progress in BE & BTech, or by approval from Engineering Programme Chair.
Content
The project will be team-based and will involve undertaking a software design problem of modest scale. Work will include specification, design, implementation, documentation and testing.
Software Development teams will take a software product through each step of the software life cycle culminating in a presentation of the software and its implementation in the client's environment.
Outcomes
1. To demonstrate an ability to work within a team to produce a software product.
2. To demonstrate an ability to document and present the documentation for a small scale project.
3. To demonstrate an ability to apply the basic principles of software engineering in the full development of a software product.
[ASYN]
G4177 Advanced Software Design II
Objectives
To provide a strong foundation in advanced design topics. In particular software architectures at the pattern and idiom level are explored, and object-oriented formal specification languages introduced as a mechanism for formalising software architectures.
Prerequisites:
Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content:
Topics include: review of architectural style; overview of open systems, standards – user interface, Operating System Application Programming Interface (API), design patterns and language architecture including information bindings, procedural (parameters etc) and modular abstractions (ADT and O-O type), exception handling, concurrency; O-O paradigm – inheritance, generics.
Outcomes:
1. To be able to describe and explain the concepts associated with concurrent, distributed and network computing.
2. To demonstrate an understanding of the use of appropriate design patterns and idioms in software applications.
3. To demonstrate an understanding and use of standard tools to design and implement client-server applications, concurrent applications and network applications.
[ASYN]
G4147 Software Engineering Thesis
Objectives
To provide exposure to, and experience with, the complete design and implementation of a substantial software application.
Pre-requisites
Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content
The project will involve the complete design and implementationof a substantial software system, possibly industry based. The project will include all aspects of the software development process and will require working in a team.
The project work will take place over two semesters, with twice the amount of time commitment in the second semester. Each student is required to prepare a complete design report.
Outcomes
1. To be able to demonstrate an understanding of a full range of techniques, tools and standards concerned with the design, implementation and testing of a substantial software product.
2. To be able to fully document and present a software solution.
3. To be able to implement to an operational level a substantial software product.
[ASYN]
G4247 Software Engineering III
Objectives:
To examine the use of various metrics to build on quality assurance and provide a method of measurement, improvement and optimisation of processes.
Prerequisites
Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content:
Software Metrics and Continuous Process Improvement
Topics include: a review of software engineering and ways in which it differs from traditional engineering; a taxonomy of software metrics; measurement of size, complexity, quality and reliability of systems; certification of systems; an introduction to the assessment of software quality using American, European and Japanese approaches; basics of CMM and SPICE; an introduction to the use of Formal Methods for verification.
Outcomes:
1. To be able to explain and demonstrate the use of metrics in product and process improvement.
2. To be able to describe and explain the use of metrics for the measurement of processes such as the prediction of development and maintenance effort.
3. To be able to apply simple techniques from Formal Methods for the analysis of System Requirements.
[ASYN]
G4257 Software Engineering IV
Objectives:
To provide an exposure to a range of concepts and technologies relating to the use of Software Engineering Environments and Tools to support software development.
Prerequisites:
Normal progress in BE or BTech, or by approval from Engineering Programme Chair.
Content:
Industrial application of Software Engineering
Topics include: the application of software engineering theories in an industrial setting; human factors in project teams; the personal improvement process; design and management for re-use; risk management; assessment of the capabilities of a software organisation using CMM and SPICE; strategic issues; current trends and future directions. Additional topics include ethics and professional and legal responsibilities of the software engineer.
Outcomes:
1. To be able to describe and explain a range of technologies and tools for the software development process.
2. To be able to demonstrate the application of these technologies and tools to full scale design tasks.
3. To be able to demonstrate Risk Management as an example of such software development techniques.
4. To be able to explain the underlying theories for themeasurement of organisational capabilities.
[ASYN]
Purdue University [Undergraduate + Graduate] (PUR)
[www.cs.purdue.edu]
CS 406 Software Engineering I
Sem. 1. Class 3, cr. 3. Prerequisite: CS 251 and 352.
An introduction to the methods and tools of software engineering; software life cycle; specification and design of software, software testing, cost and effort estimation; laboratory exercises with design, testing, and other tools.
[MIX]
CS 407 Software Engineering II
Sem. 2. Class 3, cr. 3. Prerequisite: CS 406.
Because of the nature of the project, CS 407 is an extension of CS 406. The emphasis is on the development of a large software system in a team environment. Knowledge of methods and tools acquired in CS 406 are put to use in a carefully controlled and guided project. Some advanced topics such as reliability estimation and methods, and tools for the design and verification of parallel programs are covered during the lectures.
[MIX]
CS 510 Software Engineering
Sem. 2. [In 2000-01, sem. 1 instead of sem. 2.] Class 3, cr. 3. Prerequisite: CS 251.
Software life cycles, requirements engineering, software design, design of distributed systems, verification and validation, software architecture, process metrics and models, research methods in software engineering.
[MIX]
Rochester Institute of Technology [Undergraduate] (RIT)
[www.se.rit.edu]
3010-101 Software Engineering Seminar
Provides first-year students with the skills necessary to succeed at RIT and in the software engineering program. Small group sessions are used to help new students make friends, create a stronger bond with RIT and their program and become acquainted with the campus and its facilities. In addition, students are introduced to the profession of software engineering and to ethical issues they will face at RIT and through throughout their careers. Class 1, Credit 1
3010-362 Engineering of Software Subsystems
Continuation of 0603-361 with a more in-depth treatment of design and redesign, resource estimation and testing of non-trivial software subsystems. Topics include process improvement; common subsystem design patterns; maintenance; testing techniques. Students engage in active participation in the software process through projects. (0603-361) Class 3, Lab 2, Credit 4
3010-420 Formal Methods of Specification & Design
Introduction to the use of mathematical models of sequential software systems and the refinement of these models to designs and implementations. Topics include finite state machine models and regular expressions; state machine and regular expression equivalence; language syntax and semantics; formal specification, design, implementation and verification. (0603-266, 3010-362) Class 4, Credit 4
3010-420 Formal Methods of Specification & Design
Introduction to the use of mathematical models of sequential software systems and the refinement of these models to designs and implementations. Topics include finite state machine models and regular expressions; state machine and regular expression equivalence; language syntax and semantics; formal specification, design, implementation and verification. (0603-266, 3010-362) Class 4, Credit 4
3010-440 Principles of Software Architecture & Design
Examination of the fundamental building blocks and patterns for construction of software systems in the context of a sound design process, forming the foundation for subsequent courses in the principles of concurrent, distributed and information systems. All courses are structured around exploration of design patterns of construction, case studies and standards. Topics include structuring computation, patterns of design, graphical user interfaces, documenting design and functional design. Class lectures are reinforced by laboratory exercises and projects. (3010-362) Class 3, Lab 2, Credit 4
3010-441 Principles of Concurrent Software Systems
Issues and structures common in the construction of concurrent software systems. Emphasis is on fundamentals repeated in the design and development of closely coupled systems. Topics include the basics of concurrent hardware architectures, synchronization and coordination techniques and common models of software systems. Other issues include scheduling, reliability and problem decomposition. (3010-440) Class 3, Lab 2, Credit 4
3010-442 Principles of Distributed Software Systems
Issues and structures common in the construction of distributed software systems. Emphasis in on fundamentals repeated in most systems of this type. Topics include the basics of data communication and networking as well as higher-level issues encountered in the design of distributed systems. (3010-440) Class 3, Lab 2, Credit 4
3010-443 Principles of Information Systems Design
Issues and structures common in the construction of information systems. Emphasis is on fundamentals repeated in most systems of this type. Topics include historical review of methods of organizing and accessing information, high-level modeling techniques, performance and security concerns, implications of storing new data types (e.g., sound, pictures) and new dimensions (e.g., time) on information systems architectures. Team projects are required. (3010-440) Class 3, Lab 2, Credit 4



3010-450 Software Process & Product Metrics
Software metrics help a software organization on two main fronts: quality assessment of its process and products and assessment of its progress toward its main goal—the production of software artifacts. Students are exposed to metrics used in industry to control large software processes. Topics include product and process metrics, personal metrics portfolio, metrics attributes, and resource and time estimation metrics. (3010-362) Class 4, Credit 4
3010-452 Software Verification & Validation
Introduction to a set of principles and techniques that represent the foundation for improving software products. Topics include verification and validation, unit level testing, system level testing, software quality assurance, and software reliability. Team projects are emphasized. (3010-362) Class 4, Credit 4
3010-455 Software Requirements & Specification
In-depth coverage of the early phases of the software development life cycle commonly called software requirements analysis and specification. Topics include requirements elicitation and definition, requirements prototyping, functional and nonfunctional requirements specification, and legacy systems. Team projects are emphasized. (3010-420, 3010-440) Class 4, Credit 4
3010-456 Software Engineering Process
Introduction to software engineering process and related project management issues. Topics include software maturity framework, software process assessment, software process and the software life cycle, issues in software project management and control, and measurements related to the software process. (3010-440) Class 4, Credit 4
3010-561 Software Engineering Project I
The first course in a two-course, senior-level, capstone project experience. Students work as part of a team to develop solutions to problems posed by either internal or external customers. Problems may require considerable software development or evolution and maintenance of existing software products. Culminates with the completion and presentation of the first major increment of the project solution. Class time is divided among lectures on contemporary issues in software engineering, guest lectures by industry practitioners and time devoted to team-based activities. (Senior-level standing in software engineering) Class 4, Credit 4
3010-562 Software Engineering Project II
The second course in a two-course, senior-level, capstone project experience. Students submit one or more additional increments that build upon the solution submitted at the end of the first course. Students make major presentations for both customers as well as technical-oriented audiences, turn over a complete portfolio of project-related artifacts and offer an evaluation of the project and team experience. (3010-561) Class 4, Credit 4
Stevens Institute of Technology (SIT)
[www.stevens-tech.edu]
CS 608 Mathematical Foundations of Software Engineering
The course studies professional and equational logic and their uses in the specification and verification of programs. The student will become proficient in software specification and design. Topics: substitution, equality and assignment; Boolean logic, proof styles, truth functional connectives; and, or implies, equivalence. Satisfiability, validity, counter-examples; predicate logic; axioms for quantification. Prerequisite: Ma 502.
CS 621 Analysis and Design of Real-Time Systems
An introduction to the design methodologies and considerations for embedded and organic real time systems. Review of available hardware technologies, throughput analysis, hardware/software tradeoffs. Analysis of language issues arising in real time systems. Design of real-time kernels, context switching, memory allocation and scheduling. Real-time data structures. Analysis of time/memory loading, latency issues, data freshness. Exception detection and handling. A programming project or case
study is required. Prerequisites: CS 605, CS 514. Cross-listed with CpE 621.
CS 640 Software Engineering I
This course covers the principles and theory of programming-in-the-large. The phases of software development, requirements development, software design, software coding, and module testing, and software verification will be discussed in detail. Documents, rapid phototyping, top down, bottom up, successive refinement, functional and data abstraction will be discussed. Black and white box testing methods will be covered. Hierarchical and democratic term organization structures and the effects of personalizing and group dynamics will be discussed. Prerequisite: CS 590. Cross-listed with CpE 640.
CS 642 Software Engineering II
The course will be built around a small number of detailed case studies. The intent is to illustrate the use of some methodologies for software development using both state-of-the art approaches as well as potentially more valuable but as yet unproven approaches from the research community. The course will cover the phases of requirement development, system specification, design, implementation, testing, and project management. Prerequisite: CS 640. Cross-listed with CpE 642.
CS 643 Formal Verification of Software
Formal systems for specification and verification of software; Review of the first-order predicate calculus; Abstract data types, formal specification, preconditions, postconditions, invariants, predicate transformers, proofs of correctness, partial and total correctness; Correctness for assignments, alternatives, iterations, procedure calls. Prerequisite: CS 640.
CS 674 Theory of Object-Oriented Software Design
Theory of object-oriented design, classes, interfaces, inheritance hierarchy, correctness; Abstract data types, encapsulation, formal specification with preconditions, postconditions, and invariants, proofs of correctness; Object-oriented software, objects and classes, genericity, inheritance, polymorphism, overloading; Single and multiple inheritance, programming by contract, subclassing as subcontract, specification and verification; Programming language examples include C++, Java, Smalltalk, and Eiffel. Prerequisite: CS 590 or equivalent.
CS 681 Software Engineering with Ada
Data abstraction, exception handling, and concurrency are all of fundamental importance to the design and maintenance of software systems. This course covers these principles from the perspective of the programming language Ada and modern object based programming style. Topics included: data encapsulation, packages and generic packages. The notion of object. Array types, parameterized types data abstraction, packages and generics, exceptions, exception handling, function parameters and numerics, type abstraction, recursive data structures, generic procedures. The organization of project libraries. Separate compilation issues. Interrupts and low level
I/O, distributed programming and static object-oriented programming, parallel computation with tasking. The rendezvous, priority scheduling and queuing delays. The notion of active objects with the Ada tasking model. Prerequisite: CS 640.
CS 684 Software Requirements Analysis and Specification
This course introduces students to the requirements definition phase of software development. It will discuss models, notations, and processes for software requirements identification, representation, validation and analysis. An important component is a group project: the software requirements specification of a large software system.
CS 686 Software Architecture and Design
To introduce students to the software design process and its models, representations of designing/architecture, software architectures and design plans, design method, design state assessment, design quality assurance, design verification.
CS 688 Software Testing, Quality Assurance, and Maintenance
To introduce students to systematic testing of software systems, software verification, symbolic execution, software debugging, quality assurance, measurement and prediction of software reliability, project management, software maintenance, software reuse, reverse engineering.
CS 692 Software Project
The capstone course for the Master of Science in Software Engineering program. Each student will work on a large software project in a group, using methodologies learned in CS 684, CS 686 and CS 688.
Texas Tech University (TTU)
[www.cs.ttu.edu/grad/msse.html]
+CS 5355. Real Time and Time Sharing Systems (3:3:0). Prerequisite: C S 2350, 3352, and 5364.
Study of the functional needs in real time and time sharing systems. Basic techniques and display concepts, random-access fields, computer networks, simultaneous operations, multiprogramming, and multiprocessing.
[ASYN]
+CS 5358. Software Studio I (3:3:0). Prerequisite: C S 5362 and 5363
Capstone design and implementation experience of a major software project applying comprehensive software engineering techniques.
[MIX]
+CS 5359. Software Studio II (3:3:0). Prerequisite: C S 5358
A continuation of software engineering projects begun in C S 5358.
[MIX]
+CS 5360. Software Construction and Evolution (3:3:0). Prerequisite: C S 5362, 5363, and 5364
Theory and practice of the construction, testing, and maintenance of software. Emphasis placed on techniques to evolve software over time to meet the changing needs of users during the life of the software.
[ASYN]
+CS 5361. Theory of Computing Languages (3:3:0). Prerequisite: C S 3461 and 3383, equivalent, or consent of instructor
General language theory with emphasis on computing languages, Chomsky typology, syntactical and semantic specifications. Standard and experimental methods for specification of languages. Current research on translation of natural language instructions to machine instructions.
[ASYN]
+CS 5362. Software Specification and Design (3:3:0). Prerequisite: C S 2365, equivalent, or consent of instructor
Examination of the development of the specifications, architecture, and design of software. Analysis, software architecture, design patterns, architectural design and detailed design.
[ASYN]
+CS 5363. Software Project Management (3:3:0), Prerequisite: C S 2365, equivalent, or consent of instructor
Methodologies for the management of projects involving software components. The larger context of systems development is studied, along with business management and engineering principles. Technical as well as people issues are explored.
[ASYN]
+CS 5364. Software Metrics (3:3:0). Prerequisite: C S 2365, I E 3341, equivalent or consent of instructor.
In-depth study of the use and application of software measurement to improve software products, resources, and processes. Topics include investigative techniques, data collection, and analysis.
[ASYN]
+CS 5365. Principles of Multiple-Processor Systems (3:3:0). Prerequisite: C S 3375, equivalent, or consent of instructor
Comprehensive introduction to the field of parallel and distributed computing systems. Algorithms, architectures, networks, systems. Theory and applications.
[ASYN]
*CS 5366. Software Process Improvement (3:3:0). Corequisite: C S 5363 and 5364
Theory and practice for software process improvement and certification at the organizational, project team, and individual level. CS
[ASYN]
+CS 5369 Web-Based Software Systems (3:3:0). Prerequisite: CS 2365, equivalent, or consent of instructor.
In-depth study of how to engineer web-based software systems. Topics include process, development, testing, and performance issues.
[ASYN]
University of Michigan-Dearborn (UMD)
[www.engin.umd.umich.edu/CIS]
CS 375 Introduction to Software Engineering
Prerequisite: CIS 350 or equivalent. (3).
This course presents an indepth treatment of many software engineering topics including: software engineering paradigms, requirements specification, functional design, object-oriented design, software verification, and maintenance. Comprehensive discussion of human-computer interaction and user interface design.
CIS 376 Advanced Software Engineering.
Prerequisite: CIS 375. (3).
This course continues the formal development of the software engineering material begun in CIS 375. Topics covered include: personal software process, team software process, formal methods, human computer interaction, security, software architecture, software reliability,and use of CASE tools.
CIS 475 Software Engineering Seminar.
Prerequisite: CIS 375. (3).
The focus of this course is on management issues related to modern software engineering practice. Students read and discuss papers written by master software engineering professionals. Seminar topics discussed include: management of software engineering processes,software measurement, software engineering ethics, and legal issues related to professional practice.
+CIS 525 Multimedia Web Design
Prerequisite: CIS 553 or equivalent (3).
This course deals with the study of technologies used to design and implement multimedia web sites. The focus of the courses will be hands-on development of commercial web-based applications. Students will study a variety of software technologies relevant to web design and implementation. Several applied topics are covered: programming languages, scripting langauges, network programming, client/server computing, security, and multimedia systems design.
[ASYN]
+CIS 532 Analysis and Design of Algorithms
Formal languages / grammars and the Chomsky hierarchy, computability and intractability, Church-Turing hypothesis, push-down automata and Turing machines, overview of sequential machines, application of formal languages to compiler construction.
CIS 550 Foundations of Object-Oriented Computing
This course covers foundations of object-oriented computing in which objects and nets play the fundamental role. Objects generalize primitive and abstract data types processes and are considered in the algebraic framework. For the coordination of objects, the object-net methodology is introduced and examined in the categorical framework.
+CIS 553 Software Engineering
Software engineering characterizes software production and maintenance as a process to be managed. A software process includes specification, design, verification and testing, and maintenance over a lifecycle. Related topics include metrics, design reuse, techniques for quality improvement and project management, software reliability and fault tolerance. Overview of discipline, from needs assessment to retirement. Role of software engineering in future. Impact on other industries.
CIS 565 Software Quality Assurance
Focuses on the processes, methods and techniques for developing quality software, for assessing software quality, and for maintaining the quality of software. Software testing at the unit, module, subsystem and system levels, automatic and manual techniques for generating and validating test data, the testing process, static vs. dynamic analysis, functional testing, inspections and reliability assessment. Tradeoffs between software cost, schedule, time, and quality, integration of quality into the software development process as well as the principles of test planning and test execution.
CIS 567 Formal Methods in Software Engineering
The course covers the different formal mechanisms for specifying, validating and verifying software systems. Topics include: program verification through Hoare's method and Dijkstra's weakest precondition, formal specification via algebraic specifications and abstract model specifications, including initial specification and refinement towards implementation, integration of formal methods with existing programming languages, and the application of formal methods for requirement analysis, testing, safety analysis and object oriented approaches.
CIS 573 Software Reliability and Safety
Importance of reliability for current and future software systems. Safety criteria hazard analysis and risk analysis. Analysis, design, verification and validation of mission and safety critical systems. Safety critical hardware and software. Measurements of reliability (MTTF, MTTR, defects/KLOC). Techniques to increase reliability and safety: Petri nets, formal methods, component reuse, proofs of correctness. Verification and validation, certification. Safety and security.
+CIS 575 Software Engineering Management
Quantitative models of the software lifecycle; cost effectiveness; uncertainty and risk analysis; planning and modeling a software project; software cost estimation (COCOMO, Function points); software engineering metrics; software project documentation. Special emphasis on emerging software process standards such as the Capability Maturity Model of the Software Engineering Institute, and other international ones.
*CIS 577 User Interface Analysis and Design
Current theory and design techniques concerning how user interface for computer systems should be designed to be easy to learn and use. Focus on cognitive factors, such as the amount of learning required, and the information-processing load imposed on the user. Emphasis will be on integrating multimedia in the user interface.
[ASYN]
CIS 580 CASE Tools Evaluation
Study of computer aided software-engineering tools. Both commercial products and research prototypes will be investigated. Analysis of the tools, what features are useful, and what are lacking, how they help in the different stages of the software development life cycle.
+CIS 587 Computer Game Design
This course deals with the study of the technology, science and art involved in the creation of computer games. The focus of the course will be hands-on development of computer games. Students will study a variety of software technologies relevant to languages, operating systems, file systems, networks, simulation engines, and multi-media design systems. Lecture and discussion topics will be taken from several areas of computer science simulation modeling, real-time processing, game theory, software engineering, human-computer interaction, graphic design, and game aesthetics.
[ASYN]
CIS 695/ECE 695 Case Studies and Projects
Application of the methodologies, tools, and theory of software engineering to produce a specific validated software product. Projects can be faculty generated, self generated, and/or work related. All projects must be undertaken with one or more students under the supervision of the instructor. Prior to enrollment, a project proposal must be prepared and approved by the instructor and department chair. Standard software engineering documents must be prepared and approved at each phase of the project, and an oral presentation of the project is required. Course includes lectures and case studies.
ECE 553 Software and Hardware for Rapid Prototyping Applications
Rapid prototyping technology is primarily aimed at reducing the lead times and costs associated with new product development. Rapid prototyping requires a good quality 3D CAD system. This course will cover the software and hardware widely used in the rapid prototyping including Stereolithography (SLA) and virtual reality software and hardware used for rapid prototyping.
ECE 573 Embedded Systems
Survey of real time, sampled data systems, and embedded applications, e.g., digital controllers, fuzzy logic and neural networks, diagnostic systems. Principles and characteristics of sensors and devices; embedded microprocessors; processor/device interfaces; time critical I/O handling; data communications in embedded environments. Overview of embedded operating systems, cross development techniques and tools. Design of real time systems with micro-controllers such as the 68HC11 and 68332. Object oriented software development, using both assembly language and high level languages. Project oriented course.
ECE 574 Advanced Software Techniques in Engineering Applications
Graduate level introduction to data structures, high-level engineering analysis languages, hardware description languages, and algorithm complexity analysis, engineering applications.
ECE 576 Information Engineering
This course will cover the fundamental concepts of information engineering including computation, storage, communication, and application. Examples of topics are multimedia data such as video, audio, image and text, multimedia transmission through local and wide area networks, multimedia data representation, storage and compression. Information engineering applications will be discussed and students are expected to complete a project in a selected application.
University Of Ottawa [Undergraduate] (OTTAWA]
[www.site.uottawa.ca/school/ugrad]
SEG 2100. Software Design II (3,0,3) 4 cr.
Analysis, design and programming of software systems using selected object-oriented programming languages, reusable libraries and toolsets. API's. Design using user interface construction tools. Analysis, design and programming of simple servers and clients. Prerequisites:
CSI1101 or CSI1102
SEG 2101. Software Design III (3,0,3) 4 cr.
State-transition based software design. Experience in the use of industrial-strength design toolsets. BNF and basic theory of grammars and parsing. Use of parser generators. Design of simple languages for applications and programming languages. Overview of design of software using functional or logic-based programming paradigms. Introduction to basic concurrent and parallel architectures. Prerequisite: SEG2100
SEG 2500. Conception de logiciels II (3,0,3) 4 cr.
Analyse, conception et programmation de systèmes informatiques avec des langages de programmation par objet, des bibliothèques de logiciels réutilisables et des boîtes d'outils. Interfaces de programmation. Conception utilisant des outils de création d'interfaces usager. Analyse, conception et programmation de serveurs et clients simples. Préalables : CSI1501 ou CSI1502
SEG 2501. Conception de logiciels III (3,0,3) 4 cr.
Conception de systèmes informatiques par transitions d'états. Utilisation d'outils de développement industriels. BNF et théorie de base des grammaires et de l'analyse syntaxique. Utilisation de générateurs d'analyseurs syntaxiques. Conception de langages d'application et de langages de programmation simples. Introduction à la conception de logiciels selon les paradigmes de programmation fonctionnelle et logique. Introduction aux architectures concourantes et aux programmations parallèles. Préalable : SEG2500
SEG 2910. Pratique de la profession d'ingénieur logiciel (1,0,0) 1 cr.
Principes de professionnalisme et d'éthique professionnelle dans la pratique de l'ingénieur logiciel, incluant ses obligations envers la société et l'environnement.
Professional Software Engineering Practice
Principles of professional software engineering practice and ethics, societal and environmental obligations of the software engineer.
SEG 3100. Software Development for Large-Scale Systems (3,0,3) 4 cr.
The software development life cycle. Introduction to software project management: cost estimation and project planning. Software specification and requirements analysis. Comparison of software architectures. Design principles such as coupling and cohesion. Introduction to software metrics. Software quality assurance strategies: the personal-software process, reviews, testing and inspections. Assessing software designs for safety, security, performance and economic viability. Use of static and dynamic analysis
tools. Prerequisites: SEG2101 or SEG3300
SEG 3110. Advanced Object Oriented Analysis and Design (3,0,3) 4 cr.
Advanced approaches to object oriented analysis and design. Frameworks and design patterns. Design for reusability. Advanced object oriented programming techniques. Design using object oriented databases and distributed object architectures. Design of software agents. Project involving object oriented analysis, design and implementation. Prerequisites: SEG3100 or SEG3310, CSI3317
SEG 3120. Analysis and Design of User Interfaces (3,0,3) 4 cr.
Psychological principles of human-computer interaction. Evaluation of user interfaces. Usability engineering. Task analysis, user-centred design and prototyping. Conceptual models and metaphors. Software design rationale. Design of windows, menus and commands. Voice and natural language I/O. Response time and feedback. Colour, icons and sound. Internationalization and localization. User interface architectures and APIs. Case studies and project. Prerequisites: (SEG3100 or SEG3300) and (MAT2377
or MAT2375)
SEG 3150. Telecommunications Software Engineering (3,0,3) 4 cr.
Principles of information transfer. Error control, flow control, congestion control, routing algorithms. Principles of telecommunications system software design and analysis. Prerequisites: MAT2343, SEG2101, CSI2114, ELG3300
SEG 3300. Introduction to Software Engineering (3,0,0) 3 cr.
The software development life cycle. Project management issues. Software specification and requirements analysis. Software design techniques. Cost estimation. Software metrics. Software testing strategies. Software maintenance. Prerequisites: CSI2115 or CSI3125
SEG 3310. Object-Oriented Analysis, Design and Programming (3,0,1.5) 3 cr.
Quality criteria for modular design. Subtyping and inheritance. Object-oriented analysis, object-oriented modelling and design. Object-oriented programming methodology. Object repositories and reuse. Prerequisites: CSI3125 or CSI2115 or SEG2101
SEG 3500. Développement de systèmes informatiques de taille industrielle (3,0,3) 4 cr.
Le cycle de vie d'un logiciel. Introduction à la gestion de projets informatiques: estimation des coûts et planification de projets. Spécification de logiciels et analyse des besoins. Comparaison d'architectures logicielles. Principes de conception tels que couplage et cohésion. Introduction aux métriques du logiciel. Stratégies de garantie de qualité: processus personnel de développement de logiciels
(PSP), examen, test et inspections. Évaluation des qualités concernant la sécurité, la performance et la viabilité économique. Utilisation d'outils d'analyse statiques et dynamiques. Préalables : SEG2501 ou SEG3700
SEG 3510. Concepts avancés en programmation orientée objet (3,0,3) 4 cr.
Approches approfondies pour l'analyse et la conception orientées objet. Cadres et modèles. Conception en vue de la réutilisation. Techniques de programmation avancées. Conception utilisant les bases de données orientées objet et les architectures d'objets distribués. Agents logiciels. Projet. Préalables : SEG3500 ou SEG3710, CSI3717
SEG 3520. Conception et analyse des interfaces usagers (3,0,3) 4 cr.
Principes psychologiques de l'interaction humains-machines. Évaluation des interfaces, utilisabilité. Analyse des tâches. Conception basée sur l'utilisation. Prototypage, modèles conceptuels et métaphores. Rationalisation. Conception de fenêtres, menus et commandes. Entrées naturelles, temps de réponse et rétroactions. Couleurs, icônes, sons. Localisation et internationalisation. Architectures et bibliothèques d'application. Projet et études de cas. Préalables : (SEG3500 ou SEG3700) et (MAT2775 ou MAT2777)
SEG 3550. Génie des logiciels de télécommunication (3,0,3) 4 cr.
Principes de transport de l'information. Contrôle d'erreur, contrôle de flux, contrôle de congestion, algorithmes de routage. Principes de conception et d'analyse des logiciels pour les systèmes de télécommunications. Préalables : MAT2743, SEG2501, CSI2514, ELG3700
SEG 3700. Introduction au génie logiciel (3,0,0) 3 cr.
Cycle de développement de logiciels. Gestion de projet. Estimation des coûts. Métrique des logiciels. Spécifications des logiciels et analyse des besoins. Techniques de conception de logiciels. Stratégies de test. Maintenance des logiciels. Préalables : CSI3525 ou CSI2515
SEG 3710. Analyse, conception et programmation orientée objet (3,0,1.5) 3 cr.
Critères de qualité pour la conception modulaire. Hiérarchies de types et héritage. Analyse orientée objet; modélisation et conception orientée objet. Méthodologie de programmation orientée objet. Archives d'objets et réutilisation. Préalables : CSI2515 ou CSI3525 ou SEG2501

SEG 4100. Software Project Management (3,0,3) 4 cr.
Advanced project planning, cost estimation and scheduling. Project management tools. Factors influencing productivity and success. Productivity metrics. Analysis of options and risk. Planning for change. Managing expectations. Software contracts and intellectual property. Case studies. Project involving forensic project management of a real industrial project. Prerequisites: SEG3100 or SEG3300
SEG 4111. Software Quality Engineering (3,0,3) 4 cr.
Requirements gathering techniques. Formal approaches to specification of requirements. Use of specification languages and CASE tools to model requirements. Handling uncertain and changing requirements. Certification, verification and validation techniques. Advanced testing techniques. Statistical software reliability engineering. Project. Prerequisites: (SEG3100 or SEG3300), MAT2343 and (MAT2375 or MAT2377)
SEG 4115. Software Evolution and Reengineering (3,0,3) 4 cr.
Maintainability and reusability analysis. Approaches to maintenance and long-term software development. Change management and impact analysis. Release and configuration management. Software metrics. Software process standards. Reengineering and reverse engineering. Regression testing. Case studies and project in analysis and iterative development of existing large systems. Prerequisite: SEG3100 or SEG3300
SEG 4155. Telecommunications Software Design and Analysis (3,0,3) 4 cr.
Formal models for telecommunications software design and analysis. Protocol specification, design and validation. Protocol verification and testing. Conformance testing. Protocol synthesis. Protocol conversion. Prerequisite: SEG3150
SEG 4500. Gestion des projets (3,0,3) 4 cr.
Notions avancées de planification de projet, estimation des coûts et délais. Outils de gestion de projet. Facteurs influençant la productivité et le succès. Mesures de productivité. Analyse des options et des risques. Planification des changements. Gestion des attentes. Contrats de développement de logiciel et propriété intellectuelle. Études de cas. Diagnostic d'un projet industriel réel. Préalable : SEG3500 ou SEG3700
SEG 4511. Contrôle de qualité des logiciels (3,0,3) 4 cr.
Techniques d'obtention de besoins. Approches formelles pour la spécification de besoins. Utilisation de langages de spécification et d'outils de conception de logiciels. Le traitement de besoins imprécis et changeants. Techniques pour la certification, la vérification et la validation de logiciels. Techniques de test avancées. Ingénierie statistique de la fiabilité de logiciels. Projet. Préalables : (SEG3500 ou SEG3700), MAT2743 et (MAT2775 ou MAT2777)
SEG 4515. Évolution et reconception de logiciels (3,0,3) 4 cr.
Analyse de maintenabilité et de réutilisabilité. Approches pour la maintenance et le développement à long terme de logiciels. Gestion du changement et analyse d'impact. Gestion de la mise en exploitation et de la configuration de systèmes. Métriques du logiciel. Standards du processus de développement de logiciel. Ré-ingénierie et rétro- ingénierie. Tests de régression. Études de cas et projet en analyse et développement itératif de gros systèmes existants. Préalables : SEG3500 ou SEG3700
SEG 4555. Conception et analyse de logiciels de télécommunications (3,0,3) 4 cr.
Modèles théoriques pour la conception et l'analyse de logiciels de télécommunications. Spécification, conception et validation de protocoles. Vérification et test de protocoles. Test de conformité. Synthèse et transformation de protocoles. Préalable : SEG3550
SEG 4900. Projet en génie logiciel (3,0,3) 4 cr.
Programme intégré de séminaires dans différents domaines du génie logiciel; préparation et la présentation de projets développés par groupes sous la supervision d'un ingénieur informaticien (du corps professoral ou de l'industrie). Le responsable ultime est un professeur. Le choix des projets se fait au début de l'automne. Les étudiants doivent soumettre à des dates précises: a) un plan de projet avec une estimation des coûts, b) les besoins, spécifications et ou prototypes du système, c) un rapport sur la conception et l'implantation et d) un rapport sur les garanties de qualité. Préalables : SEG3510, SEG3520
Software Engineering Project
An integrated program of lectures by invited speakers active in software engineering, and the preparation and presentation of projects. Projects are performed in teams under the direction of an experienced software engineer (from the faculty or from industry). Ultimate direction is by a faculty member. Project selection is done in the early fall. At specific dates during the year, students are required to submit: a) A project plan with a cost estimation; b) requirements, specifications and or prototypes; c) A design and implementation report; d) A quality assurance report. Prerequisites: SEG3110, SEG3120
CSI 5107 (95.569) PROGRAM CONSTRUCTION AND FAULT TOLERANCE (3 cr.)(T, E)
Mathematics for program construction and fault tolerance. Program construction by relational decomposition: the equations and the heuristics. Fundamentals of program fault tolerance. Implementing error detection and damage assessment. Forward and backward error recovery. Hybrid program validation.
CSI 5109 (95.571) SPECIFICATION METHODS FOR DISTRIBUTED SYSTEMS (3 cr.) (E, S)
Concepts of process algebras, especially with relation to the specification language LOTOS. Equivalence concepts: observation equivalence, testing equivalence. Data algebras. Rewriting systems. Verification of specifications. Specifications styles. Applications to distributed systems: communications protocols, telephone systems. Related models CSP, CCS, ACP. Relation to temporal logic and model checking.
CSI 5111 (95.551) SOFTWARE QUALITY ENGINEERING (3 cr.) (E)
Software quality issues. Quality components and metrics. Software process quality. Software reliability engineering. Software design for testability. Requirements capture and validation. Systematic design validation; grey-box approach. Test design, implementation, and management. Case studies in validation and verification of communications software. Object-oriented design and test. Theoretical aspects.
CSI 5112 (94.480) SOFTWARE ENGINEERING (3 cr.) (E)
Topics of current interest in Software Engineering, such as software development systems, structured systems analysis and design, management of software, software tools, validation and verification, programming environments.
CSI 5118 (95.532) AUTOMATED VERIFICATION AND VALIDATION OF SOFTWARE 3 cr. (E)
Topics in formal test derivation methods, test management, high-level, CASE-based verification and validation, data-flow & control-flow measures and metrics for assessing quality of designs and code, regression analysis & testing. Prerequisite: a four-year undergraduate degree in computer science, computer engineering, or software engineering.
CSI 5122 (95.531) SOFTWARE USABILITY 3 cr. (E)
Design principles and metrics for usability. Qualitative and quantitative methods for the evaluation of software system usability: Heuristic evaluation, usability testing, usability inspections and walkthroughs, cognitive walkthroughs, formal usability experimentation. Ethical concerns when performing studies with test users. Economics of usability. Integration of usability engineering into the software engineering lifecycle.
CSI 5184 (95.584) LOGIC PROGRAMMING (3 cr.) (E)
Review of Logic Programming (LP) as a foundation of fifth generation software. Two approaches to LP: automated deduction and procedural semantics. Software development methodology in the LP framework. Advanced Prolog programming. Implementations of LP. The course includes a programming project and a presentation.
CSI 5310 (95.540) SOFTWARE PATTERNS (3 cr.) (E)
Survey of current developments in software patterns, three-part rules expressing relations between software contexts, problems and solutions. Discussion of Pattern categories: architectural, design, analysis, refactoring, general-purpose, anti-patterns, and idioms. Students required to apply existing patterns and to develop and defend new ones. Prerequisites: 95.304 or CSI 3300 or equivalent.
CSI 5507 (95.569) LES PROGRAMMES : CONSTRUCTION ET TOLÉRANCE AUX FAUTES (3 cr.) (T,E)
Mathématiques pour la construction de programmes et pour la tolérance aux fautes. Construction de programmes par décomposition relationnelle : les équations et les heuristiques. Fondements de la tolérance aux fautes des programmes. Mise en oeuvre de la détection d'erreurs et de l'évaluation de la contamination. Recouvrement avant et recouvrement arrière des erreurs. Validation hybride de programmes.
CSI 5509 (95.571) MÉTHODES POUR LA SPÉCIFICATION DE SYSTÈMES RÉPARTIS (3 cr.) (E,S)
Algèbres de processus, surtout par rapport au langage de spécification LOTOS. Concepts d'équivalence: équivalence d'observation, équivalence de test. Algèbres de données. Systèmes de récriture. Vérification de spécifications. Styles de spécification. Applications à systèmes répartis: protocoles de communication, systèmes téléphoniques. Modèles reliés: CSP, CCS, ACP. Relations avec logique temporelle et contrôle de modèle.
CSI 5511 (95.551) GÉNIE DE LA QUALITÉ DES LOGICIELS (3 cr.) (E)
Critères de la qualité des logiciels. Composantes et métriques de qualité. Qualité du processus de développement des logiciels. Génie de fiabilité des logiciels. Capture et validation d'exigences. Validation systématique de la conception; approche boîte-grise. Conception, implantation et gestion des tests. Étude de cas en validation et vérification des logiciels de communication. Conception orientée objet. Aspects théoriques.
CSI 5584 (95.584) PROGRAMMATION LOGIQUE (3 cr.) (E)
Revue de programmation logique (PL) comme base du logiciel de la 5e génération des ordinateurs. Deux approches à la PL : déduction automatique ou sémantique procédurale. Méthodologie du développement du logiciel dans le cadre de PL. Concepts avancés de programmation en PROLOG. Implantation de PL. Le cours comprend le développement et la présentation d'un projet.

.