From e2c290bcc1a944c384f1a169ddc16b1e4efc0ec6 Mon Sep 17 00:00:00 2001
From: VerzatileDev <47317248+VerzatileDev@users.noreply.github.com>
Date: Thu, 13 Jun 2024 17:44:30 +0300
Subject: [PATCH 1/9] Fix a permalink to remove .html (#102)
The following change is based on the information provided at:
- https://jekyllrb.com/docs/permalinks/
(When a page is located at " Resource/myPage.html " it converts it to -> /myPage/ )
---
_config.yml | 1 +
1 file changed, 1 insertion(+)
diff --git a/_config.yml b/_config.yml
index 7f20454..70b3bae 100644
--- a/_config.yml
+++ b/_config.yml
@@ -1,6 +1,7 @@
title: Programming Handbook
description: An open-source platform for sharing and preserving programming knowledge. Discover code snippets, best practices, and resources, all continuously updated by a thriving community of developers. Join us to collaborate and enhance your coding skills in one comprehensive space.
theme: just-the-docs
+permalink: pretty
url: https://just-the-docs.github.io
From fd53c244ba34987c6284b20c0e735d2abcf12a05 Mon Sep 17 00:00:00 2001
From: JDSherbert <43964243+JDSherbert@users.noreply.github.com>
Date: Mon, 24 Jun 2024 21:00:52 +0100
Subject: [PATCH 2/9] Update Notepad++.md
Added article for Notepad++
---
docs/IDE/Notepad++/Notepad++.md | 19 ++++++++++++++-----
1 file changed, 14 insertions(+), 5 deletions(-)
diff --git a/docs/IDE/Notepad++/Notepad++.md b/docs/IDE/Notepad++/Notepad++.md
index 97b8fee..82ecf16 100644
--- a/docs/IDE/Notepad++/Notepad++.md
+++ b/docs/IDE/Notepad++/Notepad++.md
@@ -1,7 +1,7 @@
---
layout: default
title: Notepad++
-description: "Warning: The following page is currently under construction, find more about the details in future patches, or if you choose to add in the article see info on the bottom of the page."
+description: An article dicussing features, key releases and getting started topics about Notepad++
nav_order: 1
parent: IDE
has_children: false
@@ -10,10 +10,19 @@ has_children: false
{{ page.title }}
======================
-{% include under_construction.html %}
-
Download: https://notepad-plus-plus.org/
-
+Notepad++ is a free and open-source text and source code editor for Windows. It is extremely lightweight and is very useful for quick code edits, psuedocoding, or note taking. Notepad++ has a wide support for a wide variety of programming languages. Itsupports syntax highlighting and folding for programming languages (e.g., C++, Python, HTML, CSS, JavaScript). The highlighting feature makes the code more readable by coloring different parts of the syntax, while folding allows users to collapse sections of code to make it easier to manage large files.
+
+It's worth knowing that Notepad++ is primarily a text editor. It does not come with built-in support for compiling or debugging code. Users will need to use external compilers and debuggers, which can be less convenient than integrated development environments (IDEs) like Visual Studio, that provide these tools out of the box. Unlike full-fledged IDEs, Notepad++ also lacks features like project management, integrated version control, and direct execution of code.
+This doesn't make it any less useful!
+
+To use notepad, simply download it from the link above, and then install it. Run it and start writing! No other nonsense involved!
+
+
+
+
+---
-
\ No newline at end of file
+#### Author: JDSherbert
+#### Published: 24/06/2024
From af607c69af089a833972591ca30edfd8aa9bcd27 Mon Sep 17 00:00:00 2001
From: JDSherbert <43964243+JDSherbert@users.noreply.github.com>
Date: Tue, 25 Jun 2024 19:21:55 +0100
Subject: [PATCH 3/9] Update Notepad++.md (#103)
Added article for Notepad++
---
docs/IDE/Notepad++/Notepad++.md | 19 ++++++++++++++-----
1 file changed, 14 insertions(+), 5 deletions(-)
diff --git a/docs/IDE/Notepad++/Notepad++.md b/docs/IDE/Notepad++/Notepad++.md
index 97b8fee..82ecf16 100644
--- a/docs/IDE/Notepad++/Notepad++.md
+++ b/docs/IDE/Notepad++/Notepad++.md
@@ -1,7 +1,7 @@
---
layout: default
title: Notepad++
-description: "Warning: The following page is currently under construction, find more about the details in future patches, or if you choose to add in the article see info on the bottom of the page."
+description: An article dicussing features, key releases and getting started topics about Notepad++
nav_order: 1
parent: IDE
has_children: false
@@ -10,10 +10,19 @@ has_children: false
{{ page.title }}
======================
-{% include under_construction.html %}
-
Download: https://notepad-plus-plus.org/
-
+Notepad++ is a free and open-source text and source code editor for Windows. It is extremely lightweight and is very useful for quick code edits, psuedocoding, or note taking. Notepad++ has a wide support for a wide variety of programming languages. Itsupports syntax highlighting and folding for programming languages (e.g., C++, Python, HTML, CSS, JavaScript). The highlighting feature makes the code more readable by coloring different parts of the syntax, while folding allows users to collapse sections of code to make it easier to manage large files.
+
+It's worth knowing that Notepad++ is primarily a text editor. It does not come with built-in support for compiling or debugging code. Users will need to use external compilers and debuggers, which can be less convenient than integrated development environments (IDEs) like Visual Studio, that provide these tools out of the box. Unlike full-fledged IDEs, Notepad++ also lacks features like project management, integrated version control, and direct execution of code.
+This doesn't make it any less useful!
+
+To use notepad, simply download it from the link above, and then install it. Run it and start writing! No other nonsense involved!
+
+
+
+
+---
-
\ No newline at end of file
+#### Author: JDSherbert
+#### Published: 24/06/2024
From 21fe45fc7e0555b1d5c1c85a3d8945a05d3e5d65 Mon Sep 17 00:00:00 2001
From: JDSherbert <43964243+JDSherbert@users.noreply.github.com>
Date: Thu, 4 Jul 2024 00:15:39 +0100
Subject: [PATCH 4/9] Update Polymorphism.md
---
docs/Concepts/Polymorphism/Polymorphism.md | 148 ++++++++++++++++++++-
1 file changed, 143 insertions(+), 5 deletions(-)
diff --git a/docs/Concepts/Polymorphism/Polymorphism.md b/docs/Concepts/Polymorphism/Polymorphism.md
index 93b5f0e..98419c9 100644
--- a/docs/Concepts/Polymorphism/Polymorphism.md
+++ b/docs/Concepts/Polymorphism/Polymorphism.md
@@ -1,18 +1,156 @@
---
layout: default
title: Polymorphism
-description: "Warning: The following page is currently under construction, find more about the details in future patches, or if you choose to add in the article see info on the bottom of the page."
+description: An article dicussing "Polymorphism", which means "Many Forms".
nav_order: 1
-parent: Concepts
+parent: Polymorphism
+grand_parent: Concepts
has_children: false
---
{{ page.title }}
======================
-{% include under_construction.html %}
+{: .warning }
+This article is quite advanced and assumes you have an understanding of Object Oriented Programming.
+If not, please refer to the [C++](/docs/Concepts/OOP/OOP.md) section of this book!
+Polymorphism is a fundamental concept in object-oriented programming (OOP) that allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to be used for entities of different types, promoting flexibility, extensibility, and code reuse. Polymorphism can be achieved through two main mechanisms: compile-time (or static) polymorphism and run-time (or dynamic) polymorphism.
-
+### 1. Compile-Time Polymorphism
+Compile-time polymorphism is achieved using function overloading and operator overloading.
-
\ No newline at end of file
+#### Function Overloading:
+This allows multiple functions with the same name but different parameter lists to be defined within the same scope. The appropriate function to call is determined by the number and types of arguments passed to it at compile-time.
+
+{: .code }
+```
+cpp
+// Example of function overloading
+int Add(int A, int B)
+{
+ return A + B;
+}
+
+float Add(float A, float B)
+{
+ return A + B;
+}
+```
+In this example, `Add` is overloaded to accept both `int` and `float` arguments.
+
+#### Operator Overloading:
+Operators such as `+`, `-`, `*`, etc., can be overloaded to work with user-defined types in addition to their built-in functionality.
+
+{: .code }
+```
+cpp
+// Example of operator overloading
+class Complex
+{
+
+private:
+ float A;
+ float B;
+
+public:
+
+ Complex operator+(const Complex& other)
+ {
+ Complex temp;
+ temp.A = this->A + other.A;
+ temp.B = this->B + other.B;
+ return temp;
+ }
+};
+```
+
+Here, the `+` operator is overloaded to add two "Complex" objects.
+
+### 2. Run-Time Polymorphism
+Run-time polymorphism in C++ is achieved through virtual functions and abstract classes (interfaces) using inheritance.
+
+#### Virtual Functions:
+A virtual function is a member function in a base class that you expect to override in derived classes. When you refer to a derived class object using a pointer or reference to the base class, you can call a virtual function for that object and execute the derived class's version of the function.
+
+{: .code }
+```
+cpp
+// Example of virtual functions
+class Animal
+{
+
+public:
+
+ virtual void MakeSound()
+ {
+ cout << "Animal sound" << endl;
+ }
+};
+
+class Dog : public Animal
+{
+
+public:
+
+ void MakeSound() override
+ {
+ cout << "Bark!" << endl;
+ }
+};
+```
+In this example, `MakeSound()` is a virtual function in `Animal` which is overridden in `Dog`.
+
+#### Abstract Classes and Pure Virtual Functions:
+An abstract class is a class that has at least one pure virtual function. A pure virtual function is a virtual function that is declared in a base class but has no definition. Abstract classes cannot be instantiated; they are meant to be inherited from by other classes.
+
+{: .code }
+```
+cpp
+// Example of abstract class and pure virtual function
+class Shape
+{
+
+public:
+
+ virtual void Draw() = 0; // Pure virtual function
+ virtual float Area() const = 0; // Another pure virtual function
+};
+
+class Circle : public Shape
+{
+
+public:
+
+ void Draw() override
+ {
+ cout << "Drawing Circle" << endl;
+ }
+
+ float Area() const override
+ {
+ return 3.14 * radius * radius;
+ }
+
+private:
+
+ float Radius;
+};
+```
+Here, `Shape` is an abstract class with pure virtual functions `Draw()` and `Area()`. `Circle` inherits from `Shape` and provides implementations for these functions.
+
+### Benefits of Polymorphism
+- Flexibility and Extensibility: Code written using polymorphism can be easily extended by adding new classes that implement the same interfaces or inherit from the same base class.
+- Simplicity and Maintainability: Polymorphism allows for cleaner and more modular code since it encourages reusability and reduces duplication.
+- Encapsulation: By using polymorphism, you can hide the implementation details of classes and expose only the required functionality through interfaces.
+
+### Considerations and Best Practices
+- Use Interfaces When Appropriate. If you want to define a common interface without any implementation details, use abstract classes (interfaces) with pure virtual functions.
+- Avoid Slicing: When working with polymorphic objects through pointers or references to the base class, be mindful of object slicing, where the derived class's specific attributes can be lost if assigned to a base class object.
+
+Polymorphism is a powerful concept that enables elegant and efficient design of object-oriented systems. It promotes code reusability, maintainability, and flexibility, making it a cornerstone of modern software development practices.
+
+---
+
+#### Author: JDSherbert
+#### Published: 04/07/2024
From 38defa10cf940e03b388b032d71fccb9ee9fcc06 Mon Sep 17 00:00:00 2001
From: JDSherbert <43964243+JDSherbert@users.noreply.github.com>
Date: Thu, 4 Jul 2024 00:16:04 +0100
Subject: [PATCH 5/9] Update Polymorphism.md
---
docs/Concepts/Polymorphism/Polymorphism.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/Concepts/Polymorphism/Polymorphism.md b/docs/Concepts/Polymorphism/Polymorphism.md
index 98419c9..9f7dd90 100644
--- a/docs/Concepts/Polymorphism/Polymorphism.md
+++ b/docs/Concepts/Polymorphism/Polymorphism.md
@@ -13,7 +13,7 @@ has_children: false
{: .warning }
This article is quite advanced and assumes you have an understanding of Object Oriented Programming.
-If not, please refer to the [C++](/docs/Concepts/OOP/OOP.md) section of this book!
+If not, please refer to the [OOP](/docs/Concepts/OOP/OOP.md) section of this book!
Polymorphism is a fundamental concept in object-oriented programming (OOP) that allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to be used for entities of different types, promoting flexibility, extensibility, and code reuse. Polymorphism can be achieved through two main mechanisms: compile-time (or static) polymorphism and run-time (or dynamic) polymorphism.
From 93e4099d1f0ebb4f793d0d92bf79b60c6c420c0b Mon Sep 17 00:00:00 2001
From: JDSherbert <43964243+JDSherbert@users.noreply.github.com>
Date: Thu, 4 Jul 2024 00:34:46 +0100
Subject: [PATCH 6/9] Update OOP.md
---
docs/Concepts/OOP/OOP.md | 259 ++++++++++++++++++++++++++++++++++++---
1 file changed, 239 insertions(+), 20 deletions(-)
diff --git a/docs/Concepts/OOP/OOP.md b/docs/Concepts/OOP/OOP.md
index 9796eeb..09d8e85 100644
--- a/docs/Concepts/OOP/OOP.md
+++ b/docs/Concepts/OOP/OOP.md
@@ -1,33 +1,252 @@
---
layout: default
-title: OOP
-description: "Warning: The following page is currently under construction, find more about the details in future patches, or if you choose to add in the article see info on the bottom of the page."
+title: OOOP
+description: An article dicussing Object Oriented Programming.
nav_order: 1
-parent: Concepts
+parent: OOP
+grand_parent: Concepts
has_children: false
-include_programming_language_switch_script: true
---
{{ page.title }}
======================
-{% include under_construction.html %}
+Object-Oriented Programming (OOP) is a programming paradigm that revolves around the concept of objects, which are instances of classes, and allows for the organization and structure of code that is more closely aligned with real-world entities and concepts. OOP provides a way to structure software as a collection of objects that interact with each other to accomplish tasks. Here’s an in-depth exploration of the key principles and concepts of OOP:
-
-
- This is C++ content for Object-Oriented Programming.
-
+## Key Concepts of Object-Oriented Programming
+### 1. Classes and Objects
-
-
- This is C# content for Object-Oriented Programming.
-
+#### Class:
+A class is a blueprint or template for creating objects. It defines the data and behavior (methods) that objects of the class will have. For example, a Car class might define properties like color, model, and methods like start, accelerate, brake.
-
-
- This is python content for Object-Oriented Programming.
-
+{: .code }
+```
+cpp
+// Example of a simple class in C++
+class Car
+{
-
-
-
\ No newline at end of file
+private:
+
+ string Colour;
+ string Model;
+ int Year;
+
+public:
+ // Constructor
+ Car(string C, string M, int Y)
+ : Colour(C)
+ , Model(M)
+ , Year(Y)
+ {
+ }
+
+ // Method to start the car
+ void Start()
+ {
+ cout << "Car started!" << endl;
+ }
+
+ // Method to accelerate
+ void Accelerate()
+ {
+ cout << "Car accelerating!" << endl;
+ }
+
+ // Method to brake
+ void Brake()
+ {
+ cout << "Car braking!" << endl;
+ }
+};
+```
+#### Object:
+An object is an instance of a class. It represents a concrete entity based on the blueprint provided by the class. For example, an object `Ferrari` could be created from the `Car` class.
+
+{: .code }
+```
+cpp
+// Creating an object of class Car
+Car Ferrari("Red", "F40", 1987);
+```
+
+### 2. Encapsulation
+Encapsulation is the bundling of data (attributes) and methods (functions) that operate on the data into a single unit (class). It hides the internal state of an object from the outside world and only exposes a controlled interface to interact with the object.
+
+#### Access Specifiers:
+In C++, access specifiers (public, private, protected) control the visibility of class members:
+
+##### public: Members are accessible from outside the class.
+##### private: Members are accessible only from within the same class.
+##### protected: Members are accessible from within the same class and derived classes.
+
+{: .code }
+```
+cpp
+
+class SomeClass
+{
+
+private:
+
+ int PrivateMember;
+
+public:
+
+ void PublicMethod()
+ {
+ // Public method can access private member
+ PrivateMember = 10;
+ }
+};
+```
+
+### 3. Inheritance
+Inheritance allows a class (derived class) to inherit properties and behavior from another class (base class or parent class). It promotes code reuse and establishes a hierarchical relationship between classes. The base class is the class being inherited from, while the derived class is the class that inherits from the base class.
+
+{: .code }
+```
+cpp
+// Base class
+class Animal
+{
+
+protected:
+
+ void Eat()
+ {
+ cout << "Omnomnom!" << endl;
+ }
+};
+
+// Derived class inheriting from Animal
+class Dog : public Animal
+{
+
+public:
+
+ void Bark()
+ {
+ cout << "Dog is barking!" << endl;
+ }
+
+ void Hungry()
+ {
+ if(true)
+ {
+ Eat();
+ }
+ }
+};
+```
+
+### 4. Polymorphism
+Polymorphism means "many forms" and refers to the ability of objects of different classes to be treated as objects of a common superclass. It allows a single interface to be used for entities of different types, promoting flexibility and extensibility. Article here:
+[Polymorphism](/docs/Concepts/Polymorphism/Polymorphism.md)
+
+#### Compile-Time Polymorphism:
+Achieved through function overloading and operator overloading.
+
+{: .code }
+```
+cpp
+// Example of function overloading
+int Add(int A, int B)
+{
+ return A + B;
+}
+
+float Add(float A, float B)
+{
+ return A + B;
+}
+```
+
+#### Run-Time Polymorphism:
+Achieved through virtual functions and inheritance.
+
+{: .code }
+```
+cpp
+// Example of virtual functions
+class Animal
+{
+
+public:
+
+ virtual void MakeSound()
+ {
+ cout << "Animal sound" << endl;
+ }
+};
+
+class Dog : public Animal
+{
+
+public:
+
+ void MakeSound() override
+ {
+ cout << "Bark!" << endl;
+ }
+};
+```
+
+### 5. Abstraction
+Abstraction focuses on the essential features of an object and hides the irrelevant details. It allows developers to create complex systems by breaking them down into smaller, more manageable parts.
+
+#### Abstract Classes and Interfaces:
+An abstract class is a class that cannot be instantiated on its own and typically contains one or more pure virtual functions.
+An interface is a collection of abstract methods with no concrete implementation.
+
+{: .code }
+```
+cpp
+// Example of abstract class and pure virtual function
+class Shape
+{
+
+public:
+
+ virtual void Draw() = 0; // Pure virtual function
+ virtual float Area() const = 0; // Another pure virtual function
+};
+
+class Circle : public Shape
+{
+
+public:
+
+ void Draw() override
+ {
+ cout << "Drawing Circle" << endl;
+ }
+
+ float Area() const override
+ {
+ return 3.14 * radius * radius;
+ }
+
+private:
+
+ float Radius;
+};
+```
+
+### Benefits of Object-Oriented Programming
+- Modularity: OOP promotes modular design, making it easier to understand, maintain, and debug code.
+- Code Reusability: Classes and objects can be reused across different parts of an application or in different applications.
+- Flexibility and Extensibility: New features can be added by creating new classes without modifying existing code, promoting scalability.
+- Encapsulation: Protects data and methods from outside interference, enhancing security and reliability.
+
+### Best Practices
+- Single Responsibility Principle (SRP): Each class should have a single responsibility or reason to change.
+- Open/Closed Principle (OCP): Classes should be open for extension but closed for modification.
+- Liskov Substitution Principle (LSP): Objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program.
+- Interface Segregation Principle (ISP): Clients should not be forced to depend on interfaces they do not use.
+- Object-Oriented Programming is a powerful paradigm that has revolutionized software development by providing a clear and structured way to model complex systems. It encourages good design practices, enhances code quality, and improves productivity by enabling developers to think in terms of objects and their interactions.
+
+---
+
+#### Author: JDSherbert
+#### Published: 04/07/2024
From b753bd7b8720b963dffeda730387fd53a4cd53d0 Mon Sep 17 00:00:00 2001
From: JDSherbert <43964243+JDSherbert@users.noreply.github.com>
Date: Mon, 8 Jul 2024 21:02:48 +0100
Subject: [PATCH 7/9] Update OOP.md
---
docs/Concepts/OOP/OOP.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/Concepts/OOP/OOP.md b/docs/Concepts/OOP/OOP.md
index 09d8e85..1006aef 100644
--- a/docs/Concepts/OOP/OOP.md
+++ b/docs/Concepts/OOP/OOP.md
@@ -1,6 +1,6 @@
---
layout: default
-title: OOOP
+title: OOP
description: An article dicussing Object Oriented Programming.
nav_order: 1
parent: OOP
From 613b4d6a191ef3b4e4c3fbb4c58683beeb0a202f Mon Sep 17 00:00:00 2001
From: JDSherbert <43964243+JDSherbert@users.noreply.github.com>
Date: Mon, 8 Jul 2024 21:21:46 +0100
Subject: [PATCH 8/9] Update Inheritance.md
---
docs/Concepts/Inheritance/Inheritance.md | 140 ++++++++++++++++++++++-
1 file changed, 136 insertions(+), 4 deletions(-)
diff --git a/docs/Concepts/Inheritance/Inheritance.md b/docs/Concepts/Inheritance/Inheritance.md
index 64ec0b9..aa401c2 100644
--- a/docs/Concepts/Inheritance/Inheritance.md
+++ b/docs/Concepts/Inheritance/Inheritance.md
@@ -1,7 +1,7 @@
---
layout: default
title: Inheritance
-description: "Warning: The following page is currently under construction, find more about the details in future patches, or if you choose to add in the article see info on the bottom of the page."
+description: "An article dicussing Inheritance."
nav_order: 1
parent: Concepts
has_children: false
@@ -10,9 +10,141 @@ has_children: false
{{ page.title }}
======================
-{% include under_construction.html %}
+Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a new class to inherit properties and behaviors (methods) from an existing class. This mechanism promotes code reusability, organizational structure, and the ability to create a hierarchical relationship between classes.
+## Key Concepts
-
+### Base Class (Parent or Superclass):
+The class whose properties and methods are inherited by another class.
+Example: Animal might be a base class.
-
\ No newline at end of file
+### Derived Class (Child or Subclass):
+The class that inherits from the base class.
+Example: Dog might be a derived class that inherits from Animal.
+
+### Access Specifiers:
+Define the accessibility of the members of a class. Common access specifiers include:
+#### - public: Accessible from any other class.
+#### - protected: Accessible within its own class and by derived classes.
+#### - private: Accessible only within the class itself.
+
+### Override:
+The derived class can provide a specific implementation of a method that is already defined in its base class.
+
+### Extend:
+The derived class can add new methods and properties in addition to those inherited from the base class.
+Example in Python
+Here's an example of inheritance in Python:
+
+{: .code }
+```cpp
+#include
+using namespace std;
+
+class Animal
+{
+
+// "Public" means any class can access these functions.
+public:
+
+ Animal(string name)
+ : Name(name)
+ {
+ }
+
+ // "Virtual" functions can be "overridden" in child classes.
+ virtual void Speak()
+ {
+ cout << Name << " makes a sound" << endl;
+ }
+
+// "Protected" means that any derived class can access these properties.
+// It cannot be accessed outside of this class or its children.
+protected:
+
+ string Name;
+
+};
+
+class Dog : public Animal
+{
+
+public:
+
+ Dog(string name)
+ : Animal(name)
+ {
+ }
+
+ // "Override" will try to use this implementation of that function.
+ virtual void Speak()
+ {
+ cout << Name << " barks" << endl;
+ } override;
+
+};
+
+class Cat : public Animal
+{
+
+public:
+
+ Cat(string name)
+ : Animal(name)
+ {
+ }
+
+ // "Override" will try to use this implementation of that function.
+ virtual void Speak()
+ {
+ cout << name << " meows" << endl;
+ } override;
+
+};
+
+int main()
+{
+ Dog dog("Buddy");
+ Cat cat("Whiskers");
+
+ dog.Speak(); // Output: Buddy barks
+ cat.Speak(); // Output: Whiskers meows
+
+ return 69;
+}
+```
+
+## Benefits of Inheritance
+
+### Code Reusability:
+Common functionality can be written once in the base class and reused by derived classes.
+
+### Hierarchical Classification:
+Allows the creation of a natural class hierarchy, making the code more logical and easier to understand.
+
+### Extensibility:
+New functionality can be added with minimal changes to existing code.
+
+### Maintainability:
+Simplifies code maintenance by reducing redundancy.
+
+## Considerations and Best Practices
+
+### Avoid Deep Inheritance Hierarchies:
+Deep hierarchies can make the code difficult to understand and maintain. Prefer composition over inheritance when appropriate.
+
+### Use Inheritance for "Is-A" Relationships:
+Ensure that the derived class is a specialized version of the base class. For example, a Dog is an Animal.
+
+### Leverage Polymorphism:
+Use polymorphism to write more general and flexible code that can work with objects of the base class or any of its derived classes.
+You can read more about [Polymorphism](https://github.com/JDSherbert/Programming_HandBook/blob/main/docs/Concepts/Polymorphism/Polymorphism.md) here.
+
+### Override Methods Carefully:
+When overriding methods, ensure that the new implementation is consistent with the expected behavior defined in the base class.
+By understanding and applying the concept of inheritance correctly, you can create more efficient, maintainable, and organized code.
+
+---
+
+#### Author: JDSherbert
+#### Published: 08/07/2024
From 7aec77b9b2da0ffb056ff377f47073b54a9590c2 Mon Sep 17 00:00:00 2001
From: VerzatileDev <47317248+VerzatileDev@users.noreply.github.com>
Date: Fri, 12 Jul 2024 04:26:48 +0300
Subject: [PATCH 9/9] Fix (Parent / Gran.. ) Lists
The following is in reference fixing the rooting issue with using parents and grandparents to show elements in the list.
https://github.com/VerzatileDevOrg/Programming_HandBook/pull/106
---
docs/Concepts/OOP/OOP.md | 3 +--
docs/Concepts/Polymorphism/Polymorphism.md | 3 +--
2 files changed, 2 insertions(+), 4 deletions(-)
diff --git a/docs/Concepts/OOP/OOP.md b/docs/Concepts/OOP/OOP.md
index 1006aef..da7eb6b 100644
--- a/docs/Concepts/OOP/OOP.md
+++ b/docs/Concepts/OOP/OOP.md
@@ -3,8 +3,7 @@ layout: default
title: OOP
description: An article dicussing Object Oriented Programming.
nav_order: 1
-parent: OOP
-grand_parent: Concepts
+parent: Concepts
has_children: false
---
diff --git a/docs/Concepts/Polymorphism/Polymorphism.md b/docs/Concepts/Polymorphism/Polymorphism.md
index 9f7dd90..f7f7ea6 100644
--- a/docs/Concepts/Polymorphism/Polymorphism.md
+++ b/docs/Concepts/Polymorphism/Polymorphism.md
@@ -3,8 +3,7 @@ layout: default
title: Polymorphism
description: An article dicussing "Polymorphism", which means "Many Forms".
nav_order: 1
-parent: Polymorphism
-grand_parent: Concepts
+parent: Concepts
has_children: false
---