Software Engineering Lecture_1

Software Engineering Overview: Agile, Process Models, and Adaptation

Process models in this course are presented as an umbrella around Agile, recognizing that two teams won’t adopt an identical process because real-world implementation varies (books vs. practice). The instructor emphasizes that software development is a team-oriented, iterative, and adaptive discipline, with a safe space for experimentation to understand what works best and to justify those choices. The course introduces major activities such as project management, quality assurance, and configuration management, and the instructor notes a shift toward providing templates (including version control) embedded in the course templates to help students track changes and decisions. This reflects a recognition that change, configuration management, and traceability are integral, not optional.

In agile contexts, planning and estimation practices are explored, along with the most important roles and responsibilities. The course emphasizes the purpose of software analysis and design, and the development of basic UML models to design for a given case project. The overarching idea is to first define the problem, understand what the system should do, identify gaps in existing solutions, and determine who will use the system and what their requirements are. The instructor notes that students will encounter big terms (problem definition, system definition, requirements) early on, but the goal is to build familiarity and confidence through practice.

UML is introduced as a standard notation with a family of models that helps capture ideas on paper before coding, reducing risk that becomes expensive to fix later in development. An analogy is drawn to civil engineering: blueprints and calculations guide building a house; likewise, UML helps plan software before implementation. The rise of generative AI is acknowledged as increasing the need for grounded, systematic software analysis and design, since AI-generated code without context can lead to wasted effort. The famous Scrum quote highlighted is that it is useless to “develop fast something that shouldn’t be done in the first place,” underscoring the importance of purpose and value in requirements and implementation.

The course addresses both formal requirements and user stories, noting that opinions vary within the community about whether user stories qualify as formal requirements. The goal is to provide students with a bag of knowledge they can adapt to different contexts in their future careers. Quality is presented as a broad objective spanning external user-facing properties (like usability) and internal software properties. The course flags that although coding activities are not the main focus, students should still develop testing strategies, including ideas around test-driven development (writing tests before code) to illustrate how planning and verification fit into agile workflows.

UML, Analysis, and Grounding Decisions

A core aim is for students to ground their decisions through analysis and design, including the creation of UML models. UML serves as a standard notation to facilitate communication and reduce misalignment between stakeholders and developers. The course stresses the context of modern software development, where misalignment and lack of shared understanding can lead to wasted effort or misused lines of code. The role of requirements is framed within an agile lens: tolerance is intrinsic, since user needs and environments can shift; formal requirements and user stories are both explored to build a robust, adaptable knowledge base.

In modern practice, organizations balance flexibility with governance. The instructor connects theory to real-world contexts, including how governance and quality standards (e.g., GDPR compliance) can drive process choices. The discussion about context-aware decisions—choosing the right model for the right problem—serves as a reminder that one size does not fit all. The emphasis remains on understanding the user, the constraints, and the environment in which the software will operate, and on selecting modeling and design approaches accordingly.

Quality, Usability, and “Quality in Use”

Quality is defined as an overarching objective that spans the external interface and internal system properties. External quality includes usability and the mental models users rely on; if users struggle to understand or learn the interface, the software fails to meet its purpose. Internal quality concerns include maintainability, readability, and simplicity of code and design. The course introduces concepts such as usability, security, and availability as quality attributes to be prioritized and revisited as the product evolves.

The discussion introduces the idea of "quality in use"—observing users in their actual work contexts to assess whether the system supports their tasks, and to identify where the system needs adaptation. Prototyping (including low-fidelity mockups and even paper prototypes) is presented as a strategy to explore external qualities and gather user feedback early, without committing to full implementation. This iterative feedback loop helps align the product with user needs and reduces late-stage rework.

Quality considerations are tied to the broader software process focus of the course. As students explore agile practices (notably Scrum), they examine how process decisions impact quality, and how internal and external quality attributes influence design choices and testing strategies. The readings introduce the idea that quality is not a one-off checkpoint but a continuum as the product evolves in response to user feedback and changing constraints.

Requirements, Prototypes, and Testing Strategies

Even though coding is not the primary activity in this introductory course, students are encouraged to consider testing strategies early. The possibility of test-driven development (writing tests before generating code) is discussed as a way to shape thinking about requirements and verification from the outset. The course emphasizes that the project provides the practical setting to apply concepts and to develop the vocabulary of software engineering—so students can articulate decisions confidently as software engineers rather than simply solving isolated problems.

The course uses two core reading materials: Somerville’s Software Engineering as a standard introductory textbook, though it can be high-level; and a Danish-authored Orgo University book that is praised for its accessibility to non-CS backgrounds and its emphasis on language, heuristics, and practical thinking about systems. The combination of reading materials, slides, and in-class exercises is designed to bridge theory and practice, helping diverse learners acquire the foundational knowledge needed for future careers.

Learning Approach: Case-Based and Project-Based Learning

Learning is organized around two complementary modalities: case-based learning and project-based learning. Case-based learning provides real or realistic contexts that seed product ideas, while project-based learning requires teams to build a product from those ideas. The instructor argues that students are more motivated when they choose topics they care about, which supports engagement and deeper learning. Projects are team-based, with templates and tools used to support collaboration and documentation.

To support collaboration, the course provides templates embedded with version-control practices and other artifacts. The templates aim to standardize the artifacts students deliver while still allowing teams to tailor processes to their needs. The facilitator emphasizes that the goal is not to micromanage teams but to provide a shared vocabulary, required artifacts, and guidance through TAs who coach groups in their decisions. The emphasis on team-based learning mirrors real-world software engineering practice where teamwork, communication, and alignment are essential for success.

Course Organization: Materials, Schedule, and Roles

Two primary books anchor the readings: Somerville’s Software Engineering and the Danish Orgo University text. The course plan targets select chapters from each book, not the entire texts, to balance depth with the broad needs of a diverse student population. The course integrates case-based scenarios with project work and assigns two books to broaden understanding across different backgrounds.

The course is designed for a team-based project with a survey-informed grouping process. Students are assigned to groups and will work with TAs who guide the project. LaTeX templates are provided for reports and theses, reflecting the importance of formal documentation in CS education. The instructor notes a balance between providing templates and enabling teams to own their documents, a balance that has historically improved outcomes.

Structure, Toll Gates, Supervision, and Feedback

The course comprises roughly 12 regular lectures plus one industrial guest lecture, with the bulk of the project completed by November. Two intermediate toll gates serve as partial hand-ins to allow early feedback and to keep students on track. Toll gates are designed to ensure progress; a passing toll gate indicates that students may proceed, while failing requires a resubmission with feedback addressed. The toll gates use standardized feedback templates so every group receives consistent input. Final submissions are reviewed after Toll Gate 2, enabling the instructor to identify emerging issues and provide guidance before the end of the term.

Weekly supervision sessions are available, where TAs guide groups through decisions. The instructor acknowledges that TA delivery styles may vary, but emphasizes alignment on process and content across the teaching team. Students are encouraged to engage with TAs through formal channels and to use Learn It as the central hub for questions, announcements, and resources. The course plan is periodically updated, with new template versions uploaded as needed.

Time Commitment, Attendance, and Study Logistics

This is a 7.5 ECTS course with a stated workload of 7.5 ext{ CTS} and a total weekly time commitment of 11.5 ext{ hours} per student, where 2 ext{ hours} are lecture hours and the remainder is allocated to exercise sessions, reading, and group project work. Student group work is a central component, and the experience will vary by group composition, as teams adopt different working styles. A mandatory attendance rate is set at 80 ext{%} of the exercise sessions, equivalent to rac{12}{14} slots; a maximum of two absences is allowed, and missing three may impact exam eligibility, with four absences risking not taking the exam. Hybrid work is allowed but face-to-face collaboration is encouraged when possible.

A LEGO Scrum simulation is introduced as a hands-on activity to practice process rather than coding. The LEGO session will be run by Paolo Telle in two time slots to accommodate room constraints: 8:00–11:00 and 11:00–14:00, with a sign-up sheet to allocate groups to slots. Each TA will typically follow two groups, with four TAs plus Paolo supervising activities. The LEGO simulation is designed to illustrate Scrum processes and to provide a practical, engaging experience of working through agile ceremonies and roles.

Exam Format, Preparation, and AI Considerations

The course ends with an oral exam, a group exam in which a group presents for roughly up to ext{15 minutes} per presentation, followed by a Q&A session. Depending on group size (up to eight members is mentioned as a typical group size), the overall duration is allocated as 20 ext{ minutes} ext{ per person}, with breaks and targeted questions to ensure every member has a chance to respond. The exam is designed to assess the group’s ability to discuss the project, defend design decisions, and demonstrate the vocabulary of software engineering. Preparation builds on the project work and prior toll-gates, and the final exam schedule is posted on the official course description; conflicts with other exams are considered on a case-by-case basis.

The course includes a strong stance on the use of generative AI: do not create content from scratch using AI. AI can be used to augment learning (e.g., organizing ideas, drafting notes) but content should be created by students themselves to preserve authenticity and avoid easy-to-replace contributions. The instructor highlights that heavy reliance on AI can make a student’s work replaceable and stresses personal accountability and learning ownership. Templates and frameworks are provided to encourage collaboration and to reduce friction, while still requiring genuine group effort and individual accountability.

Communication, Support, and Wrap-Up

Learn It serves as the central hub for questions, announcements, and forum-based Q&A. If questions are not answerable publicly, students are encouraged to contact the instructor via email or to meet in the office. Anonymous feedback channels are available to surface concerns about communication or course structure, enabling iterative improvements while preserving instructor time and study planning.

During breaks and Q&A sessions, the instructor emphasizes a supportive stance toward student questions, normalization of different TA styles, and the importance of team-building activities early in the course to set the tone for collaboration. The final portions of the session include reminders about room locations, TA assignments, and group sign-ups for subsequent LEGO sessions, with an explicit emphasis on starting the team-building process today to prevent later conflicts.

Key Takeaways for Exam Preparation

Software engineering is a team endeavor that requires a systematic, adaptable approach to process models and design, not simply coding in isolation.
UML provides a standard, paper-first modeling language to mitigate risk by clarifying requirements, analysis, and design before implementation.
Agile, while an umbrella term, emphasizes individuals and interactions, working software, customer collaboration, and responsiveness to change over rigid plans.
Quality in software encompasses both external usability and internal software properties, with continuous assessment through prototyping and user feedback.
Requirements can be formalized or expressed as user stories, and both play roles in agile contexts; the choice depends on context and needs.
The course blends case-based and project-based learning, supported by templates, LaTeX documentation, and structured toll gates to foster progress and accountability.
Assessments include toll gates, supervision, a final oral exam, and an engaging LEGO Scrum simulation; attendance and active participation are crucial.
Generative AI is acknowledged but limited: it should not replace original student work, and students should cultivate their own software engineering vocabulary and reasoning.
Practical logistics (Learn It, group formation, room allocations, sign-up sheets, and study labs) support collaboration and continuous learning throughout the term.