Combined Bank Senior Officer (AME/AE) Written Exam: 2021প্রশ্ন ও সমাধান

Printers are classified by whether the printing mechanism physically strikes the paper.

Impact printer — the print head (a metal or plastic hammer, pin or character wheel) strikes an inked ribbon against the paper, pressing ink onto the sheet, exactly like a typewriter. Because there is mechanical contact, an impact printer can print through carbon/multi-part stationery in one pass.

Non-impact printer — characters and images are formed without any contact between the printing mechanism and the paper. Ink is sprayed, fused or heated onto the sheet instead.

graph TD
    P[Printers] --> I[Impact - head strikes ribbon]
    P --> N[Non-impact - no physical contact]
    I --> I1[Dot-matrix]
    I --> I2[Daisy-wheel / Ball]
    I --> I3[Line, Drum, Chain, Band]
    N --> N1[Inkjet - sprays ink droplets]
    N --> N2[Laser - toner fused by drum and heat]
    N --> N3[Thermal - heat-sensitive paper]
    N --> N4[Plotter / 3D / LED]

Basis	Impact Printer	Non-Impact Printer
Working principle	Print head strikes an ink ribbon against paper	Ink is sprayed / toner is fused / paper is heated
Physical contact	Yes	No
Noise	Loud, mechanical	Almost silent
Speed	Slow (characters per second / lines per minute)	Fast (pages per minute)
Print quality	Low to medium, dotted characters	High resolution, crisp text and photo graphics
Colour & graphics	Poor / limited	Excellent
Carbon copies	Can print multi-part forms in one pass	Cannot
Cost of machine	Cheap	Higher
Running cost per page	Very low (ribbon)	Higher (cartridge / toner)
Maintenance	High (many moving parts)	Low
Examples	Dot-matrix, daisy-wheel, drum, chain, line printer	Inkjet, laser, thermal, LED, plotter
Typical use	Bank passbooks, utility bills, railway tickets, invoices needing duplicate copies	Office documents, reports, photographs, POS receipts (thermal)

How the two commonest types work

• Dot-matrix (impact): a column of 9 or 24 pins fires against the ribbon; the pattern of dots forms each character. 24-pin heads give near-letter-quality output.
• Laser (non-impact): a laser beam draws the page as an electrostatic latent image on a rotating photosensitive drum; charged toner powder sticks to that image, is transferred to the paper and permanently fused by a hot roller.
• Inkjet (non-impact): microscopic droplets of liquid ink are ejected from nozzles either by a heating element (thermal bubble) or by a piezoelectric crystal.

Exam takeaway: Impact = contact + ribbon + noisy + slow but can make carbon copies (dot-matrix); non-impact = no contact + quiet + fast + high quality (laser, inkjet). That is why banks still use dot-matrix printers for passbooks and multi-copy vouchers.

POP (Procedure-Oriented Programming) decomposes a problem into a sequence of functions/procedures that operate on shared data — C, Pascal, FORTRAN. OOP (Object-Oriented Programming) decomposes a problem into objects that bundle data and the operations on that data together — C++, Java, C#, Python.

Basis	OOP	POP
Full form	Object-Oriented Programming	Procedure-Oriented Programming
Basic unit	Object (data + methods)	Function / procedure
Design approach	Bottom-up — build objects, then compose the system	Top-down — split the main task into sub-tasks
Focus	Data (data is central, functions serve the data)	Functions/logic (data moves freely between functions)
Data security	High — encapsulation + access specifiers (private, protected, public)	Low — global data is accessible to every function
Data hiding	Supported	Not supported
Inheritance	Supported (code reuse, is-a hierarchies)	Not supported
Polymorphism / overloading	Supported (compile-time and run-time)	Not supported
Abstraction	Via abstract classes and interfaces	Only procedural abstraction
Adding new data/functions	Easy — extend a class or derive a new one	Difficult — often needs edits across many functions
Suitability	Large, complex, evolving software	Small to medium programs, system/embedded code
Examples	C++, Java, C#, Python, Smalltalk	C, Pascal, FORTRAN, BASIC, COBOL

Four pillars that OOP adds over POP: Encapsulation, Abstraction, Inheritance, Polymorphism.

classDiagram
    class Account {
        -string accNo
        -double balance
        +deposit(double amt) void
        +withdraw(double amt) void
        +getBalance() double
    }
    class SavingsAccount {
        -double rate
        +addInterest() void
    }
    class CurrentAccount {
        -double overdraftLimit
    }
    Account <|-- SavingsAccount
    Account <|-- CurrentAccount

Concrete example — the same job written both ways

/* POP (C): data is global / passed around, anyone can corrupt it */
double balance = 1000;
void deposit(double amt) { balance += amt; }   /* nothing stops balance = -9999; */

// OOP (C++): the data is locked inside the object, reachable only through methods
class Account {
private:
    double balance;                       // encapsulated - cannot be touched directly
public:
    Account(double b) : balance(b) {}
    void deposit(double amt) {            // the class enforces the business rule
        if (amt > 0) balance += amt;
    }
    double getBalance() const { return balance; }
};

In the POP version any stray line of code can set balance to a nonsense value; in the OOP version the invariant is protected by the class itself. Adding a SavingsAccount in OOP requires only inheritance, while in POP every function that manipulates accounts must be rewritten.

Exam takeaway: POP = top-down, function-centric, global data, no inheritance; OOP = bottom-up, object-centric, encapsulated data, supports inheritance and polymorphism — which is why OOP scales to large systems.