Lesson Notes By Weeks and Term v5 - Grade 12

Lesson Video

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.

Performance objectives

• Apply Object-Oriented Programming (OOP) principles.
• Demonstrate proficiency in database design and SQL.
• Analyze networking technologies and protocols like TCP/IP.
• Apply security principles considering South African law (POPIA).
• Evaluate the ethical and societal implications of IT in a South African context.

Lesson summary

This week is dedicated to focused revision and exam preparation for Grade 12 Information Technology. We will concentrate on consolidating previously learned concepts and applying them to solve complex problems, mirroring the types of questions encountered in the final IEB or DBE examination. In a world increasingly driven by technology, a strong understanding of IT principles is crucial. From managing data in South African businesses to developing innovative solutions for local challenges, the skills you acquire in IT are directly applicable and highly valued.

Lesson notes

This week's focus areas will cover the following key concepts: 2.1 Object-Oriented Programming (OOP) OOP is a programming paradigm centered around "objects," which combine data (attributes) and code (methods) that operate on that data.

The key principles are: Encapsulation: Bundling data and methods that operate on that data within a single unit (the object). This hides the internal implementation details from the outside world, promoting data security and modularity. Think of a gearbox in a car – you don't need to know how it works internally, just how to use it (change gears). In code, this is achieved through access modifiers (private, protected, public).

Example: A `Student` class might have private attributes like `studentID` and `marks`, and public methods like `calculateAverageMark()` and `getStudentID()`.

Inheritance: Creating new classes (child classes or subclasses) based on existing classes (parent classes or superclasses). The child class inherits the attributes and methods of the parent class, allowing for code reuse and creating a hierarchy of related classes.

Example: A `PostgraduateStudent` class can inherit from the `Student` class, inheriting attributes like `studentID` and methods like `getStudentID()`, and then add its own specific attributes like `thesisTopic` and methods like `defendThesis()`. This avoids rewriting code for features common to all students.

Polymorphism: The ability of an object to take on many forms. This allows you to write code that can work with objects of different classes in a uniform way.

There are two main types: Method Overriding: A subclass provides a specific implementation of a method that is already defined in its parent class.

Example: Both `Student` and `PostgraduateStudent` classes have a `calculateFees()` method, but the Postgraduate student's implementation may include additional fees for research and supervision.

Method Overloading:* Defining multiple methods in the same class with the same name but different parameters. (Not always supported depending on the programming language used, but still a core concept). 2.2 Database Design and SQL A database is an organized collection of data, typically stored and accessed electronically from a computer system. Relational databases, organized into tables with rows (records) and columns (fields), are prevalent.

Database Design Principles: A well-designed database minimizes data redundancy and ensures data integrity.

Key principles include: Normalization:* Organizing data to reduce redundancy and improve data integrity. Common normal forms include 1NF, 2NF, and 3NF. Understanding these forms is crucial for avoiding anomalies during data updates and deletions.

Entity-Relationship Diagrams (ERDs):* Visual representations of entities (objects or concepts) and their relationships within a database. ERDs are vital for planning the database structure before implementation.

Primary Keys: A unique identifier for each record in a table.

Example: `studentID` in a `Students` table.

Foreign Keys: A field in one table that references the primary key of another table. This establishes relationships between tables.

Example: `courseID` in an `Enrollments` table might be a foreign key referencing the `courseID` primary key in the `Courses` table.

SQL (Structured Query Language): The standard language for interacting with relational databases.

Key SQL commands include: `SELECT`: Retrieves data from the database.

Example: `SELECT studentID, name FROM Students WHERE city = 'Johannesburg';` `INSERT`: Adds new data to the database.

Example: `INSERT INTO Students (studentID, name, city) VALUES (12345, 'Thabo Mbeki', 'Johannesburg');` `UPDATE`: Modifies existing data in the database.

Example: `UPDATE Students SET city = 'Cape Town' WHERE studentID = 12345;` `DELETE`: Removes data from the database.

Example: `DELETE FROM Students WHERE studentID = 12345;` `JOIN`: Combines data from multiple tables based on a related column.

Example: `SELECT Students.name, Courses.courseName FROM Students INNER JOIN Enrollments ON Students.studentID = Enrollments.studentID INNER JOIN Courses ON Enrollments.courseID = Courses.courseID;` This query retrieves the name of each student and the names of the courses they are enrolled in. 2.3 Computer Networks A computer network is a collection of interconnected devices that can communicate and share resources.

TCP/IP Model: A layered model that describes how data is transmitted across a network.

The key layers are: Application Layer:* Provides network services to applications (e.g., HTTP, SMTP, DNS).

Transport Layer:* Provides reliable data transfer between applications (e.g., TCP, UDP). TCP provides connection-oriented, reliable communication, while UDP provides connectionless, unreliable communication.

Network Layer:* Handles addressing and routing of data packets (e.g., IP).

Data Link Layer:* Provides error-free transmission of data frames between adjacent nodes (e.g., Ethernet).