This course introduces the principles, concepts, technologies, and practices of full-stack software development for creating end-to-end web applications using a classical client-server architecture and the model-view-controller pattern. Students acquire basic frontend and backend development skills and learn how to apply modern development practices in the context of an individual project using the plain web stack for the frontend, TypeScript and a NoSQL database layer for the backend, and other common libraries, light-weight frameworks, and tools as adjuncts. The course also reviews fundamental concepts including types, objects, multi-paradigm programming (functional and object-oriented), modularity, asynchronous and event-based computation, authentication and authorization, and dynamic updates. Students practice how to version-control their codebase, manage a small project, incrementally transform requirements expressed as user stories into working software, maintain code quality using static analysis tools, build their application on an integration server, and deploy it on the cloud. To enroll in this course, students must already be proficient in imperative programming using multiple languages and familiar with the basics of algorithms and data structures. Each student will need their own laptop computer to use in the course. This course is crosslisted with 18351. Although students in 18-351 and 18-651 will share lectures, quizzes, and all in-class components, students in 18-651 will be assigned two additional and more advanced deliverables for the project component.

In this course, you will learn about software engineering paradigms that have shaped the software industry over the past few decades. You will be exposed to fundamental disciplines of software engineering as well as engineering practices that crosscut system, project, and user perspectives. You will learn to iteratively define requirements, and architect, design, implement, integrate, test, and deploy a solution. Throughout the course, you will also leverage modern AI-driven tools to enhance engineering quality and productivity. You will work on self-organizing teams and manage the work collaboratively. You will also learn to solve a real problem subject to multiple constraints while keeping the stakeholders involved throughout the lifecycle and balancing the underlying engineering tradeoffs. The topics are applied in the context of a semester-long group project.

Software Design and Architecture aims to train software engineering graduate students for assuming the technical leadership of a software project team. The primary objective of the course is to help students develop skills in designing, developing, and justifying software architecture for enterprise-scale software-intensive systems, considering both functional and non-functional requirements as well as the system environment. Core topics include: overview of software architecture, micro architectural patterns (design patterns) and macro architectural patterns (architectural or modern patterns), service oriented architecture, architectural modeling, viewpoints and perspectives, architectural analysis techniques, architectural tactics (QoS), agile architectures, and other advanced topics. At the end of this course students will be able to: (a) competently generate architectural alternatives for a problem, and choose among them; (b) have the skills needed to construct a medium-sized software system that satisfies an architectural specification; (c) understand and analyze common modern software architectures and reason about the properties of these architectures.

Testing is an integral part of any software endeavor and underpins building dependable systems. Testing activities, which nowadays rely greatly on automation and target both functional and non-functional requirements, form the backbone of a high-quality software solution that performs its function as intended. Operations activities involve configuration, monitoring, and troubleshooting software in a live environment. DevOps practices like containerization help streamline both testing and operations processes by encapsulating an application and its dependencies in a container to yield repeatable and resource-efficient testing environments. This course introduces the students to concepts, principles, theory, types, tools, and techniques of software testing. Students will learn fundamentals of testing principles, approaches to testing (specification-based and structural), input space analysis, and designing for testability. Moreover, students will gain sufficient breadth in testing types - targeting both functional requirements (unit and end-to-end testing) and quality attributes (security, performance testing). In its second half, the course syllabus introduces DevOps practices through a project component organized around micro services - an architectural style that gained significant adoption in the industry for building scalable and maintainable systems. Students will get practical experience with Docker to containerize such software and streamline testing automation. Each team will build various types of tests for one of the services whose quality they safeguard and put in place a resource-efficient and reliable testing process.

In the era of rapidly increasing quantities of data in information systems, the need to processes them efficiently is more important than ever. One of the enablers in this area is the practice of parallel programming (i.e., programming using multiple hardware cores or processors in order to gain speed). In this context, the limits of the imperative paradigm become apparent, while functional programming comes into its own. This school of thought which uses functions only to write computer programs is on the rise, with purely functional software and tooling being created at companies like Facebook, Amazon, Paypal, and countless others.

This course aims to develop a broad understanding of the functional programming style and associated techniques using the F# language. Students will practice these concepts in a hands-on manner, by tackling concurrent big data processing and asynchronous communication mechanisms – challenges particularly relevant in modern software engineering – while keeping performance trade-offs in mind.

During the course you will also apply a business-oriented approach to producing software – Domain-Driven Design – in one of the sectors where functional programming has been most successful: FinTech.

The course also integrates the responsible use of AI throughout the software engineering workflow. Students use customized AI tools to strengthen their domain knowledge and receive targeted feedback on their software designs and implementations.

Engineering software systems entails continuously making resource and technical decisions at multiple levels subject to different sources of uncertainty, cost-benefit tradeoffs, historical data, and flexibility demands. This course will develop quantitative and modeling skills for economics-based and decision-theoretic reasoning in software engineering through a repertoire of techniques from several fields. Special consideration will be given to reasoning under uncertainty and empirical approaches to tackle a variety of software engineering decision-making problems, including technology, architecture, design, product, and process decisions. The analysis techniques covered will be illustrated through domain-specific examples. Analysis techniques that will be covered include Monte Carlo Simulation, Net Present Value, Expected Value of Information, Decision Tree Analysis, Real Options Theory, Utility Theory, and Analytic Hierarchy Process. Basic data analysis concepts, including descriptives, linear regression, correlation, and hypothesis testing will be explained and used. Examples and fully-developed case studies will illustrate how these techniques can be combined to best leverage their strengths. The course has a practical focus, but includes coverage of the necessary background theories. Orientation is distinctly quantitative. Knowledge of basic probability is required.

Good software systems should be engineered with user experience in mind. How can we design software systems that are at once useful, usable, and enjoyable to use?

This course addresses these challenges by integrating two disciplines: requirements engineering and interaction design. Students learn to combine user research, design-based ideation and validation, requirements definition, and AI-augmented workflows within an agile software development process.

Students apply this knowledge during a semester-long project. Their goal is to envision and implement the first version of an innovative software system that could make a unique contribution to society. The system should address a real problem, satisfy real stakeholders’ needs, and provide a superior user experience. Students collaborate closely with their stakeholders throughout the project for needs elicitation, design concepts validation, and usability testing.

The course exposes students to the challenges of real-world software development. Indeed, industry software systems are often complex and developed by large and distributed teams that need to continuously adapt to ever-changing circumstances. Students learn to tackle this challenge from both theoretical and practical perspectives in the context of a semester-long project where the entire class works together as a team of teams. They define the optimal software development method and AI governance for their project aimed at evolving an existing software system. They build new system increments by applying their own method and governance policies. They practice collective code ownership while balancing feature development with refactoring to avoid technical debt. They measure the quality of their product, the productivity of their team, and the predictability of their process. Students also reflect on the effectiveness of their approach and adapt their way of working via continuous improvement.

Refactoring improves the internal structure, maintainability, and evolvability of software while preserving required behavior. This course develops refactoring skills from localized source-code transformations to system-level architectural evolution. Students begin with behavior preservation, code smells, design principles, and metrics; then use a recurring case study to reason about architectural smells, service decomposition, database ownership, schema evolution with Flyway, and distributed transactions. Students also build and evaluate automated smell detection and refactoring techniques, and examine how generative AI can assist refactoring when constrained by testing, static analysis, and engineering judgment. The semester concludes with an API-evolution exercise comparing manual, deterministic automated, and AI-assisted refactoring approaches.

In this course, students learn to apply data science and machine learning to design, evaluate, and evolve AI-enabled software systems. The course covers the complete lifecycle from data collection, exploration, preprocessing, and feature engineering through model selection, evaluation, optimization, deployment, and monitoring. Topics include supervised and unsupervised learning, statistical reasoning, data leakage, bias, explainability, time-series analysis, and the integration of models into production software. Students also use contemporary AI-assisted tools to accelerate analysis, coding, experimentation, documentation, and testing, while learning to verify generated outputs for correctness, reproducibility, privacy, fairness, and responsible use. The topics are applied through hands-on assignments and a semester-long team project in which students build and assess an AI-enabled software system.

In this course, students learn the foundations of database design and database management systems from a software engineering perspective. Topics include relational and non-relational data models, SQL, schemas, keys and constraints, query processing and optimization, indexing, storage management, transactions, concurrency, recovery, caching, partitioning, replication, and sharding. Students apply these concepts by studying, extending, testing, and evaluating CapybaraDB, an instructional database management system written in C++. They also use contemporary AI-assisted development tools to navigate an unfamiliar systems codebase, explain execution paths, generate and strengthen tests, investigate failures, compare implementation alternatives, and improve technical documentation. Students learn to validate AI-generated suggestions against database semantics, integrity constraints, behavioral tests, and performance evidence. The course combines hands-on assignments with a semester-long team project in which students design and implement substantial DBMS features.