Complete Software Engineering Notes
Object-Oriented Design (OOD)
Concepts:
- Encapsulation: Binding data and methods into a single unit (class).
- Inheritance: Deriving new classes from existing ones.
- Polymorphism: Ability of different classes to respond to the same message differently.
- Abstraction: Hiding internal implementation and showing only necessary details.
Design Notation & Specification:
- Use UML diagrams (Class, Use Case, Sequence) to visualize class structure, relationships, and
interactions.
Design Methodology:
- Use Case-Driven Development
- Responsibility-Driven Design
- Design Patterns
Metrics:
- Coupling: Degree of interdependence between modules.
- Cohesion: Degree to which elements of a module belong together.
- Depth of Inheritance: Levels in the class hierarchy.
- Number of Children: Number of subclasses inheriting from a class.
Debugging Process
1. Information Gathering: Collect logs, error messages, user feedback.
2. Fault Isolation: Use breakpoints, unit tests, or logging to narrow down the problem.
3. Fault Confirmation: Replicate the error to confirm its existence.
4. Documentation: Document what caused the issue and how it was fixed.
5. Fixing and Verification: Apply the fix and retest the software.
Software Testing
Testing Fundamentals: Ensures the software behaves as intended. Involves verification and
validation.
Functional Testing (Black Box): No knowledge of internal code. Examples: Boundary Value
Analysis, Equivalence Partitioning.
Structural Testing (White Box): Based on code structure. Examples: Statement, Branch, Path
coverage.
Alpha and Beta Testing:
- Alpha Testing: Internal, by developers/testers.
- Beta Testing: External, by end users.
Testing Object-Oriented Programs: Focuses on class-level testing, inheritance, dynamic binding,
encapsulation.
Levels of Testing:
- Unit Testing: Individual modules.
- Integration Testing: Combined modules.
- System Testing: Entire application.
- Acceptance Testing: End-user validation.
Project Management for Special Software Projects
CASE Tools:
- Computer-Aided Software Engineering (CASE) tools assist in design, development, testing.
- Examples: Rational Rose, Jenkins, Selenium.
CBSE (Component-Based Software Engineering):
- Software built from reusable components.
- Benefits: Reduced cost, faster development, modularity.
UML (Unified Modeling Language)
Overview: UML is a modeling language for visualizing, specifying, constructing, and documenting
software systems.
UML Diagrams:
- Class Diagram: Static structure of classes and relationships.
- Use Case Diagram: User interactions.
- Sequence Diagram: Interaction over time.
- Activity Diagram: Workflow.
- State Diagram: State transitions.
- Component Diagram: Components and dependencies.
- Deployment Diagram: Hardware and software deployment.
UML Class Diagram Concepts
Class Notation:
+----------------------+
| ClassName |
+----------------------+
| - attribute: Type |
| + method(): Return |
+----------------------+
- `+` Public, `-` Private, `#` Protected.
Association: Relationship between classes (e.g., Student <-> Course).
Multiplicity: 1, 0..1, *, 1..* (e.g., One Library has * Books).
Generalization: Inheritance (e.g., Animal -> Dog, Cat).
Aggregation: Whole-part relationship (e.g., Department <>-- Professor).
Interfaces: Defined with <<interface>>, implemented by classes.
UML Summary
| Concept | Meaning |
|----------------|-----------------------------------------|
| Class | Object blueprint |
| Association | Relationship between classes |
| Multiplicity | Number of allowable instances |
| Generalization | Inheritance hierarchy |
| Aggregation | Part-whole relationship |
| Interface | Behavioral contract enforced by class |
