.jpg)
1. Define software engineering.
- Software Engineering is the systematic application of engineering principles to the design, development, maintenance, testing, and evaluation of software.
2. What do you mean by SEI-Capability Maturity Model?
- The SEI Capability Maturity Model (CMM) is a framework that assesses and improves the maturity of an organization's software development processes, ranging from Level 1 (Initial) to Level 5 (Optimizing).
3. What do you mean by metrics?
- Metrics are quantitative measures used to assess, compare, and track the performance, quality, and efficiency of software development processes and products.
4. What is white box testing?
- White box testing is a software testing method that involves testing internal structures, logic, and code paths of an application, typically performed by developers.
5. Which software fails?
- Software fails when it does not meet user expectations or requirements, contains bugs or defects, or cannot handle specified conditions or loads, resulting in errors or crashes.
6. What is cohesion?
- Cohesion refers to the degree to which the elements within a module are functionally related and work together to achieve a single, well-defined purpose.
7. What is validation in software development?
- Validation in software development is the process of evaluating software during or at the end of the development process to ensure it meets the requirements and fulfills its intended purpose.
8. What is client-server environment?
- A client-server environment is a network architecture where client devices request services and resources from centralized servers, which process and respond to these requests.
9. What are size metrics? How is function point metric advantageous over LOC metric?
- Size metrics are measures used to quantify the size of a software product. Common size metrics include Lines of Code (LOC) and Function Points (FP).
- LOC (Lines of Code): Measures the number of lines in the source code.
- Function Points (FP): Measures the functionality provided to the user, based on the complexity of inputs, outputs, user interactions, files, and external interfaces.
Advantages of Function Points over LOC:
1. Language Independence: Function points are not tied to any specific programming language, making them a more universal metric.
2. User-Oriented: FP focuses on the functionality delivered to the user rather than the volume of code, aligning more closely with user requirements.
3. Early Estimation: FP can be estimated early in the development process, even before the code is written, aiding in project planning and management.
4. Productivity Measurement: FP provides a better measure of developer productivity and software value by focusing on delivered functionality rather than raw code volume.
5. Comparison Across Projects: FP allows for more meaningful comparisons between projects with different programming languages and development environments.
10. How do you assess the quality of software design? Discuss SQA plan.
Assessing Software Design Quality:
1. Modularity: Evaluates if the design breaks the system into distinct modules with clear interfaces.
2. Cohesion and Coupling: Assesses the degree to which module components work together (high cohesion) and the extent of dependencies between modules (low coupling).
3. Scalability: Ensures the design can handle increased loads without significant rework.
4. Maintainability: Checks if the design allows easy updates, bug fixes, and feature additions.
5. Compliance with Standards: Verifies that the design adheres to industry and organizational standards.
SQA Plan:
1. Objectives: Define the goals of software quality assurance, focusing on defect prevention and process improvement.
2. Scope: Outline the software components and processes covered by the SQA plan.
3. Standards and Procedures: Specify the standards, guidelines, and procedures to be followed for ensuring quality.
4. Roles and Responsibilities: Define the roles and responsibilities of the SQA team and other stakeholders.
5. Review and Audits: Plan regular reviews and audits to ensure compliance with standards and identify areas for improvement.
6. Testing Strategies: Detail the testing methodologies and tools to be used for verifying software quality.
7. Metrics and Reporting: Define the metrics for assessing quality and the reporting mechanisms to track and communicate progress.
8. Continuous Improvement: Outline procedures for continuous process improvement based on feedback and performance metrics.
11. What is meant by modular design? When and how should a modular design be implemented?
Modular Design:
- Modular design is the process of dividing a software system into discrete, self-contained modules that can be developed, tested, and maintained independently. Each module encapsulates a specific functionality or a set of related functions.
When to Implement Modular Design:
- Implement modular design during the system design phase, after the requirements analysis and before detailed design and coding. It should be considered when the system is large and complex, requiring high maintainability, scalability, and reusability.
How to Implement Modular Design:
1. Identify Modules: Break down the system into functional components or modules based on functionality, requirements, and dependencies.
2. Define Interfaces: Clearly specify the interfaces between modules, detailing how they will interact and communicate with each other.
3. Encapsulation: Ensure each module encapsulates its data and functions, exposing only necessary interfaces to other modules.
4. High Cohesion and Low Coupling: Design modules with high cohesion (focused on a single task) and low coupling (minimal dependencies on other modules).
5. Iterative Development: Develop, test, and integrate modules iteratively, allowing for independent testing and debugging.
6. Documentation: Document the design, interfaces, and interactions between modules to ensure clarity and facilitate maintenance.
12. Write a detailed note on black box testing.
Black Box Testing:
- Black box testing is a software testing method that focuses on evaluating the functionality of an application without examining its internal code structure or implementation details. The tester interacts with the application through its user interface, providing inputs and verifying outputs against expected results.
Characteristics:
1. Test Cases Based on Requirements: Test cases are derived from the software requirements and specifications, ensuring the application behaves as expected under various scenarios.
2. No Knowledge of Internal Code: The tester does not need to understand the internal workings of the application, focusing instead on what the software does.
3. User Perspective: Tests are conducted from the end-user's perspective, simulating real-world usage and validating the software's external behavior.
Types of Black Box Testing:
1. Functional Testing: Verifies that each function of the software operates according to the requirements.
2. Non-Functional Testing: Assesses non-functional aspects such as performance, usability, reliability, and security.
3. Regression Testing: Ensures that new code changes do not adversely affect existing functionality.
4. Acceptance Testing: Validates the software against business requirements to determine if it is ready for deployment.
**Advantages**:
1. **Unbiased Testing**: Since the tester is unaware of the internal code, testing is unbiased and focused solely on functionality.
2. **User-Centric**: Ensures that the application meets user requirements and provides a positive user experience.
3. **Early Detection of Issues**: Helps identify functional issues early in the development process.
Disadvantages:
1. Limited Coverage: May not cover all possible input scenarios and edge cases.
2. Inefficiency in Identifying Internal Errors: May not be effective in detecting internal code errors, as it focuses on external behavior..
13. Explain in brief about Project scheduling using PERT and GANTT charts.
Project Scheduling with PERT and GANTT Charts:
PERT (Program Evaluation and Review Technique):
1. Purpose: PERT is a project management tool used to plan, schedule, and control complex projects by analyzing the tasks required to complete a project and their interdependencies.
2. Components:
- Tasks/Activities: Individual units of work.
- Events/Milestones: Key points marking the start or end of tasks.
- Dependencies: Relationships between tasks, indicating the sequence of activities.
3. Network Diagram: PERT uses a network diagram to visually represent tasks, events, and dependencies. Nodes represent events, and directed edges represent tasks.
4. Time Estimates: PERT involves three time estimates for each task: optimistic, pessimistic, and most likely. The expected time is calculated using these estimates.
5. Critical Path: The longest path through the network diagram, representing the minimum time required to complete the project. Tasks on the critical path are critical tasks.
GANTT Charts:
1. Purpose: Gantt charts are a visual project management tool used to represent the schedule of tasks or activities over time.
2. Components:
- Tasks/Activities: Listed on the vertical axis.
- Time: Represented on the horizontal axis.
- Bars: Each task is represented by a horizontal bar, indicating its start and end dates.
3. Visual Representation: Gantt charts provide a clear, visual timeline of project tasks, showing their duration, start and end dates, and overlaps.
4. Progress Tracking: Gantt charts can be used to track progress by shading the completed portions of task bars.
5. Dependencies and Milestones: Can include task dependencies and milestones for a comprehensive view of the project schedule.
Advantages of PERT:
1. Handles Uncertainty: PERT's use of multiple time estimates accounts for uncertainty in task durations.
2. Identifies Critical Path: Helps identify the critical path and critical tasks, enabling better resource allocation and prioritization.
Advantages of Gantt Charts:
1. Simple and Intuitive: Easy to understand and use for planning and tracking project progress.
2. Visual Clarity: Provides a clear, visual timeline of tasks and their relationships.
15. What are the five levels of CMM? List important features of each of these levels.
Capability Maturity Model (CMM) outlines five levels of process maturity for software development organizations:
1. Initial Level:
- Features: Processes are ad hoc, chaotic, and not standardized.
- Characteristics: Success depends on individual efforts, and projects may exceed budget and schedule.
2. Managed Level:
- Features: Basic project management processes are established.
- Characteristics: Processes are planned, documented, performed, monitored, and controlled at the project level. Projects are managed according to their documented plans.
3. Defined Level:
- Features: Processes are well-defined and documented.
- Characteristics: Standard processes are used across the organization and adapted to suit project needs. There is a focus on standardizing processes and training employees.
4. Quantitatively Managed Level:
- Features: Processes are quantitatively measured and controlled.
- Characteristics: Detailed measures of process performance are collected and used to manage processes. Continuous process improvement is enabled through quantitative feedback.
5. Optimizing Level:
- Features: Focus on continuous process improvement.
- Characteristics: Best practices are identified and shared across the organization. Emphasis on innovation and leveraging improvements to gain a competitive edge.
16. (a) What is the difference between decision table and decision tree?
(a) Decision Table:
- Definition: A decision table is a tabular representation of conditions and actions or decisions.
- Usage: Used for representing complex business rules or conditions in a structured format.
- Example:
Condition 1 | Condition 2 | Action
---------------------------------
True | True | A
False | True | B
True | False | C
False | False | D (code-box)
(b) Difference Among Formal, Semi-Formal, and Informal Methods of Software Development?
- Formal Methods:
- Definition: Rigorous mathematical techniques for specifying and verifying software systems.
- Characteristics: Use of formal languages and mathematical notations; proofs of correctness.
- Semi-Formal Methods:
- Definition: Blend of informal and formal methods; includes structured methods and techniques.
- Characteristics: Uses models, diagrams, and structured documentation; less rigorous than formal methods.
- Informal Methods:
- Definition: Ad hoc or informal techniques used in software development.
- Characteristics: Relies on natural language, diagrams, and informal techniques like brainstorming and informal reviews.
17. Software Life Cycle Models.
(a) Prototyping Model:
- Description: Iterative model where a prototype (an early approximation of a final system or product) is developed and refined through feedback.
- Process: Initial requirements gathering, prototype development, feedback, refinement, and final system development.
- Advantages: Enhances user involvement and feedback early in the process, facilitates risk reduction and requirements validation.
- Disadvantages: May lead to scope creep, potential for miscommunication regarding prototype vs. final product.
(b) Spiral Model:
- Description: Iterative and risk-driven model integrating elements of both design and prototyping in stages.
- Process: Iterative cycles of planning, risk assessment, engineering, and evaluation.
- Advantages: Accommodates changes and unknowns through iterative approach, emphasizes risk management and mitigation, suitable for large, complex projects.
- Disadvantages: Complex to manage and require expertise, may lead to increased cost and time due to iterative nature.
.jpg)