Addressing base information sections (#96)

Changes
---

The following provides the intial brief describtion for each parent
seciton for:

- IDE
- Language
- Framework
- Engine
- Concepts
- Version Controls

The brief describtion for each sections is the following:

- Talk about it, 
- What is it
- Use 
- History
- Note about brief history

Addition
---

The following addresses empty pages and removes construction signs from
the Main topics mentioned
#90

As an example on the articles


![image](https://github.com/VerzatileDevOrg/Programming_HandBook/assets/47317248/d0c524dc-f14c-42b0-bbda-72eb4c175985)

Author: JDSherbert

docs/Concepts/Algorithms.md renamed to docs/Concepts/Algorithms/Algorithms.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.
 
 
-<br>
+## What is it?
 
-<br>
+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. <br><br>
+Additionally as the concepts go into detail about these concepts, find more about them under Table of Contents.

docs/Concepts/Concepts.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.
 
 
-<br>
+## Use of Engines
 
-<br>
+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.<br><br><br>
+Please Read about the available engines on the website from Table of Contents.

docs/Concepts/DevOps.md renamed to docs/Concepts/DevOps/DevOps.md

@@ -5,9 +5,48 @@ nav_order: 3
 has_children: true
 ---
 
-{% include under_construction.html %}
+{{ page.title }}
+======================
 
 
-<br>
+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.
 
-<br>
+
+## 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 ".

docs/Concepts/ECS.md renamed to docs/Concepts/ECS/ECS.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:
+
+<br>
+
+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.
 
 <br>
 
-<br>
+{: .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.