Lesson Notes By Weeks and Term v3 - Senior Secondary 3
High Level Languages (H.L.L.)
Download the Lessonotes Mobile Nigeria 2025 app for faster lesson access on Android and iPhone.
High Level Languages (H.L.L.)
Download the Lessonotes Mobile Nigeria 2025 app for faster lesson access on Android and iPhone.
Subject: Computer & IT
Class: Senior Secondary 3
Term: 2nd Term
Week: 7
Theme: Problems - Solving Skills
This page supports the lesson note with a companion video and a short classroom-ready summary.
For class groups and homework, share this lesson page so learners also get the summary, objectives, and full lesson context.
Define High Level Languages State examples of high level.Languages ). Classify given HLLs based on suitable application ). Classify HLL as interpreted or compiled language Identify the features of some HLLs Recognize the fotmat of the HLLs State advantagesof HLLs over MLand LLL
This section provides the core content necessary for teaching High Level Languages. 2.
1. Definition of High Level Languages (H.L.L.) High Level Languages are programming languages that are designed to be user-friendly, machine-independent, and closer to human natural language (English) than to machine code. They use statements and commands that are easily understandable by programmers, abstracting away the complex details of the computer's hardware. Unlike low-level languages, H.L.L.s do not require the programmer to have a deep understanding of the computer's internal architecture, registers, or memory addresses. Before a computer can execute a program written in an H.L.L., it must be translated into machine code (binary form) by a special program called a compiler or an interpreter. Characteristics of H.L.L.s: User-friendly: Syntax is closer to human language.
Machine Independent: Programs written in H.L.L. can generally run on different types of computers with minimal or no modifications, provided a suitable translator is available.
Requires Translation: Must be translated into machine code before execution.
Problem-Oriented: Designed to solve specific problems or be general-purpose, rather than focusing on hardware operations.
Easier to Learn and Write: Reduces programming time and effort.
Easier to Debug and Maintain: Errors are simpler to identify and fix. 2.
2. Examples of High Level Languages Numerous High Level Languages exist, each with its strengths and typical applications.
Common examples include: Python: General-purpose, popular for web development, data science, AI, scripting.
Java: Object-oriented, widely used for enterprise applications, Android mobile development, web development. C++: Extension of C, used for system programming, game development, high-performance applications. C#: Developed by Microsoft, used for Windows applications, web development (ASP.NET), game development (Unity).
JavaScript: Primarily for web browsers (client-side scripting), also server-side (Node.js) and mobile apps.
PHP: Server-side scripting language, widely used for web development (e.g., WordPress). BASIC (Beginners All-purpose Symbolic Instruction Code): Historically a popular language for teaching programming.
COBOL (Common Business-Oriented Language): Primarily used for business, finance, and administrative systems.
Pascal: Structured programming language, often used for teaching and academic purposes.
Fortran (Formula Translation): Historically used for scientific and numerical computation.
Ruby: Object-oriented, popular for web development (Ruby on Rails framework).
Swift: Developed by Apple, used for iOS and macOS app development. 2.
3. Classification of H.L.L.s Based on Suitable Application Different H.L.L.s are better suited for specific types of tasks due to their design philosophy, features, and available libraries/frameworks.
Scientific and Engineering Applications: Languages: Fortran, C, C++, Python (with libraries like NumPy, SciPy), MATLA
B. Why: Designed for complex mathematical computations, simulations, and data analysis. Fortran was historically dominant, while C/C++ offers performance, and Python provides ease of use for data processing.
Nigerian Context: Used in research institutions, universities for scientific modeling, engineering design, meteorological forecasting.
Business and Commercial Applications: Languages: COBOL, Java, Python, C#, PHP, SQL (often combined with other H.L.L.s).
Why: Focus on data processing, database management, report generation, transaction processing, and robust back-end systems. COBOL has a long history in finance.
Nigerian Context: Core banking systems, payroll management, inventory systems for large corporations, e-commerce platforms like Jumia. Artificial Intelligence (AI) and Machine Learning (ML): Languages: Python (dominant), R, LISP, Prolog, Java, C++.
Why: Python's extensive libraries (TensorFlow, PyTorch, scikit-learn) make it ideal for AI/ML development. LISP and Prolog were early AI languages.
Nigerian Context: Developing predictive models for agriculture (crop yield forecasting), fraud detection in financial services, medical diagnosis systems, natural language processing for local languages.
System Programming: Languages: C, C++, Assembly Language (though LLL, it's relevant for context).
Why: Used for developing operating systems, device drivers, embedded systems, and other software that interacts closely with hardware. Offers fine-grained control and high performance.
Nigerian Context: While less common for direct OS development locally, understanding its role helps appreciate how underlying systems work, especially in embedded systems development or cybersecurity.
Web Development (Frontend & Backend): Frontend (client-side, runs in browser): JavaScript (with frameworks like React, Angular, Vue.js), HTML (markup), CSS (styling). * Backend (server-side, runs on server): PHP, Python (Django, Flask), Java (Spring), Ruby (Rails), C# (ASP.NET), Node.js (JavaScript).
Why: Used for developing operating systems, device drivers, embedded systems, and other software that interacts closely with hardware. Offers fine-grained control and high performance.
Nigerian Context: While less common for direct OS development locally, understanding its role helps appreciate how underlying systems work, especially in embedded systems development or cybersecurity.
Web Development (Frontend & Backend): Frontend (client-side, runs in browser): JavaScript (with frameworks like React, Angular, Vue.js), HTML (markup), CSS (styling). Backend (server-side, runs on server): PHP, Python (Django, Flask), Java (Spring), Ruby (Rails), C# (ASP.NET), Node.js (JavaScript).
Why: Frontend languages create interactive user interfaces; backend languages handle data, server logic, and database interaction.
Nigerian Context: Building websites for businesses, government agencies, e-learning platforms, online news portals, mobile app backends for FinTech.
General Purpose/Educational: Languages: Python, Java, C++, Pascal, BASI
C. Why: Versatile, can be used for a wide range of tasks, and often serve as introductory programming languages due to their readability and structured nature.
Nigerian Context: Used in schools and universities for teaching programming fundamentals. 2.
4. Classification of H.L.L.s as Interpreted or Compiled Language The distinction lies in how their source code is translated into machine code for execution.
Compiled Languages: Process: The entire source code is first translated into machine code (an executable file) by a program called a compiler. This compilation process occurs before the program is run. If there are syntax errors, the compiler will report them, and the program will not compile until errors are fixed.
Execution: Once compiled, the executable file can be run directly by the operating system without needing the compiler again.
Characteristics: Generally faster execution speed (once compiled), better performance, but slower development cycle (compile-run-debug loop).
Examples: C, C++, Pascal, COBOL, Fortran, Java (partially compiled to bytecode, then interpreted by JVM).
Diagram: Source Code -> Compiler -> Machine Code (Executable File) -> Run by CPU Interpreted Languages: Process: An interpreter translates and executes the source code line by line, statement by statement, at runtime. It does not produce a separate executable file. If an error is encountered, the interpreter stops execution at that point.
Execution: The interpreter must be present and active every time the program runs.
Characteristics: Slower execution speed compared to compiled languages (due to real-time translation), but faster development cycle (no compilation step), easier debugging (errors detected immediately).
Examples: Python, JavaScript, PHP, Ruby, BASIC (traditionally), Perl.
Diagram: Source Code -> Interpreter (translates & executes line-by-line) -> Run by CPU Hybrid Languages (e.g., Java): Java is often considered a hybrid. Its source code (.java files) is first compiled into an intermediate format called bytecode (.class files) by a Java compiler. This bytecode is then interpreted and executed by the Java Virtual Machine (JVM). This approach provides both portability (bytecode can run on any system with a JVM) and some performance benefits. 2.
5. Features of Specific H.L.L.s (BASIC, COBOL, Pascal) BASIC (Beginners All-purpose Symbolic Instruction Code): Origin: Developed in 1964 at Dartmouth College by John
G. Kemeny and Thomas
E. Kurtz.
Key Features:
1. Ease of Learning: Designed specifically for beginners, making it simple to learn and use.
2. Interactive: Many versions supported interactive programming environments.
3. General Purpose: Could be used for a wide range of tasks, though not specialized for any.
4. Interpreter-based: Traditionally an interpreted language, allowing for immediate execution of commands.
5. Line Numbers: Early versions required line numbers for program control (e.g., `GOTO 100`).
6. Variations: Many dialects (e.g., Microsoft BASIC, GW-BASIC, QBasic, Visual Basic) evolved.
Relevance: Historically important for introducing programming to a generation of computer users.
COBOL (Common Business-Oriented Language): Origin: Developed in 1959 by CODASYL (Conference on Data Systems Languages) committee, with significant input from Grace Hopper. * Key Features:
1. Business-Oriented: Specifically designed for commercial data processing.
2. Self-Documenting/Verbose: Uses English-like statements, making programs very readable (e.g., `ADD TAX TO TOTAL GIVING GRAND-TOTAL`).
3. Structured: Programs are divided into specific divisions (IDENTIFICATION, ENVIRONMENT, DATA, PROCEDURE).
4. Strong Record Handling: Excellent for manipulating large volumes of data records, particularly in file processing. 5. *Fixed-Point Historically important for introducing programming to a generation of computer users.
COBOL (Common Business-Oriented Language): Origin: Developed in 1959 by CODASYL (Conference on Data Systems Languages) committee, with significant input from Grace Hopper.
Key Features:
1. Business-Oriented: Specifically designed for commercial data processing.
2. Self-Documenting/Verbose: Uses English-like statements, making programs very readable (e.g., `ADD TAX TO TOTAL GIVING GRAND-TOTAL`).
3. Structured: Programs are divided into specific divisions (IDENTIFICATION, ENVIRONMENT, DATA, PROCEDURE).
4. Strong Record Handling: Excellent for manipulating large volumes of data records, particularly in file processing.
5. Fixed-Point Arithmetic: Highly reliable for financial calculations where precision is critical.
6. Legacy Systems: Still widely used in large mainframe systems for banking, insurance, and government.
Relevance: Cornerstone of financial and administrative systems globally, including in major Nigerian financial institutions.
Pascal: Origin: Developed in 1968-1969 by Niklaus Wirth.
Key Features:
1. Structured Programming: Enforces good programming practices with clear control structures (e.g., `IF-THEN-ELSE`, `WHILE-DO`, `FOR-DO`).
2. Strongly Typed: Requires variables to be declared with a specific data type, preventing type-related errors and improving code reliability.
3. Educational Tool: Widely adopted as a primary language for teaching programming concepts in universities and colleges due to its clarity and structured nature.
4. Readability: Syntax is clean and easy to understand.
5. Modularity: Supports procedures and functions, promoting modular program design.
6. Compiler-based: Typically a compiled language, resulting in efficient execution.
Relevance: Influenced many later languages and helped popularize structured programming paradigms. Still used in some academic settings. 2.
6. Format of H.L.L.s While each H.L.L. has its unique syntax, they generally share common structural elements: Keywords: Reserved words with special meaning (e.g., `IF`, `ELSE`, `FOR`, `WHILE`, `PRINT`, `READ`).
Variables: Named storage locations for data (e.g., `student_name`, `total_score`).
Data Types: Define the type of data a variable can hold (e.g., `Integer`, `String`, `Float`, `Boolean`).
Operators: Symbols for performing operations (e.g., `+`, `-`, ``, `/`, `=`, `>`).
Statements: Instructions that the computer executes (e.g., `x = 10;`, `PRINT "Hello";`).
Expressions: Combinations of variables, operators, and values that evaluate to a single value (e.g., `a + b 2`).
Control Structures: Conditional Statements: `IF-THEN-ELSE` (executes code based on a condition).
Looping Statements: `FOR`, `WHILE`, `DO-WHILE` (repeats a block of code multiple times).
Comments: Non-executable notes within the code for human readability, ignored by the translator. * Input/Output Statements: To get data from the user and display results. Example (Conceptual - not specific to one HLL): ``` // This is a comment - ignored by the computer START PROGRAM DECLARE VARIABLE score AS INTEGER DECLARE VARIABLE grade AS STRING INPUT score // Get score from user IF score >= 70 THEN SET grade = "A" ELSE IF score >= 60 THEN SET grade = "B" ELSE IF score >= 50 THEN SET grade = "C" ELSE SET grade = "F" END IF PRINT "Your grade is: " + grade END PROGRAM ``` This conceptual example demonstrates keywords (`START PROGRAM`, `DECLARE`, `INPUT`, `IF`, `THEN`, `ELSE`, `END IF`, `PRINT`, `END PROGRAM`), variables (`score`, `grade`), data types (`INTEGER`, `STRING`), operators (`>=`, `=`), and control structures (`IF-ELSE IF-ELSE`). 2.
7. Advantages of H.L.L.s over Machine Language (ML) and Low Level Languages (LLL) Machine Language (ML) consists of binary instructions (0s and 1s) directly understood by the CPU. Low Level Languages (LLL), primarily Assembly Language, use mnemonics (e.g., `ADD`, `MOV`) that are a bit more readable but still very machine-specific. H.L.L.s offer significant advantages:
1. Easier to Learn and Use: H.L.L.s use syntax and commands closer to natural human language (English), making them much simpler to learn and write compared to cryptic binary codes or assembly mnemonics.
2. Faster Development Time: Programmers can write code much more quickly in H.L.L.s because fewer lines of code are needed to perform a task, and they don't have to manage low-level hardware details.
3. Machine Independence (Portability): H.L.L. programs are generally portable; they can be run on different types of computers (e.g., Windows, macOS, Linux) with appropriate compilers/interpreters, without significant modification. LLLs are highly machine-dependent.
4. Easier to Debug and Maintain: The clear and structured nature of H.L.L.s makes it easier to and write compared to cryptic binary codes or assembly mnemonics.
2. Faster Development Time: Programmers can write code much more quickly in H.L.L.s because fewer lines of code are needed to perform a task, and they don't have to manage low-level hardware details.
3. Machine Independence (Portability): H.L.L. programs are generally portable; they can be run on different types of computers (e.g., Windows, macOS, Linux) with appropriate compilers/interpreters, without significant modification. LLLs are highly machine-dependent.
4. Easier to Debug and Maintain: The clear and structured nature of H.L.L.s makes it easier to identify and correct errors (debug) and to update or modify programs (maintain) over time. Errors in ML or LLL are often very difficult to trace.
5. Higher Level of Abstraction: H.L.L.s abstract away the complex details of the computer's hardware, allowing programmers to focus on the problem's logic rather than the intricate machine operations.
6. Improved Programmer Productivity: Programmers can be more productive as they spend less time on low-level details and more time on designing and implementing solutions.
7. Wider Range of Applications: H.L.L.s are versatile and can be used for developing a vast array of applications, from operating systems to web applications, scientific simulations, and mobile apps.
Connecting H.L.L.s to real-life applications in Nigeria helps students understand the relevance and practical impact of this knowledge.
FinTech and Banking Systems: Application: Nigerian banks (e.g., Zenith, GTBank, Access Bank) heavily rely on H.L.L.s for their core banking systems, mobile banking applications, and online portals. Languages like COBOL still power legacy mainframe systems for transaction processing, while Java, Python, and C# are used for modern mobile apps, web interfaces, and data analytics platforms.
Integration: Students can discuss how these languages enable secure online transactions, ATM operations, and easy access to banking services, directly impacting the Nigerian economy and daily lives.
E-commerce and Online Services: Application: Popular Nigerian e-commerce platforms like Jumia and Konga, as well as booking sites, news portals, and social media platforms, are built using H.L.L.s such as PHP, Python (with frameworks like Django/Flask), JavaScript (frontend and backend via Node.js), and Java.
Integration: This illustrates how H.L.L.s facilitate online shopping, digital marketing, and information dissemination, contributing to the growth of Nigeria's digital economy and entrepreneurship. Educational Technology (EdTech) and Government Services: Application: The Joint Admissions and Matriculation Board (JAMB) CBT platform, the West African Examinations Council (WAEC) result checker, National Identity Management Commission (NIMC) portal, and various e-learning platforms use H.L.L.s for their development.
Integration: Students can see how programming languages are instrumental in improving access to education, simplifying administrative processes, and enhancing service delivery for citizens across Nigeria. For instance, the algorithms that score JAMB exams or process WAEC results are written in these languages.