Program Structure

The MSE is structured in two academic semesters (12 month). In each semester students attend the core MSE courses and the Studio. All core courses are structured around the Studio project, i.e. the topics covered are immediately applied or discussed in the context of the Studio (e.g. a requirements elicitation technique is used to gather requirements for the Studio project).

Master Program in Software Engineering

Syllabus for the core MSE courses:

The Studio

The Studio project is the backbone of the MSE program. We use a learning-by-doing approach, a.k.a. project-based learning where the core MSE courses topics are applied or discussed. This is a real-world project for an external client. Students are organized in teams larger than seven members (the magic number when informal structures became ineffective). Each team is mentored by 2-3 Studio mentors. The teams present their work to a larger audience, internal and external to the university, at the middle and end of each semester.

Software Engineering Bootcamp

Bootcamp is the only Studio topic during the first week of program. This is one of the few moments when students are requested to be physically on campus. The goal is for students and mentors to know each other before the Studio project starts. Since the MSE is at its core a remote team work, this contact is fundamental to create personal bonds. We present an overview of the course topics, perform team building activities and attend a workshop by invited guests. After the bootcamp week students should be able to identify processes within a software development project and factors that might affect those processes, understand and deal with software risks, assign roles and responsibilities within the team, know to properly plan the project, and have the ability to solve inter-personal conflicts. By the end of this topic the students have a team structured and the first contact with the Studio, presented by the external client.

Managing Software
Development (MSD)

After completing this course, students will be able to write a software project management plan, address 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 Integrated 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. Be able to 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, patenteability, 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, apply leadership principles and perform requirements elicitation. These topics are illustrated and discussed in the context of the Studio project.

Topics: MSD Introduction, Case Study Discussion, Software Development Lifecycles, Introduction to Processes & How to Choose, Process Assignment Review, Software Estimation Techniques, Wideband Delphi, Requirements Elicitation and Documentation, Managing Requirements Change, Managing Customer Expectations, Expectation Management Video and Discussion, Identifying and Managing Software Risk, The Risk Game, in class exercise, Planning Software Development: Tracking and Oversight of Software Development, Managing Technical People and leadership errors, Building Quality into Software Testing Strategies, Current topic on MSD (possibly an invited talk; otherwise Strategic Planning with Architecture), Reflection

Methods: designing what to design

The professional activity of software development requires an understanding of successful methods for bridging the gap between a problem to be solved and a working software system. In this course students will study a variety of techniques to understand the problem they’re solving, the various factors that constrain the possible solutions, and approaches to deciding among alternatives.

After completing this course, students will be able to:

Identify different classes of problems and their structures;
Analyse technical, organizational, usability, and business constraints on solutions;
Apply a sound engineering approach to frame solutions.

The different techniques are apllied for the requirements elicitation of the Studio project, thus providing different complementary perspectives of the problem to solve.

Topics: Course overview; Requirements Engineering; Contextual design; Use Cases; Usability issues; Business, economics, and policies impacting requirements; A framework for requirements technique selection.

Models of Software Systems (MoSS)

Scientific foundations for software engineering depend on the use of precise, abstract models and logics for characterizing and reasoning about properties of software systems. There are a number of basic models and logics that over time have proven to be particularly important and pervasive in the study of software systems. This course is concerned with that body of knowledge.

After completing this course, students will (i) understand the strengths and weaknesses of certain models and logics including state machines, algebraic and process models, and temporal logic, (ii) 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, and (iii) capably prove elementary properties about systems described by the models introduced in the course.

Topics: Introduction: what a model is. Foundations: logic; proof techniques; sets, relations, and functions; sequences. State machines; FSP; reasoning about state machines. Introduction to Z; Z techniques and examples; refinement and abstraction.
Introduction to concurrency; concurrent state machines; FSP modeling techniques; reasoning about concurrency. Linear Temporal Logic; automated reasoning. Formal methods in the real world; introduction to Petri Nets; reasoning about Petri Nets; UML.

Architectures for Software Systems (A4SS)

After completing this course, students will: be able to describe an architecture accurately; capably recognize major architectural styles in existing software systems; competently generate architectural alternatives for a problem, and choose among them; have the skills needed to construct a medium-sized software system that satisfies an architectural specification; capably 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 properties of those architectures; use domain knowledge to specialize an architecture for a particular family of applications.

A comprehensive description of the Studio project architecture is the major output of this course.

Topics: Course Overview and Software Architecture Defined; Architectural Drivers; Structures and Views; Dataflow Styles; Client-Server and Tiered Architectures; Middleware; Event Styles; Shared Information Styles; Middleware; Event Styles; Guidance for the Architect; Design by Selection; Architecture Evaluation; Strategic Reuse: Product Lines; ACDM; Documentation: Using UML for Design Representation; Formal Specification and Analysis; Architecture Conformance; Performance; Availability; SOA and Web Services; Security; Usability; Organizational Alignment; Global Distributed Development; Platforms; Research Directions.

Analysis of Software Artifacts (AoSA)

This course focuses on analysis of software artifacts, primarily code, but also including analysis of designs, architectures, and test suites. In order to illustrate core analysis concepts in some depth, the course targets static program analysis, but it also includes a breadth of techniques such as testing, model checking, theorem proving, dynamic analysis, and type systems. 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. The course balances theoretical discussions with exercises in which students apply the ideas they are learning to real artifacts of their Studio project.

Topics: Introduction to quality and verification; Inspection; Test domain modelling; Adequacy criteria; Structural testing; Combinatorial testing; Framework Design Presentations; Random & Mutation testing; Analysis; Formal verification; Architectural analysis / DSMs; Algorithm analysis and/or profiling; Queueing theory; Queueing theory exercise / Security.

Communication for Software Engineers

This is a set of contents delivered ‘just-in-time’ integrated into the Studio addressing written and oral communication needs for software engineers. Students shall be able to recognize the importance of situational analysis, planning and revision; create documents that are correct, clear, concise, achieve the desired goals of the writer, and meet the needs of the reader; deliver individual oral presentations that are interesting and direct, and effectively collaborate with a team to produce high-quality work products; apply the principles of effective communication to one’s own written and oral presentations, while providing positive, helpful feedback to their peers. The example presentations and documents elaborated and discussed in this course are actual artifacts of the Studio project.

Topics: Writing process; situational analysis; presentations in other MSE courses; document families; document layout, templates, important elements; reading more efficiently; writing statements of work (SOWs); schema; writing Studio proposals; writing collaboratively; project descriptions, “elevator pitches”; giving presentations; creating presentation materials.