Exercise 1: What Changed and What Stayed the Same Between BALCHECK and IS-VALID-BALANCE — Possible Solution ==================================================================== WHAT GENUINELY STAYED THE SAME This chapter's own material states directly that "the real logic inside IS-VALID-BALANCE is identical to Fundamentals' own BALCHECK." Both check whether a real balance value is negative, and both set a real one-character result field to "Y" or "N" accordingly. The LINKAGE SECTION shape - a signed numeric balance field and a one-character result field, received via PROCEDURE DIVISION USING - is also genuinely unchanged between the two versions. WHAT GENUINELY CHANGED: WHERE THE CODE LIVES Fundamentals' own Chapter 9 BALCHECK is a real, standalone subprogram - its own complete compiled unit, headed by PROGRAM-ID, invoked directly via CALL "BALCHECK" USING .... This chapter's own IS-VALID-BALANCE, by contrast, is a real METHOD-ID entry nested inside an OBJECT block, itself nested inside a CLASS-ID definition - CUSTOMER-VALIDATOR. The method doesn't exist as its own independent compiled program the way BALCHECK does; it exists as one piece belonging to a real class. WHAT GENUINELY CHANGED: HOW IT'S INVOKED BALCHECK is invoked with a real, direct CALL "BALCHECK" USING WS-BALANCE WS-VALID-FLAG. IS-VALID-BALANCE, being a real method rather than a standalone program, is invoked differently - either through a real INVOKE VALIDATOR-OBJ "IS-VALID-BALANCE" USING ... statement naming both the object and the method, or through the real inline shorthand, VALIDATOR-OBJ::"IS-VALID-BALANCE". Both of these genuinely require a real object (VALIDATOR-OBJ) to invoke the method against, a concept BALCHECK's own plain CALL never needed at all. WHY THIS DIFFERENCE IS GENUINELY STRUCTURAL, NOT COSMETIC This chapter's own material frames the real change directly: "the genuine change is structural: a method now belongs to a real class, callable on a real object, rather than existing as a standalone subprogram." The underlying validation logic staying identical shows that object orientation here is genuinely a difference in how code is organized and invoked, not a difference in what the code actually computes. ANSWER: The real validation logic - checking whether a balance is negative and setting a one-character result field - is genuinely identical between BALCHECK and IS-VALID-BALANCE, as is the real LINKAGE SECTION shape receiving those two parameters. What genuinely changed is structural: BALCHECK is a standalone subprogram invoked directly via CALL, while IS-VALID-BALANCE is a method belonging to the CUSTOMER-VALIDATOR class, invoked either via INVOKE naming both an object and the method, or via the real inline object::"method" shorthand - both of which require a real object to invoke the method against, a concept the plain subprogram version never needed. WHY THIS WORKS AS AN ANSWER ------------------------------ This correctly separates what stayed identical (the real business logic) from what changed (the structural packaging and invocation mechanism), grounding both halves directly in this chapter's own stated comparison to Fundamentals' own BALCHECK.