A balanced, iterative, and brownfield introduction to Software Engineering...
CS2103/T is an introductory Software Engineering course with an equal emphasis on core SE theory and practical skills needed for industry internships or . It adopts an to covering topics and is one of the few SE courses that include both a and a .
On the theory side, this course is supported by a customized online textbook, Software Engineering for Self-Directed Learners, integrated into this course website.
On the practice side, you will first ramp up your technical skills by doing a small individual project (greenfield) in which you will develop a personal assistant chatbot called Duke. Then, you will move to a team project (brownfield) in which you will take over an existing project, AddressBook-Level3 (AB3) -- a relatively small yet non-trivial (6 ) generic product -- and evolve it into a better product.
What does it mean to 'follow an iterative approach to covering topics'?
While the course content can be neatly arranged sequentially based on different aspects of an SE project (as shown here), we will not be covering it in that sequence.
Instead, we cover a little bit of at first and then iteratively go deeper into them, revisiting each aspect many times over the course of the semester. In contrast, a sequential approach would have covered one SE aspect before moving to the next (e.g., teach the requirements aspect completely before moving to the design aspect).
Each week, we cover topics that are most relevant to the project tasks that you are expected to do around that time.
This way of 'jumping around' topics feels chaotic, but consider the benefits:
- It allows you to start doing SE projects early and work on them iteratively too. That is, you can begin with a small project from the very start and grow it progressively, learning from earlier mistakes, and getting multiple chances to improve on previous attempts.
- Important SE aspects such as testing can be practiced from the very beginning. If we followed a sequential approach, you could only learn testing near the end of the semester.
- It lowers the risk of missing out on some SE aspects altogether. For example, suppose your schedule gets heavier in the second half of the semester, and you can barely keep up with the course during that half. You still come away with a basic knowledge of all SE aspects rather than knowing some aspects deeply while missing others altogether.
To help you cope with the non-sequential progression of topics, this course website contains two versions of the topics.
- On the Schedule page, you'll find the topics organized into the order we cover them each week.
- On the Textbook page, you'll find the topics in their natural sequential order. This format is suitable for exam reference.
Given below is a summary of what the course covers and does not cover.
| Topic | Covered | Not covered |
|---|---|---|
| Java | Used heavily, but not taught | syntax (reason: expected prerequisite knowledge) |
| OOP | Used in a non-trivial project, | basics (reason: expected prerequisite knowledge) |
| SE tools/practices | those specific to start-ups | |
| Modeling | (sufficient to describe SE artifacts using models, as shown in this Developer Guide of AB3) | intensive |
| Requirements | to gather and document project requirements | rapid prototyping, heavy UI design, designing a product from scratch |
| Documentation | Documentation targeting end users (example) as well as developers (example) | Marketing materials |
| Project Management | Iterative delivery of a product, working collaboratively with team members, on-site as well as remotely | Setting up project infrastructure from scratch |
| Testing | and | |
| Application domains | Cross-platform desktop applications | Web programming, Mobile programming, Database programming |