OMSE Curriculum: Courses

OMSE offers three program options:
To take any OMSE course you must have successfully completed a bachelor's degree from an accredited North American university, or equivalent institution, and have at least two years of directly related software development experience.

The Certificate in Software Engineering is earned by successfully completing the following:

Tier 1 courses taken to earn the certificate may be applied for credit towards the masters degree. A student can earn both the certificate and the masters degree.

The Master of Software Engineering graduate degree is earned by successfully completing:

Students are required to complete all Tier 1 and Tier 2 courses before taking any Tier 3 courses. To register in Tier 2 courses, the student must demonstrate that they satisfy pre-requisite learning normally attained through undergraduate computing and software foundation courses - more specifically, computer architecture, operating systems, data structures, and discrete mathematics. Should the student be missing some of these pre-requisites, OMSE offers two foundation courses that satisfy these requirements and may be counted as elective credits.

We strongly recommend that students take OMSE 500, Principles of Software Engineering, as their first OMSE course.

Expectations, conditions and rationale associated with these courses are outlined below.
(Formal course descriptions are listed in the Portland State University bulletin.)

Tier 1 Courses

Courses
Successful completion all five (5) Tier 1 courses (OMSE 500, 511, 513, 525 and 531) qualify the student for the Graduate Certificate in Software Engineering.

OMSE 500, Principles of Software Engineering
(First course in the OMSE program.)
Current Syllabus Previous Syllabus

Course rationale: Everyone knows that software projects run notoriously behind schedule and over budget. Many clever, intelligent software professionals have tried different models over the last twenty years in an attempt to make software development more predictable and controllable. While no "silver bullet" has emerged, much has been learned that can directly benefit today's software projects.
What to expect: You will study alternative software development models and processes. This course will cover the actual benefits of these models and processes as well as the problems that can arise. You will learn how to choose appropriate models for actual projects and then customize the processes to produce the best combination of control, quality, and rapid product development. You will also consider how software processes can be reviewed and improved on a continuous basis using improvement models such as the Software Engineering Institute's Software Capability Maturity Model, their Integrated Maturity Model, and the ISO SPICE Model.

OMSE 511, Managing Software Development
Current Syllabus Previous Syllabus

Course rationale: Software projects can fail because of poor management—a very real pitfall in software development. Often the success of a software project has more to do with the way it's organized than the technical challenges. Specific management techniques must be combined with good technical knowledge to raise a project’s chance for success.
What to expect: Focuses on the knowledge and skills you need to plan, organize, lead, and control a software project. A key theme of the course is achieving results in environments that include a great deal of ambiguity and contradictory information—familiar environments if you have been involved in any software development projects. You will learn seven essential skills for successfully managing a software development project: (1) anticipate problems, (2) choose and tailor development models, (3) explain the trade-offs, (4) apply software estimation tools, ( 5) specify a measurement program, (6) apply leadership principles, and (7) write a software project management plan. Armed with these skills, you should be able to confidently handle any software project that you encounter.

OMSE 513, Professional Communication Skills for Software Engineers
Current Syllabus
Previous Syllabus

Course rationale: Poor communications among other things can lead to the failure of a software project (OMSE 511 covers how to avoid the pitfall of poor management). Software engineers must learn to communicate effectively if they want to increase their project's odds for success.
What to expect: Examines the leadership skills that make all the difference when software is developed by a team. Using individual assignments and group projects, you will learn the skills you need to make effective presentations and write persuasive proposals. You will also learn the skills you need to (1) conduct efficient meetings (keep everyone focused), (2) resolve disputes (be a good listener), (3) work successfully in a team environment (suppress the urge to dominate), and (4) make ethical decisions when faced with conflicting goals (be true to personal values).

OMSE 525, Software Quality Analysis
Current Syllabus
Previous Syllabus

Course rationale: Software delivery cycles are accelerating, and increasingly systems are developed under strict deadlines with a "design to schedule" approach—a rather scary thought. This often leads to relegating quality assurance to a testing phase at the end of development, which results in unpredictable schedules and poor quality in delivered products.
What to expect: This course emphasizes software quality engineering as an integral facet of development, from requirements through delivery, maintenance, and process improvement. You will learn how to choose appropriate quality goals at the outset of a project and select, plan, and execute quality assurance activities throughout development and evolution to predictably meet quality and schedule goals. You will learn how to carry out inspections, manual and automated static analysis techniques, design for testability, and test planning and execution. You will also learn how quality assurance can be incorporated into process improvement feedback loops that amplify the ability of an organization to cost-effectively prevent and detect faults.

OMSE 531, Software Requirements Engineering
Current Syllabus Previous Syllabus

Course rationale: The engineers who develop software and the people who use it usually have different backgrounds and perspectives. Developers and users may speak the same language, but often their words don't have a common meaning. These differences often lead to "good" software that does not do what the users really wanted or needed.
What to expect: Presents the principles, tools, and techniques for requirements elicitation, specification, and analysis. You will learn the (1) role of requirements in system development and maintenance, (2) goals of the requirements phase, (3) essential difficulties of specifying requirements, (4) effective methods, tools and techniques, (5) techniques for formally modeling and specifying software requirements, and (6) the role of prototyping in validating requirements.

Tier 2 Courses

The pre-requisites for all five (5) Tier 2 courses (OMSE 521, 522, 532, 533 and 535) include computing and software foundations normally earned in an undergraduate CS, ECE or similar program.

OMSE 521, Using Metrics and Models to Support Quantitative Decision Making
Current Syllabus
Previous Syllabus

Course rationale: Developing software involves making hundreds, perhaps thousands, of decisions. We are often forced to make these decisions purely based on hunches and rules of thumb. Unfortunately, business roadsides are cluttered with the bodies of software developers whose hunches and rules of thumb didn't keep them ahead of their competition.
What to expect: This course will cover how metrics can be combined with formalized decision models to support decision-making by software project leaders and managers. It provides the knowledge and skills needed to apply quantitative tools to make decisions in situations where a great deal of uncertainty exists. You will learn to recognize decision-making opportunities in the software development process, and be equipped to address them in a scientific, organized manner using all appropriate information sources.

OMSE 522, Modeling and Analysis of Software Systems
Current Syllabus
Previous Syllabus

Course rationale: Software projects often fall short of their goals because the software developed can't be tested or doesn't deliver the features its users actually need. The source of these problems is usually a highly ambiguous or incomplete specification.
What to expect: Explains how abstract models can be used to set the specifications of software systems. Formalized reference specifications serve as a basis for the design of software implementations as well as validating critical properties of software systems. You will learn the fundamental mathematical concepts needed to understand abstract models of software and to reason about them by using examples. (And you thought you'd never use your abstract and applied math skills.)

OMSE 532, Software Architecture and Domain Analysis
Current Syllabus
Previous Syllabus

Course rationale: The quality of sophisticated software is only as good as the architecture that underlies it. (Remember the metaphor about building a house on unstable soil?) The investment your enterprise makes in software development will have a much greater long-term payback when domain analysis is performed to consider the needs of a family of problems rather than just the problem of the moment.
What to expect: Covers the principles and methods of the architectural design of complex software systems. You will study the (1) major architectural styles, (2) strengths and weaknesses of each style, (3) application of domain analysis, (4) impact of platform dependence and independence, (5) relation of software architecture to requirements, (6) domain analysis and the architectural design process, and (7) products in a real-world context.

OMSE 533, Software Design Techniques
Current Syllabus
Previous Syllabus

Course rationale: Most software engineers agree that the quality of a design determines the usability, reliability, and maintainability of the resulting software. Choosing the techniques that best fit the needs of the problem at hand can be quite challenging, however.
What to expect: This course will give you an understanding of some of the most flexible and useful design techniques, including structured design, state-based design, and object-oriented design. It will cover how software engineering principles are applied to make appropriate trade-offs between function, quality, cost, and schedule. As a good software engineer, these are techniques that should be part of your skill set.

OMSE 535, Software Implementation and Testing
Current Syllabus
Previous Syllabus

Course rationale: Once the requirements of a software project are determined and a good design is underway, attention must then turn to implementing and testing the actual software. The quality and the maintainability of the software are directly affected by the methods and techniques used both to implement the software and to find defects before release.
What to expect: Covers implementation and testing topics including (1)coding techniques and styles, (2) module packaging principles, (3) creating testable and maintainable code, (4) code reviews and inspections, (5)specification-based (black-box) testing and structural (clear box) testing, and (6) test planning, test tools, and test administration.

Tier 3 Courses

Only students admitted to the Master of Software Engineering program may enroll in Tier 3 courses (OMSE 551, 555 and 556).

OMSE 551, Strategic Software Engineering
Current Syllabus
Previous Syllabus

Course rationale: Where traditional software engineering focuses on the development of individual systems, strategic software engineering addresses the development of multiple systems over time. Recent work shows that significant gains in productivity, cost, and schedule can result from systematic improvement of the software development process and systematic reuse of life-cycle products. The moral: taking the bird’s eye instead of the worm’s eye view in software engineering pays big dividends.
What to expect: Introduces the principles, methods, and tools for strategic software development. The tools include (1) long-term process modeling and improvement, (2) developing programs as families of systems, (3) systematic approaches to code generation, and (4) the reuse of non-code products including requirements and design.

OMSE 555 & OMSE 556, Software Development Practicum I & II
Current Syllabus
Previous Syllabus

Course rationale: The objective of the practicum is to provide hands-on software engineering management and development experience applying the principles, methods, processes and tools learned from OMSE courses. The practicum is comprised of two parts and organized as two courses, OMSE 555 and OMSE 556 completed in sequence.
What to expect: Problems undertaken by student teams apply the practices learned throughout the program. Projects range from technical evaluations, analysis and specification, through architectural design to prototype development and testing. Every project involves applying best project management, quality assurance and configuration management practices. Software development artifacts created as part of the practicum experience become part of the student's professional portfolio.


Elective Courses

The full OMSE degree requires the completion of 3 elective courses. Electives must be graduate level 3-credit courses and must be approved by the OMSE program office in advance to registering. Electives that complement the student's current application or role in their current job or planned career will generally receive approval. Courses must not be equivalent or overlap to any significant degree with courses in the OMSE curriculum. In accordance with the policies above, OMSE foundation courses may be counted as electives.

Selected and Special Topics: Selected special topic courses are offered from time to time, typically during the summer terms. Special topics courses on Process Improvement and Best Practices have been offered in the past and will most likely be re-offered.

OMSE 510, Software Process Improvement

Course rationale: This course will show you how to effectively introduce software engineering principles into real-world organizations. It has been designed by an experienced SPI practitioner to help you successfully discover and improve software engineering practices within your organization.
What to expect: Technical issues are emphasized on an equal basis with real-world considerations like organizational politics, culture, and psychology. Major themes to be discussed include: How to effectively organize, plan, and implement organizational change; the roles and responsibilities of change sponsors and champions; how to discover and redesign software processes (e.g., postmortem assessments); how to tailor processes to fit circumstances (e.g., startups; global development; How to evaluate SPI tools and frameworks (e.g., XP; the CMMI; ISO SPICE); understanding organizational culture and the psychology of change.

OMSE 510, Software Engineering Best Practices

Course rationale: Best software engineering practices are those that have proven to consistently produce successful results when applied to a given set of problems. Proponents of various software engineering methodologies and tools boast about the benefits but rarely discuss which problems they best suit. And they offer little guidance on how to decide which practices to apply in a given situation, or how to tailor them. This is a project-oriented course designed to study this aspect of software engineering.
What to expect: Practices to be studied will be drawn from core OMSE courses. Candidates for study will be jointly selected by the instructor and students from requirements management, project management, architectural design, security engineering, software safety, and continuous integration and testing. Each student will be assigned a specific area and will report back to the class during each weekly session to stimulate wider discussion and feedback. The main goal will be to identify critical factors and evaluation criteria that should be reviewed when selecting and tailoring a given practice. Each student will submit a final report documenting their findings and recommendations.

Foundation Courses

OMSE foundation courses may be taken as electives and can count towards the master's degree in the following circumstances:
  • Conditional Admits: Students conditionally admitted to the full OMSE masters degree will be required to take one or both of the foundation courses below. For such students, these courses will count as 3-credit elective courses toward the OMSE master of Software Engineering degree.

  • Full Admits: Students fully admitted to the masters degree program without conditions and with OMSE program office permission, may be permitted to take one or both of the foundation courses below for credit as OMSE electives. Such permission may be granted to mature students who completed their undergraduate foundation courses some time ago and are able to provide rationale that these courses are critical to their development as professional software engineers in order to refresh or upgrade their foundation knowledge and skills.
OMSE 514, Computing Foundations

Course rationale: This course has been designed for graduate level students who are lacking key foundation computer science knowledge in the areas of computer architecture and operating systems.
What to expect: Students are first introduced to the building blocks of a basic computing machine including the central processing unit, data transfer buses, registers, program counters, various types of memories, and instructions sets. A range of processor architectures and organizations including pipelining, virtual memory and caching are discussed. The course then explores the principles of operating systems and how they relate to the underlying hardware structures. Concurrency, process synchronization, process scheduling, memory management, interrupt handling, and device management are also covered.

OMSE 515, Software Foundations

Course rationale: This course has been designed for graduate level students who are lacking key foundation computer science knowledge in the areas of data structures and discrete mathematics.
What to expect: Students are first introduced to fundamental language constructs such as pointers, recursion and abstraction, and then to the principles of algorithmic analysis and "Big-O" notation. They then progressively explore several foundation data structures and algorithms including linked lists, trees, hashing, and graphs. These are illustrated using C, C++, and Java code fragments. The second part of the course introduces discrete math including sets, set operations and related structures. The course then explores propositional calculus, first-order predicate calculus and finite state machines.

© 2007 Oregon Master of Software Engineering