Teacher’s Guide for Informatics

8th Grade, 3rd Quarter (8 lessons)

Topics:

• Web Programming: Basics of client-server technologies, working with requests, fundamentals of API.
• Programming: Creating applications using OOP (Object-Oriented Programming) — an introduction to classes and objects.
• Working with Multimedia Files: Editing audio and video, creating multimedia projects.

Lesson 1: Basics of Client-Server Technologies

Objective:
Introduce students to the concept of client-server technologies and HTTP requests.

Lesson Plan:

1. What is a client-server model (10 min).
   The concept of client and server, how they interact on the internet, the basic principles of web services.
2. HTTP requests (10 min).
   Request methods: GET, POST, basic headers, what a URL is.
3. Practical work (20 min).
   Example of sending a simple request using a browser or a program (e.g., Postman).

Homework:
Read about the basics of the HTTP protocol and requests, prepare questions for the next lesson.

Lesson 2: Introduction to API and Interaction with Web Services

Objective:
Teach the basics of working with APIs and interacting with external services through requests.

Lesson Plan:

1. What is an API (10 min).
   Definition of API, examples of popular services with APIs (e.g., weather, maps, social networks).
2. Example of working with an API (10 min).
   How to send requests to an API, receive, and process responses (JSON, XML).
3. Practical work (20 min).
   Sending a request to an open API (e.g., weather or currency rates), receiving and processing data in a program.

Homework:
Explore different open APIs and try to retrieve data from one of them.

Lesson 3: Object-Oriented Programming (OOP) — Classes and Objects

Objective:
Introduce the basics of OOP, classes, and objects.

Lesson Plan:

1. What is OOP (10 min).
   Basic concepts: classes, objects, methods, properties.
2. Example of creating a class (10 min).
   Creating a simple class (e.g., “Car” class with methods and properties).
3. Practical work (20 min).
   Writing a program using classes and objects (e.g., creating a class to describe a book or a product).

Homework:
Create a class to describe any object (e.g., a device) and think about its methods and properties.

Lesson 4: Continuing OOP — Inheritance and Encapsulation

Objective:
Delve into more complex aspects of OOP: inheritance and encapsulation.

Lesson Plan:

1. Inheritance (10 min).
   The concept of inheritance, how one class can “inherit” properties and methods of another class.
2. Encapsulation (10 min).
   Hiding data inside a class, working with private and public methods.
3. Practical work (20 min).
   Expanding the previous program using inheritance and encapsulation (e.g., creating a subclass for the “Car” class — “ElectricCar”).

Homework:
Expand the program using the principles of encapsulation and inheritance, prepare questions on the topic.

Lesson 5: Working with Multimedia Files — Audio and Video

Objective:
Introduce the basics of editing multimedia files and creating simple audio and video projects.

Lesson Plan:

1. Editing audio and video (10 min).
   Software for working with audio and video (e.g., Audacity, Adobe Premiere), basic operations: cutting, editing.
2. Examples of creating multimedia projects (10 min).
   How multimedia can be applied in real projects (video presentations, podcasts, video reviews).
3. Practical work (20 min).
   Example of creating a simple audio clip or video (e.g., editing a short video or recording and editing sound).

Homework:
Create a short audio or video clip using editing tools.

Lesson 6: Creating Multimedia Projects — Editing and Adding Effects

Objective:
Develop skills in creating multimedia projects: editing, adding effects, and audio.

Lesson Plan:

1. Video editing and adding effects (10 min).
   How to add effects to video, improve sound, overlay music, and titles.
2. Examples of successful multimedia projects (10 min).
   Demonstration of well-edited video examples with audio effects.
3. Practical work (20 min).
   Creating a small video project with editing, sound overlay, and effects.

Homework:
Enhance the multimedia project with new effects or audio tracks.

Lesson 7: Combining OOP and Multimedia in Projects

Objective:
Teach students how to integrate OOP and multimedia into software projects.

Lesson Plan:

1. Integration of OOP and multimedia (10 min).
   How to combine OOP principles and multimedia file processing in one project (e.g., a program for creating audio or video projects).
2. Project examples (10 min).
   Review examples of software that works with multimedia files (e.g., video editing software).
3. Practical work (20 min).
   Create a program that uses OOP to work with multimedia files (e.g., an app for managing a collection of audio or video files).

Homework:
Think through and develop a project that combines OOP and multimedia file handling.

Lesson 8: Final Project — Creating a Multimedia Application

Objective:
Consolidate the studied material by creating a complete project that includes OOP and multimedia elements.

Lesson Plan:

1. Project discussion (10 min).
   Choosing topics for the final project: a multimedia application (e.g., audio player, video editor, or interactive media app).
2. Practical work (30 min).
   Beginning project development, working on the main functional blocks.
3. Discussion of results and feedback (10 min).
   Analyzing the completed work, discussing challenges and achievements.

Homework:
Complete the project, prepare a presentation of the results.

This guide will help 8th-grade students deepen their knowledge in web programming and OOP while applying these skills in the creation of multimedia projects.

A manual for a computer science teacher

8th grade, 2nd quarter (7-8 lessons)

Topics:

1. Working with databases: relational databases, the concept of tables, keys, creating and using queries (e.g. SQL).
2. Programming: working with files, input/output of data, creating programs for working with text and numerical data.
3. Web development: creating interactive web pages using HTML, CSS and JavaScript (forms, events, dynamic content change).

Lesson 1: Introduction to Relational Databases

Objective:
To introduce the concept of relational databases, tables and keys.

Lesson plan:

1. What are relational databases (10 min).
   • Basic elements: tables, rows, columns, primary and foreign keys.
2. Using databases (10 min).
   • Where and how databases are used (for example, in accounting systems, web applications).
3. Practical work (20 min).
   • Create a simple data table, define keys, add records (in the training environment or via SQL).

Homework:
Create a table to store information about students’ school subjects and grades.

Lesson 2: Working with SQL Queries

Objective:
To learn the basics of creating queries for working with databases.

Lesson plan:

1. SQL Basics (10 min).
   • Basic commands: SELECT, INSERT, UPDATE, DELETE.
2. Examples of queries (10 min).
   • Extract data, update and delete records in tables.
3. Practical work (20 min).
   • Execute queries to retrieve data from tables, add and update records.

Homework:
Write several SQL queries to select data from the table created in the last lesson.

Lesson 3: Programming – Working with Files

Objective:
To study working with files in programming: reading, writing and processing data.

Lesson plan:

1. File I/O (10 min).
   • Reading data from a file, writing data to a file, file types (text and binary).
2. Using files in programs (10 min).
   • Using files to store and process data, example tasks.
3. Practical work (20 min).
   • Writing a program to read and write data to a text file (e.g. saving and loading user data).

Homework:
Create a program to read data from a file and process it (for example, count the number of lines or words in a file).

Lesson 4: Processing Text and Numeric Data

Objective:
To teach how to process text and numerical data in programming.

Lesson plan:

1. Working with text and numbers (10 min).
   • Data conversion, formatting, working with text strings and numbers.
2. Application in real-life problems (10 min).
   • Example: calculating statistics from text data, converting numbers.
3. Practical work (20 min).
   • Writing a program to process data, such as counting the frequency of words in a text or working with tables of numerical data.

Homework:
Create a program to analyze and transform text data, such as searching for a specific word or converting the case of text.

Lesson 5: Web Development Basics – Forms and Events

Objective:
To introduce the creation of interactive web pages, forms and events in HTML, CSS and JavaScript.

Lesson plan:

1. Creating forms in HTML (10 min).
   • Basic form tags: <form>, <input>, <button>, their parameters and purpose.
2. Event Handling in JavaScript (10 min).
   • How JavaScript responds to events (button clicks, form input), creating simple event handlers.
3. Practical work (20 min).
   • Create a web page with a form and write JavaScript code to process the input and display the results.

Homework:
Create a web page with a form for entering data and a program for processing it (for example, a simple questionnaire).

Lesson 6: CSS for Dynamic Web Page Design

Objective:
To deepen knowledge of CSS, to study dynamic changes in styles and page design.

Lesson plan:

1. CSS Basics (10 min).
   • How CSS works, how you can style pages and form elements.
2. Dynamically changing styles (10 min).
   • Using CSS classes to change the styles of elements upon interaction (hover, button click).
3. Practical work (20 min).
   • Create a web page with changing styles (for example, a button that changes on hover).

Homework:
Create a web page with interactive elements that change their styles when the user interacts with them.

Lesson 7: JavaScript for Dynamic Content Changes

Objective:
To teach how to dynamically change the content of a web page using JavaScript.

Lesson plan:

1. Changing content via JavaScript (10 min).
   • How JavaScript can change text, images, and other elements on a page.
2. Examples of dynamic content change (10 min).
   • Example: dynamic updating of the product list on the website, updating information at the user’s request.
3. Practical work (20 min).
   • Create a web page that changes content based on user actions (e.g. a calculator or interactive questionnaire).

Homework:
Create a web page with dynamic content changes based on user interaction.

Lesson 8: Final Work on Databases, Programming and Web Development

Objective:
To consolidate the material covered by completing the final assignment.

Lesson plan:

1. Review of the material covered (10 min).
   • Discussion of key topics: databases, working with files, web development.
2. Final work (20 min).
   • Develop a project that combines all the topics covered (for example, creating a web page with a form that saves entered data to a file or database and displays it dynamically).
3. Discussion of results and feedback (10 min).
   • Analysis of completed projects, discussion of achievements and difficulties.

Homework:
Prepare a report on the work completed, explaining the technologies and methods used.

These lessons will help students deepen their knowledge of programming, databases, and web development, preparing them for more complex tasks in the future.

A manual for a computer science teacher

8th grade, 1st quarter (8 lessons)

Topics:

1. Review of the basics of working with the operating system and file types.
2. Advanced algorithms: data sorting, searching, working with large data arrays.
3. Programming: advanced use of functions, parameters, recursion and modularity (Python, JavaScript).

Lesson 1: Reviewing the Basics of Working with the Operating System and File Types

Objective:
To refresh knowledge about working with the operating system, file types and their organization.

Lesson plan:

1. Repetition of working with the operating system (10 min).
   • File system organization: directories, creating, copying, moving files.
2. File types (10 min).
   • Main types: text, graphic, audio, video, executable files. Their features and purpose.
3. Practical work (20 min).
   • Managing files and folders in the operating system, converting files from one format to another.

Homework:
Organize your filing system for your study materials by type and purpose.

Lesson 2: Advanced Algorithms – Sorting Data

Objective:
To study data sorting algorithms and their application in real-world problems.

Lesson plan:

1. Introduction to data sorting (10 min).
   • What is sorting, main types of sorting: bubble sort, quick sort, merge sort.
2. Using sorts (10 min).
   • How sorting works, its execution time, examples of use (including in real life).
3. Practical work (20 min).
   • Writing a program to sort arrays of data (in Python or JavaScript).

Homework:
Develop a program to sort an arbitrary set of data.

Lesson 3: Data Mining Algorithms

Objective:
To introduce the basic data retrieval algorithms, their application and efficiency.

Lesson plan:

1. Search algorithms (10 min).
   • Linear and binary search: differences, advantages and disadvantages.
2. Using search (10 min).
   • How search algorithms are used in everyday life (searching the Internet, databases, etc.).
3. Practical work (20 min).
   • Implementation of a program for searching for an element in an array using different algorithms.

Homework:
Implement a binary search algorithm for an ordered array.

Lesson 4: Working with Large Data Sets

Objective:
To teach how to work effectively with large data arrays using optimized algorithms.

Lesson plan:

1. Problems of working with big data (10 min).
   • Features of processing large data sets, complexity of algorithms.
2. Optimization of data processing (10 min).
   • Application of efficient methods for working with large volumes of data (data partitioning, buffering).
3. Practical work (20 min).
   • Writing a program to process a large array of data (for example, processing a list of students or products).

Homework:
Implement a program that processes big data using optimized algorithms.

Lesson 5: Digging into Programming – Functions and Parameters

Objective:
To study the use of functions and parameters in programming to create modular programs.

Lesson plan:

1. Functions in programming (10 min).
   • What are functions, why are they needed, how are they created and used.
2. Parameters and return values ​​(10 min).
   • Using parameters and return values ​​to make functions more general.
3. Practical work (20 min).
   • Create a program with several functions that take parameters and return results.

Homework:
Develop a program with at least three functions that use parameters for different calculations.

Lesson 6: Recursion in Programming

Objective:
To introduce the principle of recursion and its application in solving complex problems.

Lesson plan:

1. Principle of recursion (10 min).
   • What is recursion, when and why is it used.
2. Examples of recursive algorithms (10 min).
   • Factorial, Fibonacci number sequence and other problems solved with recursion.
3. Practical work (20 min).
   • Implementation of a recursive algorithm for solving a problem (for example, finding a factorial).

Homework:
Create a program with a recursive function to solve another problem (for example, a number sequence).

Lesson 7: Modularity in Programming

Objective:
To teach how to divide programs into modules to improve the efficiency and ease of development.

Lesson plan:

1. The principle of modularity (10 min).
   • What are modules in programming, why use them.
2. Dividing the program into modules (10 min).
   • Examples of modular programs, libraries and functions.
3. Practical work (20 min).
   • Developing a program using several modules (for example, a separate module for mathematical operations, working with files, etc.).

Homework:
Create a program consisting of several modules, each of which performs its own task.

Lesson 8: Consolidation of knowledge and final work

Objective:
To summarize the topics covered and check the level of assimilation of the material through a practical assignment.

Lesson plan:

1. Discussion of the material covered (10 min).
   • Brief overview of the topics, discussion of difficulties and achievements.
2. Final task (20 min).
   • Developing a program that involves the use of functions, parameters, recursion, and modules (e.g. sorting and searching data and displaying the results on the screen).
3. Discussion of results and feedback (10 min).
   • Analysis of completed work, discussion of results.

Homework:
Prepare a presentation on the completed project, explaining the algorithms and programming principles used.

These lessons will help students deepen their programming knowledge, master data manipulation, and prepare for more complex projects in the future.

A manual for a computer science teacher

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

Topics:

1. Project activities: development of individual or group projects (website, application or game), integration of programming, design and databases.
2. Working with data: delving into data analysis, working with large amounts of data, creating databases and queries, filtering and sorting information.
3. Cybersecurity: in-depth study of online threats, protection of personal data, conscious use of social networks.

Lesson 1: Introduction to project work

Objective:
To introduce students to the basics of project work, defining the project topic, and distributing tasks in groups.

Lesson plan:

1. Introduction to project activities (10 min).
   • What is a project, stages of development, goals and objectives.
2. Examples of projects (10 min).
   • Examples of successful student projects (website, game, application).
3. Selecting a project topic (15 min.)
   • Discussion of ideas and distribution of tasks in teams (if the project is a group project).
4. Getting started with a project (10 min).
   • Initial planning and assignment of roles within the team.

Homework:
Start working on the project idea, collect materials.

Lesson 2: Project Work – Programming and Design Integration

Objective:
To deepen programming skills in the context of project work and design integration.

Lesson plan:

1. Programming for the project (10 min).
   • Working with programming languages ​​(Python, HTML/CSS, JavaScript) to implement functionality.
2. Design integration in a project (15 min).
   • Basics of interface design (UI/UX), web page styling, adding graphic elements.
3. Practical work (20 min).
   • Development of the first components of the project using programming and design.

Homework:
Continue working on the functional and design aspects of the project.

Lesson 3: Working with Databases – Creation and Integration

Objective:
To introduce the basic principles of working with databases, their creation and use in projects.

Lesson plan:

1. Explaining the concept of databases (10 min).
   • What are databases, their structure, types of databases (relational).
2. Creating databases (15 min).
   • Introduction to SQL, creating simple tables and queries.
3. Integration of databases into the project (20 min).
   • Linking a project to a database, an example of working with forms and queries.

Homework:
Add a database to the project and create several queries to work with the data.

Lesson 4: Deep Data Analysis

Objective:
To teach how to work with large volumes of data, analyze information and use tools for data visualization.

Lesson plan:

1. Working with large amounts of data (10 min).
   • Example of large data sets and their application (financial reports, statistics).
2. Filtering and sorting data (15 min).
   • Working with large tables and databases, writing complex queries for sorting and filtering data.
3. Practical work (20 min).
   • Using filters and queries to work with real data in a project (data analysis).

Homework:
Apply filters and sorting of data in the project to perform real-world tasks.

Lesson 5: Cybersecurity – Protecting Personal Data

Objective:
To deepen knowledge about cyber threats and data protection, to develop skills for safe behavior on the Internet.

Lesson plan:

1. Threats on the Internet (10 min).
   • What is phishing, hacking, viruses, social engineering.
2. Protection of personal data (15 min).
   • How to protect your data: complex passwords, two-factor authentication, encryption.
3. Practical work (20 min).
   • Installation and configuration of antivirus programs, discussion of examples of cyber attacks and methods of protection.

Homework:
Review your current cybersecurity measures and update passwords, enable two-factor authentication.

Lesson 6: Cybersecurity on Social Media

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

Lesson plan:

1. The Dangers of Social Media (10 min).
   • What is cyberbullying, personal data collection, fraud.
2. Profile protection (15 min).
   • Privacy settings, secure online communication, content filtering.
3. Practical work (20 min).
   • Setting up privacy for social network profiles, using secure applications for communication.

Homework:
Audit your social media profiles and update your privacy settings.

Lesson 7: Project Completion – Presentation

Objective:
To prepare final versions of projects and present them to the class.

Lesson plan:

1. Completing projects (20 min).
   • Finishing touches: testing, bug fixing, interface improvements.
2. Presentation of projects (20 min).
   • Students present their projects to the class, explaining the technologies used and the stages of development.

Homework:
Prepare a written description of the project: goals, technologies used, difficulties and solutions.

Lesson 8: Feedback and Final Discussion

Objective:
To evaluate the results of students’ work, discuss difficulties, and provide feedback.

Lesson plan:

1. Discussion of projects (20 min).
   • Brief overview of the presented projects, highlighting strengths.
2. Feedback from teacher and students (20 min).
   • Discussion of what worked and what could be improved, advice on how to improve projects in the future.

Conclusion:
Students receive a grade on their projects and suggestions for further development.

A manual for a computer science teacher

7th grade, 3rd quarter (8 lessons)

Topics:

1. Web Development: Advanced study of HTML and CSS, creating complex web pages with stylesheets, introduction to JavaScript basics.
2. Programming: creating projects using cycles, functions, arrays, working with input and output data.
3. Multimedia projects: creating video projects, working with graphics and sound, editing video and audio.

Lesson 1: Web Development – Advanced HTML

Objective:
To teach how to create more complex web pages using HTML and CSS.

Lesson plan:

1. HTML and CSS review (10 min).
   • A quick refresher on the basic elements of HTML and CSS, and a discussion of web page structure.
2. Creating a web page using complex elements (15 min).
   • Adding headings, lists, tables and other structural elements.
3. Practical work (20 min).
   • Create a simple web page with a table, lists and CSS formatting.

Homework:
Design a web page using structural elements and style sheets for design.

Lesson 2: Advanced CSS and Styling Web Pages

Objective:
To teach advanced use of CSS for styling web pages.

Lesson plan:

1. CSS Review (10 min).
   • Basics of selectors and applying styles.
2. Creating complex styles (15 min).
   • Using pseudo-classes, pseudo-elements and complex selectors to style a web page.
3. Practical work (20 min).
   • Developing a web page using complex styles for different elements.

Homework:
Complete the web page design using advanced styles.

Lesson 3: JavaScript Basics for Dynamics on Web Pages

Objective:
To introduce students to the basics of JavaScript and how to use it to add dynamic elements to web pages.

Lesson plan:

1. What is JavaScript and why is it needed (10 min).
   • An explanation of the basic concepts and purposes of using JavaScript on web pages.
2. Basics of JavaScript Syntax (15 min).
   • Introduction of variables, conditions, cycles, creation of a simple script for interaction with the user.
3. Practical work (20 min).
   • Adding a script to a web page to interact with elements (for example, a button that changes the text on the page).

Homework:
Add a simple JavaScript script to a web page for dynamic interaction.

Lesson 4: Creating a Project – Interactive Web Page

Objective:
Apply knowledge of HTML, CSS and JavaScript to create a fully interactive web page.

Lesson plan:

1. Discussion of the project structure (10 min).
   • Analysis of the main components of an interactive web page: headings, text, styles, interactive elements (e.g. buttons).
2. Working on the project (25 min).
   • Students create a web page with interactive elements such as buttons, dynamic lists, and content that changes when clicked.

Homework:
Complete the interactive web page and prepare it for presentation.

Lesson 5: Programming – Working with Arrays and Loops

Objective:
To teach how to create programs using arrays and loops to process data.

Lesson plan:

1. Repeating arrays and loops (10 min).
   • An explanation of working with arrays, their creation and use for storing data.
2. Example of a program with arrays (15 min).
   • Developing a program for processing an array of data, for example, calculating the average value of numbers in an array.
3. Practical work (20 min).
   • Writing a program using arrays and loops to work with user data.

Homework:
Create a program that uses arrays to solve a practical problem (for example, calculating students’ grades).

Lesson 6: Working with Input and Output Data

Objective:
To teach students to create programs that interact with the user through input and output.

Lesson plan:

1. Introduction to data input and output (10 min).
   • Examples of programs that accept data from the user via text fields or the console.
2. Example of the program (15 min).
   • Develop a program that accepts input from the user and outputs results (e.g. a calculator).
3. Practical work (20 min).
   • Writing a program that takes input from the user (such as their name and age) and outputs a result (a welcome message or an age calculation in 10 years).

Homework:
Complete a program to work with user input and output.

Lesson 7: Multimedia Projects – Introduction to Video Editing

Objective:
To teach the basics of working with multimedia files, including video and audio editing.

Lesson plan:

1. Overview of tools for working with multimedia (10 min.).
   • Presentation of programs for video editing and working with graphics (for example, Windows Movie Maker, Audacity).
2. Practical work: creating a simple video project (20 min).
   • Import video and audio files, cut, add sound, overlay effects and transitions.
3. The final part (10 min).
   • Presentation of finished multimedia projects.

Homework:
Finish editing the video and prepare it for showing in the next lesson.

Lesson 8: Presentation of multimedia projects and final work

Objective:
To consolidate knowledge of multimedia technologies and give students the opportunity to present their projects.

Lesson plan:

1. Presentation of video projects (25 min).
   • Students show their multimedia projects to the class and explain the stages of creation.
2. Discussion and feedback (15 min).
   • The teacher and students discuss projects, share impressions and give feedback.

Homework:
Prepare a brief description of the process of creating a multimedia project (stages of work, difficulties and solutions).