SSN School of Advanced Software Engineering

Back to Academics

About MSIT-ESE

The MSIT-Embedded Software Engineering (ESE) specialization addresses the specialized needs of software engineers working in environments where a system’s software and hardware elements are closely coupled. The ESE specialization complements the MSIT with a tailored course of study comprised of directives and electives to prepare students as embedded software engineers. This specialization enables students to be better equipped to communicate heterogeneous engineering teams commonly found in embedded systems projects. It helps students to better understand the “fuzzy borders” where software meets hardware. Students will understand the critical issues associated with developing embedded systems design, enabling them to build higher quality embedded software. Students in this specialization will gain an in-depth understanding of:

• Sensing, Control Theory, Digital Signal Processing.
• Consequences of allocating system responsibilities to hardware or software.
• Embedded processor characteristics.
• Problematic quality attributes inherent to embedded systems design and strategies to address them.

Core Courses

There are five core courses. The concepts and the skills acquired in these core courses are applied in the Practicum. The courses are:

• Computer Science for Practicing Engineers
• Systems Engineering
• Models of Software Systems
• Architectures for Software Systems
• Distributed Embedded Sytems
• VLSI CAD: Software to Logic

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.

Architectures for 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.

Elective Courses

• Methods of Software Development
• Managing Software Development
• Analysis of Software Artifacts
• Introduction to Real-Time Software and Systems
• Advanced Computer Architecture
• Packet Switching and Computer Networks

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.

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, risk management, estimation, planning and tracking, work breakdown structure and quality assurance, all of which are used in the Practicum.

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.

Introduction to Real-Time Software and Systems

The primary purpose of this course is to present an overview of real-time computing. Basic concepts, terminology, and problems of real-time computing are introduced. The constraints of real-time computing are used to contrast real-time applications from applications that are not real-time. The course focuses on software solutions to real-time problems. Issues that are addressed include scheduling, specification of system requirements and design, real-time software architectures, languages and operating systems for real-time computing, real-time problems in a distributed processing system, and hardware-software interfaces.

Pre-requisites

The Personal Software Process

I. Summary of High Level Course Objectives

A. Concepts and Definitions

1. Making and honoring commitments
2. Measuring the work to be done
3. Estimating the effort based on the size of the work to be done
4. Production rates and allocation of effort to phases of the project
5. Improving performance and quality by finding defects early

B. Application of these concepts (Students should be able to answer these questions when they have finished the course.)

1. What problems did you have estimating the size of the work to be done and what did you learn from this experience?
2. How accurate was your effort estimates and what could you do to improve this accuracy based on your experiences?
3. How did plan versus actual performance variance change over the course of your PSP assignments and what single factor do you feel was the largest in causing this?
4. Why do we concern ourselves with determining when a defect was injected? What actions can we take to improve performance and quality base on this? Why is it easier to find defects in a review as opposed to in testing?
5. What kinds of defects were the most common in your PSP projects? What actions did you take to avoid or detect these defects early? How successful were you? What single factor was most significant in helping you improve your performance and quality?

II. Agreement on minimum requirements

1. At least seven actual programming assignments (optimal is ten)
2. These actual assignments should be in a problem domain that the students know well so there is no additional learning required to performing the programing activities
3. Students must know their programming language and their development environment prior to starting the PSP assignments
4. At least one report must be produced where the student reflects on his/her actual performance and what he/she have learned (abstract the requirements for this report from R4 and/or R5)
5. The actual programming assignments may be changed, but the size of the effort should be similar to what is in the Watts Humphrey's text, appendix D (A or B series)