Definition: Requirement Engineering (RE) is a systematic process of defining, documenting, and maintaining the requirements for a software system. It acts as a bridge between the customer's needs and the software development team. --- - ...

Note: No specific reference notes were found for this topic. The following answer is based on standard Software Engineering curriculum as taught in BSc CSIT programs. --- Requirements elicitation is the process of gathering, discovering,...

Black box testing is a software testing technique in which the internal structure, design, or implementation of the system is not known to the tester. The tester only focuses on the inputs and outputs of the system without any knowledge ...

Short Notes

a. Agile Software Development

Agile software development is an iterative and incremental approach to software development that focuses on delivering working software quickly, responding to change, and close collaboration between developers and customers.

Key Principles (Agile Manifesto):

• Individuals and interactions over processes and tools
• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan

Characteristics:

• Development is done in short cycles called sprints or iterations (typically 2-4 weeks)
• Requirements are allowed to evolve throughout the project
• Continuous feedback from the customer is incorporated
• Self-organizing, cross-functional teams work together
• Regular reflection and adaptation of processes

Popular Agile Methods:

• Scrum - uses sprints, daily stand-ups, sprint reviews
• Extreme Programming (XP) - focuses on coding practices
• Kanban - visual workflow management

Advantages:

• Faster delivery of working software
• Better adaptability to changing requirements
• Higher customer satisfaction

b. Context Model

A context model is used to illustrate the operational context of a system - it shows what lies outside the system boundaries (the environment in which the system operates) and defines what is included in and excluded from the system.

Purpose:

• To define the system boundary
• To identify external entities (other systems, people, organizations) that interact with the system
• To show the relationships and interactions between the system and its environment

Key Features:

• It does not show the nature of the relationships in detail
• It helps stakeholders understand the scope of the system
• External entities are shown as boxes or actors outside the system boundary

Example Representation:

[Payroll System] <---> [Employee Database]
[Payroll System] <---> [Bank System]
[Payroll System] <---> [HR Manager]

Types of Models Used:

• Activity diagrams can supplement context models to show how the system is used in business processes
• UML use case diagrams can also represent context

Importance:

• Helps avoid scope creep by clearly defining boundaries
• Assists in identifying all external dependencies
• Provides a foundation for further detailed modeling

Version Management

Definition

Version management (also called version control or revision control) is the process of tracking and controlling changes made to software source code, documents, and other files over time. It allows multiple versions of a software system to be stored and retrieved, enabling developers to manage the evolution of software components systematically.

Key Concepts in Version Management

• Version/Revision: A distinct state of a software component at a particular point in time.
• Baseline: A tested, approved version that serves as the basis for further development.
• Repository: A central storage location where all versions of files are maintained.
• Check-in / Check-out: The process of submitting changes to or retrieving files from the repository.

How Version Management is Carried Out

1. Version Identification

Each version of a component is assigned a unique identifier (e.g., v1.0, v1.1, v2.0). Versions may be identified by:

• Sequential numbering
• Date/time stamps
• Attribute-based identification (author, date, purpose)

2. Storage and Repository Management

All versions are stored in a version control repository (e.g., Git, SVN, CVS). The repository maintains:

• Complete history of all changes
• Who made the change and when
• Why the change was made (commit messages)

3. Check-out and Check-in Mechanism

• A developer checks out a file to work on it (may lock it to prevent conflicts).
• After modification, the developer checks in the updated file, creating a new version.

4. Branching and Merging

• Branching: Creating a separate line of development (e.g., for a new feature or bug fix) without affecting the main codebase.
• Merging: Combining changes from different branches back into the main branch.

Main:    v1.0 -----> v1.1 -----> v2.0
                \               /
Branch:          --> fix-branch

5. Change Logging

Every version change is recorded with:

• Description of changes made
• Author name
• Date and time
• Version number

6. Conflict Resolution

When two developers modify the same file, the version management system detects conflicts and assists in resolving them before merging.

Benefits of Version Management

Common Version Management Tools

• Git (most widely used, distributed)
• SVN (Subversion) (centralized)
• CVS (Concurrent Versions System)
• Mercurial

Note: Version management is a core part of Software Configuration Management (SCM), which also includes build management, change management, and release management.

Test Driven Development (TDD)

Note: No specific reference notes were found for this topic. The following answer is based on standard Software Engineering curriculum content appropriate for BSc CSIT, Tribhuvan University.

Definition

Test Driven Development (TDD) is a software development approach in which test cases are written before the actual code is written. The developer first writes a failing test, then writes the minimum amount of code to pass that test, and finally refactors the code. This cycle is repeated throughout the development process.

TDD follows the principle: "Write tests first, then write code to satisfy those tests."

The TDD Cycle (Red-Green-Refactor)

The core process of TDD follows three repeating steps:

1. RED    --> Write a test that FAILS (feature not yet implemented)
2. GREEN  --> Write just enough code to PASS the test
3. REFACTOR --> Clean up the code without breaking the test

This cycle is also known as the "Red-Green-Refactor" cycle.

Steps in TDD Process

1. Add a Test

   • Before writing any functional code, write a test case for the new feature or function.
   • The test will fail initially because the feature does not exist yet.

2. Run All Tests

   • Run the test suite to confirm the new test fails (Red phase).
   • This verifies the test is valid and the feature is truly missing.

3. Write the Code

   • Write the minimum amount of code necessary to make the failing test pass.
   • Do not write extra or unnecessary code at this stage.

4. Run Tests Again

   • Run all tests to confirm the new test now passes (Green phase).
   • Ensure no existing tests are broken.

5. Refactor the Code

   • Clean up the code: remove duplication, improve readability, optimize structure.
   • Run tests again to ensure refactoring did not break anything.

6. Repeat

   • Repeat the cycle for the next feature or requirement.

Diagram of TDD Cycle

        +------------------+
        |  Write a Test    |  <--- (Test Fails - RED)
        +--------+---------+
                 |
                 v
        +------------------+
        |  Write Code to   |  <--- (Test Passes - GREEN)
        |  Pass the Test   |
        +--------+---------+
                 |
                 v
        +------------------+
        |  Refactor Code   |  <--- (Clean Code - REFACTOR)
        +--------+---------+
                 |
                 v
           (Repeat Cycle)

Advantages of TDD

Disadvantages of TDD

Summary

Conclusion: TDD is a powerful development methodology that improves code quality, reduces bugs, and increases developer confidence. However, it requires discipline, proper training, and is most effective when applied consistently throughout the development lifecycle.

Model Driven Architecture (MDA) is a software development approach proposed by the Object Management Group (OMG) that focuses on creating and exploiting domain models (abstract representations of the problem domain) rather than focusing ...

Definition: Requirement Engineering (RE) is a systematic process of defining, documenting, and maintaining the requirements for a software system. It acts as a bridge between the customer's needs and the software development team. --- - ...

Note: No specific reference notes were found for this topic. The following answer is based on standard Software Engineering curriculum as taught in BSc CSIT programs. --- Requirements elicitation is the process of gathering, discovering,...

Black box testing is a software testing technique in which the internal structure, design, or implementation of the system is not known to the tester. The tester only focuses on the inputs and outputs of the system without any knowledge ...

Short Notes

a. Agile Software Development

Agile software development is an iterative and incremental approach to software development that focuses on delivering working software quickly, responding to change, and close collaboration between developers and customers.

Key Principles (Agile Manifesto):

• Individuals and interactions over processes and tools
• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan

Characteristics:

• Development is done in short cycles called sprints or iterations (typically 2-4 weeks)
• Requirements are allowed to evolve throughout the project
• Continuous feedback from the customer is incorporated
• Self-organizing, cross-functional teams work together
• Regular reflection and adaptation of processes

Popular Agile Methods:

• Scrum - uses sprints, daily stand-ups, sprint reviews
• Extreme Programming (XP) - focuses on coding practices
• Kanban - visual workflow management

Advantages:

• Faster delivery of working software
• Better adaptability to changing requirements
• Higher customer satisfaction

b. Context Model

A context model is used to illustrate the operational context of a system - it shows what lies outside the system boundaries (the environment in which the system operates) and defines what is included in and excluded from the system.

Purpose:

• To define the system boundary
• To identify external entities (other systems, people, organizations) that interact with the system
• To show the relationships and interactions between the system and its environment

Key Features:

• It does not show the nature of the relationships in detail
• It helps stakeholders understand the scope of the system
• External entities are shown as boxes or actors outside the system boundary

Example Representation:

[Payroll System] <---> [Employee Database]
[Payroll System] <---> [Bank System]
[Payroll System] <---> [HR Manager]

Types of Models Used:

• Activity diagrams can supplement context models to show how the system is used in business processes
• UML use case diagrams can also represent context

Importance:

• Helps avoid scope creep by clearly defining boundaries
• Assists in identifying all external dependencies
• Provides a foundation for further detailed modeling

Version Management

Definition

Version management (also called version control or revision control) is the process of tracking and controlling changes made to software source code, documents, and other files over time. It allows multiple versions of a software system to be stored and retrieved, enabling developers to manage the evolution of software components systematically.

Key Concepts in Version Management

• Version/Revision: A distinct state of a software component at a particular point in time.
• Baseline: A tested, approved version that serves as the basis for further development.
• Repository: A central storage location where all versions of files are maintained.
• Check-in / Check-out: The process of submitting changes to or retrieving files from the repository.

How Version Management is Carried Out

1. Version Identification

Each version of a component is assigned a unique identifier (e.g., v1.0, v1.1, v2.0). Versions may be identified by:

• Sequential numbering
• Date/time stamps
• Attribute-based identification (author, date, purpose)

2. Storage and Repository Management

All versions are stored in a version control repository (e.g., Git, SVN, CVS). The repository maintains:

• Complete history of all changes
• Who made the change and when
• Why the change was made (commit messages)

3. Check-out and Check-in Mechanism

• A developer checks out a file to work on it (may lock it to prevent conflicts).
• After modification, the developer checks in the updated file, creating a new version.

4. Branching and Merging

• Branching: Creating a separate line of development (e.g., for a new feature or bug fix) without affecting the main codebase.
• Merging: Combining changes from different branches back into the main branch.

Main:    v1.0 -----> v1.1 -----> v2.0
                \               /
Branch:          --> fix-branch

5. Change Logging

Every version change is recorded with:

• Description of changes made
• Author name
• Date and time
• Version number

6. Conflict Resolution

When two developers modify the same file, the version management system detects conflicts and assists in resolving them before merging.

Benefits of Version Management

Common Version Management Tools

• Git (most widely used, distributed)
• SVN (Subversion) (centralized)
• CVS (Concurrent Versions System)
• Mercurial

Note: Version management is a core part of Software Configuration Management (SCM), which also includes build management, change management, and release management.

Class Diagram for Online Voting System

Description of Classes and Relationships

The following class diagram represents an Online Voting System with registration, validation, voting, and result generation functionalities.

Class Diagram (UML Notation)

+------------------+          +----------------------+
|      User        |          |    Registration      |
+------------------+          +----------------------+
| - userId: int    |1       1 | - regId: int         |
| - name: String   |----------| - email: String      |
| - email: String  |          | - password: String   |
| - password: String|         | - status: String     |
| - isEligible: bool|         +----------------------+
+------------------+          | + register(): void   |
| + login(): bool  |          | + validate(): bool   |
| + logout(): void |          | + getStatus(): String|
| + viewResult():void|        +----------------------+
+------------------+
        |
        | 1
        |
        | (after validation)
        |
        | *
+------------------+          +------------------+
|      Vote        |          |    Candidate     |
+------------------+          +------------------+
| - voteId: int    |  *     1 | - candidateId:int|
| - userId: int    |----------| - name: String   |
| - candidateId:int|          | - party: String  |
| - voteTime:DateTime         | - voteCount: int |
+------------------+          +------------------+
| + castVote():bool|          | + getVoteCount() |
| + confirmVote()  |          |     : int        |
+------------------+          | + updateCount()  |
        |                     |     : void       |
        |                     +------------------+
        |                            |
        |                            | 1
        |                            |
        | *                          | *
+------------------+          +------------------+
|   Validation     |          |     Result       |
+------------------+          +------------------+
| - validationId   |          | - resultId: int  |
| - userId: int    |          | - candidateId:int|
| - isVerified:bool|          | - totalVotes: int|
+------------------+          | - rank: int      |
| + checkEligibility|         +------------------+
|     (): bool     |          | + generateResult()|
| + verifyUser()   |          |     : void       |
|     : bool       |          | + displayResult()|
+------------------+          |     : void       |
                              | + getWinner()    |
                              |     : Candidate  |
                              +------------------+

Relationships Summary

Key Design Points

1. User registers through the Registration class and is validated before being marked eligible (isEligible = true).
2. Validation class checks user credentials and eligibility before allowing voting.
3. Vote class records each vote with timestamp, linking user and candidate.
4. Candidate maintains a running voteCount updated on each vote.
5. Result class aggregates all votes and generates the final result with rankings and total vote counts.

An architectural view is a representation of a software system from a specific perspective, addressing the concerns of particular stakeholders. The most widely accepted model for describing software architecture using multiple views is t...

Short Notes

a) Non-Functional Requirements

Non-functional requirements (NFRs) define the quality attributes and constraints of a system rather than specific behaviors or functions. They describe how the system performs its functions, not what it does.

Key Characteristics:

• Also called quality requirements or system quality attributes
• They apply to the system as a whole, not to individual features
• Failure to meet NFRs can make the entire system unacceptable

Common Types of Non-Functional Requirements:

Importance:

• They constrain the design and implementation choices
• They are often more critical than functional requirements
• They are typically measurable and testable

b) Principles of Agile

Agile is a software development philosophy based on iterative development, collaboration, and flexibility. The Agile Manifesto (2001) defines 12 guiding principles:

Core Values (Agile Manifesto):

• Individuals and interactions over processes and tools
• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan

The 12 Principles of Agile:

1. Customer Satisfaction - Highest priority is to satisfy the customer through early and continuous delivery of valuable software.

2. Welcome Change - Welcome changing requirements, even late in development.

3. Frequent Delivery - Deliver working software frequently (weeks rather than months).

4. Collaboration - Business people and developers must work together daily throughout the project.

5. Motivated Individuals - Build projects around motivated individuals; give them the environment and trust they need.

6. Face-to-Face Communication - The most efficient method of conveying information is face-to-face conversation.

7. Working Software - Working software is the primary measure of progress.

8. Sustainable Development - Agile processes promote sustainable development at a constant pace.

9. Technical Excellence - Continuous attention to technical excellence and good design enhances agility.

10. Simplicity - The art of maximizing the amount of work NOT done is essential.

11. Self-Organizing Teams - The best architectures, requirements, and designs emerge from self-organizing teams.

12. Regular Reflection - At regular intervals, the team reflects on how to become more effective and adjusts accordingly.

Key Benefit:

Agile allows teams to adapt quickly to changing requirements, deliver value incrementally, and maintain high quality through continuous feedback and improvement.