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

• Solve database problems using SQL and normalization.
• Apply Object-Oriented Programming (OOP) principles.
• Analyze System Development Life Cycle (SDLC) methodologies.
• Evaluate the impact of emerging technologies in South Africa.
• Apply ethical and legal considerations in IT.

Lesson summary

This week is dedicated to focused revision and examination preparation for Grade 12 Information Technology. We'll concentrate on consolidating your understanding of key concepts and practicing problem-solving techniques that are essential for success in your final examinations. Mastery of IT principles is crucial not only for academic success but also for your future career prospects in a rapidly digitalizing South Africa. From developing mobile applications for local businesses to managing data in governmental organizations or contributing to the growing e-commerce sector, your IT skills will be invaluable.

Lesson notes

This week focuses on consolidating the entire Grade 12 IT curriculum.

Here's a breakdown of critical areas:

A. Database and SQL: Database Design: Understanding Entity-Relationship (ER) diagrams, translating them into database schemas (tables, primary keys, foreign keys), and database normalization (1NF, 2NF, 3NF) are vital. Remember the importance of data integrity, reducing redundancy, and ensuring data consistency.

Why Normalization Matters: In South Africa, think about a national student database. Without proper normalization, the same student's address might be entered multiple times in different tables. If they move, you'd have to update the address in numerous places, increasing the risk of errors and inconsistencies. Normalization prevents this, ensuring accurate and reliable data.

Normalization Steps: 1NF (First Normal Form): Eliminate repeating groups of data within a table. Each column should contain atomic (indivisible) values. 2NF (Second Normal Form): Be in 1NF and eliminate redundant data. Any non-key attribute must be fully functionally dependent on the primary key. 3NF (Third Normal Form): Be in 2NF and eliminate transitive dependencies. Non-key attributes should not be dependent on other non-key attributes.

SQL Queries: Mastering SELECT, INSERT, UPDATE, DELETE statements is crucial. Know how to use WHERE clauses for filtering, ORDER BY for sorting, GROUP BY for aggregating data, and JOINs to combine data from multiple tables. Understanding subqueries and views enhances query power.

Example (South African Context): Imagine a database for a local municipality storing information about residents and their electricity usage.

Query: "List the names and electricity consumption for all residents in Ward 5 who consumed more than 500 kWh in January." This requires SELECT, WHERE, JOIN (if resident and consumption data are in separate tables), and potentially GROUP BY (if you need to aggregate total consumption per resident).

SQL Code (Example): ```sql SELECT Residents.Name, SUM(ElectricityUsage.Consumption) AS TotalConsumption FROM Residents INNER JOIN ElectricityUsage ON Residents.ResidentID = ElectricityUsage.ResidentID WHERE Residents.Ward = 'Ward 5' AND ElectricityUsage.Month = 'January' GROUP BY Residents.Name HAVING SUM(ElectricityUsage.Consumption) > 500; ``` Database Transactions: Understand ACID properties (Atomicity, Consistency, Isolation, Durability) and how they ensure data integrity in concurrent environments.

B. Object-Oriented Programming (OOP): Core Principles: Encapsulation: Bundling data and methods that operate on that data within a single unit (class). This protects data from unauthorized access and modification. Think of it like a protected bank account; you need specific methods (e.g., deposit, withdraw) to interact with the data (balance).

Inheritance: Creating new classes (derived classes) based on existing classes (base classes). This promotes code reuse and reduces redundancy. E.g., a "Car" class inheriting from a "Vehicle" class, inheriting common attributes like "engine type".

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. Method Overriding and Method Overloading are two forms of Polymorphism.

Classes and Objects: Understand how to define classes (blueprints) and create objects (instances) from them. Learn about constructors (initialization methods), access modifiers (public, private, protected), and static members.

Example (South African Business): Consider a retail business.

Class: `Product` (attributes: `productID`, `name`, `price`, `quantityOnHand`)

Objects: Instances of `Product` (e.g., `Product1` = "Umqombothi", `price` = 25, `quantityOnHand` = 100).

Methods: Methods within the `Product` class might include `restock()`, `sell()`, `updatePrice()`.

Data Structures: Implement and use basic data structures like arrays, linked lists, stacks, and queues. Understand their advantages and disadvantages in different scenarios.

C. System Development Life Cycle (SDLC): Methodologies: Understand different SDLC models, including Waterfall, Agile (Scrum, Kanban), Iterative, and Spiral. Each has strengths and weaknesses depending on the project type, size, and complexity.

Waterfall: A linear, sequential approach. Suitable for well-defined projects with stable requirements.

Agile: An iterative and incremental approach. Emphasizes flexibility, collaboration, and responding to change. Well-suited for projects with evolving requirements.

Iterative: Develops the system in increments, with each iteration building on the previous one.

Spiral: Risk-driven approach, focusing on identifying and mitigating risks throughout the development process.

Phases: Understand the phases of the SDLC: Planning, Analysis, Design, Implementation, Testing, Deployment, and Maintenance.

Example (Government Project): Developing a national ID system.