UNIT 4

INTRODUCTION TO SYSTEM SOFTWARES

AND PROGRAMMING LANGUAGES
 CLASSIFICATION OF COMPUTER LANGUAGES

LOW LEVEL LANGUAGES : Binary (0’s and 1’s), Hex codes.

MIDDLE LEVEL LANGUAGES: Assembly language.

HIGH LEVEL LANGUAGES: C, C++, Python, Java.

 CLASSIFICATION OF COMPUTER LANGUAGES
LOW LEVEL LANGUAGE:

• CONSISTS OF A SET OF INSTRUCTIONS THAT ARE IN THE BINARY FORM 0 OR 1.

• CREATING A PROGRAM IN A MACHINE-LEVEL LANGUAGE IS A VERY DIFFICULT TASK.

• A MACHINE-LEVEL LANGUAGE IS NOT PORTABLE AS EACH COMPUTER HAS ITS MACHINE

INSTRUCTIONS.

MIDDLE LEVEL LANGUAGE:

• ASSEMBLY LANGUAGE CONTAINS SOME HUMAN-READABLE COMMANDS SUCH AS MOV, ADD, SUB,
ETC.

• THE TRANSLATOR USED FOR TRANSLATING THE CODE IS KNOWN AS AN ASSEMBLER.

• THE ASSEMBLY LANGUAGE CODE IS NOT PORTABLE

HIGH LEVEL LANGUAGE:

• CLOSER TO HUMAN LANGUAGES THAN MACHINE-LEVEL LANGUAGES.

• THE HIGH-LEVEL LANGUAGE IS PORTABLE; I.E., THESE LANGUAGES ARE MACHINE-INDEPENDENT.

 EVOLUTION OF PROGRAMMING LANGUAGE
• 1940'S: MACHINE LEVEL –
USE BINARY OR EQUIVALENT NOTATIONS FOR ACTUAL NUMERIC VALUES
• 1950'S: "ASSEMBLY LANGUAGE" –
NAMES FOR INSTRUCTIONS: ADD INSTEAD OF 0110101, ETC.
NAMES FOR LOCATIONS: ASSEMBLER KEEPS TRACK OF WHERE THINGS ARE IN
MEMORY;
TRANSLATES THIS MORE HUMANE LANGUAGE INTO MACHINE LANGUAGE – THIS
IS THE LEVEL USED IN THE "TOY" MACHINE – NEEDS TOTAL REWRITE IF MOVED
TO A DIFFERENT KIND OF CPU.
EVOLUTION OF PROGRAMMING LANGUAGE
 EVOLUTION OF PROGRAMMING LANGUAGE

• "HIGH LEVEL" LANGUAGES -- FORTRAN, COBOL, BASIC.

• WRITE IN A MORE NATURAL NOTATION, E.G., MATHEMATICAL FORMULAS
• POTENTIAL DISADVANTAGE: LOWER EFFICIENCY IN USE OF MACHINE
• ENORMOUS ADVANTAGES: ACCESSIBLE TO MUCH WIDER POPULATION OF
USERS, PORTABLE: SAME PROGRAM CAN BE TRANSLATED FOR DIFFERENT
MACHINES, MORE EFFICIENT IN PROGRAMMER TIME.
 EVOLUTION OF PROGRAMMING LANGUAGE

• "SYSTEM PROGRAMMING" LANGUAGES -- C

• EFFICIENT AND EXPRESSIVE ENOUGH TO TAKE ON ANY PROGRAMMING TASK
• WRITING ASSEMBLERS, COMPILERS, OPERATING SYSTEMS
• ENORMOUS ADVANTAGES: ACCESSIBLE TO MUCH WIDER POPULATION OF
PROGRAMMERS, PORTABLE: SAME PROGRAM CAN BE TRANSLATED FOR
DIFFERENT MACHINES FASTER, CHEAPER HARDWARE HELPS MAKE THIS HAPPEN
 EVOLUTION OF PROGRAMMING LANGUAGE

• “OBJECT ORIENTED" LANGUAGES – C++, JAVA, PYTHON

• BETTER CONTROL OF STRUCTURE OF REALLY LARGE PROGRAMS
• BETTER INTERNAL CHECKS, ORGANIZATION, SAFETY
• ENORMOUS ADVANTAGES: PORTABLE: SAME PROGRAM CAN BE TRANSLATED
FOR DIFFERENT MACHINES FASTER, CHEAPER HARDWARE HELPS MAKE THIS
HAPPEN
 DIFFERENCE BETWEEN PROCEDURAL & OBJECT – ORIENTED PROGRAMING

POP OOP
LESS SECURE HIGHLY SECDURED
TAKES VERY LESS MEMORY TAKES MORE MEMORY
IT DEALS WITH ALGORITHM IT DEALS WITH DATA
THERE IS NO ANY ACCESS SPECIFIER IT HAVE ACCESS SPECIFIER LIKE PUBLIC,
PRIVATE, PROTECTED ETC.
WE CANNOT PERFORM OVERLOADING. IN OOP OVERLOADING IS POSSIBLE.
TOP DOWN APPROACH. BOTTOM UP APPROACH

TOP DOWN: MAIN PROGRAM IS DIVIDED INTO SUB PROGRAMS.

BOTTOM UP: CREATE SMALL PROBLEMS FIRST, THEN WE WILL SOLVE THE SMALLER
PROBLEMS AND INTEGRATE INTO A WHOLE
 INTRODUCTION TO OPERATING SYSTEMS

• FIRST PROGRAM THAT IS LOADED IN THE COMPUTER. WITHOUT OS, COMPUTER,

MOBILES CANNOT RUN.
• SYSTEM SOFTWARE THAT ACTS AS AN INTERFACE BETWEEN USER AND
COMPUTER HARDWARE.
• OS IS A SET OF PROGRAMS STORED IN THE STORAGE DEVICE USED TO MANAGE
ALL THE PROCESSES AND RESOURCES PRESENT IN THE SYSTEM.
• TAKES INPUT FROM KEYBOARD, MOUSE AND COMMUNICATES WITH HARDWARE
TO DISPLAY THE OUTPUT ON SCREEN.
• GAMES, MS OFFICE, INTERNET BROWSERS, PHOTOSHOPS ALL CAN BE OPERATED
ONLY BY THE USE OF OS.
 HISTORY OF OPERATING SYSTEMS

• FIRST OS BY GENERAL MOTORS RESEARCH LAB IN 1956 FOR THEIR IBM 701.
• IN 1960’S, IBM STARTED DEVELOPING THEIR OS AND ALSO STARTED
DISTRIBUTING OS.
• IN THE LATE 1960, THE FIRST VERSION OF THE UNIX OS (WRITTEN IN C
LANGUAGE).
• IN 1981, FIRST OS BUILT BY MICROSOFT WAS DOS.
• IN 1985, THE PRESENT DAY POPULAR OS WINDOWS FIRST CAME INTO EXISTENCE
WHEN A GUI WAS CREATED AND PAIRED WITH MS-DOS.
 TYPES OF OPERATING SYSTEMS

• BATCH OS
• DISTRIBUTED OS
• NETWORK OS
• TIME SHARING OS
• REAL TIME OS
• MULTIPROCESSING OS
• EMBEDDED OS
• MULTIPROGRAMMING OS.
 TYPES OF OPERATING SYSTEMS

BATCH OS:
• PROCESSES DATA IN BATCHES AUTOMATICALLY.
• NO INTERACTION BETWEEN END USER AND SYSTEM.
• USED IN 2ND GENERATION COMPUTERS.
• THERE IS AN OPERATOR WHICH TAKES SIMILAR JOBS HAVING THE SAME
REQUIREMENTS AND GROUPS THEM INTO BATCHES.
• BATCH OPERATING SYSTEM IS DESIGNED TO MANAGE AND EXECUTE A LARGE
NUMBER OF JOBS EFFICIENTLY BY PROCESSING THEM IN GROUPS.
• NOT USED TODAY.
 TYPES OF OPERATING SYSTEMS

DISTRIBUTED OS:
• MANY SYSTEMS ARE PRESENT AND THEY WORK TOGETHER USING SHARED
NETWORK.
• ONE SYSTEM CAN OPERATE OTHER SYSTEM REMOTELY.
• LOAD AND RESOURCES SHARING BETWEEN SYSTEMS IS POSSIBLE.
• FAILURE OF THE MAIN NETWORK WILL LEAD TO THE FAILURE OF THE WHOLE
SYSTEM.
• NOT AVAILABLE EASILY THEY ARE VERY COSTLY.
 TYPES OF OPERATING SYSTEMS

NETWORK OS:
• THESE SYSTEMS RUN ON A SERVER AND PROVIDE THE CAPABILITY TO MANAGE
DATA, USERS, GROUPS, SECURITY, APPLICATIONS, AND OTHER NETWORKING
FUNCTIONS.
• THESE TYPES OF OPERATING SYSTEMS ALLOW SHARED ACCESS TO FILES,
PRINTERS, SECURITY, APPLICATIONS, AND OTHER NETWORKING FUNCTIONS
OVER A SMALL PRIVATE NETWORK.
 TYPES OF OPERATING SYSTEMS

TIME SHARING OR MULTI-PROGRAMMING OS:

• ALSO KNOWN AS MULTITASKING OS.
• AT ONE TIME MULTIPLE USERS CAN PERFORM MULTIPLE TASKS, ONLY ONE
SYSTEM IS INVOLVED.
• EACH TASK GETS EQUAL TIME FOR EXECUTION.
• TIME ALLOTED TO EXECUTE ONE TASK IS CALLED A QUANTUM.
• AS SOON AS ONE TASK IS EXECUTED IT SWITCHES TO ANOTHER TASK.
 TYPES OF OPERATING SYSTEMS

REAL TIME OS:

• ADVANCED OS AND SERVE REAL TIME SYSTEMS.
• RESPONSE TIME IS VERY LESS, BENEFICIAL FOR PROCESSES THAT ARE HIGHLY
SENSITIVE.
• EXAMPLE: SATELLITE LAUNCHING, OPERATING GUIDED MISSILES .
 TYPES OF OPERATING SYSTEMS

MULTIPROCESSING OS:
• USES MORE THAN ONE CPU, VERY FAST EXECUTION.
• TASKS ARE DIVIDED INTO SUBTASKS, AND ALL THE SUBTASKS ARE GIVEN TO
DIFFERENT PROCESSORS.
• NOT FOR COMMON UISERS THEY ARE USED IN SUPERCOMPUTERS .
 TYPES OF OPERATING SYSTEMS

EMBEDDED OS:
• USED FOR SPECIFIED TASKS NOT USED IN COMPUTERS.
• LIFTS, PETROL PUMPS, ATM MACHINES, SMART WATCHES.
• IT IS DEVICE SPECIFIC, OS FOR ONE DEVICE CANNOT BE USED IN OTHER DEVICE.
MULTIPROGRAMMING OS:
• MULTIPROGRAMMING OPERATING SYSTEMS CAN BE SIMPLY ILLUSTRATED AS
MORE THAN ONE PROGRAM IS PRESENT IN THE MAIN MEMORY.
• ANY ONE OF THEM CAN BE KEPT IN EXECUTION. THIS IS BASICALLY USED FOR
BETTER UTILIZATION OF RESOURCES.
 UNIX COMMANDS

• UNIX IS AN OPERATING SYSTEM, DEVELOPED IN 1969, LINUX IS BASED ON UNIX,

UNIX IS NOT GUI BASED OPERATING SYSTEM, WORKS ON COMMAND LINE.
• UNIX IS WRITTEN IN C LANGUAGE.
• UNIX WAS NOT FREE OF COST, CAN’T BE DOWNLOADED HAVE TO PURCHASE.
• LINUX IS FREE, CAME IN EXISTENCE IN 1991.
 FEATURES OF UNIX
• UNLIKE WINDOWS & DOS, UNIX CAN BE USED CONCURRENTLY BY SEVERAL USERS.
• WE CAN INTERACT WITH A UNIX SYSTEM THROUGH A COMMAND-LINE INTERPRETER
CALLED THE SHELL.
• MULTIUSER SYSTEM : IN UNIX, RESOURCES ARE ACTUALLY SHARED BETWEEN ALL THE USERS. FOR
DOING SO, COMPUTER GIVE A TIME SLICE (BREAKING UNIT OF TIME INTO SEVERAL SEGMENTS ) TO EACH
USER. SO, AT ANY INSTANT OF TIME, ONLY ONE USER IS SERVED BUT THE SWITCHING IS SO FAST THAT IT
GIVES AN ILLUSION THAT ALL THE USERS ARE SERVED SIMULTANEOUSLY.

• MULTITASK SYSTEM : A SINGLE USER MAY RUN MULTIPLE TASKS CONCURRENTLY. EXAMPLE :
EDITING A FILE, PRINTING ANOTHER ON THE PRINTER & SENDING EMAIL TO A PERSON, AND BROWSING THE
NET TOO AT THE SAME TIME. THE KERNEL IS DESIGNED TO HANDLE USER’S MULTIPLE NEEDS.

• SECURE
• FILE SYSTEM : UNIX HAS A HIERARCHICAL FILE SYSTEM, WITH ALL FILES AND
DIRECTORIES ORGANIZED UNDER A SINGLE ROOT DIRECTORY.
 DIFFERENCE BETWEEN UNIX & LINUX
UNIX LINUX
UNIX IS AVAILABLE ONLY FOR COMMERCIAL LINUX IS AN OPEN SOURCE PROJECT. (FREE)
VENDORS AND NON-PROFIT
ORGANIZATIONS. (LICENSED)
THE SOURCE CODE IS NOT ACCESSIBLE TO ACCESSIBLE.
EVERYONE.
USED IN SERVERS, WORKSTATIONS AND PCs. USED EVERYWHERE. (tablet computers,
smartphones, servers, supercomputers and so on).
Example: SunOS, Solaris, ULTRIX, etc. Example: Ubuntu, Arch etc.
NOT PORTABLE PORTABLE
SUPPORTS FILE SYSTEMS LESSER THAN SUPPORTS FILE SYSTEM MORE THAN UNIX
LINUX
PRIMARILY USED CLI PRIMARILY USES GUI WITH OPTION OF CLI
 DIFFERENCE BETWEEN UNIX & WINDOWS
UNIX WINDOWS
UNIX IS A COMMAND LINE INTERFACE WINDOWS IS A GRAPHICAL USER INTERFACE
IN UNIX USERS CAN SAVE TWO FILES WITH NOT POSSIBLE IN WINDOWS.
THE SAME NAME.
NOT USER FRIENDLY WINDOWS IS USER FRIENDLY.
UNIX IS MORE SECURE THAN WINDOWS LESS SECURE.
UNIX SUPPORTS MULTIPROCESSING. WINDOWS SUPPORT MULTITHREADING.
 FEATURES & SELECTION OF GOOD PROGRAMMING LANGUAGE
• A PROGRAMMING LANGUAGE IS A SET OF GRAMMATICAL RULES (BOTH
SYNTACTIC AND SEMANTIC) THAT INSTRUCT A COMPUTER OR A DEVICE TO
BEHAVE IN A CERTAIN WAY.
• SIMPLICITY: THE LANGUAGE MUST OFFER CLEAR AND SIMPLE CONCEPTS THAT
ARE EASY TO UNDERSTAND.
• EFFICIENCY: PROGRAMMING LANGUAGES THAT CAN BE TRANSLATED AND
EXECUTED EFFICIENTLY HELP AVOID THE EXCESSIVE CONSUMPTION OF
MEMORY AND TIME.
• COMPACTNESS: A LANGUAGE WITH THIS CHARACTERISTIC CAN EXPRESS
OPERATIONS CONCISELY WITHOUT HAVING TO WRITE TOO MANY DETAILS.
• STRUCTURING: THE LANGUAGE ALLOWS PROGRAMMERS TO WRITE THEIR CODE
ACCORDING TO STRUCTURED PROGRAMMING CONCEPTS TO AVOID CREATING
ERRORS.
 DIFFERENCE BETWEEN ALGORITHM AND FLOWCHART

Algorithm Flowchart
An algorithm is a step-by-step procedure to solve a A flowchart is a diagram created with different shapes
problem. to show the flow of data.
The algorithm is complex to understand. A flowchart is easy to understand.
In the algorithm, plain text is used. In the flowchart, symbols/shapes are used.
The algorithm does not follow any rules. The flowchart follows rules to be constructed.
The algorithm is easy to debug. A flowchart is hard to debug.
 PROGRAM TESTING AND DEBBUGING
TESTING DEBBUGING
Testing is the process to find bugs and errors. Debugging is the process of correcting the bugs found
during testing.
Testing is done before debugging Debugging is done after testing
Testing is done by the tester Debugging is done by either programmer or the
developer
There is no need of design knowledge in the testing Debugging can’t be done without proper design
process knowledge
Testing is initiated after the code is written Debugging commences with the execution of a test
case
 PROGRAMMING PARADIGM
• Programming paradigm means style or the standard way of writing a program.

• When we are choosing a programming language for writing the program, we need to make sure it is
supporting the programming paradigm approach.
 PROGRAMMING PARADIGM

• IMPERATIVE PROGRAMMING TELLS THE COMPUTER HOW TO DO THE TASK BY GIVING SET
OF COMMAND OR INSTRUCTION IN A PARTICULAR ORDER.
• DECLARATIVE PROGRAMMING IS TELLING THE MACHINE WHAT TO DO AND LETTING THE
MACHINE FIGURE OUT HOW TO DO IT.
• IF OUR PROBLEM INVOLVES COMPLEX CONTROL FLOWS AND STATE CHANGES,
IMPERATIVE PROGRAMMING MIGHT BE A BETTER CHOICE. IT GIVES US FULL CONTROL
OVER HOW YOUR PROGRAM OPERATES AND ALLOWS US TO OPTIMIZE EVERY DETAIL.
• IF OUR PROBLEM CAN BE SOLVED BY DEFINING A SET OF RULES OR TRANSFORMATIONS,
DECLARATIVE PROGRAMMING COULD BE A BETTER FIT.
 PROGRAMMING PARADIGM
IMPERATIVE DECLARATIVE
Example: Making a sandwich. Example: Ordering a
Take two slices of bread. sandwich at a café.
Spread butter on one slice. You say, "I want a cheese
Place cheese on top of the sandwich."
butter.
Put the other slice of bread on
top.
Cut the sandwich in half.

# Imperative style: using a # Declarative style: using a

loop to find the sum built-in function to find the
sum
total = 0
for i in range(1, 6): total = sum(range(1, 6))
total += i print(total) # Output: 15
print(total) # Output: 15
 PROGRAMMING PARADIGM

• IN PROCEDURAL PROGRAMMING WE DIVIDE THE PROGRAM INTO SMALL

PROCEDURES. IT MEANS TO DECOMPOSE THE PROBLEMS INTO SMALL
SUBPROBLEMS.
• IN OBJECT ORIENTED PROGRAMMING WE WILL BUILT ENTIRE PROGRAM USING
CLASS AND OBJECTS.
• IN FUNCTIONAL PROGRAMMING, WE WILL SPLIT THE ENTIRE PROGRAM INTO
SMALL FUNCTIONS. EXAMPLE: JAVASCRIPT.
• THE LOGIC PROGRAMMING PARADIGM ISN’T MADE UP OF INSTRUCTIONS –
RATHER IT’S MADE UP OF FACTS AND CLAUSES.
 PROGRAMMING PARADIGM

# Procedural style: define #Object-Oriented # Functional style: use # Logic-based style: use
functions and use them in a Programming (OOP): pure functions to calculate rules to deduce the area
sequence define a Rectangle class area
with properties and from kanren import Relation, facts,
def get_length(): run, var, eq
methods
return 5
def get_width(): length = var()
return 3 width = var()
calculate_area(length, width): class Rectangle: length = 5 area = var()
return length * width def __init__(self, length, width): width = 3 facts(length, (5,))
length = get_length() self.length = length def area(length, width): facts(width, (3,))
width = get_width() self.width = width return length * width facts(area, (15,))
area = calculate_area(length, width) print("Area:", area(length, width)) print(run(1, area, eq(area, 5 * 3)))
print("Area:", area) def area(self):
return self.length * self.width # Output: (15,)
# Output: Area: 15
# Output: Area: 15 rect = Rectangle(5, 3)
print("Area:", rect.area())

# Output: Area: 15
 PROGRAM DOCUMENTATION
ANY WRITTEN TEXT, ILLUSTRATIONS OR VIDEO THAT DESCRIBE A SOFTWARE OR PROGRAM TO ITS USERS IS CALLED PROGRAM OR
SOFTWARE DOCUMENT.

USER CAN BE ANYONE FROM A PROGRAMMER, SYSTEM ANALYST AND ADMINISTRATOR TO END USER. AT VARIOUS STAGES OF
DEVELOPMENT MULTIPLE

DOCUMENTS MAY BE CREATED FOR DIFFERENT USERS.

THESE ARE SOME OF THE ADVANTAGES OF PROVIDING PROGRAM DOCUMENTATION :

• KEEPS TRACK OF ALL PARTS OF A SOFTWARE OR PROGRAM

• MAINTENANCE IS EASIER

• PROGRAMMERS OTHER THAN THE DEVELOPER CAN UNDERSTAND ALL ASPECTS OF SOFTWARE

• IMPROVES OVERALL QUALITY OF THE SOFTWARE

• ASSISTS IN USER TRAINING

• ENSURES KNOWLEDGE DE-CENTRALIZATION, CUTTING COSTS AND EFFORT IF PEOPLE LEAVE THE SYSTEM
ABRUPTLY
 CHARACTERISTICS OF A GOOD PROGRAM
THE CHARACTERISTICS OF A GOOD PROGRAM INCLUDE:

• CLARITY AND READABILITY: THE CODE SHOULD BE EASY TO READ AND UNDERSTAND. THIS MAKES IT EASIER TO DEBUG, MAINTAIN,
AND EXTEND. USING MEANINGFUL VARIABLE NAMES, CLEAR COMMENTS, AND A CONSISTENT STYLE CONTRIBUTES TO READABILITY.

• EFFICIENCY: A GOOD PROGRAM SHOULD USE RESOURCES, LIKE CPU TIME AND MEMORY, EFFICIENTLY. EFFICIENT PROGRAMS
PERFORM THEIR TASKS QUICKLY AND MINIMIZE THE AMOUNT OF MEMORY REQUIRED.

• MODULARITY: DIVIDING CODE INTO SMALLER, REUSABLE, AND INDEPENDENT MODULES OR FUNCTIONS MAKES IT EASIER TO TEST,
DEBUG, AND MAINTAIN. EACH MODULE SHOULD IDEALLY HAVE A SINGLE RESPONSIBILITY OR FUNCTIONALITY.

• RELIABILITY: A PROGRAM SHOULD PERFORM ACCURATELY AND HANDLE ERRORS GRACEFULLY. IT SHOULD BE DESIGNED TO
ACCOUNT FOR POSSIBLE ERRORS OR UNEXPECTED INPUTS, ENSURING IT WORKS CORRECTLY UNDER VARIOUS CONDITIONS.

• SCALABILITY: GOOD PROGRAMS CAN HANDLE AN INCREASING NUMBER OF TASKS OR A GROWING AMOUNT OF DATA WITHOUT
SIGNIFICANT PERFORMANCE DEGRADATION.

• MAINTAINABILITY: THE CODE SHOULD BE EASY TO UPDATE AND MODIFY AS REQUIREMENTS CHANGE. GOOD DOCUMENTATION,
MODULAR DESIGN, AND CLEAN CODE HELP IN MAKING THE PROGRAM MAINTAINABLE.

• SECURITY: GOOD PROGRAMS PROTECT AGAINST UNAUTHORIZED ACCESS AND DATA BREACHES BY FOLLOWING SECURITY BEST
PRACTICES, SUCH AS VALIDATING INPUTS AND HANDLING DATA SECURELY.
 UNIT 7
DEBUGGING TOOLS AND COMPILER
OPTION
 DIFFERENT DEBUGGING TOOLS
IN PROGRAMMING, A DEBUGGING TOOL IS SOFTWARE THAT ASSISTS DEVELOPERS IN IDENTIFYING AND FIXING BUGS OR ERRORS IN
THEIR CODE. THESE TOOLS

ARE ESSENTIAL IN SOFTWARE DEVELOPMENT AS THEY HELP ENSURE CODE WORKS AS EXPECTED, OPERATES EFFICIENTLY, AND IS FREE
OF MAJOR ISSUES BEFORE

RELEASE.

HERE’S HOW DEBUGGING TOOLS WORK IN PROGRAMMING:

• LOCATING ERRORS: DEBUGGING TOOLS HELP PINPOINT THE EXACT LINE OR SECTION OF CODE WHERE AN ERROR OCCURS. THIS
INCLUDES SYNTAX ERRORS, RUNTIME ERRORS, AND LOGICAL ERRORS THAT MIGHT NOT BE IMMEDIATELY VISIBLE.

• SETTING BREAKPOINTS: A DEVELOPER CAN SET A BREAKPOINT AT A SPECIFIC LINE OF CODE, CAUSING THE PROGRAM TO PAUSE AT
THAT LINE WHEN IT RUNS. THIS ALLOWS THEM TO INSPECT THE PROGRAM STATE, CHECK VARIABLE VALUES, AND UNDERSTAND THE
CODE FLOW STEP-BY-STEP.

• MONITORING VARIABLES: DEBUGGING TOOLS ALLOW DEVELOPERS TO WATCH VARIABLES IN REAL-TIME, CHECKING THEIR VALUES
AT DIFFERENT STAGES. THIS HELPS ENSURE VARIABLES ARE ASSIGNED THE CORRECT VALUES AND HELPS IDENTIFY ISSUES CAUSED
BY INCORRECT DATA..

• PROVIDING REAL-TIME FEEDBACK: MANY INTEGRATED DEVELOPMENT ENVIRONMENTS (IDES) LIKE VISUAL STUDIO, PYCHARM, OR
ECLIPSE HAVE BUILT-IN DEBUGGING TOOLS THAT PROVIDE IMMEDIATE FEEDBACK ON ERRORS, ALLOWING DEVELOPERS TO FIX THEM
QUICKLY AS THEY CODE.

• IMPROVING PERFORMANCE: SOME DEBUGGING TOOLS OFFER PROFILING FEATURES TO IDENTIFY CODE SECTIONS THAT ARE SLOW
OR RESOURCE-INTENSIVE. BY ANALYZING THIS DATA, DEVELOPERS CAN OPTIMIZE THEIR CODE FOR BETTER PERFORMANCE.
 DIFFERENT DEBUGGING TOOLS

EXAMPLES OF COMMON DEBUGGING TOOLS:

• GDB (GNU DEBUGGER) FOR C/C++

• VISUAL STUDIO DEBUGGER FOR C#, C++, PYTHON, AND MORE
• CHROME DEVELOPER TOOLS FOR JAVASCRIPT, HTML, AND CSS IN WEB DEVELOPMENT
• XCODE DEBUGGER FOR IOS AND MACOS DEVELOPMENT
• PYCHARM DEBUGGER FOR PYTHON
• ANDROID STUDIO DEBUGGER FOR ANDROID APPS
• LLDB (LLVM DEBUGGER) FOR LANGUAGES LIKE SWIFT AND C++

.
 DEBUGGING

MEMORY DUMP

• DEFINITION: SNAPSHOT OF A PROGRAM'S MEMORY AT A SPECIFIC POINT IN TIME

• PURPOSE: HELPS ANALYZE MEMORY USAGE, ESPECIALLY IN DEBUGGING SEGMENTATION FAULTS

OR MEMORY LEAKS

• USE IN DEBUGGING: INSPECT THE STATE OF DATA STRUCTURES, VARIABLE CONTENTS, AND
MEMORY ADDRESSES

IT PROVIDES A DETAILED VIEW OF THE PROGRAM'S MEMORY, INCLUDING:

• CONTENTS OF VARIABLES AND DATA STRUCTURES.

• MEMORY ADDRESSES.

• PROGRAM INSTRUCTIONS CURRENTLY LOADED IN MEMORY.

TOOLS: GDB (WITH COMMANDS LIKE X AND P), VISUAL STUDIO, ANDROID STUDIO
 DEBUGGING

MEMORY DUMP
GDB (GNU DEBUGGER):

• A POPULAR TOOL FOR DEBUGGING C AND C++ PROGRAMS.

• COMMANDS FOR INSPECTING MEMORY:

• X (EXAMINE MEMORY): USED TO INSPECT MEMORY AT SPECIFIC ADDRESSES.
• EXAMPLE: X/4XW 0X7FFEE2B10 # DISPLAY 4 WORDS IN HEX STARTING AT ADDRESS 0X7FFEE2B10
(STARTS AT MEMORY ADDRESS 0X7FFEE2B10 .READS 4 WORDS (4 × 4 BYTES = 16 BYTES) OF MEMORY
SEQUENTIALLY. DISPLAYS EACH WORD IN HEXADECIMAL FORMAT
0X7FFEE2B10: 0X12345678, 0X7FFEE2B14: 0XABCDEF12, 0X7FFEE2B18: 0XDEADBEEF, 0X7FFEE2B1C: 0X00FF00FF)

• P (PRINT): PRINTS THE VALUE OF A VARIABLE OR MEMORY ADDRESS.

• EXAMPLE: P MYVARIABLE # DISPLAYS THE VALUE OF 'MYVARIABLE'
 DEBUGGING

REGISTER AND VARIABLE TRACKING

• REGISTER TRACKING: USEFUL IN LOW-LEVEL PROGRAMMING; REGISTERS HOLD TEMPORARY DATA

LIKE FUNCTION RETURN VALUES

• VARIABLE TRACKING: ALLOWS YOU TO MONITOR CHANGES TO VARIABLES THROUGHOUT THE

PROGRAM

• TOOLS AND COMMANDS: GDB COMMANDS (INFO REGISTERS, WATCH, PRINT), AND IDE FEATURES
LIKE WATCH WINDOW (VISUAL STUDIO).

REGISTERS OFTEN STORES:

FUNCTION RETURN VALUES, INTERMEDIATE RESULTS, POINTERS TO MEMORY LOCATIONS.
 DEBUGGING

REGISTER AND VARIABLE TRACKING

COMMON GDB COMMANDS FOR REGISTER TRACKING

• VIEW ALL REGISTERS:

• INFO REGISTERS (CODE)

• DISPLAYS THE CURRENT STATE OF ALL CPU REGISTERS.
• EXAMPLE OUTPUT:
• EAX 0X1 EBX 0X0 ECX 0X2 EDX 0X3
• EXPLANATION:
• EAX: STORES THE RETURN VALUE OF A FUNCTION.
• EBX, ECX, EDX: MAY HOLD ARGUMENTS OR INTERMEDIATE CALCULATIONS.
 DEBUGGING

INSTRUCTION AND FUNCTION-LEVEL DEBUGGING

• INSTRUCTION-LEVEL DEBUGGING: DEBUGGING ONE INSTRUCTION (ASSEMBLY LEVEL) AT A TIME;

CRUCIAL IN EMBEDDED AND SYSTEM PROGRAMMING

• FUNCTION-LEVEL DEBUGGING: FUNCTION-LEVEL DEBUGGING FOCUSES ON ANALYZING THE

BEHAVIOR AND OUTPUT OF INDIVIDUAL FUNCTIONS IN THE PROGRAM. INSTEAD OF DIVING INTO THE
ASSEMBLY CODE.

• USE CASES: OPTIMIZATION, DETAILED ANALYSIS OF PROGRAM CONTROL FLOW, CRITICAL FOR
PERFORMANCE TUNING
 DEBUGGING

Aspects Instruction Level Debugging Function level Debugging

Assembly-level (low-level
Scope Function-level (high-level logic).
instructions).

Hardware-focused (registers, memory Code-focused (variables, function

Abstraction
addresses). calls).

Embedded systems, performance

Use Cases Logic bugs, verifying outputs.
tuning.

Tools GDB (stepi, info registers), LLDB. GDB (break, step), IDE tools.
 DEBUGGING

COMPILER OPTIONS FOR DEBUGGING

• WHEN YOU’RE CREATING A PROGRAM, THE COMPILER TAKES YOUR CODE AND TURNS IT INTO
SOMETHING THE COMPUTER CAN RUN (CALLED AN "EXECUTABLE").

• TO MAKE DEBUGGING EASIER (FINDING AND FIXING PROBLEMS), WE CAN USE SPECIAL COMPILER
OPTIONS.

1. ADDING DEBUG INFORMATION: -G

• THE -G OPTION TELLS THE COMPILER TO ADD EXTRA INFORMATION ABOUT YOUR CODE, LIKE
WHICH LINE CAUSED A PROBLEM AND WHAT VARIABLES ARE DOING.

• WITHOUT -G, A DEBUGGER (LIKE GDB) WILL ONLY SEE MACHINE INSTRUCTIONS, WHICH ARE HARD
TO UNDERSTAND.

EXAMPLE:

GCC -G MY_PROGRAM.C -O MY_PROGRAM

 DEBUGGING

COMPILER OPTIONS FOR DEBUGGING

2. CONTROLLING OPTIMIZATIONS: -O0 (NO OPTIMIZATION)

• THE COMPILER OFTEN CHANGES YOUR CODE TO MAKE IT RUN FASTER (CALLED OPTIMIZATION). FOR
EXAMPLE:

• IT MIGHT REMOVE UNUSED VARIABLES. IT MIGHT COMBINE LOOPS OR REORDER INSTRUCTIONS.

• WHILE THIS IS GREAT FOR SPEED, IT MAKES DEBUGGING HARDER BECAUSE THE PROGRAM DOESN’T
LOOK LIKE YOUR ORIGINAL CODE.

• -O0: NO OPTIMIZATIONS (EASIER TO DEBUG).

• -O1, -O2: MORE OPTIMIZATIONS (BETTER PERFORMANCE BUT HARDER TO DEBUG).

EXAMPLE:

GCC -G -O0 MY_PROGRAM.C -O MY_PROGRAM

DEBUGGING
 DEBUGGING

PROFILE GENERATION
• DEFINITION: PROCESS OF GATHERING DATA ABOUT PROGRAM EXECUTION,
SUCH AS TIME SPENT ON EACH FUNCTION
• PURPOSE: IDENTIFIES PERFORMANCE BOTTLENECKS AND OPTIMIZES CODE
 DEBUGGING

PROFILE GENERATION
TOOLS FOR PROFILING
• THERE ARE VARIOUS TOOLS FOR PROFILING, EACH WITH ITS OWN STRENGTHS:
GPROF (GNU PROFILER)
• PURPOSE: GPROF IS A PROFILING TOOL USED TO GENERATE INFORMATION ABOUT FUNCTION CALL FREQUENCIES
AND EXECUTION TIMES IN C/C++ PROGRAMS.
• HOW IT WORKS:
• IT ADDS SPECIAL PROFILING HOOKS IN YOUR PROGRAM’S CODE DURING COMPILATION.
• AFTER THE PROGRAM RUNS, IT GENERATES A PROFILE OF THE FUNCTIONS, INCLUDING HOW MANY TIMES EACH
FUNCTION WAS CALLED AND HOW LONG EACH FUNCTION TOOK TO EXECUTE.

• WHEN TO USE: IDEAL FOR GENERAL-PURPOSE PROFILING, ESPECIALLY IN C/C++ PROGRAMS.

• EXAMPLE COMMAND:
• GCC -PG MY_PROGRAM.C -O MY_PROGRAM
• THE -PG OPTION TELLS GCC TO INCLUDE PROFILING INFORMATION IN THE PROGRAM.