Software Engineering Lab Manual for MCA/BCA Students (30 Classes)

Software Engineering Lab Manual for MCA/BCA Students (30 Classes)

---

Class 1: Introduction to Software Engineering and SDLC

Objective:
Introduce the students to the field of software engineering and the concept of the Software Development Life Cycle (SDLC).

Tasks:

• Overview of Software Engineering principles.
• Introduction to SDLC phases: Planning, Analysis, Design, Coding, Testing, and Maintenance.
• Understanding the importance of Software Engineering in real-world applications.

Exercise:

• Discuss different types of SDLC models: Waterfall, Agile, V-Model, Spiral, etc.
• Real-world examples of SDLC models.

---

Class 2: Requirements Gathering and Analysis

Objective:
Teach students how to gather requirements for software projects.

Tasks:

• Introduction to requirements gathering techniques.
• Documentation of functional and non-functional requirements.
• Use case diagram creation using UML.

Exercise:

• Create a use case diagram for a “Student Management System.”

---

Class 3: Introduction to UML (Unified Modeling Language)

Objective:
Familiarize students with UML for visualizing, specifying, constructing, and documenting the software system.

Tasks:

• Introduction to various UML diagrams: Use Case Diagram, Class Diagram, Sequence Diagram, etc.
• Creating a Class Diagram for a given system.

Exercise:

• Draw a Class Diagram for a “Library Management System.”

---

Class 4: Database Design and ER Diagram

Objective:
Teach students the importance of database design in software engineering.

Tasks:

• Introduction to Entity-Relationship (ER) diagrams.
• Database normalization and its importance.
• Creating an ER diagram for a given problem.

Exercise:

• Design an ER diagram for a “Hotel Management System.”

---

Class 5: System Architecture and Design Patterns

Objective:
Introduce students to system architecture and commonly used design patterns.

Tasks:

• Overview of design patterns: Singleton, Factory, Observer, etc.
• Introduction to system architecture design: Client-Server, Layered Architecture.

Exercise:

• Implement a simple Singleton pattern in Java/Python.

---

Class 6: Introduction to Version Control (Git)

Objective:
Teach the basics of version control and how to use Git.

Tasks:

• Introduction to Git and GitHub.
• Creating a repository and basic Git operations (clone, commit, push, pull).

Exercise:

• Create a Git repository, clone it, and push a simple Java/Python file.

---

Class 7: Writing Code Following Coding Standards

Objective:
Inculcate the importance of following coding standards.

Tasks:

• Overview of clean code principles.
• Hands-on practice with writing code that follows best practices and naming conventions.

Exercise:

• Refactor an existing piece of code to make it more readable and maintainable.

---

Class 8: Introduction to Testing and Test Cases

Objective:
Introduce students to software testing and writing test cases.

Tasks:

• Overview of different testing types: Unit Testing, Integration Testing, System Testing, etc.
• Writing basic test cases using JUnit (for Java) or PyTest (for Python).

Exercise:

• Write test cases for a simple Calculator application.

---

Class 9: Unit Testing with JUnit/PyTest

Objective:
Teach students to write unit tests for software systems.

Tasks:

• Introduction to Unit Testing frameworks.
• Writing unit tests for various modules of a system.

Exercise:

• Implement and run unit tests for the "Student Management System."

---

Class 10: Introduction to Agile Methodologies

Objective:
Introduce Agile methodologies and their implementation in software projects.

Tasks:

• Introduction to Scrum, Kanban, and Agile principles.
• Overview of sprint planning, backlogs, and user stories.

Exercise:

• Write user stories for a "Task Management System."

---

Class 11: Project Planning and Estimation

Objective:
Teach students how to plan and estimate software projects.

Tasks:

• Overview of project estimation techniques (Use Case Points, Function Points).
• Work Breakdown Structure (WBS) and timeline estimation.

Exercise:

• Create a Work Breakdown Structure (WBS) for a simple "Inventory Management System."

---

Class 12: Software Design Using UML (Part 2)

Objective:
Deepen the students' understanding of software design using UML.

Tasks:

• Introduction to Sequence and Activity diagrams.
• Creating Sequence and Activity diagrams for a given system.

Exercise:

• Create Sequence and Activity diagrams for the "Library Management System."

---

Class 13: Code Implementation for the System

Objective:
Students implement code based on their design and system specifications.

Tasks:

• Implement the system based on UML and ER diagrams.

Exercise:

• Implement a "Student Management System" (CRUD operations).

---

Class 14: Introduction to Continuous Integration (CI) and Deployment

Objective:
Introduce CI and deployment tools for automating software delivery.

Tasks:

• Overview of Continuous Integration and Continuous Delivery (CI/CD).
• Introduction to Jenkins, Travis CI, and other tools.

Exercise:

• Set up a basic Jenkins pipeline to automate the build process for a Java/Python application.

---

Class 15: Debugging and Error Handling Techniques

Objective:
Teach students how to debug software systems effectively.

Tasks:

• Introduction to debugging techniques in IDEs.
• Writing effective error handling and exception handling mechanisms.

Exercise:

• Debug a given piece of code with logical errors and fix them.

---

Class 16: Performance Testing and Optimization

Objective:
Introduce students to performance testing and optimization techniques.

Tasks:

• Overview of performance testing tools (JMeter, LoadRunner).
• Optimizing code for better performance.

Exercise:

• Optimize a basic system for performance (reduce memory usage, improve response time).

---

Class 17: Software Documentation and Technical Writing

Objective:
Teach students how to document software projects effectively.

Tasks:

• Introduction to software documentation practices.
• Writing user manuals, API documentation, and system documentation.

Exercise:

• Write API documentation for a given software system using Swagger.

---

Class 18: Testing the Software: System Testing

Objective:
Students will perform system testing on a given software project.

Tasks:

• Performing system testing on the "Library Management System."
• Writing test scripts to validate the functionality.

Exercise:

• Perform end-to-end testing on the "Library Management System."

---

Class 19: Software Maintenance and Updates

Objective:
Explain the importance of software maintenance and updates.

Tasks:

• Introduction to software maintenance practices.
• Managing and fixing bugs in production systems.

Exercise:

• Identify and fix bugs in the previously developed system.

---

Class 20: Introduction to Project Management Tools

Objective:
Introduce project management tools for tracking and managing software projects.

Tasks:

• Introduction to Jira, Trello, and similar tools.
• Creating and managing tasks, sprints, and backlogs.

Exercise:

• Set up a project in Jira and create tasks for a software project.

---

Class 21: Software Configuration Management

Objective:
Teach the basics of software configuration management.

Tasks:

• Introduction to configuration management tools (e.g., Ansible, Chef).
• Version control with Git.

Exercise:

• Set up a configuration management system for a project.

---

Class 22: Introduction to Cloud Deployment

Objective:
Introduce students to cloud deployment strategies.

Tasks:

• Overview of cloud platforms like AWS, Google Cloud, or Heroku.
• Deploying a simple web application on a cloud platform.

Exercise:

• Deploy a Java or Python web application on Heroku.

---

Class 23: Code Review and Refactoring

Objective:
Teach students to review and refactor code for better quality.

Tasks:

• Introduction to code reviews and best practices.
• Refactoring code to improve quality, readability, and performance.

Exercise:

• Review and refactor a piece of code to make it more efficient.

---

Class 24: Handling Security in Software Systems

Objective:
Teach the basics of software security.

Tasks:

• Introduction to security best practices.
• Preventing common vulnerabilities like SQL injection, XSS, etc.

Exercise:

• Implement security measures for a login system (password hashing, input validation).

---

Class 25: Group Project Work (Part 1)

Objective:
Start a group project where students will work on a full-fledged software project.

Tasks:

• Students form groups and decide on a project.
• Initial planning, requirement gathering, and design.

Exercise:

• Develop a project plan and initial design documents.

---

Class 26: Group Project Work (Part 2)

Objective:
Students will continue working on their group projects.

Tasks:

• System implementation (coding phase).
• Regular progress checks and peer code reviews.

Exercise:

• Implement the first module of the group project.

---

Class 27: Group Project Work (Part 3)

Objective:
Students will complete their group projects.

Tasks:

• Completing system implementation.
• Writing documentation and testing the system.

Exercise:

• Finalize the system and prepare the documentation.

---

Class 28: Group Project Work (Part 4)

Objective:
Students finalize their group projects for presentation.

Tasks:

• Final system testing and deployment.
• Preparing a project presentation.

Exercise:

• Perform a final demo of the group project.

---

Class 29: Project Presentation and Evaluation

Objective:
Students present their projects to the class.

Tasks:

• Presentation of the final software project.
• Evaluation of the project based on functionality, documentation, and code quality.

Exercise:

• Present the group project to the class.

---

Class 30: Course Wrap-Up and Review

Objective:
Review the course and provide feedback.

Tasks:

• Discuss lessons learned and challenges faced.
• Provide feedback on the course.

Exercise:

• Final assessment and feedback session.