I am teaching  Introduction to Software Engineering (CSC 307) this Summer. This is a senior-level course for students in the Computer Science program.

CSC 307 covers principles of agile methods; engineering requirements; analysis, design, implementation, testing, and verification of software systems; engineering tradeoffs; and working in project teams.

Lectures

This course includes 16 lectures as follows (lecture slides available):

1. Course Presentation. Over the next weeks, we’ll delve into the principles and practices of software engineering. You’ll learn to create maintainable, readable, and efficient code within a team setting. My teaching approach includes interactive discussions, peer evaluations, and hands-on labs to ensure you grasp theoretical concepts and practical skills. Active participation and consistent attendance are crucial, and all course materials will be available online for your convenience. And remember, this is not a Web development or programming languages-related course.
2. Process Models. In today’s class, we explored various software process models, starting with plan-based approaches: the waterfall model (linear and sequential), the V-model (emphasizing testing stages), the prototyping model (iterative with early user feedback), and the spiral model (iterative with risk management). We then introduced the global ideas behind Agile methodologies and contrasted them with plan-based models, highlighting flexibility, iterative progress, and customer collaboration.
3. Agile Methods. Today, we review the Agile Manifesto and key Agile principles, which include valuing individuals and interactions, working software, customer collaboration, and responsiveness to change. Practical elements like product backlogs, storyboarding, and task boards are illustrated through examples such as the development of a Pac-Man game.
4. Stories and Tasks. In this session, students are introduced to project management tools such as Taiga. The lecture emphasizes iterative development, covering concepts like sprints, task boards, and burndown charts. The session culminates in a practical assignment where students implement the Game of Life simulator using Java Swing.
5. Software Design. This lecture delves into the fundamentals of UML class diagrams for representing the structural models of software systems. We cover the graphical abstract descriptions that serve as blueprints for software solutions, detailing how class diagrams illustrate attributes, methods, and relationships between classes, including dependency, associations, aggregations, compositions, and generalization/specialization. Practical examples and activities help students apply these concepts.
6. Clean Coding. This lecture covers the principles of clean coding. Key topics include the Single Responsibility Principle (SRP), Don’t Repeat Yourself (DRY), and Keep It Simple (KIS). We discuss refactoring, error handling, modular design, comprehensive testing, minimizing dependencies, consistent formatting, effective commenting, and performance considerations.
7. Design Patterns. This lecture explores the use of design patterns, emphasizing their definitions and the importance of reusable designs in real-world applications, particularly those from the Gang of Four (GoF) patterns. We will focus on the observer, singleton, decorator, and composite patterns. Diverse practical examples and code references are provided.
8. Design Patterns in Action. Today, we will focus on combining design patterns within an application example. The application includes a runnable class that generates random data points and three panels that observe the data. Additionally, we will introduce Astah as a tool for UML diagramming, with an emphasis on creating class diagrams and correctly establishing relationships among classes.
9. Dependency Management with Maven. This lecture focuses on managing dependencies and utilizing libraries in Java applications. We will explore Maven for automating dependency management and ensuring consistent builds. Examples are presented by integrating Jsoup for HTML parsing, JavaParser for code analysis, JFreeChart for chart creation, and Weka for machine learning. Additionally, we discuss JDBC for database connectivity, using MariaDB as an example.
10. Logging with SL4J Logback. In this lecture, we focus on logging practices and exemplify using SLF4J Logback. We cover configuring logging, understanding severity levels, and best practices for application maintenance. Further, we explore cloud-based log management with BetterStack and revisit Maven for project setup and dependency management.
11. Software Metrics. Code metrics are essential tools for assessing the quality and complexity of software. Today, we review size metrics, including Lines of Code (LOC), effective Lines of Code (eLOC), and logical Lines of Code (lLOC), a complexity metric that measures the number of linearly independent paths in a program called Cyclomatic Complexity (CC), and structural metrics, including Abstractness and Instability. 

Projects

This is an example of a project developed by students in this course:

Related