Added сourse theory

Author: anchouls

CodeStyleAndFormatting/CodeSchemasAndEditorConfig/Theory/task.md

@@ -0,0 +1,45 @@
+IntelliJ IDEA provides two ways to comply with the project’s code style guidelines:
+**_code schemas_** and **_editor configs_**.
+In this lesson, we will talk about both of them.
+
+### Code schemas
+
+There are two predefined code schemas:
+
+- **Project scheme**: you configure settings for one specific project, they’re stored in the codeStyles folder
+  under **.idea** and are shared through the VCS together with the project.
+- **Default scheme**: you configure the settings that could be applied to all the projects you work on in the IDE that have the Default
+  schema selected.
+
+Note that code schemas are language-specific.
+
+To configure the **code schema**,
+1. Press `⌘,` (macOS) or `Ctrl+Alt+S` (Linux/Windows) to open the IDE settings and select Editor | Code Style.
+2. Select `Java` programming language.
+3. Select the code schema you would like to configure (Project or Default).
+4. Configure code style settings, such as tabs and indents, import settings (using single name import or import with `*`), and many others.
+
+<p align="center">
+    <img src="../../../common/src/main/resources/images/CodeStyleAndFormatting/CodeSchemasAndEditorConfig/code_style.png" alt="Code Style" width="400"/>
+</p>
+
+### EditorConfig
+
+Another way to configure code style settings is to define the **EditorConfig.**
+Adding an EditorConfig to your project is pretty easy – you just need to add the `.editorconfig` file to the directory you
+would like to apply code style settings to.
+
+It is also possible to have several `.editorconfig` files in the project,
+for example, one for the source code and another for tests. Just put them in the corresponding folders, and all settings
+will be applied to all sub-folders.
+
+There are two types of settings in `.editorconfig` files:
+- Standard options from EditorConfig, such as `tabs_width` or `indent_size`. The full list of options
+  is available [here](https://github.com/editorconfig/editorconfig/wiki/EditorConfig-Properties).
+- IntelliJ IDEA-specific options, their names start with the `ij_` prefix. For example, `ij_smart_tabs`.
+
+To better understand how EditorConfig works and see examples, please read its
+specification [here](https://spec.editorconfig.org/).
+If some property is not configured in `.editorconfig`, the IDE takes it from the code schema.
+
+**See Also**: [Detailed overview of formatting features by Trisha Gee](https://blog.jetbrains.com/idea/2020/06/code-formatting/)

CodeStyleAndFormatting/Introduction/CodeStyleAndFormattingIntroduction/task.md

@@ -4,3 +4,7 @@ In this section, we will cover the following topics:
 - The concepts of code style and formatting
 - Code style schema and EditorConfig
 - Automatic formatting using the IDE
+
+<p align="center">
+    <img src="../../../common/src/main/resources/images/CodeStyleAndFormatting/Introduction/code_style_and_formatting_intro.png" alt="Code style and formatting" width="400"/>
+</p>

CodeStyleAndFormatting/WhatIsFormatting/ReformatTheCodeUsingIDEPractice/task.md

@@ -2,6 +2,22 @@
 
 ### Theory
 
+To perform any refactoring in the IDE, you can use the Refactoring Menu or a specific shortcut.
+It’s also possible to configure custom shortcuts.
+Use the **&shortcut:ReformatCode;** (macOS) or **Ctrl + Alt + L** (Windows/Linux) shortcut to make the IDE automatically reformat your code.
+You can run it on some specific code fragment if you first select it and then type the shortcut, but you can also run it on the whole file.
+
+You can specify reformatting settings in the **Reformat dialog**, which is available by pressing
+**&shortcut:ShowReformatFileDialog;** (macOS) or `Ctrl+Alt+Shift+L` (Windows/Linux) shortcut.
+In this dialog, you can specify the scope of formatting changes and select the options to apply:
+- **Optimize imports** option will remove all unused imports in your file. Alternatively, you can invoke it using the **&shortcut:OptimizeImports;** or **Ctrl+Alt+O** (Windows/Linux) shortcut.
+- **Code cleanup** option runs code cleanup inspections.
+- **Do not keep line breaks** option reformats line breaks according to the code style settings.
+
+<p align="center">
+    <img src="../../../common/src/main/resources/images/CodeStyleAndFormatting/WhatIsFormatting/reformat_dialog.png" alt="Reformat dialog" width="400"/>
+</p>
+
 ### Task
 
 In this task, you need to reformat the provided code fragment using the shortcut.

CodeStyleAndFormatting/WhatIsFormatting/Theory/task.md

@@ -1 +1,53 @@
-# Task 1/4: What is formatting?
+# Task 1/4: What is formatting?
+
+**_Code style_** is a set of guidelines used in a development team on how to write code.
+Usually, the code style depends on the programming language and developers’ preferences and includes rules about formatting,
+documentation, naming conventions, and other aspect that affect code readability.
+
+**_Code formatting_** refers to the arrangement of code, including indentation, spacing, line breaks, and other stylistic conventions.
+Consistent indentation, clear spacing, and logical line breaks help developers quickly understand the code structure,
+flow, and relationships between different code elements.
+
+Let's take a look at the two simple code snippets.
+
+**Before fixing formatting:**
+```java
+public class Main {
+    public static void main(String[] args){
+        double l = 5.0; double w = 3.0; double area = calculateRectangleArea(l, w);
+        System.out.println("Rectangle area: " + area);
+    }
+
+    public static double calculateRectangleArea(double length,double width){
+        return length*width; }
+}
+```
+This code snippet doesn't have consistent indentation and proper spacing, making the code difficult to read and understand.
+
+**After fixing formatting:**
+```java
+public class Main {
+    public static void main(String[] args) {
+        double l = 5.0;
+        double w = 3.0;
+        double area = calculateRectangleArea(l, w);
+        System.out.println("Rectangle area: " + area);
+    }
+
+    public static double calculateRectangleArea(double length, double width) {
+        return length * width;
+    }
+}
+```
+The **refactored version** demonstrates improved formatting and naming, leading to enhanced readability and maintainability.
+
+<div class="hint" title="Code Formatting's Role in Code Review">
+
+One of the examples that shows how a lack of consistency might be confusing is the code review process.
+In real life, developers use version control systems to share their code with colleagues, and **inconsistent formatting
+makes the code review process more complicated**.
+Imagine you and your colleague use different formatting styles, and your colleague makes a minor change in the code but
+then formats the code according to their style.
+It will lead to the situation when you see lots of code line changes, but in fact, only a couple of lines contain functional changes.
+It is one of the examples of why you should pay attention to formatting.
+</div>

Conclusion/Conclusion/Conclusion/task.md

@@ -1,3 +1,23 @@
 # Section 8: Conclusion
 
 Congratulations! 🎉
+
+<p align="center">
+    <img src="../../../common/src/main/resources/images/Conclusion/Conclusion/conclusion_conclusion.png" alt="Conclusion" width="400"/>
+</p>
+
+You've completed the **Introduction to IDE Java Code Refactoring** course.
+You've dived into the art of enhancing code quality, improving software design, and mastering techniques
+to make your codebase more readable, maintainable, and flexible.
+
+As you continue on your programming journey, here are a few recommended next steps:
+- **Practice makes perfect**: Keep refining your skills by applying the concepts you've learned to real-world projects. The more you refactor and apply design patterns, the more intuitive and effective these techniques will become.
+- **Explore advanced patterns**: While this course introduced you to several fundamental design patterns, there are many more out there waiting for you to explore. Patterns like Observer, Singleton, and Decorator are just a few examples. Dive into resources and books dedicated to design patterns to expand your knowledge.
+- **Read widely**: Stay curious and keep reading articles, blogs, and books on software development, best practices, and emerging technologies.
+
+Here's a **list of recommended books and resource**s for further learning on refactorings and design patterns:
+- [Refactoring: Improving the Design of Existing Code by Martin Fowler](https://www.oreilly.com/library/view/refactoring-improving-the/9780134757681/)
+- [Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides](https://www.oreilly.com/library/view/design-patterns-elements/0201633612/)
+
+Stay curious, stay inspired, and keep coding! 🚀
+

Conclusion/FeedbackSurvey/FeedbackSurvey/task.md

@@ -1 +1,6 @@
 # Feedback survey
+
+Thank you for taking our Introduction to IDE Java Code Refactoring course!
+We would really appreciate it if you could take a few minutes to
+answer [our survey]().
+Your feedback will help us improve this course and make it relevant for future students.

ExtractingCode/Introduction/ExtractingCodeIntroduction/task.md

@@ -4,3 +4,7 @@ In this section, we will cover the following topics:
 - Long method code smell
 - Extract refactoring
 - Magic numbers
+
+<p align="center">
+    <img src="../../../common/src/main/resources/images/ExtractingCode/Introduction/extracting_code_intro.png" alt="Extracting code" width="400"/>
+</p>

ExtractingCode/WhatIsExtractMethodRefactoring/Theory/task.md

@@ -1 +1,19 @@
 # Task 1/2: What is Extract Method refactoring?
+
+As we mentioned before, **duplicated code can lead to undesirable effects**, such as when you fix a bug in one place
+but forget to fix it consistently in duplicates.
+The bug will still remain, and now it is even harder to find.
+
+We recommend avoiding duplicated code, but what can you do if it already exists?
+The solution is to **extract the duplicated code into a new separate function** and replace all the duplicated code fragments
+with calls to the newly introduced function.
+It is called an **Extract Method**.
+
+Also, we apply Extract Method refactoring when we encounter **long methods**.
+While there's no fixed limit on the number of lines a method should have, **consider extracting
+a block of code statements into a separate method** if those statements are cohesive
+and expose a piece of functionality that can be reused in other places.
+This also improves code readability and organization.
+
+Smaller functions make the code easier to read and understand, as each method has one single responsibility,
+making the overall flow more evident.

ExtractingCode/WhatIsExtractVariableRefactoring/Theory/task.md

@@ -1 +1,10 @@
 # Task 1/2: What is Extract Variable refactoring?
+
+A *magic number* is a numerical value used in the code without a comment explaining its purpose.
+Using magic numbers in code is considered bad practice because it makes the code prone to errors and less maintainable and readable.
+
+To resolve this problem, you can press the &shortcut:IntroduceConstant; (macOS) or `Ctrl+Alt+C` (Windows/Linux) shortcut to create a constant variable
+with a meaningful name and use it in the code.
+
+If there are duplicated values in the code (string values or just lines of code),
+you can use the &shortcut:IntroduceVariable; (macOS) or `Ctrl+Alt+V` (Windows/Linux) shortcut to introduce a variable.

InliningCode/InlineMethodRefactoring/Theory/task.md

@@ -1 +1,6 @@
 # Task 1/2: Inline Method refactoring
+
+Apply the Inline Method refactoring when a method's behavior is simple and its purpose is clear, but it is called from only one place.
+If the method has become redundant or does not add significant value, it can be safely inlined.
+
+To apply the Inline Method refactoring, select the code you want to inline and press the &shortcut:Inline; (macOS) or `Ctrl+Alt+N` (Windows/Linux) shortcut.