Software Engineering (ECE 651K)

Spring 2023-2024 (14 weeks, 35 hours)

Course Period: January 8 - April 25, 2024

  • Lectures: Tuesday / Thursday @ 10:15-11:30 (Classroom: WDR 1003)
  • Office Hours: Thursday @ 09:00-10:00 (Office: WDR 2106)
Instructor: Mustafa MISIR (Office: WDR 2106), mustafa.misir [at] dukekunshan.edu.cn
Teaching Assistant (DKU / On-Campus): Zhibo Jia (Office/Desk: IB2072-2B25), zhibo.jia [at] duke.edu
  • Office Hours: Monday / Tuesday / Wednesday / Thursday @ 16:00-17:00 (IB2072-2B25)
Teaching Assistant (Duke U. / Remote): Jing Wang (Office: Zoom), jing.wang [at] duke.edu
  • Office Hours: Monday / Tuesday / Wednesday / Thursday / Friday @ 21:00-22:00 (Zoom)
Software refers to computer programs and associated documentation. There are many different types of software systems, ranging from simple embedded systems to complex, worldwide information systems. Whether it resides within a mobile device, on the desktop, in the cloud, or within a mainframe computer or autonomous machine, software is an information transformer-producing, managing, acquiring, modifying, displaying, or transmitting information that can be as simple as a single bit or as complex as an augmented reality representation derived from data acquired from dozens of independent sources and then overlaid on the real world. Software systems are abstract and intangible. They are not constrained by the properties of materials, nor are they governed by physical laws or by manufacturing processes. This simplifies software engineering, as there are no natural limits to the potential of software. However, because of the lack of physical constraints, software systems can quickly become extremely complex, difficult to understand, and expensive to change. Software engineering is an engineering discipline that is concerned with all aspects of software production from initial conception to operation and maintenance. Software engineering is essential for the functioning of government, society, and national and international businesses and institutions.

This course focuses on software skills required to move to larger scale projects: design, testing, and teamwork. The class is built around learning fundamental design principles, and then seeing how they appear at different scales. The class begins with the small scale, i.e., a few classes, and we explore design patterns and revisit testing. We move to larger and larger scales, until we are considering system architecture, and revisit similar principles throughout.

The course is aligned with ECE 651 at Duke University [ Syllabus ]

Refer to the ECE 651: Development Environment Setup guide for effectively realizing your course related programming activities.

Follow Canvas for announcements and discussions

Reference Books

There is no official textbook for this course. Still, the following books can be used as references.

Supplementary Books: Java Programming: Requirements Specifications / Engineering: Design Patterns: Software Testing: Refactoring & Technical Debt: Agile Software Development: User Interface (UI) / User Experience (UX) Design: Software Architecture: Microservices: Computer / Software Security:

Lecture Notes / Slides

  • Week 1   [08/01 - 11/01]   (Keywords: Course Policies; History; Terminology and Basics; Introduction to Software Engineering; Design Principles)

  • Week 2   [15/01 - 18/01]   (Keywords: Object-Oriented Programming (OOP), Java Programming, C++ vs. Java)
    • Java Programming: From C++ to Java
      • Book: Core Java: Volume 1 - Fundamentals by Cay Horstmann (12th Ed., 2018)
    • Object-Oriented (OO) Design Fundamentals (Review)
      • Book Chapter: Java - How to Program: Early Objects by Paul Deitel, Harvey Deitel (11th Ed., 2018), Chapter 8 - Classes and Objects
      • Book Chapter: Java - How to Program: Early Objects by Paul Deitel, Harvey Deitel (11th Ed., 2018), Chapter 9 - Inheritance
      • Book Chapter: Java - How to Program: Early Objects by Paul Deitel, Harvey Deitel (11th Ed., 2018), Chapter 10 - Polymorphism

  • Week 3   [22/01 - 25/01]  (Keywords: Software Design Process; Requirements Specification)
    • Software Design Process
      • Book Chapter: Software Engineering by Ian Sommerville (10th Ed., 2015), Chapter 2 - Software Processes
    • Requirements Definition
    • Software Process Models: Waterfall vs. Agile
    • Task Breakdown & Estimating Work
      • Book Chapter: Beginning Software Engineering by Rod Stephens (2nd Ed., 2022), Chapter 4 - Project Management

  • Week 4   [29/01 - 01/02]  (Keywords: Software Testing; Unified Modelling Language (UML); Class-Responsibility-Collaboration (CRC) Cards; Structural Patterns)
    • Software Testing: Black-box
    • Software Testing: White-box
      • Book Chapter: Software Testing: A Craftsman's Approach by Paul C. Jorgensen, Byron DeVries (5th Ed., 2022), Chapter 8 - Code-Based Testing
    • Software Testing: Mutation
      • Book Chapter: Introduction to Software Testing by Paul Ammann, Jeff Offutt (2nd Ed., 2016), Chapter 9 - Syntax-Based Testing
    • Unified Modeling Language (UML)
    • Design Patterns
      • Book Chapter: Design Patterns: Elements of Reusable Object-Oriented Software by Gamma et al. (1st Ed., 1994), Chapter 4 - Structural Patterns

  • Week 5   [05/02 - 08/02]   (Keywords: Object-Oriented Design; Design Patterns; Creational Patterns; Behavioral Patterns)
    • Design Patterns (cont.)
      • Book Chapter: Software Engineering: Theory and Practice by Shari Lawrence Pfleeger, Joanne M. Atlee (4th Ed., 2010), Chapter 6.5 - OO Design Patterns
      • Book Chapter: Object-Oriented Software Engineering Using UML, Patterns, and Java (3rd Ed., 2011/2014), Chapter 8 - Object Design: Reusing Pattern Solutions
      • Book Chapter: Design Patterns: Elements of Reusable Object-Oriented Software by Gamma et al. (1st Ed., 1994), Chapter 3 - Creational Patterns

    HOLIDAY [09/02 - 18/02]: Spring Festival / Chinese New Year (NO CLASSES)


  • Week 6   [19/02 - 22/02]   (Keywords: Bad Design; Code Smells; Technical Debt; Refactoring; Regression Testing)
    • Bad Design: Technical Debt
      • Book Chapter: Refactoring for Software Design Smells: Managing Technical Debt by Girish Suryanarayana, Ganesh Samarthyam, Tushar Sharma (1st Ed., 2014), Chapter 1 - Technical Debt
      • External Source: Martin Fowler - Technical Debt
    • Bad Design: Code Smells
      • Book Chapter: Refactoring: Improving the Design of Existing Code by Martin Fowler (2nd Ed., 2018), Chapter 3 - Bad Smells in Code
      • Book Chapter: Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin (1st Ed., 2008), Chapter 17 - Smells and Heuristics
    • Bad Design: Fix - Refactoring
    • Bad Design: Detection - Regression Testing

  • Week 7   [26/02 - 29/02] (Keywords: Team Development; DevOps; CI/CD; Blue/Green Development; Canary Release; Scrum)
    • Team Development
      • Book Chapter: Beginning Software Engineering by Rod Stephens (2nd Ed., 2022), Chapter 3 - The Team
    • Software Development (Dev) and IT Operations (Ops): DevOps
      • Book Chapter: Engineering Software Products: An Introduction to Modern Software Engineering by Ian Sommerville (1st Ed., 2019), Chapter 10 - DevOps and Code Management
      • Book Chapter: Deployment and Operations for Software Engineers, Len Bass, John Klein (2nd Ed., 2023)
    • Continuous Integration (CI) / Continuous Delivery/Deployment (CD)
      • Book Chapter: Engineering Software Products: An Introduction to Modern Software Engineering by Ian Sommerville (1st Ed., 2019), Chapter 10.2 - DevOps Automation
      • External Tutorial (Optional): RedHat - What is CI/CD?
    • Blue / Green Deployment
    • Canary Release
    • Scrum
      • Book Chapter: Software Engineering by Ian Sommerville (10th Ed., 2015), Chapter 3 - Agile Software Development
      • Book Chapter: Engineering Software Products: An Introduction to Modern Software Engineering by Ian Sommerville (1st Ed., 2019), Chapter 2.3 - Scrum
      • Book Chapter (Optional): Software Engineering: A Practitioners Approach by Roger Pressman, Bruce Maxim (9th Ed., 2020), Chapter 3.4 - Scrum
      • Book Chapter (Optional): Essential Scrum: A Practical Guide to the Most Popular Agile Process (1st Ed., 2012)

  • Week 8   [04/03 - 07/03]    Software Testing (Revisited)   (Keywords: Stubs; Spikes; Mocking; Unit Testing; Integration Testing; System Testing)
    • Stubs
      • Book Chapter: Introduction to Software Testing by Paul Ammann, Jeff Offutt (2nd Ed., 2016), Section 12.2 - Test Doubles
    • Spies
    • Mocks
      • Book Chapter: Software Testing: A Craftsman's Approach by Paul C. Jorgensen, Byron DeVries (5th Ed., 2022), Section 9.2 - Mock Objects and Automated Object Mocking
      • Book Chapter: Introduction to Software Testing by Paul Ammann, Jeff Offutt (2nd Ed., 2016), Section 12.2 - Test Doubles
    • Unit Testing
      • Book Chapter: Software Testing: A Craftsman's Approach by Paul C. Jorgensen, Byron DeVries (5th Ed., 2022), Part 2 - Unit Testing
    • Integration Testing
      • Book Chapter: Software Testing: A Craftsman's Approach by Paul C. Jorgensen, Byron DeVries (5th Ed., 2022), Chapter 12 - Integration Testing
    • System Testing
      • Book Chapter: Software Testing: A Craftsman's Approach by Paul C. Jorgensen, Byron DeVries (5th Ed., 2022), Chapter 13 - System Testing

    MIDTERM EXAM [07/03, Thursday] (NO LECTURE)


    HOLIDAY [11/03 - 15/03]: Spring recess for graduate programs (NO CLASSES)


  • Week 9 [18/03 - 21/03]   (Keywords: Designing Modules; Interfaces; Model-View-Controller (MVC); User Interfaces (UIs))
    • Designing Modules and Interfaces
      • Book Chapter: Domain-Driven Design: Tackling Complexity in the Heart of Software by Evans Eric (1st Ed., 2003), Chapter 5 - A Model Expressed in Software
    • Model-View-Controller (MVC) Design Pattern
      • Book Chapter: Software Engineering by Ian Sommerville (10th Ed., 2015), Section 6.3 - Architectural Patterns
    • User Interfaces (UIs)
      • Book: User Interface Design: A Software Engineering Perspective by Soren Lauesen (1st Ed., 2004)
      • Book: Designing with the Mind in Mind by Jeff Johnson (3rd Ed., 2020)

  • Week 10   [25/03 - 28/03]      (Keywords: User Interfaces (UIs); User Experience (UX))
    • User Interfaces (UIs) (cont.)
      • Book: User Interface Design: A Software Engineering Perspective by Soren Lauesen (1st Ed., 2004)
      • Book: Designing with the Mind in Mind by Jeff Johnson (3rd Ed., 2020)
    • User Experience (UX)
      • Book: Measuring the User Experience: Collecting, Analyzing, and Presenting UX Metrics by Bill Albert, Tom Tullis (3rd Ed., 2022)
      • Book: Observing the User Experience: A Practitioner's Guide to User Research by Elizabeth Goodman, Mike Kuniavsky, Andrea Moed (2nd Ed., 2012)

  • Week 11   [01/04 - 04/04]    System Architecture   (Keywords: 3-Tier; Monolith; Event-Driven)
    • User Interface (UI) / User Experience (UX) Testing
    • System Architecture: 3-Tier
      • Book Chapter: Fundamentals of Software Architecture: An Engineering Approach by Mark Richards, Neal Ford (1st Ed., 2020), Chapter 9 - Foundations
    • System Architecture: Monolith
      • Book Chapter: Fundamentals of Software Architecture: An Engineering Approach by Mark Richards, Neal Ford (1st Ed., 2020), Chapter 9 - Foundations
    • System Architecture: Event-Driven
      • Book Chapter: Fundamentals of Software Architecture: An Engineering Approach by Mark Richards, Neal Ford (1st Ed., 2020), Chapter 14 - Event-Driven Architecture Style

    HOLIDAY [04/04]: Qing Ming - Tomb Sweeping Day (NO CLASSES) - Continue on Friday [05/04]


  • Week 12   [08/04 - 11/04]    System Components   (Keywords: Frameworks; Object Relational Mappers (ORMs); Micro-services)
    • Frameworks and Object Relational Mappers (ORMs)
    • Software Architecture - Modern Architectures: Micro-services
      • Book Chapter: Microservices Patterns: With Examples in Java by Chris Richardson (1st Ed., 2018), 2018, Chapter 1 - Escaping Monolithic Hell
      • Book Chapter: Engineering Software Products: An Introduction to Modern Software Engineering by Ian Sommerville (1st Ed., 2019), Chapter 6 - Microservices Architecture

  • Week 13   [15/04 - 18/04]   (Keywords: Security; Confidentiality; Integrity; Accountability; Authenticity; Design Metrics; Maintenance Metrics)
    • Software Security
      • Book Chapter: Software Engineering by Ian Sommerville (10th Ed., 2015), Chapter 13 - Security Engineering
      • Book Chapter: Computer Security: Principles and Practice by William Stallings, Lawrie Brown (4th Ed., 2017), Chapter 1 - Overview
      • External Lecture Slides: ECE 560: Computer and Information Security (Tyler Bletsch, Duke U) - Computer Security Overview
    • Software Design & Maintenance Metrics
      • Book Chapter: Software Engineering: A Practitioners Approach by Roger Pressman, Bruce Maxim (9th Ed., 2020), Chapter 23 - Software Metrics and Analytics

  • Week 14   [22/04 - 25/04]

    • PROJECT DEMOS [23-25/04, Tuesday + Thursday] (NO LECTURE)


    FINAL EXAM [06-08/05, TBA (3 Hours)]


Grading

  • Class Participation: 5%
  • Assignments: 20%
    • Assignment 1 - Programming: 10%
    • Assignment 2 - Interviews: 10%
  • Team Project: 40%
    • Phase 1: 10%
    • Phase 2: 10%
    • Phase 3: 15%
    • Presentation: 5%
  • Midterm: 15%
  • Final: 20%

Other Reading Resources

Quick / Easy Reads:

Other Materials / Resources