diff --git a/docs/Concepts/Algorithms.md b/docs/Concepts/Algorithms/Algorithms.md
similarity index 100%
rename from docs/Concepts/Algorithms.md
rename to docs/Concepts/Algorithms/Algorithms.md
diff --git a/docs/Concepts/Concepts.md b/docs/Concepts/Concepts.md
index c155a14..c1c68db 100644
--- a/docs/Concepts/Concepts.md
+++ b/docs/Concepts/Concepts.md
@@ -8,9 +8,50 @@ has_children: true
{{ page.title }}
======================
-{% include under_construction.html %}
+Programming concepts are fundamental ideas and principles that underpin the design, development, and maintenance of software systems. They provide a framework for structuring code, organizing functionalities, and ensuring the scalability and maintainability of software projects. These concepts serve as guiding principles for developers, helping them write efficient, readable, and adaptable code.
-
+## What is it?
-
\ No newline at end of file
+One aspect of programming concepts is abstraction, which involves simplifying complex systems by focusing on essential details while hiding unnecessary complexities. Abstraction allows developers to create reusable components, making code more modular and easier to maintain.
+
+A crucial programming concept is encapsulation, involves bundling data and methods that operate on that data into a single unit, known as a class. Encapsulation helps to hide the internal implementation details of a class, promoting information hiding and reducing the complexity of code.
+
+## Use
+
+Programming concepts are utilized extensively in software development processes across various domains, including web development, mobile app development, game development, etc. They enable developers to write code that is modular, reusable, and easy to understand, facilitating collaboration among team members and enhancing the overall quality of software products.
+
+## History
+
+1. The Foundation of Theoretical Computer Science (1930s)
+
+ - Alan Turing's seminal work establishes theoretical computer science.
+ - Concepts of algorithms and the universal computing machine are introduced, laying the groundwork for modern computing.
+2. The Dawn of High-Level Languages (1940s - 1950s)
+
+ - Grace Hopper pioneers the development of the first compiler for a programming language.
+ - Machine-independent programming languages begin to emerge, paving the way for modern software development methodologies.
+3.The Era of High-Level Languages (1950s - 1960s)
+
+ - High-level programming languages like FORTRAN, COBOL, and Lisp come into prominence.
+ - Concepts of structured programming are introduced, emphasizing readability and maintainability through control structures like loops and conditionals.
+4. The Birth of Object-Oriented Programming (OOP) (1960s - 1970s)
+
+ - Simula, developed in the 1960s, lays the foundation for object-oriented programming.
+ - Smalltalk, created in the 1970s, popularizes the concepts of classes and objects, revolutionizing software development methodologies.
+5. The Rise of Object-Oriented Paradigm (1970s - 1980s)
+
+ - Object-oriented programming (OOP) gains widespread adoption, organizing code around objects and their interactions.
+ - The concept of inheritance and polymorphism becomes integral to software design, facilitating code reuse and extensibility.
+6. Design Patterns (1990s)
+
+ - The Gang of Four (Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides) publishes "Design Patterns: Elements of Reusable Object-Oriented Software" in 1994.
+ - 23 design patterns are cataloged, providing reusable solutions to common software design problems and becoming essential tools for developers.
+7. Evolution and Innovation (2000s - Present)
+
+ - The evolution of programming concepts continues, driven by emerging technologies such as artificial intelligence, cloud computing, and blockchain.
+ - Concepts like microservices architecture, containerization, and domain-driven design shape the way software is developed and deployed in the modern era.
+
+{: .note}
+This is only the brief history of concepts make sure to further research the foundation of Computer Science, which is the core of what we all know today.
+Additionally as the concepts go into detail about these concepts, find more about them under Table of Contents.
\ No newline at end of file
diff --git a/docs/Concepts/DevOps.md b/docs/Concepts/DevOps/DevOps.md
similarity index 100%
rename from docs/Concepts/DevOps.md
rename to docs/Concepts/DevOps/DevOps.md
diff --git a/docs/Concepts/ECS.md b/docs/Concepts/ECS/ECS.md
similarity index 100%
rename from docs/Concepts/ECS.md
rename to docs/Concepts/ECS/ECS.md
diff --git a/docs/Concepts/Inheritance.md b/docs/Concepts/Inheritance/Inheritance.md
similarity index 100%
rename from docs/Concepts/Inheritance.md
rename to docs/Concepts/Inheritance/Inheritance.md
diff --git a/docs/Concepts/Memory.md b/docs/Concepts/Memory/Memory.md
similarity index 100%
rename from docs/Concepts/Memory.md
rename to docs/Concepts/Memory/Memory.md
diff --git a/docs/Concepts/OOP.md b/docs/Concepts/OOP/OOP.md
similarity index 100%
rename from docs/Concepts/OOP.md
rename to docs/Concepts/OOP/OOP.md
diff --git a/docs/Concepts/Polymorphism.md b/docs/Concepts/Polymorphism/Polymorphism.md
similarity index 100%
rename from docs/Concepts/Polymorphism.md
rename to docs/Concepts/Polymorphism/Polymorphism.md
diff --git a/docs/Concepts/SOLID.md b/docs/Concepts/SOLID/SOLID.md
similarity index 100%
rename from docs/Concepts/SOLID.md
rename to docs/Concepts/SOLID/SOLID.md
diff --git a/docs/Engine/Engine.md b/docs/Engine/Engine.md
index e69b5ea..e7f0699 100644
--- a/docs/Engine/Engine.md
+++ b/docs/Engine/Engine.md
@@ -5,12 +5,45 @@ nav_order: 4
has_children: true
---
-{{ page.title }}
+Video Game {{ page.title }}
======================
-{% include under_construction.html %}
+A video game engine is a software framework used by developers, designers and artists to make video games or movie production. It provides the necessary tools and functionalities to design, develop and eventually deploy these projects to various existing platforms. As its core, a game engine offers a suit of feature pipelines such as rendering engines for 2D and 3D graphics, physicss engines to simulate movement and interactions, sound and animations. Each engine has its specific purpose and use case based on the projects requirements, and by that used by different extent of industries not only tied to movies and video games, but even concept work.
-
+## Use of Engines
-
\ No newline at end of file
+As the advancement of modern video game engines, it introduces a wide range of possibilities for video game design, movie makers and environmental designers who use these to showcase their work in the best format depending on the engine and to publish them to the wider audience.
+
+1. Video Game Development
+
+ - Commonly these engines are developed for a specific reason to mainstream 2D / 3D games or both.
+ - Some of the common engines that are widely used are Unity built for 2D games, and Unreal Engine built for 3D games, though both of them support the pipelines for 2D and 3D.
+ - Provides a possibility to develop for various platforms like Mobile, Computer, Console, HTML.
+2. Prototyping
+
+ - These engines are also used by developers to prototype ideas to test game machanics, introduce concepts for movies or even to showcase environments and projects.
+3. Cross-Platform Development
+
+ - Many modern engines support multi-platform deployment, allowing games to be released on PCs, consoles, and mobile devices with minimal additional effort.
+4. Simulation and Training
+
+ - Game engines are employed in industries like military, healthcare, and education for creating realistic simulations and training programs.
+5. Virtual Reality (VR) and Augmented Reality (AR):
+
+ - Game engines are also used to develop immersive VR and AR experiences, broadening the scope of interactive applications beyond traditional gaming.
+ - As an example simulating a planes cockpit to teach the consumer the expectations and make it available for them before learning in an actual one.
+
+## History
+
+The history of video game engines is deeply intertwined with the evolution of video games, tracing back to the mid-20th century. Early experiments like "Tennis for Two" (1958) and "Spacewar!" (1962) were groundbreaking but were hard-coded for specific hardware, making them inflexible and difficult to adapt.
+
+As the video game industry emerged in the late 1970s and early 1980s with arcade classics like "Pong" (1972) and "Space Invaders" (1978), developers recognized the need for reusable software components. This led to the early development of game engines, with games like "Elite" (1984) featuring a basic 3D graphics engine.
+
+A significant breakthrough came with id Software's "Wolfenstein 3D" (1992), which introduced the concept of separating game code from engine code. This approach was further refined with "Doom" (1993), whose engine was licensed to other developers, establishing a commercial model for game engines.
+
+The mid-1990s saw the advent of more sophisticated engines like the "Quake" engine, which enabled true 3D environments and supported extensive modding. By the early 2000s, engines such as Unreal Engine and Unity provided comprehensive toolsets and multi-platform support, making game development more efficient and accessible.
+
+{: .note}
+This is the brief history of games and the start of engines, remember this is a brief explanation its best to further research in regards to "Spacewar!", and "Wolfenstein 3D", which set the groundwork for the engines we know today as well as video games.
+Please Read about the available engines on the website from Table of Contents.
\ No newline at end of file
diff --git a/docs/Framework/Framework.md b/docs/Framework/Framework.md
index a9bd5a3..3232776 100644
--- a/docs/Framework/Framework.md
+++ b/docs/Framework/Framework.md
@@ -5,9 +5,48 @@ nav_order: 3
has_children: true
---
-{% include under_construction.html %}
+{{ page.title }}
+======================
-
+Is an essential tool in software development, which provides the developers with a structured foundation to built their applications upon. A framework is a pre-built set of code libraries, tools, conventions designed to ease and streamline the development process for specified applications or tasks.
-
\ No newline at end of file
+
+## What is it?
+
+Think of a framework as scaffolding around a building. Just as scaffolding provides a set of guidelines and support structures to help builders create a stable and well-constructed building, a framework provides developers with a set of guidelines and functionalities to create software applications. It offers pre-written code for best practices and common tasks, enabling developers to focus on the unique aspects of their projects without having to write everything from scratch.
+
+Frameworks come in various forms, such as web, frontend and general-purpose which aids building a wide range of applications and set a path for them. By specifying concepts of functionality, a framework ensures that developers follow consistency and an efficient approach to the development of software.
+
+
+## Use of Frameworks
+
+The primary purpose of using a framework is to enhance efficiency and maintainability in software development.
+
+1. Efficiency
+
+ - Offers pre-built components and pre-defines structured sets, which reduces the time required to build an application from scratch.
+2. Consistency
+
+ - Enforces a coding standard and a design pattern, that ensures consistency and creation accorss different parts of the application and collaborators.
+3. Maintanance
+
+ - Comes with a built-in Debugging and testing tools, that simplifies the process of troubleshooting and maintaining the codebase over time.
+4. Scalability
+
+ - Supports database abstraction layers and caching mechanisms and ensures the possibility for increased load as the applications expand.
+5. Collaboration
+
+ - Developers are provided with a set of instructions such as naming conventions and overall a familiar structure to provide more suitable platform for collaborators.
+
+
+## History
+
+The concept of frameworks dates back to ancient times for construction and building that set certain criterias and references to manage the structure being built. As the concept of frameworks evolves alongside software development itself, specific origins of software frameworks is difficult to references upon, though their widespread adoption gained a momentum in the late 20th century with addition of object-oriented programming languages and the complexity of software applications.
+
+The earliest known examples of a framework is considered to be (MVC) Model-View-Controller, which dates to around 1970s. They laid the groundwork for the modern web framework, seperating data manipulation and presentation with user interaction. IWeb development, in the late 1990s and early 2000s saw the rise of frameworks like Struts for Java and ASP.NET for Microsoft's .NET platform. These frameworks introduced developers to the concept of reusable components and standardized development practices.
+
+As frameworks and standardization keeps rapidly evolving, each new framework aims to address specific challanges with the advancement of technology. Modern frameworks as of now play a central role in nearly every aspect of software development for web, data and more. Which empowers developers to build a maintainable, scalable, and robust applications as efficiently as possible.
+
+{: .note}
+This is only the brief history, though the topic goes deeper in the next sections to see and learn more about them see the existing ones within the website, under " Table of contents ".
diff --git a/docs/IDE/IDE.md b/docs/IDE/IDE.md
index 54f60dc..f898920 100644
--- a/docs/IDE/IDE.md
+++ b/docs/IDE/IDE.md
@@ -5,11 +5,72 @@ nav_order: 2
has_children: true
---
-{{ page.title }}
+Integrated Development Environment (IDE)
======================
-{% include under_construction.html %}
+(IDE) is a software application that provides programmers and developers a comprehensive facilities to develop software. An IDE consists of source code editor, debugger and a build automation tools. IDE's such as [Microsoft Visual studio](https://visualstudio.microsoft.com/) contains various other features such as a compiler, interpreter or both of them, though not every IDE is specifically designed to includes these add-ons as they are done with external software or libraries where the purpose of such an IDE for example [Notepad++](https://notepad-plus-plus.org/) is mainly there to write code or run it.
+
+
+## What is an IDE used for?
+
+IDE's are designed to provide and maximize productivity of developers by providing them with simplifies interfaces and addons that simply the workflow and help manage the codebase. They reduce setup time, increase the speed of development and its tasks, maintaining standardization and most importantly offering debugging tools to identify and rectify errors efficiently.
+
+
+## History
+
+Evolution
+
+The history of IDE's is traced back to the earlier days of programming when most of the programming was done in [low-level languages](https://en.wikipedia.org/wiki/Low-level_programming_language) such as Machine code and assembly using a glorified macro / scripting based IDE such for example [TECO](https://en.wikipedia.org/wiki/TECO_(text_editor)), which was developed in 1962. As the times change so do the languages, hardware and software that evolve over the decades:
+
+
+
+1. Text Editors (1950s - 1960s)
+
+ - Programmers used a basic text editor to write and edit code. Editors lacked advanced features and interfaces and were commonly used primarly for code entry.
+2. Command-Line Compilers (1970s)
+
+ - Programmers started using command-line compilers. Developers would write code within text editors and have the possibility to compile the code with seperate command-line tools. Though as the process was cumbersome and tidious to use it provided a way for the future and was quite advanced for its time.
+3. Simple IDEs (1980)
+
+ - First generation where the combination of text editor, compiler and the introduction of debugging was integrated into a single interface. For simple examples [Trubo Pascal](https://et.wikipedia.org/wiki/Turbo_Pascal), which provided an integrated and user-friendly experience for programmers.
+4. Graphical User Interfaces (1990s)
+
+ - The first introduction for GUIs, IDEs became sophisticated and providing a better organized and feature rich development interface. Tools such as [Borland Delphi](https://en.wikipedia.org/wiki/Delphi_(software)) and Microsoft [Microsoft Visual studio](https://visualstudio.microsoft.com/), offering adnvaced debugging, design tools, and project management features. The following integrations brought its developers from a command line based IDEs to the modern interfaces we use now.
+5. Web-Based IDEs & Open-Source (2000s)
+
+ - The immense growth of the internet and expansion of the people connected through it additionally open source software led to the development of web-based IDEs such as [Eclipse](https://en.wikipedia.org/wiki/Eclipse_(software)) and [NetBeans](https://en.wikipedia.org/wiki/NetBeans). One of the most segnificant era which started the Open-Source communities immensly and contributed to the evolution and expansion of such tools.
+6. Modern IDEs (2010-Present)
+
+ - In the current era IDEs are the core of most of the development offering various tools, expansions and addons ranging from debuggers, compilers, editors and organization with cross-platform support and cloud integration. The following tools incoroprate advanced features such as Real-Time collaboration, Artificial intelligance drive code do help you with the code with various costomization options to suit your needs. Tools listed and related to the following chapters are here to talk further about them make sure to read the Table of Contents.
+
+## Key features (Modern IDEs)
+
+
+1. Source Code Editor
+
+ - Synstax Highlighting: Makes code readable by introducing indintation and color-coding to language constructs.
+ - Code Folding: Allows collapsing and expanding sections of the code to see what is important ignoring the rest of the code.
+2. Build Automation
+
+ - Integrated Build Tools: Maven, Gradle, built-in compilers & more.
+ - Continuous integration: Support for CI tools like Travis CI use to test software.
+3. Debugging
+
+ - BreakPoints: Specifies an area by the developer to pause at a specific point in code or pause execution of it.
+ - Step through code: Enables to execute code line-by-line in order to examine the logic flow and state of the codebase.
+4. Refactoring
+
+ - Automatic Refactoring: Tools to rename variables, extract methods and fix area of code without changing its external behaviour.
+ - Code Analysis: Static code analysis to find and fix potential issues.
+5. IntelliSense
+
+ - Auto-Completion: Suggestions to complete line or lines of code as you type them.
+ - Find References: Locate all references to a piece of code.
+6. Integrated Version Control
+
+ - Git: Interface for version control, commits, branches and merging.
-
\ No newline at end of file
+{: .note}
+The following should give you the basic outline for the discussion of next chapters, make sure to check Table of Contents at the bottom of the page to read more about the IDEs mentioned here.
diff --git a/docs/Language/Language.md b/docs/Language/Language.md
index 14171a8..486e6bb 100644
--- a/docs/Language/Language.md
+++ b/docs/Language/Language.md
@@ -5,11 +5,79 @@ nav_order: 2
has_children: true
---
-{{ page.title }}
+Programming Languages
======================
-{% include under_construction.html %}
+Programming languages are fundemental tools that enable developers communicate with computers. Consisting of a set of instruction and syntaxes used to write software to perform specific tasks in order to solve problems. It is the backbone of software development, allowing developers to create application, control and manage data.
-
-
\ No newline at end of file
+## What is it?
+
+Is a formal language comprising of a set of instructions that produce various kinds of outputs. They are used to implement algorithms and control the behaviour of machines by simplying binary code to a set of commands. They are designed to be read and written by developers, which the set of commands is then translate into machine code that is executed by the computer.
+
+Programming Languages have syntax rules that define the structure of programs and semantics. Languages can be high-level, providing abstractions from the hardware, or low-level, offering a minimal abstraction from the computer's instruction set architecture.
+
+
+## Use of Programming Languages
+
+1. Web Development
+
+ - HTML, CSS, Javascript, and PHP
+ - Used for Developing website and web related applications such as HTML or javascript video-games.
+2. Software Development
+
+ - Java, C++, Python, C#, C, etc
+ - Used to build software ranging from desktop applications to enterprise systems.
+3. Mobile App Development
+
+ - Swift, Kotlin, etc.
+ - Populair languages for developing IOS and Android applications.
+4. Data Science and Machine Learning
+
+ - Python, R, etc.
+ - Used for data analysis, statistical modelling and machine learning.
+5. Systems Programming
+
+ - C, Rust, etc.
+ - Used to develop operating systems (OS), or performance-critical applications.
+6. Game Development
+
+ - Python, C++, C#, Java, etc.
+ - Used for video game development in engines such as Unity, Unreal Engine & more.
+
+{: .note}
+These are brief examples what certain languages are capable of and not limited to these, but what they are commonly known for.
+
+
+## History
+
+Ada Lovelace, born in 1815, is known as the first computer programmer for her work on Charles Babbage's Analytical Engine. She wrote the first algorithm intended for implementation on a machine, marking the inception of programming. Her work laid the groundwork for the development of programming languages and served as a catalyst for the evolution of programming as a discipline. Her insights into the potential of computing to manipulate symbols and perform complex tasks foreshadowed the diversity of modern programming languages and their applications across various fields, shaping the landscape of technology and innovation.
+
+1. Early Language (1800s - 1940s)
+
+ - Ada Lovelance: Created the first algorithm intended for processing on an analytical engine.
+ - Assembly Language: First low-level programming language, providing a direct correspondance between machine instructions and their symbolic code.
+2. New beginnings (1950s - 1960s)
+
+ - FORTRAN: Developed by IBM, it was the first high-level programming language designed for scientific and engineering calculations.
+ - COBOL: Created for business data processing, emphasizing record-processing capabilities.
+ - LISP: Developed for artificial intelligence research, introducing the concept of symbolic computation.
+3. The advancement (1970s - 1980s)
+
+ - C: Developed by Dennis Ritchie at Bell Labs, C became the foundation for many modern languages and operating systems.
+ - Pascal: Designed for teaching structured programming, influencing future languages like Ada and Modula-2.
+ - Smalltalk: Pioneered object-oriented programming, significantly impacting the design of later languages like Java and Python.
+4. The expansion (1990s - 2000s)
+
+ - Java: Introduced by Sun Microsystems, Java emphasized portability and object-oriented principles, becoming widely used for web and enterprise applications.
+ - Python: Developed by Guido van Rossum, Python's simplicity and readability have made it popular in diverse fields, from web development to data science.
+ - JavaScript: Created by Netscape, JavaScript became essential for dynamic web content and interactivity.
+5. Globalisation (2010s - Present)
+
+ - Swift: Apple's modern language for iOS and macOS development, emphasizing safety and performance.
+ - Rust: Sponsored by Mozilla, Rust focuses on safety and concurrency, becoming popular for systems programming.
+ - Kotlin: Adopted by Google as the preferred language for Android development, known for its interoperability with Java.
+
+
+{: .note}
+This is a brief timeline of common languages, to read further on the upcoming sections and languages please head to the Table of Contents, which addresses these specifically.
diff --git a/docs/VersionControl/VersionControl.md b/docs/VersionControl/VersionControl.md
index be041f0..eebf142 100644
--- a/docs/VersionControl/VersionControl.md
+++ b/docs/VersionControl/VersionControl.md
@@ -8,8 +8,49 @@ has_children: true
{{ page.title }}
======================
-{% include under_construction.html %}
+Version control is a fundemental part of development, which gives a chance to see the history of previous commits, avoiding issues that might be pushed to the main available branch to avoid corruption and a loss of data. It stands as a cornerstone for collaboration and ensures the integrity of codebases. The main practise of version control is to practise tracking and managing its changes to the softwares codebase, while helping the developers to revise current and past changes to its source code to aid in debugging and rebuilding.
-
+## What is it?
-
\ No newline at end of file
+At its core, version control is a system that manages changes to documents, programs, or any set of files over time. It enables multiple contributors to work on a project simultaneously, keeping track of every modification, addition, or deletion made to the files. This ensures that developers can revert to previous versions if necessary, compare changes, and collaborate seamlessly.
+
+## Use
+
+Version control systems find applications across various domains, including software development, document management. In software development, version control is indispensable, allowing developers to coordinate, maintain code quality, and deploy updates efficiently. It provides a structured framework for managing different branches of development, facilitating parallel development of features and bug fixes. Fosters accountability by attributing changes to specific contributors, enabling effective code review processes.
+
+## History
+
+1. Manual Methods (1950s - 1960s)
+
+ - Programmers manually labeled physical copies of code with version numbers.
+2. Source Code Control System (SCCS) (1972)
+
+ - Marc Rochkind develops SCCS at Bell Labs, one of the earliest centralized version control systems.
+ -SCCS allows tracking changes and reverting to previous versions but operates on a centralized model.
+3. Concurrent Versions System (CVS) (1990s)
+
+ - CVS, an open-source version control system, is developed by Dick Grune and others.
+ - Introduces features like branching and merging, facilitating collaboration among distributed teams.
+4. Subversion (SVN) (2000s)
+
+ - SVN emerges as a successor to CVS, addressing many of its deficiencies.
+ - Introduces improvements like atomic commits, versioned directories, and better support for binary files.
+ - Maintains a centralized architecture, posing scalability and availability challenges for distributed teams.
+5. Dawn of Distributed Version Control Systems (DVCS) (Mid-2000s)
+
+ - Git and Mercurial gain traction as distributed version control systems.
+ - Offer a decentralized model, enabling every user to have a complete copy of the repository.
+ - Facilitates offline work and faster operations.
+6. Git Revolution (2005)
+
+ - Linus Torvalds creates Git for managing the Linux kernel development.
+ - Emphasizes speed, data integrity, and branching flexibility.
+ - Empowers individuals and teams to collaborate seamlessly, leading to widespread adoption.
+7. Mercurial and Beyond (2005)
+
+ - Mercurial is launched as a notable alternative to Git.
+ - Developed with a decentralized architecture similar to Git.
+ - Continues to evolve with ongoing development efforts focused on performance enhancements and usability improvements.
+
+{: .note}
+This is a brief history on the following, read more from the sub-topics provided in the Table of Contents.
\ No newline at end of file