A manual for a computer science teacher

9th grade, 4th quarter (7-8 lessons)

Topics:

1. Project work: creating individual or group projects (e.g. web application, database or multimedia project), integrating programming, web development and data science skills.
2. Working with big data: data analysis, data visualization, using tools for processing large amounts of information.
3. Cybersecurity: protecting data online, cryptography basics, preventing cyberattacks, conscious use of Internet resources and social networks.

Lesson 1: Planning Project Activities

Objective:
To introduce students to the stages of project activities and to distribute tasks for creating individual or group projects.

Lesson plan:

1. Stages of project development (10 min).
   • Defining the project goal: what is planned to be created (web application, database, multimedia project).
   • Stages of work: requirements collection, planning, implementation, testing, presentation.
2. Selecting project topics (15 min).
   • Project ideas: website, data tracking app, multimedia project using video and sound.
   • Discussion of technical requirements: technologies used (HTML, CSS, JavaScript, databases).
3. Practical work (15 min).
   • Division into groups (if the project is a group project), distribution of roles in the team (programmer, designer, analyst).
   • Getting started with the project plan: creating a project structure and objectives.

Homework:
Prepare a detailed description of the project, including the purpose, technologies and expected result.

Lesson 2: Working with Big Data – Basics of Data Analysis

Objective:
To introduce the principles of big data analysis and teach how to use tools for working with large volumes of information.

Lesson plan:

1. Basics of working with big data (10 min).
   • What is big data, examples of use (business, science, social networks).
   • Main tasks: collecting, filtering, sorting, analyzing data.
2. Data Analysis Tools (10 min).
   • Programs for working with big data (for example, Google Sheets, Excel, specialized tools).
   • An introduction to the basics of working with large tables and charts.
3. Practical work (20 min).
   • Filtering, sorting and analyzing data using a real large data set as an example (e.g. working with a data table).

Homework:
Analyze the selected data set using filtering and sorting and prepare visualization (charts).

Lesson 3: Data Visualization

Objective:
To teach students to visualize data for better understanding and analysis.

Lesson plan:

1. What is data visualization (10 min).
   • Why visualization is needed: examples (diagrams, graphs, maps).
   • Principles of creating visualizations: chart selection, data accuracy, interpretation.
2. Data Visualization Tools (10 min).
   • Using graphs and charts in spreadsheets (Google Sheets, Excel).
   • Examples of creating interactive visualizations.
3. Practical work (20 min).
   • Create several types of charts based on a data set, interpret the results.

Homework:
Prepare a data report with visualization, choosing the most visual ways to present information.

Lesson 4: Cybersecurity Basics – Protecting Data Online

Objective:
To teach the basics of cybersecurity and data protection on the Internet.

Lesson plan:

1. Internet threats and data protection (10 min).
   • Main Internet threats: phishing, viruses, cyber attacks.
   • Practical tips for protection: using antiviruses, complex passwords, two-factor authentication.
2. Basics of cryptography (10 min).
   • What is cryptography: data encryption, symmetric and asymmetric encryption.
   • Examples of using cryptography to protect data on the network.
3. Practical work (20 min).
   • Creating and using secure passwords.
   • An example of working with data encryption (using a simple encryption method).

Homework:
Research modern cyberattack methods and prepare a short report on methods of protection against them.

Lesson 5: Preventive Measures Against Cyber ​​Attacks

Objective:
To teach students how to prevent cyber attacks and how to behave safely online.

Lesson plan:

1. Cyberattacks and how to prevent them (10 min).
   • Main types of attacks: DDoS, SQL injections, weak password attacks.
   • How to protect your system: using security tools, updating software, monitoring the network.
2. Security in social networks and instant messengers (10 min).
   • Dangers of social networks: disclosure of personal data, use of fake accounts.
   • Practical security tips: checking privacy settings, being mindful about publishing information.
3. Practical work (20 min).
   • Analysis of examples of attacks on databases and study of protection against SQL injections.
   • Setting up privacy for social network accounts.

Homework:
Prepare a paper on cyber attacks and suggest methods of protection for various situations.

Lesson 6: Project Development – Implementation Stage

Objective:
Continue working on the project, focusing on its implementation.

Lesson plan:

1. Stages of project implementation (10 min).
   • A reminder of the project structure and tasks.
   • The importance of testing and debugging during the implementation phase.
2. Practical work (30 min).
   • Project implementation: working with program code, data, design and multimedia.
   • Checking the code for errors, refining functions.

Homework:
Complete the main part of the project, preparing it for testing.

Lesson 7: Testing and refining the project

Objective:
To teach how to test a project, troubleshoot, and prepare for a presentation.

Lesson plan:

1. Testing the project (10 min).
   • Main approaches to testing: checking functionality, stability, user interface.
   • How to find and fix errors.
2. Practical work (30 min).
   • Project testing: performing functional tests.
   • Refining and correcting found errors, improving the user interface.

Homework:
Prepare the project for presentation: final check and adding finishing touches.

Lesson 8: Presentation and Defense of Projects

Objective:
To evaluate students’ work, provide feedback on their projects and summarize the results.

Lesson plan:

1. Presentation of projects (25 min).
   • Each group or individual student presents their project, demonstrating its functionality and design.
   • Discussion of problems and solutions that arose during the creation process.
2. Evaluation and discussion (15 min).
   • Feedback from the teacher and classmates: creativity, quality of execution, compliance with the tasks set.
   • Summing up the quarter and discussing the knowledge gained.

Homework:
Prepare a report on the results of the project, describing the stages of its creation and the problems that had to be solved.

This resource will help 9th grade students develop project-based, big data, and cybersecurity skills and integrate this knowledge into their projects.

A manual for a computer science teacher

9th grade, 3rd quarter (8 lessons)

Topics:

1. Client-server technologies: basics of working with a server and a client, the concept of server and client languages, interaction with a server via HTTP requests.
2. Programming: Introduction to Object-Oriented Programming (OOP) – creating classes, objects, inheritance, polymorphism.
3. Working with multimedia files: creating and editing multimedia projects (video, graphics, sound), using multimedia technologies in project activities.

Lesson 1: Introduction to Client-Server Technologies

Objective:
To introduce students to the basic principles of client-server architecture and the HTTP protocol.

Lesson plan:

1. Client-server architecture (10 min).
   • The concept of client and server, distribution of tasks between client and server.
   • Examples: web browsers, websites, databases.
2. HTTP protocol (10 min).
   • HTTP Protocol Basics: Requests and Responses.
   • Status codes, query methods ( GET, POSTetc.).
3. Practical work (20 min).
   • An example of an HTTP request and its parsing (for example, using browser tools for analyzing network requests).
   • Working with simple queries and responses.

Homework:
Explore several websites, analyze HTTP requests and responses using developer tools in the browser.

Lesson 2: Interacting with the Server via HTTP Requests

Objective:
To teach students the basics of sending and receiving data over HTTP.

Lesson plan:

1. HTTP requests and interaction with the server (10 min).
   • How to send requests to the server, receive data.
   • Basics of interacting with API (using a public API as an example).
2. Working with a simple API (10 min).
   • An example of a data request from a public API (for example, getting weather or news).
3. Practical work (20 min).
   • Writing a simple script that sends a request to the server and receives data (e.g. using JavaScript or Python).

Homework:
Explore the documentation for the selected public API, prepare an example of requests to obtain data.

Lesson 3: Introduction to Object-Oriented Programming (OOP)

Objective:
To introduce students to the basic principles of OOP: creating classes and objects.

Lesson plan:

1. What is OOP (10 min).
   • Basic concepts: classes, objects, attributes, methods.
   • Advantages of OOP: data structuring, code reuse.
2. Example of creating a class and objects (10 min).
   • Example in Python or JavaScript: creating a simple class, creating objects, working with attributes and methods.
3. Practical work (20 min).
   • Writing a program with a class and objects (for example, a “Car” class with attributes and methods).

Homework:
Create a class for the selected object (for example, “Phone”, “Animal”), implement its attributes and methods.

Lesson 4: Inheritance and Polymorphism in OOP

Objective:
To study inheritance and polymorphism in object-oriented programming.

Lesson plan:

1. Inheritance (10 min).
   • The concept of inheritance: creating descendant classes, overriding methods.
2. Polymorphism (10 min).
   • Understanding Polymorphism: Working with Methods in Subclasses.
3. Practical work (20 min).
   • Create a base class and several child classes (e.g. Vehicle, Car, Airplane).

Homework:
Extend the inheritance project by adding another inheritor class and implementing additional methods.

Lesson 5: Editing Multimedia Files – Working with Graphics

Objective:
To teach the basics of image editing using graphics programs.

Lesson plan:

1. Basics of working with graphic editors (10 min).
   • Programs for working with graphics: GIMP, Adobe Photoshop or others.
   • Basic tools: selection, cropping, layers, filters.
2. Example of image editing (10 min).
   • Example of image editing: resizing, cropping, adding text.
3. Practical work (20 min).
   • Task: edit the image by adding text and effects.

Homework:
Complete image editing and prepare a presentation of your work.

Lesson 6: Working with Multimedia Files – Editing Audio and Video

Objective:
To introduce the basics of working with audio and video editors.

Lesson plan:

1. Basics of Audio Editing (10 min).
   • Audio editing programs (eg Audacity).
   • Basic tools: cropping, normalization, adding effects.
2. Basics of video editing (10 min).
   • Video editing programs (eg OpenShot, Adobe Premiere).
   • Basic tools: editing, transitions, working with sound.
3. Practical work (20 min).
   • Task: create a short video project with music, titles and editing.

Homework:
Improve the video project by adding additional effects or improving the editing.

Lesson 7: Application of multimedia technologies in project activities

Objective:
To teach how to use multimedia technologies to create projects.

Lesson plan:

1. Example of a multimedia project (10 min).
   • Analysis of a multimedia project: using graphics, sound, video in one project.
2. Designing a multimedia project (10 min).
   • How to plan a multimedia project: choosing a topic, collecting materials, stages of work.
3. Practical work (20 min).
   • Getting started with the project: choosing a topic and starting work on creating a multimedia product (video, slide show, etc.).

Homework:
Continue working on the multimedia project by collecting additional materials and elements.

Lesson 8: Completing and Defending a Multimedia Project

Objective:
To complete and present a multimedia project.

Lesson plan:

1. Completion of the project (20 min).
   • Students complete their projects: adding finishing touches, final editing.
2. Presentation of projects (20 min).
   • Presentation of projects to the class, discussion of ideas and technologies used in the project.
3. Evaluation and discussion (10 min).
   • Evaluation of work: creativity, use of technology, final result.

Homework:
Prepare a project report, describing the stages of work and the technologies used.

This manual allows 9th grade students to master the basic principles of client-server technologies, OOP and working with multimedia files, as well as apply them in project activities.

A manual for a computer science teacher

9th grade, 2nd quarter (7–8 lessons)

Topics:

1. Working with databases: creating and managing databases, designing tables, creating queries in SQL, normalizing data.
2. Programming: working with files, input and output of data, creating programs for processing text information.
3. Web development: creating interactive pages using HTML, CSS, JavaScript. Basics of working with forms, events, processing data from web forms.

Lesson 1: Introduction to Databases and Table Design

Objective:
To introduce students to database basics, table design, and key concepts.

Lesson plan:

1. What is a database (10 min).
   • Definition of databases, their purpose and use.
   • Relational databases: tables, rows, columns.
2. Designing tables (10 min).
   • Table structure: fields, data types (text, number, date, etc.).
   • Primary key and its purpose.
3. Practical work (20 min).
   • Design and create a simple table of data (for example, a table of student data).

Homework:
Create a table project for the chosen topic (for example, library, store) and describe the fields and their types.

Lesson 2: Creating SQL Queries

Objective:
To learn basic SQL commands for working with databases.

Lesson plan:

1. Introduction to SQL (10 min).
   • Basic SQL commands: CREATE, INSERT, SELECT, UPDATE, DELETE.
2. Example of working with requests (10 min).
   • Example queries for creating and changing data in a table.
3. Practical work (20 min).
   • Create a database and perform basic queries using SQL: add data to a table, retrieve data, update and delete it.

Homework:
Prepare a list of SQL queries to work with the table created in the homework from the last lesson.

Lesson 3: Data Normalization

Objective:
To learn the concept of data normalization in databases and how it improves table structure.

Lesson plan:

1. What is normalization (10 min).
   • The concept of normalization, levels of normalization (1NF, 2NF, 3NF).
   • How normalization helps avoid data duplication and improve database structure.
2. Examples of normalization (10 min).
   • Examples of normalized and denormalized tables.
3. Practical work (20 min).
   • Performing a database normalization task: dividing data into several tables and creating relationships between them.

Homework:
Normalize the created database, if necessary, and recreate the structure in the form of several related tables.

Lesson 4: Programming – Working with Files

Objective:
To teach students to work with files, input and output data using programs.

Lesson plan:

1. Basics of working with files (10 min).
   • Input and output of data to text files.
   • Opening, reading, writing and closing files in programming (eg Python).
2. Examples of working with files (10 min).
   • Examples of programs that read and write data to text files.
3. Practical work (20 min).
   • Write a program that reads data from a text file and saves the result of processing to a new file (for example, counting words or lines).

Homework:
Write a program to process a text file, performing specified operations (for example, searching for a string, deleting or replacing words).

Lesson 5: Creating programs for processing text information

Objective:
To deepen skills in working with text files, data processing and automation.

Lesson plan:

1. Processing text data (10 min).
   • Text processing: replacing words, deleting lines, counting characters and words.
   • Reading and writing large text files.
2. Examples of programs (10 min).
   • An example of a program for searching and replacing text, counting words.
3. Practical work (20 min).
   • Creating a text editor program: search, replace, delete, create reports.

Homework:
Modify a text editor program with advanced features (for example, adding saving changes to a separate file).

Lesson 6: Web Development – HTML and CSS Basics

Objective:
To teach the basics of creating web pages using HTML and CSS.

Lesson plan:

1. Basics of HTML and CSS (10 min).
   • Basics of HTML markup: tags, page structure, headings, paragraphs, links, images.
   • CSS Basics: Styling Text, Blocks, Colors, Backgrounds, Indents.
2. Example of page creation (10 min).
   • An example of a simple page with HTML and CSS elements.
3. Practical work (20 min).
   • Create a web page using HTML and CSS: create headings, paragraphs, images, style with CSS.

Homework:
Create a web page on a topic of your choice using the HTML tags and CSS styles you learned.

Lesson 7: Working with Web Forms and Event Handling in JavaScript

Objective:
To teach how to create interactive elements on web pages using forms and events.

Lesson plan:

1. Working with web forms (10 min).
   • Creating forms: input fields, buttons, drop-down lists.
   • Example of a data collection form.
2. Basics of working with events in JavaScript (10 min).
   • Event handling: clicks, data entry.
   • An example program for processing form data using JavaScript.
3. Practical work (20 min).
   • Create a web page with a form, process the form data on the client side using JavaScript.

Homework:
Create a web form that collects data and performs basic validation using JavaScript.

Lesson 8: Final Practical Work – Creating an Interactive Web Page

Objective:
To consolidate the material learned on web development by creating an interactive web page.

Lesson plan:

1. Statement of the problem (10 min).
   • Example task: create a web page with a form, styles and interactive elements in JavaScript (for example, a registration form with data validation).
2. Practical work (30 min).
   • Students create a web page using HTML, CSS, and JavaScript.
3. Discussion and analysis of works (10 min).
   • Presentation of solutions, discussion of difficulties and errors.

Homework:
Complete the project and prepare a report on the created web page, describing the technologies used.

This manual allows 9th grade students to master the basics of working with databases, deepen their knowledge of programming, and also acquire web development skills using modern technologies.

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.

A manual for a computer science teacher

8th grade, 4th quarter (7-8 lessons)

Topics:

1. Project activities: development of individual or group projects using all studied technologies.
2. Working with big data: basics of data analysis, using programs for analyzing large amounts of data.
3. Cybersecurity: data protection on the Internet, information encryption, safe behavior in social networks and instant messengers.

Lesson 1: Project Planning

Objective:
To teach students to plan and structure projects using various technologies.

Lesson plan:

1. Definition of the project (10 min).
   • What is a project, types of projects (eg website, app, database).
   • Choice of topic: individual or group project.
2. Project structure (10 min).
   • Development stages: setting the task, choosing tools, development, testing and presentation.
3. Practical work (20 min).
   • Beginning project planning: drawing up a structure, choosing technologies, setting goals.

Homework:
Prepare a project plan, distribute tasks among group members.

Lesson 2: Working with Big Data – Basics of Analysis

Objective:
To introduce students to the basic principles of big data analysis and programs for processing them.

Lesson plan:

1. The concept of big data (10 min).
   • What is big data, its examples (social networks, search queries, data from devices).
   • Data analysis methods: sorting, filtering, visualization.
2. Data Tools (10 min).
   • Analysis programs: spreadsheets, databases.
   • Examples of using charts and graphs to visualize data.
3. Practical work (20 min).
   • Working with a set of data (for example, in spreadsheets): sorting, filtering, creating charts.

Homework:
Analyze the data set and prepare a report visualizing the results.

Lesson 3: Data Protection and Encryption

Objective:
To teach the basics of data protection and encryption of information on the Internet.

Lesson plan:

1. Principles of data protection (10 min).
   • What is data protection, methods of storing and transmitting protected information.
2. Basics of encryption (10 min).
   • What is encryption, its types (symmetric and asymmetric), examples of use.
3. Practical work (20 min).
   • An example of encrypting and decrypting messages (e.g. using online tools or Python libraries).

Homework:
Study examples of data encryption in popular instant messengers and social networks.

Lesson 4: Safe Behavior on the Internet

Objective:
To teach the rules of safe behavior on the Internet and social networks.

Lesson plan:

1. Internet threats (10 min).
   • Main types of threats: phishing, hacking, malware, data manipulation.
2. Safe behavior on social networks (10 min).
   • How to protect accounts, what can and cannot be published, two-factor authentication.
3. Practical work (20 min).
   • Check security settings on popular platforms (eg Google, Instagram, Facebook).
   • Installing and configuring two-factor authentication.

Homework:
Conduct an audit of the security settings of your social media accounts.

Lesson 5: Working with Big Data – Processing and Visualization

Objective:
To develop skills in working with large amounts of data, their processing and visualization.

Lesson plan:

1. Data Analysis Methods (10 min).
   • How to organize and structure large data sets, examples of application of analysis in various fields (marketing, finance, science).
2. Data analysis programs (10 min).
   • Use of data visualization and analysis tools (e.g. Google Sheets, Excel, databases).
3. Practical work (20 min).
   • Download and analyze real datasets (e.g. internet usage statistics, temperature data).

Homework:
Prepare a report based on the results of analyzing a large data set, visualize key points.

Lesson 6: Project Development – Practical Work

Objective:
Continue working on projects integrating programming, web development and data analysis technologies.

Lesson plan:

1. Discussion of the project (10 min).
   • Discussion of project progress, analysis of difficulties, consultation on issues.
2. Practical work (30 min).
   • Project development: creation of functional elements, work with databases, integration of data and technologies.

Homework:
Continue developing the project, paying attention to the integration of the studied technologies.

Lesson 7: Finalizing and Presenting Projects

Objective:
To complete the project development and prepare it for presentation.

Lesson plan:

1. Completion of work on the project (10 min).
   • Final testing and bug fixing, preparation for project presentation.
2. Presentation of projects (30 min).
   • Students demonstrate their projects (websites, applications, databases), discuss the creation process and the technologies used.
3. Discussion and feedback (10 min).
   • Analysis of completed work, discussion of the strengths of projects and suggestions for improvement.

Homework:
Prepare a written report on the project, describing the creation process and the results.

This manual helps 8th grade students consolidate the knowledge and skills acquired over the year through project activities and in-depth work with big data and cybersecurity.