Software Engineering

This foundational course introduces students to the essential principles, practices, and tools used in modern software engineering. It explores the software development life cycle (SDLC), comparing traditional and agile approaches like Waterfall, Scrum, and Kanban. Students will examine requirement gathering, system design, software testing, deployment, and maintenance phases. Key skills such as teamwork, version control (using Git), documentation, and testing are introduced in practical lab settings. The course culminates in a team-based project simulating the end-to-end development of a small software system, reinforcing critical thinking, planning, and problem-solving abilities.

This course provides a deep dive into the structured phases of the Software Development Life Cycle (SDLC), guiding students through each stage from requirements and planning to deployment and maintenance. Students will study multiple SDLC models including Agile, Spiral, V-Model, and DevOps pipelines, learning how to select and apply the most appropriate model based on project requirements. They will participate in a full-cycle simulation project that includes documentation creation, development practices, and test planning. Emphasis is placed on structured thinking, proper documentation, and the discipline required for professional software development.

Students learn how to identify, gather, analyze, document, and manage software requirements throughout a project’s lifecycle. The course covers techniques for stakeholder interviews, workshops, surveys, and observation. Students will distinguish between functional and non-functional requirements, build Software Requirements Specifications (SRS), and model using UML diagrams. Traceability matrices and change control are used to manage evolving requirements. By engaging in roleplay, team exercises, and simulation projects, students will develop the ability to communicate clearly with stakeholders and prepare high-quality documentation aligned with real-world software needs.

This course introduces key concepts and techniques used in designing scalable, maintainable, and testable software systems. Students will apply object-oriented design (OOD) principles and gain practical experience implementing SOLID, DRY, KISS, and YAGNI design guidelines. They will analyze and implement structural and behavioral design patterns including Singleton, Factory, Strategy, and Observer. UML diagrams are used to visualize system designs, and students participate in group design reviews to practice technical communication. The course prepares students to create software solutions that are robust and adaptable to future changes.

This course builds practical and theoretical knowledge of the Unified Modeling Language (UML) as a tool for software system visualization and documentation. Students will design use case, class, sequence, activity, and deployment diagrams. The course emphasizes modeling software behavior and architecture, aiding communication among developers and stakeholders. Students will use modeling tools to support requirement analysis, system design, and documentation preparation. The final project involves modeling a case study system end-to-end, reinforcing the ability to translate functional requirements into technical specifications visually.

This course focuses on techniques for estimating software project effort, time, and cost. Students will apply models such as Use Case Points (UCP), Function Point Analysis (FPA), and the Constructive Cost Model (COCOMO) to real and simulated projects. UML diagrams are used to support scoping and effort estimation. Students will also develop project timelines using Work Breakdown Structures (WBS) and Gantt charts. Through labs and collaborative activities, students will produce complete project proposals with detailed time, effort, and cost breakdowns, including risk assessments and estimation logs.

This course introduces students to high-level design and architectural decision-making for software systems. Students will study architectural styles such as monolithic, layered, microservices, and client-server models, examining trade-offs in performance, scalability, and maintenance. Practical tools like UML and the C4 model will be used to document design decisions. Students will conduct scenario-based evaluations of quality attributes such as availability, modifiability, and security, preparing full architectural proposals with supporting artifacts and team presentations.

Students will explore the essential tools and practices of collaborative software development, focusing on version control systems such as Git and platforms like GitHub or GitLab. Key topics include initializing repositories, managing remote codebases, handling branching and merging, resolving conflicts, and participating in peer code reviews. Students will also simulate professional workflows using pull requests, issues, and project boards. The course introduces CI/CD integration to give students hands-on practice with continuous integration workflows and development automation.

Students will develop foundational skills in writing maintainable, reliable, and efficient software. Emphasis is placed on clean code practices, code-level design, modularization, and the use of tools for debugging and static analysis. Students will learn how to use abstraction, encapsulation, and separation of concerns to write robust code. The course integrates unit testing, defensive programming, and collaborative practices such as peer code reviews. The final project challenges students to build a complete, testable application module within a team environment.

This course prepares students to ensure software quality through testing and quality assurance processes. Topics include designing test cases, performing unit, integration, system, and acceptance testing, and writing test documentation. Students will work with both manual and automated tools (e.g., Selenium, PyTest, JUnit) and simulate full testing cycles. Test planning, bug reporting, and metrics such as defect density and code coverage are emphasized. The course culminates in a comprehensive group QA project with test plans, execution logs, and quality reports.

This course teaches students how modern software teams develop and deploy code through Agile and DevOps methodologies. Students explore Scrum, Kanban, sprints, user stories, and backlog management using tools like Jira or Trello. DevOps components include CI/CD pipelines, infrastructure automation, containerization with Docker, and monitoring tools. Real-world labs simulate sprint planning, code reviews, builds, and deployments, giving students hands-on practice integrating development and operations. The course highlights the continuous delivery mindset essential in today’s industry.

Students will learn to design and build software with security in mind, identifying and mitigating risks through secure coding, threat modeling, and testing. The course covers common vulnerabilities such as SQL injection, XSS, and buffer overflows. Best practices for secure authentication, access control, and data handling are explored. Students use static and dynamic analysis tools (e.g., SonarQube, Bandit) and practice integrating security in CI/CD pipelines (DevSecOps). Legal and compliance frameworks like OWASP Top 10, GDPR, and ISO 27001 are discussed in depth.

This course focuses on the long-term sustainability and evolution of software systems. Students explore different maintenance types—corrective, adaptive, perfective, and preventive—and learn how to analyze legacy systems for refactoring opportunities. They apply testing strategies to ensure system stability during code improvements. Emphasis is placed on using static analysis tools, managing technical debt, and participating in collaborative code reviews. Students will document maintenance activities and present refactored applications that demonstrate improved performance and maintainability.

In the final stage of the program, students will work in teams to complete a comprehensive capstone project. They will design, develop, test, and deploy a software application that solves a real-world problem or meets a simulated client’s requirements. This project will require students to integrate the full software development life cycle—from requirements gathering and UML modeling to coding, QA testing, and final deployment. Each team will present their solution in a professional setting, demonstrating not only technical skills but also project management, documentation, and team collaboration. The capstone is a culmination of the knowledge and hands-on experience acquired throughout the diploma.

This course examines the professional responsibilities and ethical dilemmas faced by software engineers in a rapidly evolving digital landscape. Topics include privacy, intellectual property, AI ethics, algorithmic bias, accessibility, and the societal impact of software. Students will apply ethical frameworks like deontology and utilitarianism to case studies and evaluate legal standards such as GDPR and copyright law. Through group debates, reflection papers, and a final presentation, students will demonstrate their understanding of ethics in software practice and develop professional communication and conduct skills.