IFIC Bank — Officer IT — Exam: 2025 (IFIC)প্রশ্ন ও সমাধান

SDLC (Software Development Life Cycle) is a structured, phase-wise process/framework followed by software teams to plan, design, build, test, deploy, and maintain software, ensuring quality and predictability rather than ad-hoc coding.

The 6 core phases:

flowchart LR
    A[1. Requirement Analysis] --> B[2. Design]
    B --> C[3. Implementation / Coding]
    C --> D[4. Testing]
    D --> E[5. Deployment]
    E --> F[6. Maintenance]
    F -.feedback.-> A

Phase	Key Activity	Output
1. Requirement Analysis	Gather and document what the system must do	SRS (Software Requirement Specification)
2. Design	Architecture, database schema, UI/UX, module breakdown	Design document, ER/UML diagrams
3. Implementation	Actual coding per design	Source code
4. Testing	Unit, integration, system, UAT testing to find bugs	Test reports, verified build
5. Deployment	Release to production/end users	Live/running system
6. Maintenance	Fix bugs, patches, add features post-release	Updated releases

• SDLC can follow different models: Waterfall (strictly sequential), Agile (iterative sprints), Spiral (risk-driven iterations), V-Model (testing paired with each dev phase).
• Following SDLC reduces the cost of late-discovered defects, improves stakeholder alignment, and gives measurable milestones/documentation for large government/enterprise projects.

Exam takeaway: SDLC = Requirement Analysis → Design → Implementation → Testing → Deployment → Maintenance, a repeatable framework instantiated differently by models like Waterfall or Agile.

Polymorphism means "many forms" — the ability of the same function/operator name to behave differently depending on context. It comes in two kinds, distinguished by when the correct version is decided.

Feature	Compile-time (Static) Polymorphism	Runtime (Dynamic) Polymorphism
Resolved	At compile time	At run time
Achieved via	Function overloading, operator overloading	Method overriding (with virtual functions/inheritance)
Binding	Early/static binding	Late/dynamic binding
Speed	Faster (no lookup needed at runtime)	Slightly slower (vtable lookup)
Flexibility	Less flexible	More flexible — "one interface, many implementations"

Compile-time example — function overloading:

class Calc {
public:
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
};
// Compiler decides which add() to call based on argument types - before the program runs

Runtime example — method overriding:

class Animal {
public:
    virtual void sound() { cout << "Animal sound" << endl; }
};
class Dog : public Animal {
public:
    void sound() override { cout << "Bark" << endl; }
};
int main() {
    Animal* a = new Dog();
    a->sound();   // Output: Bark - decided at runtime via the vtable, using the actual object type (Dog), not the pointer type (Animal)
}

Exam takeaway: overloading (same name, different parameters, resolved at compile time) = static polymorphism; overriding (virtual + inheritance, resolved via the actual object at runtime) = dynamic polymorphism.