Software remains a key element in most technological breakthroughs. Research in software engineering provides methods, languages, tools, and environments that enables productive, on-budget development of new complex software-intensive systems. Furthermore it helps practitioners improve the quality of the software systems that they build and maintain.
Sara Moshtari Zohreh Nama (advisor: Mehdi Mirakhorli)
Nuthan Munaiah (advisor: Andy Meneely)
Anthony Peruma (advisor: Christian Newman)
Joanna Santos (advisor: Mehdi Mirakhorli)
Hitesh Sapkota (advisor: Pradeep Murukannaiah)
Ali Shokri (advisor: Mehdi Mirakhorli)
Héctor Valdecantos (advisor: Mehdi Mirakhorli)
Elizabeth Visconti (advisor: Mehdi Mirakhorli)
Waleed Zogaan (advisor: Mehdi Mirakhorli)
Foundations of Software Engineering
An overview course in software engineering emphasizing software design and software development projects. The course will focus on object-oriented (OO) analysis, design principles and techniques. Students will be introduced to OO modeling, design patterns and design/code refactoring techniques. While there is a significant emphasis on product development, students will be required to use a rigorous process in a team-based product development project. Major topics include analysis and specification of software, subsystem modeling using patterns, and software testing. A term-long, team-based project is used to reinforce concepts presented in class. Programming is required.
Overview of the academic research methodologies used in graduate level work. Topics include: Writing style, Audience analysis, Research Planning, Experiment design and result analysis, Document structure, Research validation, and the process for submission and review to conferences and journals. In this course the student will identify and develop a detailed thesis or capstone proposal that may be continued in a subsequent course. An in-depth study of a software engineering topic will be research focused. The student selects a research problem, conducts background research, and selects appropriate technology and methodologies needed to fully conduct the project. The topic is selected by the student and is in agreement with the student’s advisor and committee. The proposal is presented in a scholarly format for approval by the advisor and committee.
Collaborative Software Development
This course covers processes, tools, and techniques for software development, in general, and collaborative, distributed software development, in particular. Students will learn how to design a process specific to their organization and development project needs. This includes how to select a software development life-cycle model, how to select and sequence the development and management activities of a collaborative, distributed software development team structure and dynamics, and how to define the work products, tools, and methods used to perform those activities. The Software Process Engineering Metamodel (SPEM, an Object Management Group standard) will serve to graphically describe, analyze, discuss, and improve software development processes. Special attention will be given to collaboration needs and approaches for small and large teams that may be globally distributed.
Modeling plays a pivotal role during the software lifecycle during the pre-construction and post-construction activities of the software lifecycle. During the pre-construction stage, models help software engineers understand, specify, and analyze software requirements and designs. During the post-construction stage, models can be used to analyze software systems while in operation. This kind of analysis includes reliability and safety issues as well as timing constraint analysis. (Department approval)
A system’s software architecture is the first technical artifact that illustrates a proposed solution to a stated problem. For all but the simplest system, the achievement of qualities such as flexibility, modifiability, security, and reliability is critically dependent on the components and interactions defined by the architecture. The course focuses on the definition of architectural structures, the analysis of architectures in terms of trade-offs among conflicting constraints, the documentation of architecture for use over a product’s life cycle, and the role of architecture during coding activities.
Software Quality Assurance
This course explores the concepts of process and product quality assurance and introduces approaches and support tools used to extract the information needed to assess and evaluate the quality of existing software systems. Major maintenance activities are detailed including unit and regression testing, test case generation, software refactoring, API migrations, bug localization and triage, and predicting technical debt. Students will participate in an active learning approach by exercising and practicing code reviews, software testing tools, and quality frameworks.
Advanced Programming Skills
The goal of this course is to introduce the students to a programming paradigm and an appropriate programming language chosen from those that are currently important or that show high promise of becoming important. A significant portion of the learning curve occurs through programming assignments with exemplary solutions discussed later in class. The instructor will post specifics prior to registration. With the approval of the program coordinator, the course can be taken for credit more than once, provided each instance deals with a different paradigm and language. A term project involving independent investigation is also required. Note: students who complete CSCI-541 may not take CSCI-641 for credit.
This course provides an introduction to secure coding including topics such as principles of secure coding, security architectures and design, operational practices and testing, programmatic use of cryptography, and defenses against software exploitation. Other topics include software based fault isolation, type-safe languages, certifying compilers; proof-carrying code, and automated program analysis and program rewriting. Programming projects, presentations, and a term paper will be required.
Programming Language Theory
This course is an introduction to the formal study of programming languages, demonstrating important intellectual tools for the precise description of programming languages and investigating the essential features of programming languages using these tools. Topics include: dynamic semantics (such as operational semantics); static semantics (such as type systems); proofs by induction on structures and derivations; formal treatment of essential programming-language features (such as assignment, scope, functions, objects, and threads). Both written and programming assignments will be required.
This course discusses design and implementation of language processors and translators. Topics include lexical, syntactic, and semantic descriptions, algorithms for analysis tools, and programming techniques, as well as interpreters and code generation for typical computer architectures. Teams of students will be required to design and implement a programming language with nested block structure and data aggregates.
Software Development Tools
This course investigates and evaluates various software tools used in the development of software. Topics include simple dependency-based tools such as make and ant as well as full-featured integrated development environments. Working with and proposing modeling languages for such tools is an important part of the course. Programming projects will be required.
Topics in Languages and Tools
This course examines current topics in Languages and Tools. This is intended to allow faculty to pilot potential new graduate offerings. Specific course details (such as prerequisites, course topics, format, learning outcomes, assessment methods, and resource needs) will be determined by the faculty member(s) who propose a specific topics course in this area. Specific course instances will be identified as belonging to the Languages and Tools cluster, the Security cluster, or both clusters.
Resilient Design [Mehdi Mirakhorli]: Architecture-first approach is more increasingly becoming the mainstream development approach for addressing cyber resiliency concerns in mission-critical and software-intensive systems. In such an approach, resiliency is built in the system from the ground up and starts with robust architecture design. Therefore, the weaknesses in the architecture of a software system can have a greater impact on the system’s ability to anticipate, withstand, recover from, and adapt to adverse conditions, stresses, attacks, or compromises on cyber resources. Despite the importance of the architecture-first approach to enhancing and ensuring the resiliency of mission-critical systems, the state of the art and practice lack automated tools to help engineers and architects reason the resiliency of their architecture, verify the correctness of architectural decisions, and detect the design weaknesses. In this project, we work on the development of practical solutions for addressing the above challenges.
Modelling the Language of Software [Christian Newman]: Software engineers rely on natural language (e.g., English) and programming language rules to comprehend software in their daily activities. Together, the rules of the programming language and the natural language embedded within the code (e.g., in identifiers) are how developers comprehend what the code says it does and what it is doing. Using this knowledge, developers can then carry out their development tasks. If the source code is low quality, it is riddled with faults that will cause improper behavior. If the writing (e.g., natural language) embedded in the code is low quality, then the source code may be correct, but it will be difficult for a developer to understand and difficult for natural-language-based tools to analyze. There are no tools that can consistently advise developers in how to optimize the natural language used in the source code and no models to tell us what optimality looks like in this context. Therefore, in this project, we aim to create and study a model that understands how identifier names are influenced by the behavior of the code they describe.
Program comprehension [Carlos Rivero]: Many software-related activities require comprehending programs that other programmers wrote. In the majority of such scenarios, program comprehension is a manual process since current approaches cannot adequately handle program variability and, in particular, interleaved tasks, i.e., sets of non-contiguous program statements with specific semantic purposes. We model programs as program dependence graphs to perform computer-aided, data-driven program comprehension. Such graphs are approximately matched and, assuming a large codebase, pervasive patterns are extracted by detecting communities of statements with similar semantics.
Software process improvement and software process mining [Scott Hawker]
Software Quality Assurance [Mohamed Wiem Mkaouer]: Software evolution brings a constant challenge for software engineers, as they are exposed to various problems related to the decay of software design and architecture, deprecation of external libraries and services, regression of its functionality and performance. Therefore, research in software maintenance aims to support software engineers by providing them with intelligent tools and frameworks, to enhance their maintenance activities. In this project, we design solutions, and implement tools to support 1) the automation of software refactoring, as a response to software design decay; 2) service migration as a response to library and service deprecation; and 3) test case selection, as a response to performance regression.