Course Schedule

This schedule will definitely change over the course of the semester. Please continue to check back for updates.

1. Intro to Software Engineering

This unit introduces the idea of software engineering, including how it is similar and different from programming, and a host of considerations for building software that is scalable and maintainable over time.

Tu, Aug 18

Intro to the Course

This unit introduces the idea of software engineering, including how it is similar and different from programming, and a host of considerations for building software that is scalable and maintainable over time.

Slides / Activities
Quizzes
  • (Self-check covering tracing, OOP, lists, maps, and debugging)
Th, Aug 20

Lab 1 + What is Software Engineering?

Required Readings
  1. Preface. Software Engineering at Google Link
  2. Chapter 1. What is Software Engineering? Link
Optional Readings
  1. Programming Readiness Modules Link
  2. Configuring WSL Link
  3. Command line cheat sheet Link
  4. Configuring zsh/bash Link
  5. VS Code Link
  6. vim Link
  7. emacs Link
Assigned:
Su, Aug 23

Last day to add / drop

2. Version Control & Branch Management

Version control is perhaps one of the most important topics in software engineering. Version control systems allow teams to collaborate on projects, review one another's code, experiment with new features and ideas, and revert to previous versions when needed. In this unit, we will explore different approaches that teams might take to organize their code repositories. We will also do various hands-on activities so that you can familiarize yourself with bash and git commands.

Tu, Aug 25

Intro to Version Control

Version control is perhaps one of the most important topics in software engineering. Version control systems allow teams to collaborate on projects, review one another's code, experiment with new features and ideas, and revert to previous versions when needed. In this unit, we will explore different approaches that teams might take to organize their code repositories. We will also do various hands-on activities so that you can familiarize yourself with bash and git commands.

Slides / Activities
Required Readings
  1. Chapter 16. Version Control and Branch Management Link
Th, Aug 27

Lab 2: Version Control Part 1

Slides / Activities
Assigned:
  • Lab 2: Configuring git and GitHub
Quizzes
  • (Take after completing Lab 2)
Tu, Sep 1

Version Control and Collaborative Workflows

Required Readings
  1. Git Wikipedia article
    Read the "History" and "Characteristics" sections.
Optional Readings
  1. Pro Git book
    The Pro Git book provides some useful context and conceptual models, particularly 2.1-2.5, 3.1-3.1, and 3.6.
Quizzes
  • Git Collaboration Activity (Take after completing the in-class git collaboration activity)
Th, Sep 3

Lab 3: Version Control Part 2

Required Readings
  1. Collaborating with git and GitHub (video) Link
Optional Readings
  1. What is git rebase? (video) Link
  2. How to rebase + handle merge conflicts Link
Assigned:
  • Lab 3: A Tour of Git Commands
Quizzes
  • (Take after completing Lab 3)

3. Everything As Code (+ Docker)

In this unit, we will explore the idea of formalizing your entire software stack using code (e.g. operating system configurations, dependencies, documentation, and more). Even if your team is collaborating on the same codebase, if each team member is developing software with a different compiler, interpreter, language version, operating system, etc., you will likely run into conflicts and inconsistencies. Give this, you will learn about why "everything as code" is such an important idea, and some tools and strategies for managing your system stack over time.

Tu, Sep 8

Version Control Wrap

In this unit, we will explore the idea of formalizing your entire software stack using code (e.g. operating system configurations, dependencies, documentation, and more). Even if your team is collaborating on the same codebase, if each team member is developing software with a different compiler, interpreter, language version, operating system, etc., you will likely run into conflicts and inconsistencies. Give this, you will learn about why "everything as code" is such an important idea, and some tools and strategies for managing your system stack over time.

Required Readings
  1. Everything as Code Link
  2. Docker Wikipedia article Link
Th, Sep 10

Lab 4. Docker

Slides / Activities
Optional Readings
  1. Docker cheat sheet reference Link
Assigned:
Quizzes
  • (Take after completing Lab 4)

4. Package & Dependency Management

When developing software, it is common to rely on dependencies -- code that has been developed by other people. However, your code isn't the only code that changes. Dependencies (and their dependencies, and their dependencies' dependencies) also evolve over time as new features are added and bugs are patched. Given this, in this unit we will examine some tools, approaches, and considerations for managing code dependencies. We will also experiment with a few different dependency management tools, such as npm, poetry, and apt.
Tu, Sep 15

Package & Dependency Management

When developing software, it is common to rely on dependencies -- code that has been developed by other people. However, your code isn't the only code that changes. Dependencies (and their dependencies, and their dependencies' dependencies) also evolve over time as new features are added and bugs are patched. Given this, in this unit we will examine some tools, approaches, and considerations for managing code dependencies. We will also experiment with a few different dependency management tools, such as npm, poetry, and apt.
Required Readings
  1. Chapter 21. Dependency Management Link
  2. How one programmer broke the internet by deleting a tiny piece of code. Link
  3. NPM’s "everything" debacle. Link
Optional Readings
  1. Havoc Pennington's 2017 blog post (Outlines the problems with non-exact dependency resolution) Link
  2. Facebook's blog post upon the release of yarn (How did Facebook solve some of the dependency resolution challenges noted in our other readings?) Link
Th, Sep 17

Lab 5. Package Managers

Assigned:
  • Lab 5: Understanding Package Managers
Quizzes
  • (Take after completing Lab 5)

5. Testing, Static Analysis, & Continuous Integration (CI)

Continuous integration (CI), static analysis, and testing are complementary software development techniques that ensure that teams can deploy software continuously with a high degree of confidence in the quality of their code. In this unit, we will learn about ways you and your team can automate code testing and validation procedures before merging code updates into the main branch. By setting up a few tools up front, you will save time and energy and increase the reliability of your code base.

Tu, Sep 22

Intro to Testing

Continuous integration (CI), static analysis, and testing are complementary software development techniques that ensure that teams can deploy software continuously with a high degree of confidence in the quality of their code. In this unit, we will learn about ways you and your team can automate code testing and validation procedures before merging code updates into the main branch. By setting up a few tools up front, you will save time and energy and increase the reliability of your code base.

Slides / Activities
Required Readings
  1. High-level overview of unit v. integration testing Link
  2. Chapter 11. Testing Overview Link
Th, Sep 24

Testing Lab: Rock, Paper, Scissors

Assigned:
  • Lab 6: Testing & Static Analysis
Quizzes
  • (Take after completing Lab 6)
Tu, Sep 29

Static Analysis & Continuous Integration

Required Readings
  1. Chapter 20. Static Analysis Link
  2. Chapter 23. Continuous Integration Link
Th, Oct 1

Testing, Static Analysis, & Continuous Integration (CI)

Slides / Activities
Assigned:

6. Midterm Exam Review & Midterm

This unit is dedicated to consolidating what we have covered so far. The midterm will draw on the big ideas from the first half of the course, so it is important that you actively study the study questions for each topic, review the assigned readings, and revisit both the programming problems and the git collaborative workflow we practiced in class and labs. Use the mid-semester review session to identify gaps and ask questions before the exam.

Tu, Oct 6

Fall Break

Th, Oct 8

Mid-Semester Review

Required Readings
  1. Please review all of the readings and study questions assigned thus far, in preparation for the mid-term review.
Quizzes
  • (Practice for the midterm. Draws heavily on the assigned chapters of Software Engineering at Google (Ch. 1, 11, 16, 20, 21, 23) plus the Unit 2-4 study questions (git, Docker, dependency management).)
Tu, Oct 13

Midterm Exam

Slides / Activities
  • Midterm Exam
Th, Oct 15

Working with Textual (Midterm Project)

7. Back-End: the MVC Design Pattern + AsyncIO

As applications grow beyond simple scripts, structure and concurrency become essential. In this unit, we introduce the Model–View–Controller (MVC) design pattern as a way to organize server-side code so that data, presentation, and control logic stay separable and maintainable. We also explore AsyncIO in Python, which helps you write non-blocking back-end code that can handle many concurrent tasks efficiently -- an important foundation for responsive web services.

Tu, Oct 20

AsyncIO + MVC

Required Readings
  1. Mastering Python's Asyncio: A Practical Guide Link
Optional Readings
  1. AsyncIO and the Event Loop Explained Link
Th, Oct 22

Guest Speaker

Tu, Oct 27

MVC + AsyncIO Lab

Slides / Activities
Assigned:
Quizzes
  • (Take after Lab 7 (MVC). Covers separation of concerns and the roles of the Model, View, and Controller.)

8. Back-End: Databases & ORMs

Most real applications need durable, queryable storage. In this unit, we introduce relational databases and SQL as the foundation for persisting application data, then turn to object-relational mappers (ORMs) such as SQLAlchemy. Understanding how to model data, query it effectively, and bridge between database tables and application objects is critical for building reliable back-end systems.

Th, Oct 29

Intro to Databases & Object-Relational Mappings

Required Readings
Assigned:
  • Lab 8: Database + ORM Lab
Quizzes
  • (Take after the SQL practice and tasks in Lab 8. Examples use the dvdrental database.)
Tu, Nov 3

Databases & ORMs Lab

Required Readings
Quizzes
  • (Take after the SQLAlchemy practice and tasks in Lab 8. Covers async queries, sessions, and CRUD.)

9. Challenges in Client-Side Engineering

In this unit, we will explore some software engineering ideas that are specific to client-side engineering. To do this, we're going to learn some HTML, CSS, JavaScript, and React concepts as a means of learning various client-side software engineering principles
Th, Nov 5

Client-Side Engineering (Part I): Intro to Design

In this unit, we will explore some software engineering ideas that are specific to client-side engineering. To do this, we're going to learn some HTML, CSS, JavaScript, and React concepts as a means of learning various client-side software engineering principles
Required Readings
  1. JavaScript vs Java: Quick Reference (read before class) Link
  2. Ask ChatGPT to answer the study questions (Be ready to have a conversation about the discussion questions, including what you learned from ChatGPT (and whether you think ChatGPT got it right).) Link
Optional Readings
  1. Design Systems Link
  2. More JavaScript resources (higher-order array functions, spread & destructuring, fetch/async/await) Link
Quizzes
  • (Take after completing the in-class JavaScript Essentials activity (Nov 5).)
Tu, Nov 10

Client-Side Engineering (Part II): React

Slides / Activities
Optional Readings
  1. React Docs: Thinking in React Link
  2. React Docs: Describing the UI Link
  3. How A Small Team of Developers Created React at Facebook (video) Link
Assigned:
  • Lab 9: Intro to client-side programming with React
Quizzes
  • (Take after completing Lab 9)
Th, Nov 12

Client-Side Engineering (Part III): Communicating over HTTP

Slides / Activities
Quizzes
  • (Take before starting Project 2 (FastAPI + React). Covers what each HTTP method means, status codes, and RESTful URL design.)
Tu, Nov 17

Symposium - No Class

Th, Nov 19

Client-Side Engineering (Part IV): Design Systems & External Data Lab

Assigned:
Quizzes
  • (Take after Lab 10. Covers importing and configuring antd/MUI components, props, forms, and customization.)
  • (Take after Lab 10. Covers fetch, async/await, useState, and useEffect for loading data.)
Tu, Nov 24

Introduction to Project 2

Slides / Activities
  • Introduction to Project 2

10. Back-End: Scaling Up

Once an application works for a small number of users, the next challenge is making it work under growth. In this unit, we examine what it means to scale a back-end system, including strategies for handling more traffic, coordinating services, and thinking about infrastructure that can evolve with demand. These ideas matter as you move from class projects toward production-minded software.

Th, Nov 26

Thanksgiving Break

Tu, Dec 1

Scaling an App

Slides / Activities
  • Scaling an App
Optional Readings
  1. Kubernetes Basics (Tutorial) Link

13. Final Exam

Tu, Dec 8

Final Exam

Slides / Activities
  • Final Exam (8:00AM)

UNC Asheville Department of Computer Science