7.

1 THE PROGRAM DEVELOPMENT LIFECYCLE

#TPDL Is DIVIDED INTO FIVE sTAGEs-

ANALYsIs , DEsIGN, CODING, TEsTING AND
MAINTENANCE.

#IF ANY PRObLEM Is bEING sOLVED FIRsT THE

PRObLEM sOLVER sHOuLD kNOw wHAT Is THE
PRObLEM AbOuT sO THE PRObLEM sHOuLD bE
ANALYsED OR DEFINED PROPERLY THAT THE
PRObLEM sOLVER COuLD uNDERsTAND AND THIs
Is CALLED As 'REquIREMENTs sPECIFICATION'
FOR THE PROGRAM. THIs ANALYsIs sTAGE usEs
AbsTRACTION AND DECOMPOsITION TOOLs TO
IDENTIFY ExACTLY wHAT Is REquIRED FOR THE
PROGRAM.

#AbsTRACTION Is THE kEY ELEMENT REquIRED

FOR PRObLEM sOLVING AND IT's wORk Is TO
DIsCARD ANY uNNECEssARY DETAILs AND
INFORMATION THAT Is NOT REquIRED.
#sO bAsICALLY DECOMPOsITION bREAks DOwN
THE PRObLEM INTO sMALLER PARTs AND INTO
MORE sMALLER PARTs THAT CAN bE sOLVED.

COMPuTER sYsTEMs, sub-sYsTEMs AND

DECOMPOsITION

# COMPuTER sYsTEMs ARE MADE uP OF

sOFTwARE, HARDwARE AND COMMuNICATION
AND IT CAN FuRTHER DIVIDED INTO A sET OF sub
sYsTEMs AND THEsE CAN bE FuRTHER DIVIDED
INTO sub sYsTEMs sO uNTIL THAT ONE sub
sYsTEM CAN PERFORM ONLY ONE ACTION AT A
TIME.

# sO bAsICALLY IN OuR DAILY LIFE's wE usE

MANY COMPuTER sYsTEMs wITHOuT EVEN
kNOwING LIkE FOR ExAMPLE ALARM CLOCks
wHEATHER FORCAsT AND MANY OTHERs.

#FLOwCHARTs AND PsEuDOCODE ARE bOTH

TOOLs usED IN COMPuTER PROGRAMMING TO
PLAN AND DOCuMENT THE LOGIC OF A PROGRAM
OR ALGORITHM bEFORE IT's ACTuALLY wRITTEN
IN A sPECIFIC PROGRAMMING LANGuAGE. THEY
sERVE As bLuEPRINTs FOR THE CODE. HERE's A
bREAkDOwN OF EACH:
FLOwCHARTs
* wHAT IT Is: A FLOwCHART Is A VIsuAL
REPREsENTATION OF A PROCEss OR
ALGORITHM. IT usEs sYMbOLs AND ARROws TO
DEPICT THE sTEPs INVOLVED AND THE ORDER IN
wHICH THEY OCCuR.
* HOw IT wORks: DIFFERENT sHAPEs
REPREsENT DIFFERENT ACTIONs OR DECIsIONs:
* OVALs: sTART AND END POINTs OF THE
PROCEss.
* RECTANGLEs: PROCEssING sTEPs OR
INsTRuCTIONs.
* DIAMONDs: DECIsION POINTs wITH YEs/NO OR
TRuE/FALsE OuTCOMEs.
* ARROws: sHOw THE FLOw OF CONTROL OR
THE sEquENCE OF sTEPs.
* bENEFITs:
 * EAsY TO uNDERsTAND AND VIsuALIzE THE
LOGIC.
* HELPs IN IDENTIFYING POTENTIAL PRObLEMs
OR INEFFICIENCIEs IN THE PROCEss.
* usEFuL FOR COMMuNICATING THE LOGIC TO
OTHERs.
PsEuDOCODE
* wHAT IT Is: PsEuDOCODE Is A sIMPLIFIED,
INFORMAL LANGuAGE usED TO DEsCRIbE THE
LOGIC OF A PROGRAM. IT's NOT ACTuAL CODE
THAT CAN bE ExECuTED bY A COMPuTER, buT
IT REsEMbLEs CODE AND Is MEANT TO bE
EAsILY uNDERsTOOD bY HuMANs.
* HOw IT wORks: PsEuDOCODE usEs PLAIN
LANGuAGE sTATEMENTs TO OuTLINE THE sTEPs
OF AN ALGORITHM, OFTEN wITH sOME
INDENTATION TO sHOw THE sTRuCTuRE OF THE
LOGIC.
* bENEFITs:
* ALLOws YOu TO FOCus ON THE LOGIC
wITHOuT wORRYING AbOuT THE sYNTAx OF A
sPECIFIC PROGRAMMING LANGuAGE.
 * EAsIER TO wRITE AND MODIFY THAN ACTuAL
CODE.
* CAN bE TRANsLATED INTO ANY
PROGRAMMING LANGuAGE.
kEY DIFFERENCEs
* VIsuAL Vs. TExTuAL: FLOwCHARTs ARE
VIsuAL, wHILE PsEuDOCODE Is TExTuAL.
* LEVEL OF DETAIL: FLOwCHARTs CAN bE MORE
DETAILED, sHOwING EVERY sINGLE sTEP, wHILE
PsEuDOCODE MIGHT bE MORE AbsTRACT.
* EAsE OF usE: FLOwCHARTs CAN bE EAsIER
FOR bEGINNERs TO GRAsP, wHILE PsEuDOCODE
MIGHT bE MORE FAMILIAR TO THOsE wITH sOME
PROGRAMMING ExPERIENCE.
IN suMMARY
FLOwCHARTs AND PsEuDOCODE ARE bOTH
VALuAbLE TOOLs FOR PLANNING AND
DOCuMENTING PROGRAM LOGIC. FLOwCHARTs
PROVIDE A VIsuAL REPREsENTATION, wHILE
PsEuDOCODE usEs A MORE TExTuAL
APPROACH. THE CHOICE bETwEEN THEM OFTEN
DEPENDs ON PERsONAL PREFERENCE AND THE
COMPLExITY OF THE ALGORITHM.

# INPuTs – THE DATA usED bY THE sYsTEM

THAT NEEDs TO bE ENTERED wHILE THE
sYsTEM Is ACTIVE
» PROCEssEs – THE TAsks THAT NEED TO bE
PERFORMED usING THE INPuT DATA AND ANY
OTHER PREVIOusLY sTORED DATA
» OuTPuTs – INFORMATION THAT NEEDs TO bE
DIsPLAYED OR PRINTED FOR THE usERs OF
THE sYsTEM
» sTORAGE – DATA THAT NEEDs TO bE sTORED
IN FILEs ON AN APPROPRIATE MEDIuM FOR
usE IN THE FuTuRE.

# AbsOLuTELY! LET's bREAk DOwN THE

FLOwCHART AND THEN CONVERT IT INTO
PsEuDOCODE.
ExPLANATION OF THE FLOwCHART
THE FLOwCHART DEsCRIbEs THE ALGORITHM
FOR CALCuLATING THE COsT OF CONCERT
TICkETs wITH DIsCOuNTs bAsED ON THE
NuMbER OF TICkETs PuRCHAsED. HERE's A
sTEP-bY-sTEP ExPLANATION:
* sTART: THE PROCEss bEGINs.
* INPuT NuMbER OF TICkETs: THE PROGRAM
PROMPTs THE usER TO ENTER THE NuMbER OF
TICkETs THEY wANT TO buY AND sTOREs THIs
VALuE IN A VARIAbLE CALLED N.
* VALIDATION CHECk (N >= 1 AND N < 26): THE
PROGRAM CHECks IF THE NuMbER OF TICkETs
ENTERED Is VALID. IT sHOuLD bE GREATER
THAN OR EquAL TO 1 AND LEss THAN 26 (As
PER THE RuLE "NO MORE THAN 25 TICkETs CAN
bE bOuGHT").
* INVALID INPuT (NO): IF THE INPuT Is INVALID,
THE PROGRAM LIkELY ENDs (As sHOwN IN THE
FLOwCHART). IDEALLY, IT sHOuLD PROVIDE AN
ERROR MEssAGE AND Ask FOR INPuT AGAIN,
buT THE FLOwCHART DOEsN'T sHOw THIs
ExPLICITLY.
 * VALID INPuT (YEs): IF THE INPuT Is VALID,
THE PROGRAM PROCEEDs TO CHECk FOR
DIsCOuNTs.
* CHECk FOR DIsCOuNT LEVEL 1 (N < 10): THE
PROGRAM CHECks IF THE NuMbER OF TICkETs Is
LEss THAN 10.
* LEss THAN 10 (YEs): IF YEs, IT MEANs NO
DIsCOuNT APPLIEs, sO THE DIsCOuNT D Is sET
TO 0.
* NOT LEss THAN 10 (NO): IF THE NuMbER OF
TICkETs Is 10 OR MORE, THE PROGRAM
PROCEEDs TO THE NExT DIsCOuNT CHECk.
* CHECk FOR DIsCOuNT LEVEL 2 (N < TO 20): THE
PROGRAM CHECks IF THE NuMbER OF TICkETs Is
LEss THAN 20.
* LEss THAN 20 (YEs): IF YEs, IT MEANs A 10%
DIsCOuNT APPLIEs, sO THE DIsCOuNT D Is sET
TO 0.1 (10%).
* NOT LEss THAN 20 (NO): IF THE NuMbER OF
TICkETs Is 20 OR MORE, THE PROGRAM
PROCEEDs TO THE NExT DIsCOuNT CHECk.
* DIsCOuNT LEVEL 3 (20 OR MORE): IF THE
NuMbER OF TICkETs Is NOT LEss THAN 20, IT
MEANs 20 OR MORE TICkETs wERE bOuGHT, sO
A 20% DIsCOuNT APPLIEs. THE DIsCOuNT D Is
sET TO 0.2 (20%).
* CALCuLATE COsT: THE PROGRAM
CALCuLATEs THE TOTAL COsT usING THE
FORMuLA: COsT = N * (1 - D). THIs APPLIEs THE
DIsCOuNT TO THE TOTAL PRICE OF THE TICkETs.
* OuTPuT COsT: THE PROGRAM DIsPLAYs THE
CALCuLATED COsT TO THE usER.
* sTOP: THE PROCEss ENDs.
PsEuDOCODE CONVERsION
bEGIN
OuTPuT "HOw MANY TICkETs wOuLD YOu LIkE
TO buY?"
INPuT N

IF (N < 1 OR N > 25) THEN

OuTPuT "INVALID NuMbER OF TICkETs.
PLEAsE ENTER A NuMbER bETwEEN 1 AND 25."
 // IDEALLY, LOOP bACk TO INPuT AGAIN, buT
FLOwCHART DOEsN'T sHOw IT.
ELsE
IF (N < 10) THEN
D←0
ELsE IF (N < 20) THEN
D ← 0.1
ELsE
D ← 0.2
ENDIF

COsT ← N * (1 - D)
OuTPuT "YOuR TICkETs COsT", COsT
ENDIF
END

ExPLANATION OF THE PsEuDOCODE

* bEGIN/END: MARks THE sTART AND END OF
THE PROGRAM bLOCk.
* OuTPuT/INPuT: HANDLEs DIsPLAYING
PROMPTs TO THE usER AND RECEIVING INPuT.
* IF/ELsE/ENDIF: IMPLEMENTs THE DECIsION-
MAkING LOGIC FOR VALIDATING THE NuMbER OF
TICkETs AND APPLYING DIsCOuNTs.
* ←: REPREsENTs AssIGNMENT (sETTING A
VARIAbLE's VALuE).
* COMMENTs: THE // INDICATEs A COMMENT
ExPLAINING THE IDEAL bEHAVIOR FOR INVALID
INPuT (LOOPING bACk), wHICH IsN'T ExPLICITLY
sHOwN IN THE FLOwCHART.
kEY POINTs
* THE PsEuDOCODE CLOsELY MIRRORs THE
LOGIC OF THE FLOwCHART.
* INDENTATION Is usED TO CLEARLY sHOw THE
bLOCks OF CODE wITHIN THE IF sTATEMENTs.
* THE ELsE IF sTRuCTuRE sIMPLIFIEs THE
DIsCOuNT CHECkING LOGIC, MAkING IT MORE
READAbLE.
THIs PsEuDOCODE PROVIDEs A CLEAR, sTEP-bY-
sTEP REPREsENTATION OF THE ALGORITHM,
wHICH CAN THEN bE EAsILY TRANsLATED INTO
ANY PROGRAMMING LANGuAGE.

# LET's LEARN AbOuT IF...THEN...ELsE...ENDIF

sTATEMENTs, wHICH ARE FuNDAMENTAL TO
PROGRAMMING LOGIC. THEY ALLOw YOuR CODE
TO MAkE DECIsIONs bAsED ON CONDITIONs.
bAsIC sTRuCTuRE
THE bAsIC sTRuCTuRE LOOks LIkE THIs:
IF (CONDITION) THEN
// CODE TO ExECuTE IF THE CONDITION Is TRuE
ELsE
// CODE TO ExECuTE IF THE CONDITION Is
FALsE
ENDIF

HOw IT wORks
* CONDITION: THE CONDITION Is AN ExPREssION
THAT CAN bE EVALuATED As EITHER TRuE OR
FALsE. THIs Is OFTEN A COMPARIsON (E.G., x >
10, NAME == "ALICE", AGE >= 18).
* IF: THE IF sTATEMENT CHECks THE CONDITION.
* THEN: IF THE CONDITION Is TRuE, THE CODE
wITHIN THE THEN bLOCk Is ExECuTED.
* ELsE: IF THE CONDITION Is FALsE, THE CODE
wITHIN THE ELsE bLOCk Is ExECuTED.
* ENDIF: MARks THE END OF THE IF sTATEMENT.
IT's EssENTIAL TO PROPERLY CLOsE YOuR IF
bLOCks.
ExAMPLEs
LET's ILLusTRATE wITH sOME ExAMPLEs, FIRsT
IN PsEuDOCODE (wHICH Is LANGuAGE-
AGNOsTIC) AND THEN IN PYTHON.
ExAMPLE 1: CHECkING AGE
* PsEuDOCODE:
IF (AGE >= 18) THEN
OuTPuT "YOu ARE AN ADuLT."
ELsE
OuTPuT "YOu ARE A MINOR."
ENDIF
* PYTHON:
AGE = 16 # ExAMPLE AGE

IF AGE >= 18:

PRINT("YOu ARE AN ADuLT.")
ELsE:
PRINT("YOu ARE A MINOR.")

ExAMPLE 2: CHECkING FOR POsITIVE NuMbER

* PsEuDOCODE:
IF (NuMbER > 0) THEN
OuTPuT "THE NuMbER Is POsITIVE."
ELsE IF (NuMbER < 0) THEN // NOTICE ELsE IF
FOR ANOTHER CONDITION
OuTPuT "THE NuMbER Is NEGATIVE."
ELsE
OuTPuT "THE NuMbER Is zERO."
ENDIF
* PYTHON:
NuMbER = -5 # ExAMPLE NuMbER

IF NuMbER > 0:
PRINT("THE NuMbER Is POsITIVE.")
ELIF NuMbER < 0: # PYTHON's wAY OF ELsE IF
PRINT("THE NuMbER Is NEGATIVE.")
ELsE:
PRINT("THE NuMbER Is zERO.")

ExAMPLE 3: COMPARING sTRINGs

* PsEuDOCODE:
IF (NAME == "ALICE") THEN
OuTPuT "HELLO, ALICE!"
ELsE
OuTPuT "YOu ARE NOT ALICE."
ENDIF

* PYTHON:
NAME = "bOb" # ExAMPLE NAME

IF NAME == "ALICE":
PRINT("HELLO, ALICE!")
ELsE:
PRINT("YOu ARE NOT ALICE.")

kEY POINTs
* INDENTATION: IN PYTHON (AND MANY OTHER
LANGuAGEs), INDENTATION Is CRuCIAL. IT's
HOw THE CODE kNOws wHICH sTATEMENTs
bELONG TO THE IF bLOCk, THE ELsE bLOCk, ETC.
CONsIsTENT INDENTATION Is VITAL FOR
CORRECT ExECuTION.
* COMPARIsON OPERATORs: YOu'LL usE
COMPARIsON OPERATORs wITHIN THE
CONDITION:
* == (EquALs)
* != (NOT EquALs)
* > (GREATER THAN)
 * < (LEss THAN)
* >= (GREATER THAN OR EquALs)
* <= (LEss THAN OR EquALs)
* LOGICAL OPERATORs (AND, OR, NOT): YOu
CAN COMbINE CONDITIONs usING LOGICAL
OPERATORs:
* AND: bOTH CONDITIONs MusT bE TRuE.
* OR: AT LEAsT ONE CONDITION MusT bE TRuE.
* NOT: REVERsEs THE TRuTH VALuE OF A
CONDITION.
* ELsIF (OR ELIF IN PYTHON): usE ELsIF (OR
ELIF) wHEN YOu NEED TO CHECk MuLTIPLE
CONDITIONs IN sEquENCE.
ExAMPLE wITH LOGICAL OPERATORs (PYTHON)
AGE = 20
HAs_LICENsE = TRuE

IF AGE >= 18 AND HAs_LICENsE:

PRINT("YOu ARE ELIGIbLE TO DRIVE.")
ELsE:
PRINT("YOu ARE NOT ELIGIbLE TO DRIVE.")

LET ME kNOw IF YOu'D LIkE MORE ExAMPLEs OR

wANT TO ExPLORE NEsTED IF sTATEMENTs
(PuTTING IF sTATEMENTs INsIDE OTHER IF
sTATEMENTs)! I'M HAPPY TO HELP YOu MAsTER
THIs EssENTIAL PROGRAMMING CONCEPT.

# THE CAsE OF (OR sOMETIMEs CALLED

swITCH) sTATEMENT Is A CONTROL FLOw
sTRuCTuRE THAT PROVIDEs A MORE CONCIsE
wAY TO HANDLE MuLTIPLE, MuTuALLY
ExCLusIVE CONDITIONs COMPARED TO A LONG
CHAIN OF IF...ELsIF...ELsE sTATEMENTs. IT's
LIkE A MORE ORGANIzED VERsION OF CHECkING
sEVERAL POssIbILITIEs.
GENERAL sTRuCTuRE (PsEuDOCODE)
CAsE OF VARIAbLE
CAsE VALuE1:
// CODE TO ExECuTE IF VARIAbLE EquALs
VALuE1
 bREAk // IMPORTANT: ExIT THE CAsE bLOCk
AFTER A MATCH
CAsE VALuE2:
// CODE TO ExECuTE IF VARIAbLE EquALs
VALuE2
bREAk // IMPORTANT: ExIT THE CAsE bLOCk
AFTER A MATCH
CAsE VALuE3:
// CODE TO ExECuTE IF VARIAbLE EquALs
VALuE3
bREAk // IMPORTANT: ExIT THE CAsE bLOCk
AFTER A MATCH
OTHERwIsE: // OPTIONAL: CODE TO ExECuTE IF
NO OTHER CAsE MATCHEs
// CODE TO ExECuTE IF NONE OF THE AbOVE
VALuEs MATCH
ENDCAsE

HOw IT wORks
* CAsE OF VARIAbLE: THE sTATEMENT sTARTs
bY sPECIFYING THE VARIAbLE wHOsE VALuE
YOu wANT TO CHECk AGAINsT DIFFERENT
CAsEs.
* CAsE VALuE1, CAsE VALuE2, ETC.: EACH
CAsE REPREsENTs A sPECIFIC VALuE THAT THE
VARIAbLE MIGHT HOLD. THE CODE wITHIN A
CAsE Is ExECuTED ONLY IF THE VARIAbLE's
VALuE MATCHEs THAT CAsE's VALuE.
* bREAk: THE bREAk sTATEMENT Is CRuCIAL.
IT ENsuREs THAT AFTER A MATCH Is FOuND
AND THE CORREsPONDING CODE Is ExECuTED,
THE PROGRAM ExITs THE CAsE bLOCk. wITHOuT
bREAk, ExECuTION MIGHT "FALL THROuGH" TO
THE NExT CAsE, wHICH Is usuALLY NOT wHAT
YOu wANT.
* OTHERwIsE: THE OTHERwIsE CLAusE Is
OPTIONAL. IT PROVIDEs A DEFAuLT bLOCk OF
CODE TO bE ExECuTED IF THE VARIAbLE's
VALuE DOEsN'T MATCH ANY OF THE sPECIFIED
CAsE VALuEs.
* ENDCAsE: MARks THE END OF THE CAsE
sTATEMENT.
ExAMPLEs
LET's ILLusTRATE wITH ExAMPLEs IN
PsEuDOCODE AND PYTHON:
ExAMPLE 1: DAY OF THE wEEk
* PsEuDOCODE:
CAsE OF DAY_NuMbER
CAsE 1:
OuTPuT "MONDAY"
bREAk
CAsE 2:
OuTPuT "TuEsDAY"
bREAk
CAsE 3:
OuTPuT "wEDNEsDAY"
bREAk
CAsE 4:
OuTPuT "THuRsDAY"
bREAk
CAsE 5:
OuTPuT "FRIDAY"
 bREAk
CAsE 6:
OuTPuT "sATuRDAY"
bREAk
CAsE 7:
OuTPuT "suNDAY"
bREAk
OTHERwIsE:
OuTPuT "INVALID DAY NuMbER"
ENDCAsE

* PYTHON (usING MATCH sTATEMENT, PYTHON

3.10+):
DAY_NuMbER = 4

MATCH DAY_NuMbER:
CAsE 1:
PRINT("MONDAY")
CAsE 2:
 PRINT("TuEsDAY")
CAsE 3:
PRINT("wEDNEsDAY")
CAsE 4:
PRINT("THuRsDAY")
CAsE 5:
PRINT("FRIDAY")
CAsE 6:
PRINT("sATuRDAY")
CAsE 7:
PRINT("suNDAY")
CAsE : # THE "" ACTs As THE DEFAuLT
(OTHERwIsE)
PRINT("INVALID DAY NuMbER")

ExAMPLE 2: TRAFFIC LIGHT

* PsEuDOCODE:
CAsE OF LIGHT_COLOR
CAsE "RED":
 OuTPuT "sTOP"
bREAk
CAsE "YELLOw":
OuTPuT "CAuTION"
bREAk
CAsE "GREEN":
OuTPuT "GO"
bREAk
OTHERwIsE:
OuTPuT "INVALID LIGHT COLOR"
ENDCAsE

* PYTHON:
LIGHT_COLOR = "bLuE"

MATCH LIGHT_COLOR:
CAsE "RED":
PRINT("sTOP")
CAsE "YELLOw":
 PRINT("CAuTION")
CAsE "GREEN":
PRINT("GO")
CAsE _:
PRINT("INVALID LIGHT COLOR")

IMPORTANT NOTEs
* LANGuAGEs VARY: THE ExACT sYNTAx AND
FEATuREs OF CAsE OF OR swITCH sTATEMENTs
CAN VARY sLIGHTLY bETwEEN PROGRAMMING
LANGuAGEs. sOME LANGuAGEs MIGHT NOT
HAVE A CAsE OF CONsTRuCT DIRECTLY buT
PROVIDE sIMILAR FuNCTIONALITY usING swITCH
(C++, JAVA, JAVAsCRIPT) OR MATCH (PYTHON
3.10+).
* bREAk Is EssENTIAL: FOR MOsT LANGuAGEs,
THE bREAk sTATEMENT (OR ITs EquIVALENT)
Is VITAL TO PREVENT "FALLTHROuGH." wITHOuT
IT, ExECuTION MIGHT CONTINuE INTO THE NExT
CAsE, EVEN IF THE CONDITION DOEsN'T MATCH.
* PYTHON's MATCH: THE PYTHON ExAMPLE
usEs THE MATCH sTATEMENT (INTRODuCED IN
PYTHON 3.10), wHICH PROVIDEs PATTERN
MATCHING CAPAbILITIEs. THE _ ACTs As THE
DEFAuLT CAsE (sIMILAR TO OTHERwIsE).
THE CAsE OF OR swITCH/MATCH sTATEMENT
PROVIDEs A CLEAN AND EFFICIENT wAY TO
HANDLE sITuATIONs wHERE YOu HAVE
MuLTIPLE DIsCRETE VALuEs TO CHECk AGAINsT
A sINGLE VARIAbLE. IT GENERALLY IMPROVEs
CODE READAbILITY COMPARED TO NEsTED IF
sTATEMENTs wHEN DEALING wITH MANY
CONDITIONs.