Lesson Notes By Weeks and Term v5 - Grade 11

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 OOP principles to solve practical problems.
• Design and implement relational databases using SQL.
• Analyze and evaluate cybersecurity risks and measures.
• Critically evaluate software development methodologies.
• Solve logic problems using Boolean algebra.

Lesson summary

This week focuses on integrated revision and exam preparation for Grade 11 Information Technology, specifically tailored to the CAPS curriculum. We will consolidate our understanding of key concepts covered so far this term and practice applying these concepts to exam-style questions. Effective revision and exam preparation are crucial for success, not just in IT, but in all aspects of life. Understanding how to manage your time, prioritize information, and apply your knowledge under pressure are skills that will serve you well beyond the classroom. For example, imagine you are starting a small business in your community.

Lesson notes

2.1 Object-Oriented Programming (OOP) OOP is a programming paradigm based on the concept of "objects," which contain data (attributes) and code (methods) that operate on that data. The core principles of OOP are encapsulation, inheritance, and polymorphism.

Encapsulation: Bundling data and methods that operate on that data within a class. This hides the internal state of the object and protects it from external access, except through well-defined interfaces.

Think of it like a clinic file: only authorized personnel (methods) can access and modify a patient's information (data).

Example: Consider a `BankAccount` class. It has attributes like `accountNumber`, `accountHolderName`, and `balance`. Methods like `deposit()` and `withdraw()` are used to interact with the `balance`. The `balance` itself is not directly accessible from outside the class, preventing accidental or unauthorized modifications.

Inheritance: Allows a new class (subclass/child class) to inherit attributes and methods from an existing class (superclass/parent class). This promotes code reuse and reduces redundancy. Think of family resemblances – you inherit traits from your parents.

Example: We can create subclasses `SavingsAccount` and `CurrentAccount` that inherit from the `BankAccount` class. `SavingsAccount` might have an additional attribute `interestRate` and a method `calculateInterest()`, while `CurrentAccount` might have a `overdraftLimit` attribute. Both inherit the basic functionality of `deposit()` and `withdraw()` from `BankAccount`.

Polymorphism: The ability of an object to take on many forms. It allows objects of different classes to be treated as objects of a common type. This is achieved through method overriding and interfaces. Think of different types of vehicles (cars, trucks, motorcycles) – they all have a `startEngine()` method, but each performs it differently.

Method Overriding: A subclass provides a specific implementation for a method that is already defined in its superclass.

Interfaces: Define a set of methods that a class must implement. Any class that implements the interface is guaranteed to have those methods. 2.2 Relational Databases and SQL A relational database organizes data into tables, where each table represents a collection of related entities. Relationships between tables are established using foreign keys. SQL (Structured Query Language) is the standard language for interacting with relational databases.

Key Concepts: Table: A collection of related data organized into rows (records) and columns (fields).

Row (Record): A single instance of an entity in the table.

Column (Field): An attribute of the entity represented by the table.

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

Foreign Key: A field in one table that references the primary key of another table, establishing a relationship between the tables.

SQL Statements: `SELECT`, `INSERT`, `UPDATE`, `DELETE`, `CREATE TABLE`, `ALTER TABLE`, `DROP TABLE`.

Example: Consider a database for a school. `Students` table: `StudentID` (primary key), `Name`, `Surname`, `Grade`. `Courses` table: `CourseID` (primary key), `CourseName`, `Credits`. `Enrollments` table: `EnrollmentID` (primary key), `StudentID` (foreign key referencing `Students`), `CourseID` (foreign key referencing `Courses`). SQL

Example: To retrieve the names of all students enrolled in a course named "IT": ```sql SELECT s.Name, s.Surname FROM Students s JOIN Enrollments e ON s.StudentID = e.StudentID JOIN Courses c ON e.CourseID = c.CourseID WHERE c.CourseName = "IT"; ``` 2.3 Cybersecurity Cybersecurity involves protecting computer systems, networks, and data from unauthorized access, use, disclosure, disruption, modification, or destruction. It's especially relevant in South Africa due to the increasing reliance on digital technologies and the rise of cybercrime.

Key Concepts: Threats: Potential dangers to systems and data (e.g., malware, phishing, hacking).

Vulnerabilities: Weaknesses in systems that can be exploited by threats.

Risks: The likelihood of a threat exploiting a vulnerability, and the potential impact.

Security Measures: Controls implemented to mitigate risks (e.g., firewalls, antivirus software, strong passwords, encryption).

Social Engineering: Manipulating people to divulge confidential information.

Example: A local business using outdated software is vulnerable to malware attacks (vulnerability). If a cybercriminal successfully installs ransomware, it could encrypt the business's data and demand a ransom (threat). The risk is the likelihood of this happening and the impact on the business's operations and finances. Security measures could include updating software, using a firewall, and training employees to recognize phishing emails. 2.4 Software Development Methodologies A software development methodology is a framework that guides the process of building software. Different methodologies offer different approaches to managing the development process.