most recent changes including mostly formatting updates

Author: gbowne1

C_and_Cpp_Programming/intellisense-configuration.md

@@ -42,8 +42,10 @@ It generally looks like this in Linux:
    "limitSymbolsToIncludedHeaders": true,
    "intelliSenseMode": "linux-gcc-x86",
    "configurationProvider": "ms-vscode.cmake-tools",
-   "databaseFilename": "${workspaceFolder}/.vscode/browse.vc.db"
-   }
+   "databaseFilename": "${workspaceFolder}/.vscode/browse.vc.db",
+   "enableConfigurationSquiggles": "",
+   "mergeConfigurations": "",
+   },
   ],
  "version": 4
 }

Databases/learning-sql.md

@@ -26,4 +26,4 @@ SQL commands are syntax that is designed for accessing, modifying, and extractin
 SQL is an interactive and interpretive language and it does not demand coding skills like other programming languages.
 It is known for its easy usability and the ability to carry out varied functions on vast amounts of structured data.
 SQL queries are used to request or retrieve data from a database, and SQL statements are valid instructions that
-relational database management systems understand
+relational database management systems understand

GitHub/configuring-github.md

@@ -16,4 +16,9 @@ Inside the .github folder/directory create a folder called `workflows`.
 
 GitHub workflows are also primarily written in YAML and have the file extension .yml or .yaml, the same as an action would be.
 
-Also in this folder you
+## Configuring Issue Templates
+
+## Configuring PR Templates
+
+## Other Special GitHub stuff
+

PHP/php-development.md

@@ -4,3 +4,6 @@ PHP gets lots of hate.  It's old, been around a while.  It's gotten way better o
 
 I don't know a great deal about PHP development nor have I used a lot of PHP in my projects.
 
+    <?php
+
+    ?>

React_Development/react-development-notes.md

@@ -12,7 +12,7 @@ There's some things I have learned via getting contributions to my React applica
 
 React is typically used in conjunction or with other things called a stack or a tech stack.
 
-A typical tech stack, whether full stack or not, consists of various components that work together to build an application. For a web application, a tech stack usually includes both frontend and backend technologies. Some common components of a tech stack are:
+A typical tech stack, whether `full stack` or not, consists of various components that work together to build an application. For a web application, a tech stack usually includes both frontend and backend technologies. Some common components of a tech stack are:
 
 Frontend:
 

VSCode/create-a-settings.json file.md

@@ -0,0 +1,3 @@
+# Creating a settings.json file for VSCode
+
+Ideally one should create 

WebDevelopment/beginning-webdev.md

@@ -21,7 +21,7 @@ command line/shell/terminal/console to use your editor or use the GUI or user in
 feel strongly about the editor or IDE they use.  You should use the one that gets the job done for you.
 
 This should go without saying, but you should try a few out before you settle on one and do not rely on what
-someone told you their editor or IDE is.  You might or might not like the first editor or IDE you choose.
+someone told you their editor or IDE is.  You might or might not like the first editor or IDE you choose
 
 ## Projects and what to make
 

WebDevelopment/css.md

@@ -112,30 +112,26 @@ There are various types of selectors in CSS that are used to target HTML element
 
 And in your HTML document:
 
-```html
-<p class="highlight">This is a highlighted paragraph.</p>
-<div class="highlight">This is a highlighted div.</div>
-```
+    ```html
+    <p class="highlight">This is a highlighted paragraph.</p>
+    <div class="highlight">This is a highlighted div.</div>
+    ```
 
 This will apply the specified styles to all elements with the "highlight" class. Class selectors allow you to apply unique style properties to groups of HTML elements to achieve your desired web page appearance
 
 - ID selectors: Select a single element based on its ID attribute (e.g., #header for an element with id "header").
 
     A CSS ID selector is used to select a specific HTML element based on the value of its id attribute, which must be unique within a page. To use an ID selector in CSS, you write a hash (#) followed by the ID of the element, and then define the style properties you want to apply to the element in curly brackets. Here's an example of how to use an ID selector:
 
-```css
-#idname {
-  /* Define properties here */
-}
-```
+    #idname {
+      Define properties here
+    }
 
 The IDs are used to identify a single element, and they have a higher specificity than classes, making them useful for applying specific styles to individual elements. In contrast, a class selector is used to select elements with a specific class attribute, and it can be applied to multiple elements. Here's an example of a class selector:
 
-```css
-.class-name {
-  /* Define properties here */
-}
-```
+    .class-name {
+      /* Define properties here */
+    }
 
 In general, it's a best practice to use IDs for unique elements and classes for multiple elements, and to avoid using IDs for styling purposes in order to keep the styling separate from the content
 
@@ -155,27 +151,23 @@ Attribute selectors provide a powerful way to target and style elements based on
 
 CSS rules should not be empty and your editor or IDE might even warn you about that:
 
-```css
-body {
-   /* Not a great idea to leave this part empty */
-};
-```
+    body {
+       /* Not a great idea to leave this part empty */
+    };
 
 ## CSS Variables
 
 CSS variables, also known as custom properties, are entities defined by CSS authors that represent specific values to be reused throughout a document. They are set using the @property at-rule or by custom property syntax (e.g., --primary-color: blue;). Custom properties are accessed using the CSS var() function (e.g., color: var(--primary-color);). They allow a value to be defined in one place and then referenced in multiple other places, making it easier to work with and improving readability and semantics. CSS variables can have global or local scope, and they can be changed with JavaScript and based on media queries. They are useful for managing websites with numerous similar values, reducing the friction associated with refactoring or updating code
 
 To declare a CSS variable, you use the following syntax:
 
-```css
-:root {
---primary-color: blue;
-}
+    :root {
+    --primary-color: blue;
+    }
 
-.element {
-color: var(--primary-color);
-}
-```
+    .element {
+    color: var(--primary-color);
+    }
 
 In this example, --primary-color is the variable name, and blue is the value. The variable is then accessed using the var() function, as shown in the color property of the .element selector
 
@@ -185,13 +177,11 @@ CSS variables provide a more efficient way to write and manage CSS code, making
 
 The universal selector in CSS is denoted by an asterisk (*) and is used to select all elements on an HTML page. It matches elements of any type and can be used to apply styles globally. Here's a brief overview of how to use the universal selector:
 
-```css
-* {
-  margin: 0;
-  padding: 0;
-  /*Add more global styles here*/
-}
-```
+    * {
+      margin: 0;
+      padding: 0;
+      /*Add more global styles here*/
+    }
 
 The universal selector selects all elements and can also be used to select all elements inside another element. It is a powerful tool for applying styles globally, but it's important to use it judiciously as it can affect the performance of the page if overused.
 
@@ -217,13 +207,11 @@ These @ rules provide additional functionality and flexibility to CSS, allowing
 
 To use the :root pseudo-class in CSS, you can define global CSS variables and apply styles to the root element of the document. Here's a brief overview of how to use it:
 
-```css
-:root {
-  --main-color: hotpink;
-  --pane-padding: 5px 42px;
-  /* Add more global variables and styles here */
-}
-```
+    :root {
+      --main-color: hotpink;
+      --pane-padding: 5px 42px;
+      /* Add more global variables and styles here */
+    }
 
 The :root pseudo-class matches the root element of a document, which is typically the `<html>` element in HTML. It is similar to the html selector but has higher specificity, making it useful for declaring global CSS variables that can be accessed throughout the document
 

about-yaml.md

@@ -13,10 +13,46 @@ YAML is a human-readable data serialization language that is commonly used for c
 - It is used mainly in the DevOps domain, where it is widely used with well-known tools such as Kubernetes, Ansible, Terraform, and many others
 - YAML is also used by the Ansible automation tool to create automation processes, in the form of Ansible Playbooks
 - YAML is a powerful language that can be used for a variety of purposes. If you're interested in learning more about YAML and its applications, there are many resources available online, including tutorials, documentation, and blog post
-
-- YAML has features that come from Perl, C, XML, HTML, and other programming languages4
+- YAML has features that come from Perl, C, XML, HTML, and other programming languages
 - YAML also contains scalars, which are arbitrary data (encoded in Unicode) that can be used as values such as strings, integers, dates, numbers
 - YAML files are structured using indentation and whitespace, and are often used for configuration files and in applications where data is being stored or transmitted
 - YAML files are made up of key/value pairs, which are commonly called a “hash” or a “dictionary”
 - Sequences in YAML are represented by using the hyphen (-) and space, and are ordered and can be embedded inside a map using indentation4
 - YAML also supports comments, which begin with the (#) character and must be separated from other tokens by whitespaces
+
+Here are the basic syntax rules and elements for YAML
+
+So, YAML is a human-readable data serialization language that is often used for configuration files, and it supports various data types, such as strings, numbers, and boolean values. The basic syntax of YAML involves key-value pairs in the format key: value and using spaces to indicate nesting.
+
+- Key-value pairs: YAML uses key-value pairs to store data in a hierarchical structure. The key is the first line of a newline, and the value follows it, also on a newline.
+
+- Spaces and indentation: Spaces are used to indicate nesting in YAML. Indentation is not used for indentation in YAML files.
+Comments: Comments in YAML begin with the # character and must be separated from other tokens by whitespaces.
+
+- Lists and arrays: List members are denoted by a leading hyphen - and enclosed in square brackets. Associative arrays are represented using : in the format of key-value pairs and enclosed in curly braces {}.
+
+- Scalar types: YAML supports various scalar types, such as strings, numbers, and boolean values. Scalar values can span multiple lines, and YAML processes the first value as ending with a carriage return and linefeed.
+
+- Folding: Folded text converts newlines to spaces and removes leading whitespace.
+
+- Tags: Tags can be used to explicitly specify a type for a value. For example, !!str indicates a string value, !!int indicates an integer value, and !!bool indicates a boolean value.
+
+- Anchors and aliases: YAML allows the use of anchors and aliases to reuse values in the document. Anchors can be used to define a value once and then reference it elsewhere in the document using its anchor name.
+
+YAML is a human-readable data serialization language that is often used for writing configuration files, and it is recommended over JSON in many cases due to its better readability and user-friendliness. Some good use cases for YAML include:
+
+- Configuration files: YAML is commonly used to create configuration files for applications and services, as it is easier to read and understand than JSON.
+
+- Cross-language data sharing: YAML is language-independent, meaning it can be used across various programming languages, making it suitable for data sharing between different languages.
+
+- Log files: YAML can be used to store log files, as it can easily represent complex data structures and is human-readable.
+
+- Debugging complex data structures: YAML is useful for debugging and managing complex data structures, as it provides a clear and concise way to represent and understand the data.
+
+- Interprocess messaging: YAML can be used for interprocess messaging, as it can represent complex data structures and is easy to read.
+
+- Object persistence: YAML can be used for object persistence, as it can store and manage data in a flexible and human-readable format.
+
+- Automation processes: YAML is used by Ansible® to create automation processes, in the form of Ansible Playbooks, which are easy to read and understand.
+
+YAML is often preferred over other data serialization languages like JSON or XML due to its focus on data rather than documents, and its flexibility and accessibility.

dotnet/about_csharp.md

@@ -0,0 +1,2 @@
+# About C# programming
+

regex.md

@@ -0,0 +1,4 @@
+# Regex 101
+
+I don't know a lot about regex.
+