Course Schedule

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.

• Intro to the Course
• Warm Up

• What is Software Engineering?

1. Preface. Software Engineering at Google Link
2. Chapter 1. What is Software Engineering? Link

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

• Lab 1: Code Editors

• Lab 1: Command Line Review(Take after completing Lab 1)

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.

• Intro to Version Control

1. Chapter 16. Version Control and Branch Management Link

• Introduction to Lab 2

• Lab 2: Configuring git and GitHub

• Git Collaboration Activity
• Version Control and Collaborative Workflows

1. <a href="https://en.wikipedia.org/wiki/git" target="_blank">Git Wikipedia article </a><br>Read the "History" and "Characteristics" sections.

1. <a href="https://git-scm.com/book/en/v2" target="_blank">Pro Git book</a><br>The Pro Git book provides some useful context and conceptual models, particularly 2.1-2.5, 3.1-3.1, and 3.6.

• Intro to Lab 3

1. Collaborating with git and GitHub (video) Link

1. What is git rebase? (video) Link
2. How to rebase + handle merge conflicts Link

• Lab 3: A Tour of git Commands

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.

• Coding Practice
• Targeted Programming Readiness Remediation
• Version Control Wrap

1. Everything as Code Link
2. Docker Wikipedia article Link

• Everything as Code

1. Docker cheat sheet reference Link

• Lab 4: Intro to Docker

When developing software, it is common to rely on dependencies -- code that has been developed by other people. However, <em>your code</em> 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.

• Package & Dependency Management

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

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

• Python Practice
• Python Practice (after Java readiness practice)

• Lab 5: Understanding Package Managers

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.

• Intro to Testing
• Readiness Testing and Debugging Practice

1. High-level overview of unit v. integration testing Link
2. Chapter 11. Testing Overview Link

• Programming Readiness Modules
• Unit Test Activity

• Lab 6: Testing & Static Analysis

• Static Analysis & Continuous Integration
• Team Preferences

1. Chapter 20. Static Analysis Link
2. Chapter 23. Continuous Integration Link

• Project 1 Set-Up

• Project 1: UNCA Course Lookup

• Mid Semester Review Cheat Sheet
• Mid-Semester Review

1. Please review all of the readings and study questions assigned thus far, in preparation for the mid-term review.

• Midterm Exam

• AsyncIO + MVC
• AsyncIO Activity

1. <a href="https://medium.com/@moraneus/mastering-pythons-asyncio-a-practical-guide-0a673265cf04" target="_blank">Mastering Python’s Asyncio: A Practical Guide</a>

1. <a href="https://www.youtube.com/watch?v=RIVcqT2OGPA" target="_blank">AsyncIO and the Event Loop Explained</a>

• MVC Lab Slides

• Lab 7: AsyncIO + MVC

• Intro to Databases & Object-Relational Mappings

1. <strong>SQL Readings</strong>: Please review the reference materials on SQL: <ul> <li><a href="resources/databases">Database resources page</a></li> <li><a href="https://www.postgresql.org/docs/current/tutorial-select.html" target="_blank">Querying a Table</a></li> <li><a href="https://www.postgresql.org/docs/current/tutorial-join.html" target="_blank">Joins Between Tables</a></li> <li><a href="https://www.postgresql.org/docs/current/tutorial-agg.html" target="_blank">Aggregate Functions</a></li> <li><a href="https://www.postgresql.org/docs/current/tutorial-populate.html" target="_blank">Inserts</a></li> <li><a href="https://www.postgresql.org/docs/current/tutorial-update.html" target="_blank">Updates</a></li> <li><a href="https://www.postgresql.org/docs/current/tutorial-delete.html" target="_blank">Deletions</a></li> </ul>
2. <strong>Object-Relational Mapping Readings</strong>: <ul> <li><a href="https://martinxpn.medium.com/working-with-databases-using-asyncio-in-python-sqlalchemy-example-79-100-days-of-python-1a5cef841803" target="_blank">High-level walkthrough / overview of SQLAlchemy</a></li> <li><a href="https://docs.sqlalchemy.org/en/20/orm/queryguide/index.html" target="_blank">SQLAlchemy Reference</a></li> </ul>

• Lab 7: AsyncIO + MVC

• Lab 8: Database + ORM Lab

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 <em>as a means of learning</em> various client-side software engineering principles

• Client-Side Engineering (Part I)

1. 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

1. Design Systems Link
2. Intro to JavaScript Programming Link

• React

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

• Lab 9: Intro to client-side programming with React

• Communicating over HTTP

• Lab 10: Design Systems & External Data

• Introduction to Project 2

• Project 2: Full Stack Application

• Lab 10: Design Systems & External Data

• Project 2 work: Ideally, you'll begin customizing your vertical feature today

• Scaling an App

1. Kubernetes Basics (Tutorial) Link

• Final Exam (8:00AM)