Dev Wiki - User contributions [en]

Django/Production

2026-01-09T12:51:42Z

Brodriguez: Correct permission values

The following is an attempt at detailing steps to push a Django project into production.

Note that this page makes references to several system root folders, particularly {{ ic |srv}} and {{ ic |opt}}. For details on what root folders are generally meant for, see https://help.ubuntu.com/community/LinuxFilesystemTreeOverview.

However, having said that, these folders are not set in stone and if you have reason to change directory paths, that's okay as long as you change all references to such.

{{ note | Most of this page will assume you have root account access, as that's required for Apache/Nginx setup anyways. If you don't, then consult the provider of your webhosting for how they recommend to proceed. }}

== Pre-Setup ==
If not yet done, create an appropriate database instance for your project. Note that SqLite is not sufficient, as it's unlikely to be able to handle throughput necessary for a server. [[Programming/MySQL | MySQL]]/[[Programming/PostgreSQL | PostgreSQL]]/Oracle/etc are designed for this.

Also update your project package requirements to include the {{ ic |uWSGI}} Python package. This is required for Apache/Daphne (aka Nginx) to interface with a Python virtual environment.

== Base Project Setup ==
=== Project Location ===
First, create directories and clone your project to the desired location on the server. The recommended location is somewhere like:
/src/web_serve/django/<project_name>/

=== Initial Production Settings Values ===
Then edit your project settings for bare minimum production values to get it up and running. This likely includes things like:
* Connection settings for the production database.
* Static file serve locations.
* Logging setup.
* Allowed Hosts setting.
* Secret Key setting.
* Any possible custom project settings, required to get the project running.

While you're editing the settings file(s), it's recommended to set these as well, but technically it can wait until the end of the project setup.
* Email settings.
* Security settings.
* Any possible custom project settings, required for long-term stability & security

{{ todo | Document Django settings file production values. }}

=== Installation ===
If your project has any custom installation scripts, now might be a good time to run them. Otherwise, install system dependencies (such as [[Apt-Get Packages]]) and then run the standard {{ ic |manage.py}} setup commands.

==== Apt Package Installation ====
Assuming use of an Ubuntu server, common system packages for production are:
* The desired [[Apt-Get#Python |Python version]] to serve your project.
* [[Apt-Get Packages#Apache | Apache packages]], for a standard Django install (alternatively, can use Nginx if you'd prefer).
* [[Apt-Get Packages#Nginx | Nginx packages]], if using Django Channels.
* [[Apt-Get Packages#Redis | Redis packages]], also if using Django Channels.

Note that these are the bare minimum for a standard Django install. Depending on your project, you might need other things such as [[Apt-Get Packages#Npm/NodeJs | NPM packages]] to manage [[Programming/JavaScript]] files.

==== Setup Python Environment ====
After installing system packages, you can create a [[Programming/Python/Setup#Virtual Environments | Python Virtual Environment]] to serve your project from.

The recommended location is something like:
/opt/env/<environment_name>/

Once created, remember to load the environment to your console, and then install project packages. (ex: {{ ic |pip install -r requirements.txt}} from project root).

==== Manage.py Setup Commands ====
{{ Note | Before this step, if your project has any static files (CSS or JavaScript) to compile, you should probably do that here.}}

Once all system packages are installed and the environment is setup, we can finally run our manage.py commands.

Depending on your project, you may have additional custom commands to install. But the standard default ones are (in order):
* {{ ic |python manage.py migrate}}
* {{ ic |python manage.py collectstatic}}
* {{ ic |python manage.py check}}

{{ warn | Note that we don't run {{ ic |python manage.py makemigrations}} in production. This is because migration files should always be created and committed in development, and then pushed up after thorough testing.}}

==== Project Permissions ====
Permissions should be set such that both the expected user(s) and apache/nginx can access project files.

Nginx seems to assume the user is {{www-data}}. You should probably also create a group that all users belong to. Thus we set folder/file permissions to {{ ic |www-data:<group_name>}}.

In both cases, you'll probably want to set permissions such that:
* Users/groups both have read/write/execute permissions on folders.
* Users/groups both have read/write permissions on files.
* Other users have no access on folders or files.

You'll want to make sure to set these permissions on:
* Project folders
* Static folders associated with the project
* The local virtual environment
* Project logging folders
* Any other files/folders that your website will need direct access to.

For more details on permissions, see [[Linux/Permissions | Linux Permissions]].

==== Post-Installation Notes ====
At this point, your project should be set up enough to run via {{ ic |python manage.py runserver}} and project UnitTests should pass when run.

While we definitely don't want to serve the project as it is now (and you shouldn't be able to load pages in a web browser at this point), these act as a good check to make sure everything is handling correctly so far.

If you get any errors at this stage, go back and troubleshoot it before proceeding.

{{ todo | apache setup? }}

== Nginx Setup ==
If you're using Django Channels, then you must use Nginx to serve the project. Apache is physically incapable of handling the asynchronous websocket connections that channels uses.

=== Configuring Volatile Project Files ===
First, we want to configure our "volatile" project files. This includes our project runtime process, our web-socket files, and other entities pertaining to our project, which only exist during runtime.

It's recommended to put these in the {{ ic |/run/<process_name>/}} directory and associated logs in the {{ ic |/var/log/<process_name>/ directory}}.

This can be done by creating the following files with the respective contents:
{{ hc |/etc/tmpfiles.d/daphne.conf|
d /run/daphne 0775 www-data www-data -
d /var/log/daphne 0775 www-data www-data -
}}

{{ hc |/etc/tmpfiles.d/uwsgi.conf|
d /run/uwsgi 0775 www-data www-data -
d /var/log/uwsgi 0775 www-data www-data -
}}

Once the files are created, we can execute them with
sudo systemd-tmpfiles --create

For more details on these tmpfiles, see https://manpages.ubuntu.com/manpages/bionic/man5/tmpfiles.d.5.html

=== uWSGI Configurations ===
uWSGI is essentially a project meant to "provide a common api and configuration style" for hosting services from various different languages.

It's effectively the interface we use to connect Nginx and Django together.

For this, first we create the following folder and set ownership to {{ ic |www-data}}:
sudo mkdir -p /etc/uwsgi/sites
sudo touch /etc/uwsgi/sites/<project_name>.ini
sudo chown www-data:www-data /etc/uwsgi -R

Next, we add a configuration file for our project:
{{ hc |/etc/uwsgi/sites/<project_name>.ini|
<nowiki>[uwsgi]
project = <project_name>

# Django Settings.
chdir = /srv/web_serve/django/%(project)
home = /opt/env/<virtual_env_name>
module = <project_settings_folder>.wsgi:application

# Process Settings.
master = true
processes = 5
threads = 2
uid = www-data
gid = www-data
chmod-socket = 664
pidfile = /run/uwsgi/%(project).pid
socket = /run/uwsgi/%(project).sock
wsgi-file = %(chdir)/settings/wsgi.py
manage-script-name = true
vacuum = true
max-requests = 5000
logto = /var/log/uwsgi/%n.log</nowiki>
}}

For this config, note to change:
* {{ ic |<nowiki>project = <project_name></nowiki>}} (the second line) to match your project's root folder name.
* {{ ic |<nowiki>home = /opt/env/<virtual_env_name></nowiki>}} (the seventh line) to match your virtual environment location.
* {{ ic |<nowiki>module = <project_settings_folder>.wsgi:application</nowiki>}} (the eigth line) to match your project settings folder.
* {{ ic |<nowiki>wsgi-file = %(chdir)</nowiki>/settings/wsgi.py}} (5th to last line) to point to the actual uwsgi file in your project.

While these settings won't work for all projects, they should be a good starting point for the average small Django project to get up and running.

=== Nginx Configurations ===
There are many ways to setup a nginx server, with some basics located at [[Programming/Nginx]].

{{ todo | Document making server more secure with possible SSL params. }}

Recommended steps for serving a Django project are as follows:
* First, it's strongly recommended to [[Programming/Nginx#HTTPS and SSL | set up HTTPS]] and redirect all server traffic to HTTPS.
* Set up [[Programming/Nginx#Example 1: Serving static | static file handling]] for the {{ ic |/media}} and {{ ic |/static}} urls (or whatever the equivalent is for your specific Django project).
* If applicable, set up [[Programming/Nginx#Example 2: Redirecting Specific Requests | request redirects]] for your project, where needed.
* Define your core [[Programming/Nginx#Example 3: Passing Requests to UWSGI | UWSGI request handler]], preferably via [[Programming/Nginx#Reusable Location Blocks | reusable location blocks]].
* Finally, if using something that needs websocket request handling (such as [https://channels.readthedocs.io/en/stable/ DjangoChannels], then we need an additional handler. The following code snippet passes requests to Daphne for DjangoChannels handling (this assumes websockets are all served under a root url of {{ ic |example.com/ws/}}):
{{ hc |/etc/nginx/sites-available/<project_name>.conf|
<nowiki> # Send websocket connections to Daphne.
location /ws {
proxy_pass http://unix:/run/daphne/<project_name>.sock;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";

proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-OP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Host $server_name;
}</nowiki>
}}

=== Systemd Service File Configurations ===
The systemd service files are effectively how Linux determines what processes should start on boot. They are located in the {{ ic |/etc/systemd/system/}} folder.

For our project, we will create two files here:
{{ hc |/etc/systemd/system/daphne.service|
<nowiki>[Unit]
Description=Daphne server for Django web projects
After=syslog.target network.target uwsgi.service

[Service]
ExecStart=/opt/env/<virtual_env_name>/bin/daphne -u /run/daphne/<project_name>.sock <project_settings_folder>.asgi:application
Restart=always
Type=simple
WorkingDirectory=/srv/web_serve/<project_name>
User=www-data
Group=<group_name>
StandardOutput=syslog
StandardError=syslog
KillSignal=SIGQUIT

[Install]
WantedBy=multi-user.target</nowiki>
}}

{{ hc |/etc/systemd/system/uwsgi.service|
<nowiki>[Unit]
Description=uWSGI Application Server in Emperor Mode
After=syslog.target network.target

[Service]
ExecStart=/opt/env/<virtual_env_name>/bin/uwsgi --emperor /etc/uwsgi/sites
Restart=always
Type=notify
User=www-data
Group=<group_name>
StandardOutput=syslog
StandardError=syslog
KillSignal=SIGQUIT
NotifyAccess=all

[Install]
WantedBy=multi-user.target</nowiki>
}}

Once the files are created, tell the system to reload:
sudo systemctl daemon-reload
sudo systemctl start daphne
sudo systemctl enable daphne
sudo systemctl start uwsgi
sudo systemctl enable uwsgi

Check for possible errors with:
journalctl -xe

If no errors occur, then everything is good and your project is officially serving in production. Verify by trying to access your site in a browser.

Python/PipEnv

2025-12-29T07:57:42Z

Brodriguez: Update docs for installing pipenv

PipEnv is an attempt to make Python Pip behave more like [https://getcomposer.org/ Composer] (from Php/Laravel).

In other words, this is meant to streamline project package/environment management. You tell PipEnv what packages you care about, and it effectively installs + manages versions (and sub-dependency versions) for you. 
This data is stored in files called {{ ic |PipFile}} and {{ ic |PipFile.lock}}, at your project root.

Official docs can be found at https://docs.pipenv.org/

This page shows quick, basic options for ease of use.

== Linux Setup ==
Before using PipEnv, it's recommended to add some additional settings to the local system environment.
To do this, edit the user's local {{ ic |.bashrc}} file (or equivalent) and add the following:

Update terminal path to find PipEnv:
export PATH="$PATH:/home/<username>/.local/bin"

Update PipEnv settings to always use venv folders in project:
export PIPENV_VENV_IN_PROJECT=true

Reminder to restart terminal after saving changes.

== Important Commands ==

=== Install Commands ===
Install PipEnv for Mac:
brew install pipenv

Install PipEnv for Linux:
Set and load up a virtual environment {{ic |python<version> -m venv .venv}} for the local project. Then run:
pip install pipenv
Note that this only installs pipenv for that environment. You will need to repeat for every project.

=== Package Management Commands ===
{{ note | For the below commands, you can also add the {{ ic |--dev}} flag, which tells PipEnv to install optional "dev-packages" to the local Python environment. Aka, those dependencies that were defined in the "development section" of the PipFile.}}

Install current project dependencies to the local Python environment, as listed in PipEnv files:
pipenv sync

Update project dependencies listed in PipEnv files, then install them to the local python environment:
pipenv install

Update a specific dependency (warning - may also update unrelated dependencies):
pipenv update <dependency>

Uninstall a specific dependency with:
pipenv uninstall <dependency>

Apt-Get Packages

2025-04-10T02:05:56Z

Brodriguez: Update docker install instructions

This page lists the '''apt-get''' commands to install various packages. 
For general information about '''apt-get''' usage, see [[Apt-Get]].

{{ todo | Where applicable, remove content from this page and put on the language/application's main wiki page (ex: [[Python]]). Then just import installation text from that page to here. That way it's consistent across the wiki. }}

== System Utilities ==

=== Gparted ===
A helpful hard drive management tool, with a user-friendly GUI.
sudo apt update
sudo apt install gparted

=== Extra Hard Drive Utils ===
Used, for example, in network share mounting.
sudo apt update
sudo apt install cifs-utils

=== Compiz Config ===
For managing detailed desktop settings Ubuntu 16.04.
sudo apt update
sudo apt install compizconfig-settings-manager

=== Gnome Tweaks ===
For managing detailed desktop settings of Ubuntu 18.04.
sudo add-apt-repository universe
sudo apt install gnome-tweaks

=== Gnome Extensions ===
For generally customizing the gnome desktop.
sudo apt update
sudo apt install gnome-shell-extensions

== System Other ==

=== Build Essential ===
A package that essentially contains references to other packages. 
Generally common to install for software development.
sudo apt update
sudo apt install build-essential

=== DKMS ===
A package used to rebuild system kernels after a kernel update. 
Generally needed if you manually upgrade kernels on your machine, or if running as a VM.
sudo apt update
sudo apt install dkms

=== OpenConnect ===
Allows easy VPN connections through the terminal.
sudo apt update
sudo apt install openconnect

=== Nvidia ===

==== Base Drivers ====
If no drivers are detecting on initial install, find default preferred drivers with:
sudo ubuntu-drivers autoinstall
sudo prime-select nvidia

==== Cuda ====
With proper Nvidia drivers already installed:
sudo apt update
sudo apt install nvidia-cuda-toolkit

== General ==

=== Chrome ===
Installs the standard Google Chrome web browser.

sudo apt update
sudo apt install chromium-browser

=== Gimp ===
Gimp is a free image editor tool.

sudo apt install gimp

=== VLC ===
VLC is an all-encompassing media player. It can handle just about any standardized media format you could throw at it.

VLC is not available directly via apt. However, it can be installed with the <code>snap</code> manager:
sudo apt install snapd
sudo snap install vlc

=== LaTeX ===
For creating and editing pdf files.
sudo apt update
sudo apt install texlive-full texmaker

=== DropBox ===
For storing and managing files in the cloud.
sudo apt update
sudo apt install nautilus-dropbox

=== KeePass ===
For storing passwords securely.
sudo apt update
sudo apt install keepass2

=== qbit Torrent ===
For torrent tracking.
sudo apt update
sudo apt install qbittorrent

== Communication ==

=== Slack ===
Slack is not available directly via apt. However, it can be installed with the <code>snap</code> manager:
sudo apt install snapd
sudo snap install slack --classic

=== Discord ===
Discord is not available directly via apt. However, it can be installed with the <code>snap</code> manager:
sudo apt install snapd
sudo snap install discord

=== Telegram ===
Telegram is not available directly via apt. However, it can be installed with the <code>snap</code> manager:
sudo apt install snapd
sudo snap install telegram-desktop

== General Programming ==

=== Git and Gitk ===
Installed on most distro's by default, but not always. Pretty essential for anything programming. If not present, can be installed with:
sudo apt update
sudo apt install git gitk

=== VirtualBox ===
VirtualBox is a free way to create and run Virtual Machines.

Since this seems to be updated frequently, see https://www.virtualbox.org/wiki/Linux_Downloads for up to date details. 
It's recommended to specifically choose the newest version, as the base command seems to generally install an out-of-date version.

=== Docker ===
Docker does to software what VirtualMachines do to operating systems. 
Essentially, docker creates individual, stand-alone environments (or containers) that allow a set of software to run.

For install instructions, see https://docs.docker.com/engine/install/ubuntu/#install-using-the-repository

=== MySQL Workbench ===
A useful and easy interface for interacting with MySQL servers.
sudo apt update
sudo apt install mysql-workbench

== Programming Languages ==

=== Npm/NodeJs ===
Npm & NodeJs are bundled together. Npm has turned into the standard project manager for anything JavaScript.

To install:
curl -sL https://deb.nodesource.com/setup_15.x | sudo -E bash -
sudo apt install nodejs

=== SASS ===
Sass is a CSS pre-processor language, that upgrades CSS from just a "markup language" to a working "programming language". Very useful.

The current latest recommended means of installing SASS is dart-sass, via Npm:
sudo npm install -g sass

=== MySQL ===
Installs MySQL server and runs initial install setup.
sudo apt update
sudo apt install mysql-server
sudo mysql_secure_installation

=== Php ===
{{ Note | As of summer 2020, these packages seem to work with the current version of Laravel and Php. }}
sudo apt install php php-all-dev php-common php-dev php-bcmath php-bz2 php-cli php-curl php-gd php-imap php-json php-intl php-ldap php-mbstring php-mysql php-xml php-zip

To install an older version of Php, specify the number. Ex:
sudo apt install php7.4 php7.4-common php7.4-dev php7.4-bcmath php7.4-bz2 php7.4-cli php7.4-curl php7.4-gd php7.4-imap php7.4-json php7.4-intl php7.4-ldap php7.4-mbstring php7.4-mysql php7.4-xml php7.4-zip

If trying to install really old versions of php, you may first need:
sudo add-apt-repository ppa:ondrej/php

==== Laravel ====
Laravel is a Php based web framework.

To install Laravel:
* First install the desired Php version, using the above steps.
* Download composer from https://getcomposer.org/download/
* Add execution permissions {{ ic |sudo chmod +x <path_to_composer_file>}}
* Move composer file with {{ ic |sudo mv <path_to_composer_file> /usr/local/bin/composer}}
* Restart terminal
* Run {{ ic | composer global require laravel/installer }}

(Optional) To update what version of php that composer uses, run:
php<version> /usr/local/bin/composer update
Where {{ ic |<version>}} corresponds to the version of Php you'd like composer to use. Note that this version of Php must be installed on your system for the command to work.

=== Python ===
Depending on your version of Ubuntu, you might only have certain Python versions available for install. To correct this, run:
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update

Then you can install the desired Python version.
For example, some more recent versions are {{ ic |python3.6}}, {{ ic |python3.7}}, or {{ ic |python3.8}}.
sudo apt install python<version>
sudo apt install python<version>-dev
sudo apt install python<version>-venv

If you get an error when trying to use Pip or run the '''python -m venv''' command, you might also need to run the following:
sudo apt install python3-pip

==== PipEnv ====
For Python environment management.

First add the following to the system path:
PATH="$PATH:/home/<username>/.local/bin"
PIPENV_VENV_IN_PROJECT=true

Then install with the following command:
python3 -m pip install --user pipenv

== Programming IDEs ==

=== Sublime Text ===
A text editor that, by itself, isn't very impressive. But it has a lot of support for extensions and customization, which make it as good as most standard IDE's.

==== Ubuntu22 ====
wget -qO - https://download.sublimetext.com/sublimehq-pub.gpg | sudo gpg --dearmor -o /usr/share/keyrings/sublimetext-keyring.gpg
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/sublimetext-keyring.gpg] https://download.sublimetext.com/ apt/stable/" | sudo tee /etc/apt/sources.list.d/sublime-text.list
sudo apt update
sudo apt install sublime-text

==== Ubuntu20 ====
wget -qO - https://download.sublimetext.com/sublimehq-pub.gpg | sudo apt-key add -
echo "deb https://download.sublimetext.com/ apt/stable/" | sudo tee /etc/apt/sources.list.d/sublime-text.list
sudo apt update
sudo apt install sublime-text

=== Pycharm ===
An IDE created specifically for Python. Made by the JetBrains people.

PyCharm is not available directly via apt. However, it can be installed with the {{ ic |snap}} manager:
* Community
sudo apt install snapd
sudo snap install pycharm-community --classic
* Professional
sudo apt install snapd
sudo snap install pycharm-professional --classic

=== VsCode ===
A lightweight version of VisualStudio. Has support for many different languages.

VsCode is not available directly via apt. However, it can be installed with the <code>snap</code> manager:
sudo apt install snapd
sudo snap install code --classic

=== R Studio ===
An interface for programming with the [[R | R language]].
sudo apt update
sudo apt install r-base

Then follow the steps at https://rstudio.com/products/rstudio/download-server/debian-ubuntu/

== Server Packages ==

=== Apache ===
Apache is one of the two most common web solutions for serving HTTP/HTTPS requests on a server.

Apache itself comes preinstalled on most modern Ubuntu installations, although most of the related packages do not.

To install apache itself, run:
sudo apt install apache2 apache2-dev

To install dependencies for serving [[Programming/Django]] ([[Programming/Python]]) projects, run:
sudo apt install libapache2-mod-wsgi-py3

=== Nginx ===
Nginx is the other of the two most common web solutions for serving HTTP/HTTPS requests on a server.

Note that with their default values, only one of Apache/Nginx can be enabled at a time. It is possible to get them running together, but it takes effort and manual configuration.

Having said that, to get nginx to run, you'll (initially) need to disable Apache with:
sudo systemctl stop apache2
sudo systemctl disable apache2

You can then install nginx with:
sudo apt install nginx

=== Redis ===
Redis is a "in-memory data struct store" that is sometimes used in web projects to help manage and cache data.

Install with:
sudo apt install redis-server

Programming/PostgreSQL/Databases

2025-04-04T06:52:59Z

Brodriguez: Update section to allow database privileges

{{ note | Unless otherwise specified, all commands from this page assume you're in the [[PostgreSQL#Basics | PostgreSQL shell]]. }}

== General Commands ==

=== Show All Databases ===
\l

=== Show Currently Selected Database ===
SELECT current_database();

=== Create a New Database ===
CREATE DATABASE <database_name>;

=== Load a Database ===
\c <database_name>

=== Delete a Database ===
{{ warn | Note that this action cannot be undone. }}
DROP DATABASE <database_name>;

=== Set Database Privileges ===
GRANT ALL PRIVILEGES ON DATABASE <database_name> TO <user_name>;

On newer installations of Postgres, you may also need the following command for the user to properly create/modify tables:
# First, load the desired database:
\c <database_name>

# Then run command:
GRANT ALL ON SCHEMA public TO <user>;

== Database Backups ==
=== Export Database to file ===
pg_dump -Fc -U <user_name> -d <database_name> > <file_location>

Optional Flags:
* {{ ic |-h <host>}} - Allows specification of host, such as for connecting to a remote server.
* {{ ic |-p <port>}} - Allows specification of port, such as for non-standard installations that don't use the default port {{ ic |5432}}.

=== Import Database from File ===
pg_restore -U <user_name> -d <database_name> <file_location>

Optional Flags:
* {{ ic |-h <host>}} - Allows specification of host, such as for connecting to a remote server.
* {{ ic |-p <port>}} - Allows specification of port, such as for non-standard installations that don't use the default port {{ ic |5432}}.

SSH

2024-01-31T07:28:21Z

Brodriguez: Update to elaborate on the IdentitiesOnly value in the ssh config

SSH stands for "Secure Shell". It's used to securely connect to remote machines.

Most common uses are to securely access repositories in sites like Github, GitLab, or Bitbucket. Or to gain access to a remote machine's terminal (such as if you're the admin of said machine).

SSH authentication can be done through either a standard "username + password" combination, or through SSH Keys. Note that SSH Keys are generally considered more secure, as it's a physical code that the user needs access to.

== SSH Keys ==

=== What are SSH Keys ===
At their core, SSH keys are based of "difficult to solve" mathematical problems. Generally speaking, these problems have "two part" solutions, where the '''PublicKey''' and '''PrivateKey''' each represent a part of said solution.

The '''PublicKey''' is intended to be shared publicly, such as stored on GitHub for future authentication attempts. The '''PrivateKey''' is meant to be stored locally on your machine, and should always be kept secret.

Essentially, when you try to authenticate, these two keys can be used together create a valid solution to the mathematical problem, with minimal computational cost. Meanwhile, because the difficulty of the problem they represent, finding the solution is actually very computationally costly without both keys. Usually, this comes down to simply guessing an unfathomably large number of possible pairs for the "correct" solution.

=== Types of SSH Keys ===
{{ Note | Note that there will never be a universally "best" key type, per say, as new key types are being discovered with time. Furthermore, computers are always improving, so keys that "are very secure" right now may not be so in 10 years. }}

There are multiple SSH Key types, where each key type represents a different mathematical problem.

As of writing this (in year 2020), there appear to be four main types of SSH keys:
* '''RSA''' - Based off the "difficulty of factoring very large numbers".
** Recommend a minimum strength of 2048 bits. 4096 is preferred for systems that support it.
** One of the oldest key types, so virtually all devices support it at this point.
* '''DSA''' - Based off the "Discrete Logarithm" problem.
** Considered essentially equal to RSA as far as security.
** Faster than RSA in some respects, while slower in others.
* '''ECDSA''' - A specific version of the DSA problem, called the "Elliptic Curve Discrete Logarithm" problem.
** Keys for this can be much smaller than RSA, while still providing as much security as RSA does.
* '''ED25519''' - Yet another improvement of ECDSA, using the "Twisted Edwards Curve".
** Once again, can use smaller key sizes while being as secure as RSA.
** Has the added benefit of being very fast to verify if you have both keys.
** Generally newer than other key types, so not all devices/systems support it yet (even if most do by this point).

Generally speaking as of writing this, it seems ED25519 is the preferred type, with RSA as a fallback for systems that don't yet support ED25519.

=== Generating SSH Keys ===
As stated above, it's currently best to try an '''ED25519''' key first. If it's not supported by your system yet, then fallback to '''RSA''' of at least 2048 bits.

Creating an ED25519 Key:
ssh-keygen -t ed25519 -C "<your_email>"

Creating a RSA Key:
ssh-keygen -o -t rsa -b <bit_length> -C "<your_email>"
* '''<bit_length>''' - Specifies a key bit length of either 2048, 3072, or 4096. Generally higher is better.

Either of the above commands will start the process to create a new key pair.
* Hit enter to use the default path. Alternatively, retype the path and change the {{ ic |id_rsa}} to a filename of your choice.
** If you change the filename, make it something useful and descriptive.
** For example, if making a RSA key for GitHub, it might be good to change the name to something like {{ ic |github_rsa}}.
** This allows you to have multiple keys, where each key corresponds to a different service or use case.

== Connecting Via SSH ==
Connecting via SSH can be as simple as a single command, at least if authenticating via username + password:

ssh <username>@<server_name_or_ip>

If connecting via an SSH Key, then you probably want to [[SSH#SSH Config Files | Use a Config file]].

Once the config file is set up, then you can connect with:
ssh <config_Host_value>

== SSH Config Files ==
It's possible to create config files for SSH connections. This is particularly recommended when regularly connecting to different servers/repositories on a single machine.

Config file should be located at {{ ic |~/.ssh/config}}.

Syntax is (generally) as follows:
Host <corresponding_value>
HostName <corresponding_value>
<ssh_option> <corresponding_value>

Comments can also be added with {{ ic |#}}.

Possible options are as follows:
* '''Host''' - Required. Can be any arbitrary value. This is what is typed locally to call this specific SSH configuration.
** Generally, this is either the same as '''HostName''' or an abbreviation of such. But in reality, you can think of it as an alias.
* '''HostName''' - Required. This is the actual address to connect to.
** Ex: An IP address if connecting to a production server. Or "github.com" if connecting to GitHub. Etc.
* '''Port''' - Required if port is not 22. Self explanatory.
* '''User''' - The username to try to authenticate with, on the server itself.
** If not provided, then attempts to use the name of the local user invoking the ssh call.
* '''PreferredAuthentications''' - Specifies the order which the client should attempt to authenticate with. Most common options are '''publickey''' or '''password'''.
* '''IdentitiesOnly''' - Indicates if attempts to connect to the Hostname should ONLY use keys indicated in the config file. See below section for further details.
* '''IdentityFile''' - If applicable, the file to attempt to authenticate through.
** Ex: In the below examples, we use a {{ ic |github_rsa}} key and a {{ ic |bitbucket_ed2}} key, respectively.

=== Config File Example ===
Shows a good example of how a full config may generally look.

# GitHub repo connection.
Host github
User git
Hostname github.com
Port 22
PreferredAuthentications publickey
IdentitiesOnly yes
IdentityFile /home/my_user/.ssh/github_rsa

# BitBucket repo connection.
Host bitbucket
User my_user
Hostname bitbucket.org
Port 22
PreferredAuthentications publickey
IdentitiesOnly yes
IdentityFile /home/my_user/.ssh/bitbucket_ed2

=== On Using IdentitiesOnly ===
From manual testing, this arg doesn't seem to harm anything as long as you define all your connections in the config file. With this in mind, then it seems to be best to always set `IdentitiesOnly yes` for every entry in the config. Then just make sure to always add new entries into your config, every time there's a new ssh authentication you need (frankly, you should be always adding to the config anyways, it's just easier in the long run).

Think of the following edge-case scenarios:

==== Scenario 1 - You want to connect to some site with ssh, but using a password and not a generated ssh key ====

This is fine, set everything as needed similar to the above examples. The only difference being that you won't need the `IdentityFile` line (you want to provide a password, not provide a key), and that you want to set {{ ic |PreferredAuthentications password}}.

==== Scenario 2 - You want to connect to a site to access repos on two or more different accounts (such as github) ====
Because you're connecting to repos, and not as a full ssh authentication login, you can't specify the user account in the config (it uses `git` as a base value for username)

'''Short Answer''': {{ ic |IdentitiesOnly yes}} accounts for this.

'''Long Answer''': Every time you try to authenticate, your ssh might actually send multiple different auth attempts, when multiple sets of credentials match the Hostname. (To Verify, you can try to connect with extra-verbose ({ic |-vvv}} flag) prior to adding the `IdentitiesOnly` line). In essence, ssh does not magically know how it's meant to connect unless you tell it. So it might try to incorrectly guess and lead to behavior that "seems dumb" to you as the end user. Such as trying to prompt for a password when the proper entry is clearly in the config.

By setting the {{ ic |IdentitiesOnly yes}} line, you're telling ssh "this connection to the HostName is definitely defined in here, even if the first one or two you try end up wrong." So it will only try values explicitly in the config file, and give up if has exhausted all applicable config entries.

{{ note | If you have many different accounts to a single host (three accounts, four, or even more), then it's possible this method won't be enough either. Even when forced to only try specific config entries, it still might run out of authentication attempts and error before getting to the "correct one". See https://superuser.com/a/272613 for more information in that case. But if you only have two or maybe three accounts to a single hostname, then most likely it will work just by setting the {{ ic |IdentitiesOnly yes}} line.}}

==== Scenario 3 - You have many entries (15+) in your config file ====

I'm not sure of the exact point this starts happening, but there are some instances when ssh config credentials start being problematic, once you have too many entries in your config.

Now this might have been fixed, it was last observed in 2021 or so. But at least at the time, after a certain threshold of config entries, you might start getting prompts to enter a password, despite having a proper config entry defined and wanting to connect password-less. Or alternatively, you might get an authentication error, despite having a properly defined config entry.

Basically, the reason for this is kind of similar to above {{ ic |Scenario 2}}, only this case seems to be more of a bug, where the number of config entries makes behavior stupid, and it starts trying entries where the HostName doesn't actually make sense.

In either case, setting the {{ ic |IdentitiesOnly yes}} line seems to fix this, as it forces ssh to only check values explicitly defined in the config.

== Passing Your PubKey to the Remote Service ==
Essentially, this allows secure connections via your credentials, without having to enter your password anymore. It's generally considered more secure, and thus recommended.

=== Setting Up Keys for Remote Repositories ===
This allows connect to things like GitHub and Gitlab, and to pull and push repositories of code easier.

The process is generally fairly straightforward:
* First, log into the associated website, and find the page to upload SSH Keys for your user account.
* After [[SSH#Generating SSH Keys | Generating a SSH Key]], find the newly created PublicKey location.
** On Linux, the default location will be something like {{ ic |~/.ssh/<key_name>.pub}}.
* Copy the full contents of the PublicKey file, and paste it into the box on the website.
* Give a meaningful title if provided an option to. Ex: {{ ic |Home_Desktop_GitHub}}.
* Save and [[SSH#Testing SSH Keys | Test Your SSH Key]].

==== Testing SSH Keys ====
For remote repositories, they usually have a built in method to test your key once uploaded.

Usually, this is done via terminal, via something like {{ ic |ssh -T git@<website>}}.
* Ex: To test a key on GitHub, you would use {{ ic |ssh -T git@github.com}}.
* To troubleshoot, you can add the '''-v''', '''-vv''', or '''-vvv''' flags, where each one provides a little bit more information.

=== Setting up Password-less Server Credentials ===
This allows you to remote into a server (via Terminal) without entering your password every time.

First, you'll need to be able to make SSH connections using passwords. If not already enabled on the server, then enable it with the following:
* Note that this requires enabling at least one user that can log in with a standard password. AWS EC2, for example, does not create such a user by default.
* Edit the file {{ ic |/etc/ssh/sshd_config}}.
* Update the line {{ ic |PasswordAuthentication}} to '''yes'''.
* Restart the service with {{ ic |sudo service ssh restart}}.

Next, pass your public key to the server with the command:
ssh-copy-id -i <public_key_to_pass> <server_address>

Test that it works by connecting to the server with ssh. It should connect without asking for a password.

Finally, disable ssh connections with passwords to make the server more secure:
* Edit the file {{ ic |/etc/ssh/sshd_config}}.
* Update the line {{ ic |PasswordAuthentication}} to '''no'''.
* Restart the service with {{ ic |sudo service ssh restart}}

== SSH not Prompting for Password ==
https://askubuntu.com/a/419562

Docker

2023-07-19T22:42:16Z

Brodriguez: Add command

{{ todo | Page is very incomplete. Notes of learning docker/kubernetes here. }}

== Docker ==

[https://www.docker.com/ Docker] creates and runs '''containers''', which are sand-boxed processes, isolated from all other processes, with their own allocated cpu/memory/etc.

Each docker container is "meant to do exactly one thing, and do it well". So it's common to have a docker stack comprised of multiple containers. For example, one container to run your main application, and another for your database.

=== Docker Sub Parts ===

Core Parts:
* '''Image''' - A definition of docker logic, which can be spun up and run as a '''container'''.
** Due to how docker works, any number of containers can be build from this image, and it will run on any OS that supports docker.
* '''Container''' - A unique, running instance of a docker '''image'''.
** Multiple containers can be created from a single image.
* '''Volume''' - An location for docker to persist data to long-term.
** Allows data to last even as a container is started, stopped, and restarted.
** Also allows multiple containers to share a set of data, so long as the data is put into the volume.

Setup:
* '''docker-compose.yml''' - A file that defines the docker service to run.
* '''Dockerfile''' - A file that defines the actual commands the docker instance should execute once it is created, in order to setup the intended container service.

{{ todo |Are the below two commands useful? Needed?}}
These two files should be put into the same directory. Then {{ ic |cd}} into the directory and build it with {{ ic |docker-compose run}}.

Finally, start the service with {{ ic |docker-compose up -build -d}}.

=== Docker Commands ===

==== Commands to Launch Containers ====

Launch a built image as a new container instance:
docker run -d <image_name>
Where {{ ic |image_name}} - Corresponds to the name of the image you wish to create a container of.
* See below sections for additional useful optional args.

Example:
docker run -d my-cool-image

{{ warn |With the above command, data will NEVER persist long term. If the container is ever restarted or rebuilt, all data in the container will be lost. See Mounting Subsection for solutions.}}

===== Port Mapping Subsection =====

To expose ports of a container instance to the host, we use port mapping.

Command follows the format of:
-p <host>:<host_port>:<container_port>
Where:
* {{ ic |host}} - Corresponds to the host address to connect to. Often {{ ic |127.0.0.1}}.
* {{ ic |host_port}} - Corresponds to the port to use on the host machine for mapping.
* {{ ic |container_port}} - Corresponds to the port to connect to on the container.

Example:
docker run -d -p 127.0.0.1:3000:3000 my-cool-image

===== Command Mount Subsection =====

To persist data long term, we need to add some form of '''mount''' subcommand.

Volume Mount:
* '''Volume Mount''' - Allows persisting data for docker instances.
** Follows the format {{ ic |<nowiki>--mount type=volume,src=<volume_name>,target=<filepath_in_container></nowiki>}}.
*** Where:
**** {{ ic |volume_name}} - Corresponds to the name of the already-created docker '''volume''' to mount.
**** {{ ic |filepath_in_container}} - Corresponds to the filepath the volume should mount to, within the container. Ex: {{ ic |/etc/my_volume}}.

Example:
docker run -d --mount type=volume,src=my-volume,target=/etc/my_volume my-cool-image

Bind Mount:
* '''Bind Mount''' - Allows sharing data between host machine and container, via linking filepaths (similar to a [[Linux/Hard Drive Management#Sym_Links | symlink]]).
** Follows the format {{ ic |<nowiki>--mount type=bind,src=<filepath_on_host>,target=<filepath_in_container></nowiki>}}.
*** Where:
**** {{ ic |filepath_on_host}} - Corresponds to a folder located on HOST machine, to share with container.
**** {{ ic |filepath_in_container}} - Corresponds to the filepath the volume should mount to, within the container. Ex: {{ ic |/etc/my_volume}}.

Example:
docker run -d --mount type=bind,src=/srv/my_project/share_folder,target=/etc/my_volume my-cool-image

===== Command Network Subsection =====

Docker '''networks''' are used to allow containers to connect and communicate among each other.

Attach Network:
--network <network_name>
Where {{ ic |network_name}} - Is the docker virtual network to connect in.

Example:
docker run -d --network my_network my-cool-image

==== General Commands ====

List all live docker containers:
docker ps

List all (including stopped) docker containers:
docker ps --al

Access a given running container:
docker exec <container_id>
Where {{ ic |container_id}} is the id of the container you wish to access.

Build docker image from the {{ ic |Dockerfile}} in current directory:
docker build -t <image_name>
Where {{ ic |image_name}} is the name you wish to give the image.

Stop running docker container:
docker stop <container_id>
Where {{ ic |container_id}} is the id of the container you wish to stop.

Remove existing docker container:
docker rm <container_id>

OR combine the above two commands with:
docker rm -f <container_id>
Where {{ ic |container_id}} is the id of the container you wish to stop.

Create a new volume to allow persisting data long-term:
docker volume create <volume_name>
Where {{ ic |volume_name}} is the name the volume should use.

Examine logs of running docker instance:
sudo docker logs -f <container_name>

== Kubernetes ==

[https://kubernetes.io/ Kubernetes] is a an architecture that runs and manages docker-like containers for applications.

{{ note | This is a simplified overview of useful commands for using Kubernetes. For full official docs, see https://kubernetes.io/docs/concepts/overview/}}

=== Kubernetes Sub Parts ===

* '''Control Plane''' - Where decisions are made.
** Generally has 3 of these running, to ensure availability.
* '''Worker Node''' - A location where something might be running.
** Can have any number of these, as needed.
** Parts:
*** '''Kubletes''' - Manages one or more PODS, each POD being a group of docker-style containers.
*** '''Kube Proxy''' - Ensures communication is fluid between all parts.
*** '''Controller''' - Helps control all other aspects, to ensure it does what it's meant to.
* '''External Resources''' - Various outside resources that the '''Control Plane''' and '''Worker Nodes''' do work with.
** Ex: Storage, load balancers, etc.
* '''API''' - An interface for humans to interact with the '''Control Planes'''.
** Most interactions with the '''API''' involve telling Kubernetes "this is the state I want everything to be in". Kubernetes then figures out how to make that happen.
** Parts:
*** '''Scheduler''' - Determines what should happen, when, and where.
*** '''Controller Manager''' - Manages the controllers.
*** '''Key-Value Store''' - Effectively a "database of possible states".

=== Kubernetes Commands ===

{{ todo | Figure out common/useful commands and add here. }}

Docker

2023-07-19T22:33:40Z

Brodriguez: Add command

{{ todo | Page is very incomplete. Notes of learning docker/kubernetes here. }}

== Docker ==

[https://www.docker.com/ Docker] creates and runs '''containers''', which are sand-boxed processes, isolated from all other processes, with their own allocated cpu/memory/etc.

Each docker container is "meant to do exactly one thing, and do it well". So it's common to have a docker stack comprised of multiple containers. For example, one container to run your main application, and another for your database.

=== Docker Sub Parts ===

Core Parts:
* '''Image''' - A definition of docker logic, which can be spun up and run as a '''container'''.
** Due to how docker works, any number of containers can be build from this image, and it will run on any OS that supports docker.
* '''Container''' - A unique, running instance of a docker '''image'''.
** Multiple containers can be created from a single image.
* '''Volume''' - An location for docker to persist data to long-term.
** Allows data to last even as a container is started, stopped, and restarted.
** Also allows multiple containers to share a set of data, so long as the data is put into the volume.

Setup:
* '''docker-compose.yml''' - A file that defines the docker service to run.
* '''Dockerfile''' - A file that defines the actual commands the docker instance should execute once it is created, in order to setup the intended container service.

{{ todo |Are the below two commands useful? Needed?}}
These two files should be put into the same directory. Then {{ ic |cd}} into the directory and build it with {{ ic |docker-compose run}}.

Finally, start the service with {{ ic |docker-compose up -build -d}}.

=== Docker Commands ===

==== Commands to Launch Containers ====

Launch a built image as a new container instance:
docker run -d <image_name>
Where {{ ic |image_name}} - Corresponds to the name of the image you wish to create a container of.
* See below sections for additional useful optional args.

Example:
docker run -d my-cool-image

{{ warn |With the above command, data will NEVER persist long term. If the container is ever restarted or rebuilt, all data in the container will be lost. See Mounting Subsection for solutions.}}

===== Port Mapping Subsection =====

To expose ports of a container instance to the host, we use port mapping.

Command follows the format of:
-p <host>:<host_port>:<container_port>
Where:
* {{ ic |host}} - Corresponds to the host address to connect to. Often {{ ic |127.0.0.1}}.
* {{ ic |host_port}} - Corresponds to the port to use on the host machine for mapping.
* {{ ic |container_port}} - Corresponds to the port to connect to on the container.

Example:
docker run -d -p 127.0.0.1:3000:3000 my-cool-image

===== Command Mount Subsection =====

To persist data long term, we need to add some form of '''mount''' subcommand.

Volume Mount:
* '''Volume Mount''' - Allows persisting data for docker instances.
** Follows the format {{ ic |<nowiki>--mount type=volume,src=<volume_name>,target=<filepath_in_container></nowiki>}}.
*** Where:
**** {{ ic |volume_name}} - Corresponds to the name of the already-created docker '''volume''' to mount.
**** {{ ic |filepath_in_container}} - Corresponds to the filepath the volume should mount to, within the container. Ex: {{ ic |/etc/my_volume}}.

Example:
docker run -d --mount type=volume,src=my-volume,target=/etc/my_volume my-cool-image

Bind Mount:
* '''Bind Mount''' - Allows sharing data between host machine and container, via linking filepaths (similar to a [[Linux/Hard Drive Management#Sym_Links | symlink]]).
** Follows the format {{ ic |<nowiki>--mount type=bind,src=<filepath_on_host>,target=<filepath_in_container></nowiki>}}.
*** Where:
**** {{ ic |filepath_on_host}} - Corresponds to a folder located on HOST machine, to share with container.
**** {{ ic |filepath_in_container}} - Corresponds to the filepath the volume should mount to, within the container. Ex: {{ ic |/etc/my_volume}}.

Example:
docker run -d --mount type=bind,src=/srv/my_project/share_folder,target=/etc/my_volume my-cool-image

===== Command Network Subsection =====

Docker '''networks''' are used to allow containers to connect and communicate among each other.

Attach Network:
--network <network_name>
Where {{ ic |network_name}} - Is the docker virtual network to connect in.

Example:
docker run -d --network my_network my-cool-image

==== General Commands ====

List all live docker containers:
docker ps

List all (including stopped) docker containers:
docker ps --al

Access a given running container:
docker exec <container_id>
Where {{ ic |container_id}} is the id of the container you wish to access.

Build docker image from the {{ ic |Dockerfile}} in current directory:
docker build -t <image_name>
Where {{ ic |image_name}} is the name you wish to give the image.

Stop running docker container:
docker stop <container_id>
Where {{ ic |container_id}} is the id of the container you wish to stop.

Remove existing docker container:
docker rm <container_id>

OR combine the above two commands with:
docker rm -f <container_id>
Where {{ ic |container_id}} is the id of the container you wish to stop.

Create a new volume to allow persisting data long-term:
docker volume create <volume_name>
Where {{ ic |volume_name}} is the name the volume should use.

== Kubernetes ==

[https://kubernetes.io/ Kubernetes] is a an architecture that runs and manages docker-like containers for applications.

{{ note | This is a simplified overview of useful commands for using Kubernetes. For full official docs, see https://kubernetes.io/docs/concepts/overview/}}

=== Kubernetes Sub Parts ===

* '''Control Plane''' - Where decisions are made.
** Generally has 3 of these running, to ensure availability.
* '''Worker Node''' - A location where something might be running.
** Can have any number of these, as needed.
** Parts:
*** '''Kubletes''' - Manages one or more PODS, each POD being a group of docker-style containers.
*** '''Kube Proxy''' - Ensures communication is fluid between all parts.
*** '''Controller''' - Helps control all other aspects, to ensure it does what it's meant to.
* '''External Resources''' - Various outside resources that the '''Control Plane''' and '''Worker Nodes''' do work with.
** Ex: Storage, load balancers, etc.
* '''API''' - An interface for humans to interact with the '''Control Planes'''.
** Most interactions with the '''API''' involve telling Kubernetes "this is the state I want everything to be in". Kubernetes then figures out how to make that happen.
** Parts:
*** '''Scheduler''' - Determines what should happen, when, and where.
*** '''Controller Manager''' - Manages the controllers.
*** '''Key-Value Store''' - Effectively a "database of possible states".

=== Kubernetes Commands ===

{{ todo | Figure out common/useful commands and add here. }}

Adobe/Photoshop

2023-07-18T19:43:32Z

Brodriguez: Correct link

[https://www.adobe.com/products/photoshop.html Photoshop] is an [https://www.adobe.com/ Adobe] product made for creation and manipulation of 2D images.

Specifically, 2D pixel-based images. For 2D vector images, see [[Adobe/Illustrator | Illustrator]].

Adobe/Illustrator

2023-07-18T19:43:13Z

Brodriguez: Correct link

[https://www.adobe.com/products/illustrator.html Illustrator] is an [https://www.adobe.com/ Adobe] product made for creation and manipulation of 2D images.

Specifically, 2D vector-based images. For 2D pixel images, see [[Adobe/Photoshop | Photoshop]].

Photoshop

2023-07-18T19:42:22Z

Brodriguez: Brodriguez moved page Photoshop to Adobe/Photoshop

#REDIRECT [[Adobe/Photoshop]]

Adobe/Photoshop

2023-07-18T19:42:22Z

Brodriguez: Brodriguez moved page Photoshop to Adobe/Photoshop

Illustrator

2023-07-18T19:42:10Z

Brodriguez: Brodriguez moved page Illustrator to Adobe/Illustrator

#REDIRECT [[Adobe/Illustrator]]

Adobe/Illustrator

2023-07-18T19:42:10Z

Brodriguez: Brodriguez moved page Illustrator to Adobe/Illustrator

Other

2023-07-18T19:41:47Z

Brodriguez: Update links

Documentation for various non-programming related topics.

== Art Programs ==
* [[Adobe]]
** [[Adobe/Illustrator]]
** [[Adobe/Photoshop]]
* [[Blender]]
* [[Maya]]
* [[zBrush]]

== Engines ==
* [[Unreal Engine]]

== Music ==
* [[Music Theory]]

Adobe/Illustrator

2023-07-18T19:41:29Z

Brodriguez: Create page

Adobe/Photoshop

2023-07-18T19:40:43Z

Brodriguez: Create page

Other

2023-07-18T14:11:17Z

Brodriguez: Add links

Documentation for various non-programming related topics.

== Art Programs ==
* [[Blender]]
* [[Photoshop]]
* [[Maya]]
* [[zBrush]]

== Engines ==
* [[Unreal Engine]]

== Music ==
* [[Music Theory]]

Docker

2023-07-06T04:48:31Z

Brodriguez: Save commands

{{ todo | Page is very incomplete. Notes of learning docker/kubernetes here. }}

== Docker ==

[https://www.docker.com/ Docker] creates and runs '''containers''', which are sand-boxed processes, isolated from all other processes, with their own allocated cpu/memory/etc.

Each docker container is "meant to do exactly one thing, and do it well". So it's common to have a docker stack comprised of multiple containers. For example, one container to run your main application, and another for your database.

=== Docker Sub Parts ===

Core Parts:
* '''Image''' - A definition of docker logic, which can be spun up and run as a '''container'''.
** Due to how docker works, any number of containers can be build from this image, and it will run on any OS that supports docker.
* '''Container''' - A unique, running instance of a docker '''image'''.
** Multiple containers can be created from a single image.
* '''Volume''' - An location for docker to persist data to long-term.
** Allows data to last even as a container is started, stopped, and restarted.
** Also allows multiple containers to share a set of data, so long as the data is put into the volume.

Setup:
* '''docker-compose.yml''' - A file that defines the docker service to run.
* '''Dockerfile''' - A file that defines the actual commands the docker instance should execute once it is created, in order to setup the intended container service.

{{ todo |Are the below two commands useful? Needed?}}
These two files should be put into the same directory. Then {{ ic |cd}} into the directory and build it with {{ ic |docker-compose run}}.

Finally, start the service with {{ ic |docker-compose up -build -d}}.

=== Docker Commands ===

==== Commands to Launch Containers ====

Launch a built image as a new container instance:
docker run -d <image_name>
Where {{ ic |image_name}} - Corresponds to the name of the image you wish to create a container of.
* See below sections for additional useful optional args.

Example:
docker run -d my-cool-image

{{ warn |With the above command, data will NEVER persist long term. If the container is ever restarted or rebuilt, all data in the container will be lost. See Mounting Subsection for solutions.}}

===== Port Mapping Subsection =====

To expose ports of a container instance to the host, we use port mapping.

Command follows the format of:
-p <host>:<host_port>:<container_port>
Where:
* {{ ic |host}} - Corresponds to the host address to connect to. Often {{ ic |127.0.0.1}}.
* {{ ic |host_port}} - Corresponds to the port to use on the host machine for mapping.
* {{ ic |container_port}} - Corresponds to the port to connect to on the container.

Example:
docker run -d -p 127.0.0.1:3000:3000 my-cool-image

===== Command Mount Subsection =====

To persist data long term, we need to add some form of '''mount''' subcommand.

Volume Mount:
* '''Volume Mount''' - Allows persisting data for docker instances.
** Follows the format {{ ic |<nowiki>--mount type=volume,src=<volume_name>,target=<filepath_in_container></nowiki>}}.
*** Where:
**** {{ ic |volume_name}} - Corresponds to the name of the already-created docker '''volume''' to mount.
**** {{ ic |filepath_in_container}} - Corresponds to the filepath the volume should mount to, within the container. Ex: {{ ic |/etc/my_volume}}.

Example:
docker run -d --mount type=volume,src=my-volume,target=/etc/my_volume my-cool-image

Bind Mount:
* '''Bind Mount''' - Allows sharing data between host machine and container, via linking filepaths (similar to a [[Linux/Hard Drive Management#Sym_Links | symlink]]).
** Follows the format {{ ic |<nowiki>--mount type=bind,src=<filepath_on_host>,target=<filepath_in_container></nowiki>}}.
*** Where:
**** {{ ic |filepath_on_host}} - Corresponds to a folder located on HOST machine, to share with container.
**** {{ ic |filepath_in_container}} - Corresponds to the filepath the volume should mount to, within the container. Ex: {{ ic |/etc/my_volume}}.

Example:
docker run -d --mount type=bind,src=/srv/my_project/share_folder,target=/etc/my_volume my-cool-image

===== Command Network Subsection =====

Docker '''networks''' are used to allow containers to connect and communicate among each other.

Attach Network:
--network <network_name>
Where {{ ic |network_name}} - Is the docker virtual network to connect in.

Example:
docker run -d --network my_network my-cool-image

==== General Commands ====

List all docker containers:
docker ps

Access a given running container:
docker exec <container_id>
Where {{ ic |container_id}} is the id of the container you wish to access.

Build docker image from the {{ ic |Dockerfile}} in current directory:
docker build -t <image_name>
Where {{ ic |image_name}} is the name you wish to give the image.

Stop running docker container:
docker stop <container_id>
Where {{ ic |container_id}} is the id of the container you wish to stop.

Remove existing docker container:
docker rm <container_id>

OR combine the above two commands with:
docker rm -f <container_id>
Where {{ ic |container_id}} is the id of the container you wish to stop.

Create a new volume to allow persisting data long-term:
docker volume create <volume_name>
Where {{ ic |volume_name}} is the name the volume should use.

== Kubernetes ==

[https://kubernetes.io/ Kubernetes] is a an architecture that runs and manages docker-like containers for applications.

{{ note | This is a simplified overview of useful commands for using Kubernetes. For full official docs, see https://kubernetes.io/docs/concepts/overview/}}

=== Kubernetes Sub Parts ===

* '''Control Plane''' - Where decisions are made.
** Generally has 3 of these running, to ensure availability.
* '''Worker Node''' - A location where something might be running.
** Can have any number of these, as needed.
** Parts:
*** '''Kubletes''' - Manages one or more PODS, each POD being a group of docker-style containers.
*** '''Kube Proxy''' - Ensures communication is fluid between all parts.
*** '''Controller''' - Helps control all other aspects, to ensure it does what it's meant to.
* '''External Resources''' - Various outside resources that the '''Control Plane''' and '''Worker Nodes''' do work with.
** Ex: Storage, load balancers, etc.
* '''API''' - An interface for humans to interact with the '''Control Planes'''.
** Most interactions with the '''API''' involve telling Kubernetes "this is the state I want everything to be in". Kubernetes then figures out how to make that happen.
** Parts:
*** '''Scheduler''' - Determines what should happen, when, and where.
*** '''Controller Manager''' - Manages the controllers.
*** '''Key-Value Store''' - Effectively a "database of possible states".

=== Kubernetes Commands ===

{{ todo | Figure out common/useful commands and add here. }}

Docker

2023-07-06T03:32:45Z

Brodriguez: Add various commands and such

{{ todo | Page is very incomplete. Notes of learning docker/kubernetes here. }}

== Docker ==

[https://www.docker.com/ Docker] creates and runs '''containers''', which are sand-boxed processes, isolated from all other processes, with their own allocated cpu/memory/etc.

=== Docker Sub Parts ===

Core Parts:
* '''Image''' - A definition of docker logic, which can be spun up and run as a '''container'''.
** Due to how docker works, any number of containers can be build from this image, and it will run on any OS that supports docker.
* '''Container''' - A unique, running instance of a docker '''image'''.
** Multiple containers can be created from a single image.
* '''Volume''' - An location for docker to persist data to long-term.
** Allows data to last even as a container is started, stopped, and restarted.
** Also allows multiple containers to share a set of data, so long as the data is put into the volume.

Setup:
* '''docker-compose.yml''' - A file that defines the docker service to run.
* '''Dockerfile''' - A file that defines the actual commands the docker instance should execute once it is created, in order to setup the intended container service.

{{ todo |Are the below two commands useful? Needed?}}
These two files should be put into the same directory. Then {{ ic |cd}} into the directory and build it with {{ ic |docker-compose run}}.

Finally, start the service with {{ ic |docker-compose up -build -d}}.

=== Docker Commands ===

==== Commands to Launch Containers ====

Launch a built image as a new container instance:
docker run -dp <ports_to_map> <optional_mount_command> <image_name>
Where:
* {{ ic |ports_to_map}} corresponds to the {{ ic |HOST:PORT:PORT}} values to map the container ports to the host.
** Ex: A value of {{ ic |127.0.0.1:3000:3000 }} would map port 3000 on localhost to port 3000 on the container.
* {{ ic |optional_mount_command}} - Optional. See below for mount command explanations.
* {{ ic |image_name}} - Corresponds to the name of the image you wish to create a container of.

Example:
docker run -dp 127.0.0.1:3000:3000 my-cool-image

{{ warn |With the above command, data will NEVER persist long term. If the container is ever restarted or rebuilt, all data in the container will be lost.}}

===== Command Mount Subsection =====

To persist data long term, we need to add some form of '''mount''' subcommand.

Volume Mount:
* '''Volume Mount''' - Allows persisting data for docker instances.
** Follows the format {{ ic |<nowiki>--mount type=volume,src=<volume_name>,target=<filepath_in_container></nowiki>}}.
*** Where:
**** {{ ic |volume_name}} - Corresponds to the name of the already-created docker '''volume''' to mount.
**** {{ ic |filepath_in_container}} - Corresponds to the filepath the volume should mount to, within the container. Ex: {{ ic |/etc/my_volume}}.

Example:
docker run -dp 127.0.0.1:3000:3000 --mount type=volume,src=my-volume,target=/etc/my_volume my-cool-image

Bind Mount:
* '''Bind Mount''' - Allows sharing data between host machine and container, via linking filepaths (similar to a [[Linux/Hard Drive Management#Sym_Links | symlink]]).
** Follows the format {{ ic |<nowiki>--mount type=bind,src=<filepath_on_host>,target=<filepath_in_container></nowiki>}}.
*** Where:
**** {{ ic |filepath_on_host}} - Corresponds to a folder located on HOST machine, to share with container.
**** {{ ic |filepath_in_container}} - Corresponds to the filepath the volume should mount to, within the container. Ex: {{ ic |/etc/my_volume}}.

Example:
docker run -dp 127.0.0.1:3000:3000 --mount type=bind,src=/srv/my_project/share_folder,target=/etc/my_volume my-cool-image

==== General Commands ====

List all docker containers:
docker ps

Access a given running container:
docker exec <container_id>
Where {{ ic |container_id}} is the id of the container you wish to access.

Build docker image from the {{ ic |Dockerfile}} in current directory:
docker build -t <image_name>
Where {{ ic |image_name}} is the name you wish to give the image.

Stop running docker container:
docker stop <container_id>
Where {{ ic |container_id}} is the id of the container you wish to stop.

Remove existing docker container:
docker rm <container_id>

OR combine the above two commands with:
docker rm -f <container_id>
Where {{ ic |container_id}} is the id of the container you wish to stop.

Create a new volume to allow persisting data long-term:
docker volume create <volume_name>
Where {{ ic |volume_name}} is the name the volume should use.

== Kubernetes ==

[https://kubernetes.io/ Kubernetes] is a an architecture that runs and manages docker-like containers for applications.

{{ note | This is a simplified overview of useful commands for using Kubernetes. For full official docs, see https://kubernetes.io/docs/concepts/overview/}}

=== Kubernetes Sub Parts ===

* '''Control Plane''' - Where decisions are made.
** Generally has 3 of these running, to ensure availability.
* '''Worker Node''' - A location where something might be running.
** Can have any number of these, as needed.
** Parts:
*** '''Kubletes''' - Manages one or more PODS, each POD being a group of docker-style containers.
*** '''Kube Proxy''' - Ensures communication is fluid between all parts.
*** '''Controller''' - Helps control all other aspects, to ensure it does what it's meant to.
* '''External Resources''' - Various outside resources that the '''Control Plane''' and '''Worker Nodes''' do work with.
** Ex: Storage, load balancers, etc.
* '''API''' - An interface for humans to interact with the '''Control Planes'''.
** Most interactions with the '''API''' involve telling Kubernetes "this is the state I want everything to be in". Kubernetes then figures out how to make that happen.
** Parts:
*** '''Scheduler''' - Determines what should happen, when, and where.
*** '''Controller Manager''' - Manages the controllers.
*** '''Key-Value Store''' - Effectively a "database of possible states".

=== Kubernetes Commands ===

{{ todo | Figure out common/useful commands and add here. }}

Docker

2023-07-06T01:17:12Z

Brodriguez: Update page formatting

{{ todo | Page is very incomplete. Notes of learning docker/kubernetes here. }}

== Docker ==

The {{ ic |docker-compose.yml}} file defines the docker service to run.

The {{ ic |Dockerfile}} file defines the actual commands the docker instance should execute once it is created, in order to get our service.

These two files should be put into the same directory. Then {{ ic |cd}} into the directory and build it with {{ ic |docker-compose run}}.

Finally, start the service with {{ ic |docker-compose up -build -d}}.

== Kubernetes ==

Kubernetes is a an architecture that runs and manages docker-like containers for applications.

{{ note | This is a simplified overview of useful commands for using Kubernetes. For full official docs, see https://kubernetes.io/docs/concepts/overview/}}

=== Kubernetes Sub Parts ===

* '''Control Plane''' - Where decisions are made.
** Generally has 3 of these running, to ensure availability.
* '''Worker Node''' - A location where something might be running.
** Can have any number of these, as needed.
** Parts:
*** '''Kubletes''' - Manages one or more PODS, each POD being a group of docker-style containers.
*** '''Kube Proxy''' - Ensures communication is fluid between all parts.
*** '''Controller''' - Helps control all other aspects, to ensure it does what it's meant to.
* '''External Resources''' - Various outside resources that the '''Control Plane''' and '''Worker Nodes''' do work with.
** Ex: Storage, load balancers, etc.
* '''API''' - An interface for humans to interact with the '''Control Planes'''.
** Most interactions with the '''API''' involve telling Kubernetes "this is the state I want everything to be in". Kubernetes then figures out how to make that happen.
** Parts:
*** '''Scheduler''' - Determines what should happen, when, and where.
*** '''Controller Manager''' - Manages the controllers.
*** '''Key-Value Store''' - Effectively a "database of possible states".

=== Kubernetes Commands ===

{{ todo | Figure out common/useful commands and add here. }}

Docker

2023-07-06T00:55:55Z

Brodriguez: Add initial kubernetes section

{{ todo | Page is very incomplete. Notes of learning docker/kubernetes here. }}

== Docker ==

The {{ ic |docker-compose.yml}} file defines the docker service to run.

The {{ ic |Dockerfile}} file defines the actual commands the docker instance should execute once it is created, in order to get our service.

These two files should be put into the same directory. Then {{ ic |cd}} into the directory and build it with {{ ic |docker-compose run}}.

Finally, start the service with {{ ic |docker-compose up -build -d}}.

== Kubernetes ==

Kubernetes is a an architecture that runs and manages docker-like containers for applications.

Consists of:
* '''Control Plane''' - Where decisions are made.
** Generally has 3 of these running, to ensure availability.
* '''Worker Node''' - A location where something might be running.
** Can have any number of these, as needed.
** Parts:
*** '''Kubletes''' - Manages one or more PODS, each POD being a group of docker-style containers.
*** '''Kube Proxy''' - Ensures communication is fluid between all parts.
*** '''Controller''' - Helps control all other aspects, to ensure it does what it's meant to.
* '''External Resources''' - Various outside resources that the '''Control Plane''' and '''Worker Nodes''' do work with.
** Ex: Storage, load balancers, etc.
* '''API''' - An interface for humans to interact with the '''Control Planes'''.
** Most interactions with the '''API''' involve telling Kubernetes "this is the state I want everything to be in". Kubernetes then figures out how to make that happen.
** Parts:
*** '''Scheduler''' - Determines what should happen, when, and where.
*** '''Controller Manager''' - Manages the controllers.
*** '''Key-Value Store''' - Effectively a "database of possible states".

MediaWiki:Common.css

2023-07-06T00:40:10Z

Brodriguez: Add todo style

/* CSS placed here will be applied to all skins */

/* Styling for code snippets. */
pre, .mw-code, code {
background-color: #f5fcff;
border-color: #999999;
}

/* General styles for template boxes. */
.wiki-template-box {
padding: 5px;
margin: 0.5em;
background-color: #f8f9fa;
border: thin solid #eaecf0;
}

.wiki-template-box.tip {
background-color: #ddffdd;
border-color: #bbddbb;
}

.wiki-template-box.note {
background-color: #ddddff;
border-color: #bbbbdd;
}

.wiki-template-box.warn {
background-color: #ffdddd;
border-color: #ddbbbb;
}

.wiki-template-box.todo {
background-color: #fffcf5;
border-color: #ddbbbb;
}

Template:Todo

2023-07-06T00:38:06Z

Brodriguez: Create page

<noinclude>
== Description ==
A template used to describe WIP/unfinished content.

== Usage ==

{{bc|<nowiki>{{Todo|Something needing work updating.}}</nowiki>}}

== Example ==

{{Todo|Something needing work or updating.}}

</noinclude><includeonly><div class="wiki-template-box todo">ToDo: {{{1}}}</div></includeonly>

Docker

2023-07-05T20:00:13Z

Brodriguez: Create page

{{ todo | Page is very incomplete. Notes of learning docker here. }}

The {{ ic |docker-compose.yml}} file defines the docker service to run.

The {{ ic |Dockerfile}} file defines the actual commands the docker instance should execute once it is created, in order to get our service.

These two files should be put into the same directory. Then {{ ic |cd}} into the directory and build it with {{ ic |docker-compose run}}.

Finally, start the service with {{ ic |docker-compose up -build -d}}.

Linux

2023-07-05T19:53:50Z

Brodriguez: Add link

== General Linux Management ==
* [[Linux/User Management | User Management]]
* [[Linux/Hard Drive Management | Hard Drive Management]]
* [[Linux/Crontab | Crontab]]
* [[Linux/Screen |Screen]]
* [[Linux/Swap Space | Swap Space]]
* [[Linux/Uncomplicated Firewall | Uncomplicated Firewall]]
* [[SSH]]
* [[Linux Tar Files | Tar Files]]
* [[Linux/General Server Management | General Server Management]]

== Ubuntu ==
* [[Ubuntu Troubleshooting]]
* [[Apt-Get]]
* [[Apt-Get Packages]]
* [[Ubuntu Desktop Configuration]]

== Arch Linux ==
* [[Arch Troubleshooting]]
* [[Pacman]]
* [[Pacman Packages]]

== Other ==
* [[Docker]]
* [[VirtualBox]]

Linux

2023-05-07T01:27:42Z

Brodriguez: Correct link

Programming/Git

2023-05-07T01:26:55Z

Brodriguez: Add some additional commands

'''Git''' is the current, most common way of applying '''Version Control''' to programming projects.

Effectively, it's like making backups of your code, but doing so in a very organized way that's universally accepted by the entire programming community.

While there are plenty of different GUI interfaces for using git, it's best to learn how to use it from the command line. That way, no matter what OS or environment you're in, you'll always know what you're doing.

== Getting Started ==
If you've never used git before, I strongly recommend looking into https://learngitbranching.js.org/ before anything else.

At minimum, I recommend doing the first three lessons to get started. If you plan to do any coding with others, then the first row of the '''Remote''' lessons is also strongly encouraged.

== Installation ==

=== Windows ===
Download the latest installer from https://git-scm.com/download/win
* {{ TODO | Check current install options. }}

=== Arch Linux ===
sudo pacman -Syu git tk

=== Ubuntu ===
sudo apt update
sudo apt install git gitk

== Setup ==
Once installed on your machine, you'll need to set some default values.

The two required defaults are:
git config --global user.name '<your_name>'
git config --global user.email '<your_email>'

Where '''<your_name>''' and '''<your_email>''' are your actual first+last name, and email, surrounded by single quotes.

Optionally, you can also change the default text editor for commands like {{ ic |git commit}} via:
git config --global core.editor '<text_editor>'

Where '''<text_editor>''' is your preferred text editor, such as '''notepad''', '''nano''', or '''vim'''.

== Using Git ==
Once you get used to it, git really isn't as complicated as it might initially seem.

Having said that, here are some important concepts to keep in mind:
* Before you use any other git commands, you'll need to create or pull a git repo.
** This can be done with either the {{ ic |git init}} or {{ ic |git clone <repo_url>}} commands.
* '''Committing''' - Committing a file essentially means "saving the changes to the git repo, so that it's preserved."
* '''Staging''' - Staging a file is an intermediary step between changing the file, and committing it.
** The point of staging is that you can ensure you only commit changes you intended to add. And you can double check for typos/bugs, etc.

=== Gitk ===
'''Gitk''' is a common GUI extension to git, that can be brought up from the command line.

It shows all sorts of useful information, such as commits (with visual branch merges), who wrote the commit, date, files changed in commit, etc. Very strongly recommend learning to use.

== Git Commands ==

=== Basic Commands ===
The most basic of commands. You'll use these often.

To check the current staging status of the project:
git status

To check more detailed status of the project:
gitk

To stage a single changed file:
git add <path_to_file>

To stage all changed files and subfolders in a given folder:
git add <path_to_folder>

To stage all changed files in repo:
git add -A

To unstage a file or folder:
git reset <path_to_file_or_folder>

To create a commit of all staged files:
git commit

=== Repo Management Commands ===
Commands that aren't used often, but are essential to managing git projects long term.

To create a new git repo with the current directory as root:
git init

To set a url for the current project:
git remote add origin <git_repo_url>

To change a url for the current project:
git remote set-url origin <git_repo_url>

To push all local commits to the project url:
git push

To pull all commits that aren't yet on the local machine:
git pull

=== Branch Commands ===
Commands that pertain to managing branches. Fairly essential for larger, group projects.

To display all existing local branches:
git branch

To create a new branch using the current commit:
git branch <branch_name>

To select a different branch:
git checkout <branch_name>

To merge the contents of a different branch into the current one:
git merge <branch_name>

To delete an existing branch:
git branch -d <branch_name>

Show all known branches, including from origin:
git branch -a

Remove any local references to remote branches that are now gone:
git remote prune origin

=== Tag Commands ===
Git tags are useful placeholders which target a specific commit, giving it the project meaningful label (such as a version number) at a given place in project history.

To create a tag at the currently checked-out commit:
git tag <tag_name>

To push all created tags from local to remote:
git push --tags

To delete a tag locally:
git tag -d <tag_name>

To delete a tag on remote:
git push origin --delete <tag_name>

=== Advanced Commands ===
{{ warn | These commands can potentially break your repo or make you lose code if you don't know what you're doing. But they can be very powerful if you're comfortable with git. }}

To tell git to assume a file is unchanged (Only persists on the local machine):
git update-index --assume-unchanged <path_to_file>

To undo the above command:
git update-index --no-assume-unchanged <path_to_file>

To completely reset the project to the status of the last commit (changes will be lost!):
git reset --hard

==== Rebasing ====
Rebasing is effectively a fancy way of saying "editing previous commits".

Generally, it's fine to do if the commits you're editing are all local, and not yet pushed up to the server yet. But unless you know what you're doing, it's strongly recommended to avoid rebasing if the commits you want to edit are already pushed.

To start a rebase:
* First, look at your commit history (either via something like gitk, or exploring the online repo).
* Find the commit directly prior to the one you wish to edit. Note the first 6 or so letters and digits of the commit hash.
* In a terminal, run:
git rebase --interactive <first_6_values>

At this point, a new view will open up with your text editor of choice. It will display all commits from the current one, all the way until it finds the commit indicated by those 6 hash values.

For each commit, you can choose one of multiple options. Most common are:
* '''pick''' - Leave commit as-is. No changes. This is the default.
* '''edit''' - Select commit for editing.
* '''drop''' - Remove commit and associated changes from project.

If you selected any commits for editing, then the project will go through them, in order of oldest to newest. Make the changes you wish, stage the files with {{ ic |git add}}, and then update the commit with:
git commit --amend

Once you're done editing the commit and wish to move on, use:
git rebase --continue

==== Git Log Tree ====
This is a long command that shows the git repo tree in a terminal-friendly output:
git log --graph --simplify-by-decoration --pretty=format:'\''%d'\'' --all

Recommended to save this to the {{ ic |.bashrc}} file, such as via:
gbtree='git log --graph --simplify-by-decoration --pretty=format:'\''%d'\'' --all'
==== Repo Statistics ====
Generally speaking, these commands aren't used much. 
For example different developers will have different sizes of commits. And even if they were consistent, one person might have higher quality code than the other, which these can't measure.

Having said that, these commands may still be useful on rare occasion. More as a general approximation than a direct metric.

To see the number of total commits per author:
git shortlog -sne

To see the number of code lines updated by an author:
git log --numstat --pretty="%H" --author="<author_name>" <start_commit>..<end_commit> | awk 'NF==3 {plus+=$1; minus+=$2} END {printf("+%d, -%d\n", plus, minus)}'
* '''<author_name>''' - Should be replaced by the author's commit name. Can be seen when using the '''gitk''' command.
* '''<start_commit>''' - The hash for the commit to start checking from.
* '''<end_commit>''' - The hash for the commit to check up through.

{{ note | For the above, the first 6 or so characters of the hash should be enough. Commit hashes can be found via the '''gitk''' command. Most online repository sites (GitHub, Bitbucket, etc) also display commit hashes. }}

Linux/General Server Management

2023-05-07T01:23:06Z

Brodriguez: Add hostname values

== HostName Management ==
The '''HostName''' is the value that displays such as when connecting via an ssh terminal.

=== Display Current HostName ===

hostname

To view additional information, use:
hostnamectl

=== Change HostName ===

sudo hostnamectl set-hostname <desired_new_name>

== Datetime Management ==
These commands control what datetime your system uses.

=== View Current System Timezone ===
cat /etc/timezone

=== View Current System Date ===
date

=== Set System Timezone ===
sudo timedatectl set-timezone <timezone>

For example:
sudo timedatectl set-timezone America/New_York

Linux/Datetime Management

2023-05-07T01:20:44Z

Brodriguez: Brodriguez moved page Linux/Datetime Management to Linux/General Server Management

#REDIRECT [[Linux/General Server Management]]

Linux/General Server Management

2023-05-07T01:20:44Z

Brodriguez: Brodriguez moved page Linux/Datetime Management to Linux/General Server Management

== View Current System Timezone ==
cat /etc/timezone

== View Current System Date ==
date

== Set System Timezone ==
sudo timedatectl set-timezone <timezone>

For example:
sudo timedatectl set-timezone America/New_York

Programming/Arrays

2023-05-05T06:20:06Z

Brodriguez: test

Arrays are one of the most common data structures.

For the most basic implementation (that most languages use), arrays are a sequential block of memory, where items are placed one after another from beginning to end. In other words, you can think of an array as a sequential, non-interrupting list of items.

Specifying an index declares which item number you wish to examine in the list.

{{ Note | The first array index for most (but not all) languages will start at 0. This is contradictory to what most people expect when being introduced to arrays, who will (naturally) assume it starts at 1.}}

Generally speaking, the syntax for arrays in most languages uses [ ] (square brackets).
Ex: [1, 2, 3, 4, 5, 6, 10]

== Managing Arrays ==
Computers generally need to be explicitly told what to do. This is no exception for arrays. Thus, when an array is created, an explicit size needs to be provided so the computer understands how large to make it.

Furthermore, in most languages, each array can only hold one single data type. To be able to allocate multiple data types, either use multiple arrays or consider making an array of predefined [[Structs]].

{{ Tip | Some languages, such as JavaScript and Python are intelligent enough to handle array sizing for you, in the background. However, for most languages such as C, C#, and Java, you have to manage the size of the array yourself.}}

=== Resizing Arrays ===
Since array sizes need to be explicitly defined, they can't be arbitrarily expanded or shrunken. To change the size of an already existing array, create a new array of the desired size, then loop through the indexes of the old one and copy each value over.

For example, achieving this in C# may look as follows:
// Original array creation. Has 4 total elements, with indexes 0 through 3.
old_array = new string[4] { "Apple", "Orange", "Pineapple", "Pear" };
 
...
 
// Updating array to hold another element.
// Following the advice below, we upgrade our array to a size of 8.
new_array = new string[8];
for (int index = 0; index < old_array.Length; index++) {
new_array[index] = old_array[index];
}

Furthermore, consider keeping the array size as a power of 2. This is for two reasons:
# Due to how computer memory management works, powers of 2 tend to be the most efficient, space-wise.
# This forces creation of multiple new index values, instead of just one. That way, the array doesn't need to be recreated for each individual new index added. Instead it's recreated once in a while, and the extra indexes effectively provide a buffer for future additions.

For example, if you need an array of 5 elements, use a size of 8 (aka <math>2^3</math>).

Then, at a later date, say you hypothetically need to increase the size of this array to be four times larger (20 elements). Create a new array of size 32 (aka <math>2^5</math>), and then copy those initial 5 elements over from the original array.

== Multi-Dimensional Arrays ==
{{ Todo | Add this section. }}

Programming/Arrays

2023-05-05T06:19:59Z

Brodriguez:

test

Arrays are one of the most common data structures.

For the most basic implementation (that most languages use), arrays are a sequential block of memory, where items are placed one after another from beginning to end. In other words, you can think of an array as a sequential, non-interrupting list of items.

Specifying an index declares which item number you wish to examine in the list.

{{ Note | The first array index for most (but not all) languages will start at 0. This is contradictory to what most people expect when being introduced to arrays, who will (naturally) assume it starts at 1.}}

Generally speaking, the syntax for arrays in most languages uses [ ] (square brackets).
Ex: [1, 2, 3, 4, 5, 6, 10]

== Managing Arrays ==
Computers generally need to be explicitly told what to do. This is no exception for arrays. Thus, when an array is created, an explicit size needs to be provided so the computer understands how large to make it.

Furthermore, in most languages, each array can only hold one single data type. To be able to allocate multiple data types, either use multiple arrays or consider making an array of predefined [[Structs]].

{{ Tip | Some languages, such as JavaScript and Python are intelligent enough to handle array sizing for you, in the background. However, for most languages such as C, C#, and Java, you have to manage the size of the array yourself.}}

=== Resizing Arrays ===
Since array sizes need to be explicitly defined, they can't be arbitrarily expanded or shrunken. To change the size of an already existing array, create a new array of the desired size, then loop through the indexes of the old one and copy each value over.

For example, achieving this in C# may look as follows:
// Original array creation. Has 4 total elements, with indexes 0 through 3.
old_array = new string[4] { "Apple", "Orange", "Pineapple", "Pear" };
 
...
 
// Updating array to hold another element.
// Following the advice below, we upgrade our array to a size of 8.
new_array = new string[8];
for (int index = 0; index < old_array.Length; index++) {
new_array[index] = old_array[index];
}

Furthermore, consider keeping the array size as a power of 2. This is for two reasons:
# Due to how computer memory management works, powers of 2 tend to be the most efficient, space-wise.
# This forces creation of multiple new index values, instead of just one. That way, the array doesn't need to be recreated for each individual new index added. Instead it's recreated once in a while, and the extra indexes effectively provide a buffer for future additions.

For example, if you need an array of 5 elements, use a size of 8 (aka <math>2^3</math>).

Then, at a later date, say you hypothetically need to increase the size of this array to be four times larger (20 elements). Create a new array of size 32 (aka <math>2^5</math>), and then copy those initial 5 elements over from the original array.

== Multi-Dimensional Arrays ==
{{ Todo | Add this section. }}

Programming/C/Memory Model

2023-04-23T02:47:39Z

Brodriguez: Add more about pointers

Both [[ Programming/C | C]] and [[ Programming/C++ | C++]] force the programmer to manage pointers and memory.

This is a manual process. This is also both a blessing and a curse.

On one hand, the programmer can potentially manage references and variable/object deconstruction (aka, what many languages refer to as "garbage collection") much better than any language that has garbage collection built-in and handled automagically. 
In other words, a given [[ Programming/C | C]]/[[ Programming/C++ | C++]] program can potentially be magnitudes more efficient.

On the other hand, if not careful, or if they don't know what they're doing, a programmer can introduce many bugs and unintentional problems by incorrect manual garbage collection. 
A set of memory can be allocated that's too small. So memory references overlap and garble data. Or data can be forgotten about, potentially hanging in memory and taking up space far far longer than it would have been around with automatic garbage collection.

Pointers and memory management is one of the biggest differences between C/C++ and any other language.

== Computer Memory ==

A computer's memory is a series of locations called '''addresses'''. Each memory address:
* Can contain a set amount of data, represented as a given amount of 1's and 0's.
* Is represented with a unique identifier number.

{{ todo | Document binary, at least basics. }}

The 1's and 0's are called '''Binary'''. The computer automatically converts data to binary to store it in memory, and then back to the original format, so we as humans can understand it. Similarly, the computer will automatically determine the unique identifiers that correspond to each address space.

So while it's potentially useful to understand these underlying concepts, we as programmers don't (usually) need to directly deal with these concepts.

{{ Note | For very large pieces of data, we can chain together memory addresses to store more information. Thus, different addresses have varying sizes. }}

== Stack Memory Vs Heap Memory ==

=== Stack ===

The '''stack''' is a contiguous section of memory that contains memory for local variables. Every program has a unique stack generated at runtime.

It is called "the stack" because variables are placed in stack-order. 
Aka, a program starts, and the {{ ic |main()}} function (as well as any corresponding local variables) are immediately placed on the stack. 
Any time another function is called, that is placed directly on top of the current existing stack (along with any corresponding local variables for that function).

In this way, when a function is done executing, it will always be on the top of the stack, and will thusly be popped off the stack, as it is no longer required.

This process repeats until all functions for the program have completed, and the program's {{ ic |main()}} function finally terminates.

Due to how this works, the stack size for any given function is known at compile time. This memory is allocated at application start up.

A '''Stack Overflow''' error is when functions on the stack nest too deep, and the application runs out of the stack memory that was assigned at program startup.

=== Heap ===

The '''heap''' is a section of memory that allows variables to be dynamically allocated during runtime. This is done via calls with the {{ ic |new}} keyword, {{ ic |malloc()}} calls, or other similar functions.

Note that, unlike the stack, everything in the heap is manually allocated by the programmer.

Similarly, it everything in the heap should be manually unallocated when no longer used. Any instance when a program does NOT release allocated heap memory is a memory leak.

As long as the OS has enough memory available, memory of any size can be allocated.

== Pointers ==

A '''pointer''' is simply a variable that says "there is something here at this specific location in memory, and I expect it to be of x size."

In other words, pointers are references to specific locations in memory. Any value can have a pointer created for it, regardless of it the value is on the stack or heap.

The actual size of a pointer depends on the OS. For example, in a 64-bit OS, the pointer is really just a 64-bit unsigned integer.

When possible, it's better to pass pointers around, as it's faster to pass a pointer than, say a whole class object. Aka, pointers are often preferable to copying a value.

=== Implicit Vs Explicit References ===

Pointers are defined by using the {{ ic |*}} character after the variable type. We can also get the memory location of a value by using the {{ ic |&}} character before a variable.

This is an '''implicit''' example. In this code, it will look like and be treated as if it were a standard variable.
// Create int with value of "5".
int my_int = 5;

// Create pointer to above int.
int& my_pointer = my_int;

// We can then reference as if it were any standard variable.
printf("%d", my_pointer);

This is an '''explicit''' example. In this code, it will look like and be treated as a pointer.
// Create int with value of "5".
int my_int = 5;

// Create pointer to above int.
int* my_pointer = &my_int;

// We must then use pointer syntax to actually get our value.
printf("%d", *my_pointer);

{{ warn |If you ever have a variable on the heap (created via {{ ic |new}}, {{ ic |malloc()}}, or similar)}} that no longer has a pointer referencing it, then that is a memory leak}}.

== Misc Advice ==

* Be careful when copying any non-trivial variables, such as classes.
** Any class variables such as pointers will be copied as-is. This means when the copy is destroyed, the pointer is de-referenced for all classes.
** This would then potentially cause errors for any other copies (or the original) when trying to access the pointer or deconstruct those as well.
* With classes, it's generally best to define manually constructors and deconstructors. This can, for example, help avoid the above problem, as well as other potential problems.

Programming/C/Memory Model

2023-04-23T01:53:40Z

Brodriguez: Update page

Both [[ Programming/C | C]] and [[ Programming/C++ | C++]] force the programmer to manage pointers and memory.

This is a manual process. This is also both a blessing and a curse.

On one hand, the programmer can potentially manage references and variable/object deconstruction (aka, what many languages refer to as "garbage collection") much better than any language that has garbage collection built-in and handled automagically. 
In other words, a given [[ Programming/C | C]]/[[ Programming/C++ | C++]] program can potentially be magnitudes more efficient.

On the other hand, if not careful, or if they don't know what they're doing, a programmer can introduce many bugs and unintentional problems by incorrect manual garbage collection. 
A set of memory can be allocated that's too small. So memory references overlap and garble data. Or data can be forgotten about, potentially hanging in memory and taking up space far far longer than it would have been around with automatic garbage collection.

Pointers and memory management is one of the biggest differences between C/C++ and any other language.

== Computer Memory ==

A computer's memory is a series of locations called '''addresses'''. Each memory address:
* Can contain a set amount of data, represented as a given amount of 1's and 0's.
* Is represented with a unique identifier number.

{{ todo | Document binary, at least basics. }}

The 1's and 0's are called '''Binary'''. The computer automatically converts data to binary to store it in memory, and then back to the original format, so we as humans can understand it. Similarly, the computer will automatically determine the unique identifiers that correspond to each address space.

So while it's potentially useful to understand these underlying concepts, we as programmers don't (usually) need to directly deal with these concepts.

{{ Note | For very large pieces of data, we can chain together memory addresses to store more information. Thus, different addresses have varying sizes. }}

== Stack Memory Vs Heap Memory ==

=== Stack ===

The '''stack''' is a contiguous section of memory that contains memory for local variables. Every program has a unique stack generated at runtime.

It is called "the stack" because variables are placed in stack-order. 
Aka, a program starts, and the {{ ic |main()}} function (as well as any corresponding local variables) are immediately placed on the stack. 
Any time another function is called, that is placed directly on top of the current existing stack (along with any corresponding local variables for that function).

In this way, when a function is done executing, it will always be on the top of the stack, and will thusly be popped off the stack, as it is no longer required.

This process repeats until all functions for the program have completed, and the program's {{ ic |main()}} function finally terminates.

Due to how this works, the stack size for any given function is known at compile time. This memory is allocated at application start up.

A '''Stack Overflow''' error is when functions on the stack nest too deep, and the application runs out of the stack memory that was assigned at program startup.

=== Heap ===

The '''heap''' is a section of memory that allows variables to be dynamically allocated during runtime. This is done via calls with the {{ ic |new}} keyword, {{ ic |malloc()}} calls, or other similar functions.

Note that, unlike the stack, everything in the heap is manually allocated by the programmer.

Similarly, it everything in the heap should be manually unallocated when no longer used. Any instance when a program does NOT release allocated heap memory is a memory leak.

As long as the OS has enough memory available, memory of any size can be allocated.

== Pointers ==

A '''pointer''' is simply a variable that says "there is something here at this specific location in memory, and I expect it to be of x size."

In other words, pointers are references to specific locations in memory. Any value can have a pointer created for it, regardless of it the value is on the stack or heap.

== Misc Advice ==

* Be careful when copying any non-trivial variables, such as classes.
** Any class variables such as pointers will be copied as-is. This means when the copy is destroyed, the pointer is de-referenced for all classes.
** This would then potentially cause errors for any other copies (or the original) when trying to access the pointer or deconstruct those as well.
* With classes, it's generally best to define manually constructors and deconstructors. This can, for example, help avoid the above problem, as well as other potential problems.

Programming/C/Memory Model

2023-04-22T20:33:09Z

Brodriguez: Expand page

Programming/C Sharp

2023-04-22T19:54:53Z

Brodriguez: Add some notes

C# is a higher level version of C. It was designed by Microsoft, and for the longest time, was generally only supported on Windows.

It's used often in large, enterprise/business scale projects, due to having solid scaffolding for enforcing consistency through the project, which allows many people to work on a given project with less maintenance overhead. This is accomplished via things like required strong typing and good support for the [[interface class]] structure.

== Other ==

* Classes are always passes by reference.
* Structs and value types (when not part of a class) are always passed by value.

== Comments ==

=== Inline Comments ===
// This is an inline comment.

=== Block Comments ===
Because there is minimal difference in C# between inline and block comments, these are really only useful when declared above a class or function declaration line.

This is because C# knows to treat this as documentation and adds special logic around it. For example, hovering over a class instantiation will display the block comment data for that class.

/// This is a block comment.
/// Comment line 2.
/// Another block comment line.

=== Block/Region Declaration ===
Regions are used for organizational purposes, and allow for code folding at the click of a button. To be useful, both the start and end must be declared.

#region MyRegionName
 
...
 
#endregion MyRegionName

== Variables ==
Variables are strongly typed in C#. That means that you must declare the type (bool, int, string, etc) as well as the variable name.

=== Variable Definition ===
bool a_bool = true;
bool b_bool = false;
string my_var_1 = "This is ";
string my_var_2 = "a string.";

=== Variable Usage ===
Console.WriteLine("Printing variable values.");
Console.WriteLine(a_bool);
Console.WriteLine(b_bool);
Console.WriteLine(my_var_1 + my_var_2);

=== Variable Casting ===
Variables will be treated as the originally indicated type until a cast statement is used.

For example, to convert a boolean to an int, use:
bool a_bool = true;
int converted_bool = Convert.ToInt32(a_bool);

== If Statements ==

=== Basic If ===
if (x == y)
{
// Logic if true.
}

=== Full If ===
if (x == y)
{
// Logic if true.
} else if ( x && (y || z) )
{
// Logic for "else if" true.
} else
{
// Logic for false.
}

=== Switch/Case Statements ===
switch (my_var)
{
case "1":
// Logic for case value of "1".
break;
case "a":
// Logic for case value of "a".
break;
case "test":
// Logic for case value of "test".
break;
default:
// Logic for no match.
break;
}

== Functions ==
Functions in C# are syntactically handled similarly to C, with a few modifications. The format is:
<accessibility> <return_type> <function_name>(<args>)
{
// Function logic here.
}

For example:
public void MyFunc(int my_int, string my_string)
{
// Function logic here.
}

=== Accessibility ===
Accessibility levels indicate what can and cannot access the given variable or function. The most types are as follows:

{{ note | See [https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/accessibility-levels this link] to see the all levels in the Microsoft docs. }}
* <code>public</code> - Anything can access it.
* <code>protected</code> - This class and all inheriting children can access it.
* <code>private</code> - Only this class can access it. Not even inheriting children have access.

=== Return Type ===
The return type is exactly that. Aka, the type of the variable that the function returns on function exit. If a variable does not return anything, then the type of <code>void</code> type.

== Basic Data structures ==

=== Arrays ===
Arrays are one of the most common data structures. See [[Arrays]] for more info.

In C#, all indexes for a given array must hold the same data type.

==== Declaring Arrays ====
Declare an array by specifying the type, followed by brackets, followed by the array name.
string[] my_array;

Then we can initialize the array by declaring the number of indexes. For example, to declare 4 indexes, use:
my_array = new string[4];

If you want to initialize with pre-populated values, you can take it a step further with something like:
my_array = new string[4] { "Index 0", "Index 1", "Some String Value", "Final Index" };

Finally, note that you can combine declaration and initialization into one line.

==== Accessing Array Values ====
The syntax to access an array is as follows:
// Update index 1.
my_array[1] = "Test Index 1";
// Read index 1.
Console.WriteLine(my_array[1]);

To access all array indexes in order, use a standard for loop.
for (int index = 0; index < my_array.Length; index++)
{
Console.WriteLine(my_array[index]);
}

=== Dictionaries ===
Dictionaries can be incredibly powerful. See [[Dictionaries]] for more info.

==== Declaring Dictionaries ====
Similarly to C# arrays, once the data type is declared in a dictionary, it cannot be changed. However, note that "keys" and "values" in a dictionary can each hold a different, unique data type.

For example, to declare a dictionary of string keys and int values, use:
Dictionary<string, int> my_dict = new Dictionary<string, int>();

==== Accessing Dictionary Values ====
To set new key-value pairs, use:
my_dict.Add(<key>, <value>);

To read an existing key-value pair, use:
my_dict[<key>]

To update an existing key-value pair, use:
my_dict[<key>] = <updated_value>;

To remove an existing key-value pair, use:
my_dict.Remove(<key>);

==== Example ====
Here's an example of a dictionary for a hypothetical business trying to track count of items sold.

// Create our dict.
Dictionary<string, int> product_sold = new Dictionary<string, int>();
 
// Add initial values.
product_sold.Add("Ice Cream", 50);
product_sold.Add("Burgers", 56);
product_sold.Add("Pizza", 102);
 
// Sold another pizza. Update value.
product_sold["Pizza"] += 1;

=== Structs ===
Structs are essentially a means to group sets of variables together. They are handled very similarly to C structs.

Unlike C# arrays or dicts, structs are able to combine as many variable types as desired.

==== Struct Declaration ====
First, declare the struct type itself. 
If familiar with classes, this will look a lot like declaring a simplified class that has only class variables and nothing else.
struct MyStructObject
{
public bool test_bool;
public int test_int;
public string test_string;
}

Once the struct type is declared, we can create instances of it to use.
MyStructObject a_struct = new MyStructObject();

==== Accessing Struct Items ====
Structs are basically containers for holding the associated variables within. Thus, we can easily access the contained variables with syntax that should look fairly familiar.
// Set or update struct values.
a_struct.test_bool = true;
a_struct.test_int = 5;
a_struct.test_string = "My test string";
 
// Print struct values.
Console.WriteLine(a_struct.test_bool);
Console.WriteLine(a_struct.test_int);
Console.WriteLine(a_struct.test_string);

== Classes ==
A class can be thought of as a struct that can have functions built into it.

Classes are generally defined in new, separate files. A good rule of thumb is to only include multiple classes in one file if they are nested, inner subclasses within the first class.

{{ note | In C#, class variables and methods are often called with <code>this.<value></code>, to help differentiate between local and class level values. However, this is optional and will not always be followed. }}

=== Class Variables ===
To declare class level variables, declare the variable name and type in the class, but don't assign to it.

For organization, it's recommended to do this at the very top of the class, and enclose it within a region.

class MyClass
{
#region Variables
 
bool test_bool;
int test_int;
string test_string;
 
#endregion Variables
 
...
}

=== Constructor ===
A constructor is essentially the logic that's ran on class instantiation.

To declare a constructor, declare a method with the same name as the class and <code>public</code> accessibility.

If your class needs to be able to handle multiple possible sets of passed arguments, then create one constructor for each.

For example, this is a constructor for a class that takes 0 arguments.
class MyClass
{
...
 
public MyClass()
{
// Constructor logic here.
}
 
...
}

=== Properties ===
Properties are a "safer" way to read (get) and update (set) class variables.

Effectively, properties are functions that handle a single variable, and allow for custom logic to clean/validate your variable before saving it to the class or returning it for use outside of the class.

Minimum property syntax (to both set and get) is as follows:
class MyClass
{
#region Variables
 
string test_string;
 
#endregion Variables
 
...
 
public string TestString
{
get { return this.test_string; }
set { this.test_string = value; }
}
 
...
}

If we want to expand this to show how it can be useful, we can validate our value first.
class MyClass
{
#region Variables
 
string test_string;
 
#endregion Variables
 
...
 
public string TestString
{
get
{
// First check if our string is a known bad value.
if (this.test_string == "I'm an invalid value, ohno!")
{
// Invalid value detected! Return something else as a fallback.
return "Default string value."
} else
{
// If we got here, then the string is valid. Return that.
return this.test_string;
}
}
set
{
// Check if our provided value is valid before setting.
// In this case, we simply make sure it's 3 characters or greater.
if (this.test_string.Length > 2)
{
this.test_string = value;
}
}
}
 
...
}

=== Class Functions ===
Class functions are declared and handled the same way as any other C# function. See functions section.

Programming/C/Memory Model

2023-04-22T19:15:33Z

Brodriguez: Import memory sections for C++ page

Programming/C++

2023-04-22T19:12:39Z

Brodriguez: Further update page links

== General C/C++ Shared Pages ==
* [[Programming/C++/Compiling Code | Compiling Code]]
* [[Programming/C++/Memory Model | Memory Model]]

== C++ SubPages ==
* [[Programming/C++/Syntax | Syntax]]
* [[Programming/C++/Pointers and Memory Management | Pointers and Memory Management]]
* [[Programming/C++/Objects and Data Structures | Objects and Data Structures]]
* [[Programming/C++/Headers and File Including | Headers and File Including]]

== Compiling C++ ==
To run any C++ code, it must first be compiled.

To do this, in terminal, cd to the desired directory and run {{ ic |g++ <path_to_file> -o <name_of_file_to_create>}}.

This will generate a new executable file, based on the compiled code. 
Run this file via {{ ic |./<name_of_created_file>}}.

For further details of how the compilation process works, see [[Programming/C++/Compiling Code | Compiling Code]].

== Types of Errors ==

* Compile Time Errors - Errors that happen during file compile.
** Syntax Errors - Errors that happen from incorrect typed syntax for the given language.
** Type Errors - Errors that happen due to mismatch of declared type and attempted type usage.
* Link Time Errors - Errors that happen when trying to combine compiled files into a single executable program.
** Ex: Using a function that was never defined, or {{ ic |Main()}} instead of {{ ic |main()}}.
* Run Time Errors - Errors that happen during program execution.
** Ex: Divide-by-zero errors, or attempting to open a file mid-runtime and said file doesn't exist.
* Logic Errors - Soft errors that don't cause an actual crash. But can cause a program soft-lock, or general unintended behavior.

Programming/C++

2023-04-22T19:06:49Z

Brodriguez: Update page links

== General C/C++ Shared Pages ==
* [[Programming/C++/Compiling Code | Compiling Code]]
* [[Programming/C++/Memory Model | Memory Model]]

== C++ SubPages ==
* [[C++/Syntax]]
* [[C++/Pointers and Memory Management]]
* [[C++/Objects and Data Structures]]
* [[C++/Headers and File Including]]

== Compiling C++ ==
To run any C++ code, it must first be compiled.

To do this, in terminal, cd to the desired directory and run {{ ic |g++ <path_to_file> -o <name_of_file_to_create>}}.

This will generate a new executable file, based on the compiled code. 
Run this file via {{ ic |./<name_of_created_file>}}.

== Types of Errors ==

* Compile Time Errors - Errors that happen during file compile.
** Syntax Errors - Errors that happen from incorrect typed syntax for the given language.
** Type Errors - Errors that happen due to mismatch of declared type and attempted type usage.
* Link Time Errors - Errors that happen when trying to combine compiled files into a single executable program.
** Ex: Using a function that was never defined, or {{ ic |Main()}} instead of {{ ic |main()}}.
* Run Time Errors - Errors that happen during program execution.
** Ex: Divide-by-zero errors, or attempting to open a file mid-runtime and said file doesn't exist.
* Logic Errors - Soft errors that don't cause an actual crash. But can cause a program soft-lock, or general unintended behavior.

C++/Memory Model

2023-04-22T19:05:48Z

Brodriguez: Changed redirect target from C/Memory Model to Programming/C/Memory Model

#REDIRECT [[Programming/C/Memory Model]]

C/Memory Model

2023-04-22T19:05:28Z

Brodriguez: Changed redirect target from Programming/C++/Memory Model to Programming/C/Memory Model

#REDIRECT [[Programming/C/Memory Model]]

C++/Compiling Code

2023-04-22T19:05:12Z

Brodriguez: Changed redirect target from C/Compiling Code to Programming/C/Compiling Code

#REDIRECT [[Programming/C/Compiling Code]]

C/Compiling Code

2023-04-22T19:04:49Z

Brodriguez: Changed redirect target from Programming/C++/Compiling Code to Programming/C/Compiling Code

#REDIRECT [[Programming/C/Compiling Code]]

Programming/C++/Compiling Code

2023-04-22T19:04:22Z

Brodriguez: Brodriguez moved page Programming/C++/Compiling Code to Programming/C/Compiling Code

#REDIRECT [[Programming/C/Compiling Code]]

Programming/C/Compiling Code

2023-04-22T19:04:22Z

Brodriguez: Brodriguez moved page Programming/C++/Compiling Code to Programming/C/Compiling Code

TODO: Populate page

Programming/C++/Memory Model

2023-04-22T19:04:21Z

Brodriguez: Brodriguez moved page Programming/C++/Memory Model to Programming/C/Memory Model

#REDIRECT [[Programming/C/Memory Model]]

Programming/C/Memory Model

2023-04-22T19:04:21Z

Brodriguez: Brodriguez moved page Programming/C++/Memory Model to Programming/C/Memory Model

TODO: Populate page

C/Memory Model

2023-04-22T19:04:07Z

Brodriguez: Brodriguez moved page C/Memory Model to Programming/C++/Memory Model

#REDIRECT [[Programming/C++/Memory Model]]

Programming/C/Memory Model

2023-04-22T19:04:07Z

Brodriguez: Brodriguez moved page C/Memory Model to Programming/C++/Memory Model

TODO: Populate page

C/Compiling Code

2023-04-22T19:03:56Z

Brodriguez: Brodriguez moved page C/Compiling Code to Programming/C++/Compiling Code

#REDIRECT [[Programming/C++/Compiling Code]]