Загрузка
UP

A manual for a computer science teacher

9th grade, 1st quarter (8 lessons)

Topics:

  1. Review of basic concepts: computer structure, file system, working with different types of files (text, graphics, video).
  2. Algorithms and data structures: sorting, searching, working with linear data structures (lists, stacks, queues).
  3. Programming: delving into loops, functions, recursion and data manipulation.

Lesson 1: Review of Basic Concepts – Computer Structure and File System

Objective:
To remind you of the basic elements of a computer, file types and principles of working with the file system.

Lesson plan:

  1. The structure of a computer (10 min).
    • Main components: processor, RAM, storage devices, peripherals.
    • Functions and interactions between elements.
  2. File system (10 min).
    • Tree structure of the file system: folders, files, file extensions.
    • Operations with files and folders: creation, renaming, moving, deleting.
  3. Practical work (20 min).
    • Working with the file system: creating and organizing files in various formats (text, graphic, video files).

Homework:
Organize your home file system by dividing files into folders based on their type.

Lesson 2: Working with different file types

Objective:
To introduce students to file types and programs for processing them.

Lesson plan:

  1. File types (10 min).
    • Text files (txt, docx), graphic files (png, jpg), video files (mp4, avi).
    • Programs for working with each type of file: text editors, graphic editors, video editors.
  2. Practical work (30 min).
    • Processing files in different formats: editing text documents, creating and editing images, basic video editing.

Homework:
Create a simple project that includes text, images, and videos saved in their appropriate formats.

Lesson 3: Algorithms and Data Structures – Sorting and Searching

Objective:
To introduce basic algorithms for sorting and searching data.

Lesson plan:

  1. The concept of sorting and searching algorithms (10 min).
    • Main types of sorting: bubble sorting, quick sorting.
    • Search algorithms: linear and binary search.
  2. Practical work (30 min).
    • Implementation of sorting and searching algorithms on small data sets (e.g. in Python or JavaScript).

Homework:
Write a program to sort and search data in a given array.

Lesson 4: Linear Data Structures – Lists

Objective:
To explore the concept of linear data structures using lists as an example.

Lesson plan:

  1. What are lists (10 min).
    • Definition of lists, their properties and application in programming.
  2. Operations with lists (10 min).
    • Add, remove, search and sort items in lists.
  3. Practical work (20 min).
    • Writing a program to work with lists: creating, changing, sorting.

Homework:
Implement a program that takes a list of items and performs basic operations on it.

Lesson 5: Linear Data Structures – Stacks and Queues

Objective:
To introduce students to data structures such as stacks and queues and their applications.

Lesson plan:

  1. What are stacks and queues (10 min).
    • Stack: LIFO (last in first out) principle of operation.
    • Queue: FIFO (first in, first out) principle of operation.
  2. Using Stacks and Queues (10 min).
    • Examples of use in real-world tasks: working with a browser, tasks on reverse Polish notation.
  3. Practical work (20 min).
    • Implementation of stacks and queues using a task example (for example, processing a sequence of actions in an application).

Homework:
Write a program that simulates the operation of a stack or queue.

Lesson 6: Programming – Working with Loops and Functions

Objective:
To consolidate programming skills using cycles and functions.

Lesson plan:

  1. Cycles in programming (10 min).
    • Types of cycles: for, while, their features and areas of application.
  2. Functions and parameters (10 min).
    • Defining functions, passing parameters to functions, returning values.
  3. Practical work (20 min).
    • Writing a program using loops and functions: calculating a sum, processing data.

Homework:
Write a program that performs calculations using loops and functions.

Lesson 7: Recursion in Programming

Objective:
To study the principle of recursion and its application in programming.

Lesson plan:

  1. The concept of recursion (10 min).
    • What is recursion, basic principles: recursive function call, termination condition.
  2. Examples of recursive algorithms (10 min).
    • Examples: factorial calculation, depth-first search, sorting algorithms (quicksort, Towers of Hanoi).
  3. Practical work (20 min).
    • Writing a recursive program (for example, to calculate factorial or Fibonacci numbers).

Homework:
Implement a recursive algorithm to solve one of the problems studied in the lesson.

Lesson 8: Final Practical Work – Creating a Program Using All the Concepts Learned

Objective:
To consolidate the material covered by creating a program that includes working with loops, functions, recursion and data structures.

Lesson plan:

  1. Statement of the problem (10 min).
    • Example task: develop a program for processing data using lists, loops and functions.
  2. Practical work (30 min).
    • Students create a program using all the concepts they have learned.
  3. Discussion and analysis of works (10 min).
    • Presentation of solutions, discussion of difficulties and errors.

Homework:
Complete the program if required and prepare a brief report on the work.

This manual allows 9th graders to deepen their knowledge of programming, algorithms and data structures, focusing on the practical application of knowledge through the implementation of programs.