Setting Up a Development Workstation on Rocky Linux

Rocky Linux provides an excellent foundation for a development workstation, offering enterprise-grade stability with access to modern development tools. This comprehensive guide will walk you through transforming a fresh Rocky Linux installation into a fully-equipped development powerhouse, complete with programming languages, IDEs, databases, containers, and essential developer tools.

Prerequisites and System Preparation
Essential Development Tools
Programming Languages and Runtimes
Integrated Development Environments
Version Control Systems
Database Systems
Container and Virtualization Tools
Web Development Tools
DevOps and Cloud Tools
System Optimization for Development
Security Considerations
Productivity Tools and Utilities

Prerequisites and System Preparation

System Requirements

For an optimal development experience, ensure your system meets these requirements:

CPU: Minimum 4 cores, 8+ cores recommended
RAM: Minimum 8GB, 16GB+ recommended
Storage: 100GB+ SSD recommended
Graphics: Dedicated GPU beneficial for ML/AI development
Network: Stable internet connection

Initial System Update

# Update system packages
sudo dnf update -y

# Enable EPEL repository
sudo dnf install -y epel-release

# Enable PowerTools/CRB repository
sudo dnf config-manager --set-enabled crb

# Install development tools group
sudo dnf groupinstall -y "Development Tools"

# Install essential packages
sudo dnf install -y \
    kernel-devel \
    kernel-headers \
    dkms \
    cmake \
    gcc-c++ \
    make \
    automake \
    autoconf \
    libtool \
    pkg-config

Configure User Environment

# Create development directories
mkdir -p ~/Development/{projects,scripts,configs,tools}
mkdir -p ~/.local/{bin,share,lib}

# Add local bin to PATH
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc

# Set default editor
echo 'export EDITOR=vim' >> ~/.bashrc
echo 'export VISUAL=vim' >> ~/.bashrc

# Source the updated bashrc
source ~/.bashrc

Essential Development Tools

Build Essentials

# Install build dependencies
sudo dnf install -y \
    binutils \
    elfutils-libelf-devel \
    glibc-devel \
    glibc-headers \
    libstdc++-devel \
    zlib-devel \
    openssl-devel \
    readline-devel \
    sqlite-devel \
    bzip2-devel \
    libffi-devel \
    xz-devel

Terminal Enhancements

# Install modern terminal tools
sudo dnf install -y \
    tmux \
    screen \
    htop \
    neovim \
    fish \
    zsh \
    bat \
    exa \
    fd-find \
    ripgrep \
    fzf

# Install Oh My Zsh (optional)
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

# Configure tmux
cat > ~/.tmux.conf << 'EOF'
# Enable mouse support
set -g mouse on

# Set prefix to Ctrl-a
unbind C-b
set-option -g prefix C-a
bind-key C-a send-prefix

# Split panes using | and -
bind | split-window -h
bind - split-window -v
unbind '"'
unbind %

# Switch panes using Alt-arrow
bind -n M-Left select-pane -L
bind -n M-Right select-pane -R
bind -n M-Up select-pane -U
bind -n M-Down select-pane -D

# Enable 256 colors
set -g default-terminal "screen-256color"
EOF

Shell Productivity

# Install shell enhancement tools
sudo dnf install -y \
    bash-completion \
    ShellCheck \
    jq \
    yq \
    httpie \
    curl \
    wget \
    tree \
    ncdu \
    tig

# Configure useful aliases
cat >> ~/.bashrc << 'EOF'
# Development aliases
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'
alias dev='cd ~/Development/projects'
alias ..='cd ..'
alias ...='cd ../..'
alias grep='grep --color=auto'
alias df='df -h'
alias du='du -h'
alias free='free -h'

# Git aliases
alias gs='git status'
alias ga='git add'
alias gc='git commit'
alias gp='git push'
alias gl='git log --oneline --graph'
alias gd='git diff'
EOF

Programming Languages and Runtimes

Python Development

# Install Python 3 and pip
sudo dnf install -y python3 python3-pip python3-devel

# Install Python build dependencies
sudo dnf install -y \
    python3-setuptools \
    python3-wheel \
    python3-virtualenv \
    python3-pytest

# Install pyenv for Python version management
curl https://pyenv.run | bash

# Add pyenv to PATH
cat >> ~/.bashrc << 'EOF'
export PYENV_ROOT="$HOME/.pyenv"
command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"
EOF

source ~/.bashrc

# Install multiple Python versions
pyenv install 3.9.18
pyenv install 3.10.13
pyenv install 3.11.7
pyenv install 3.12.1

# Set global Python version
pyenv global 3.11.7

# Install essential Python packages
pip install --user \
    pipenv \
    poetry \
    black \
    flake8 \
    mypy \
    pytest \
    ipython \
    jupyter \
    pandas \
    numpy \
    requests

Node.js and JavaScript

# Install Node.js via NodeSource repository
curl -fsSL https://rpm.nodesource.com/setup_lts.x | sudo bash -
sudo dnf install -y nodejs

# Install Yarn package manager
sudo npm install -g yarn

# Install pnpm
sudo npm install -g pnpm

# Install essential global packages
sudo npm install -g \
    typescript \
    @types/node \
    nodemon \
    pm2 \
    eslint \
    prettier \
    webpack \
    webpack-cli \
    @angular/cli \
    @vue/cli \
    create-react-app \
    express-generator

# Install nvm for Node version management
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

# Add nvm to PATH
cat >> ~/.bashrc << 'EOF'
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"
EOF

source ~/.bashrc

Go Development

# Download and install Go
GO_VERSION="1.21.6"
wget https://go.dev/dl/go${GO_VERSION}.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go${GO_VERSION}.linux-amd64.tar.gz
rm go${GO_VERSION}.linux-amd64.tar.gz

# Configure Go environment
cat >> ~/.bashrc << 'EOF'
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export PATH=$GOPATH/bin:$GOROOT/bin:$PATH
EOF

source ~/.bashrc

# Install Go tools
go install golang.org/x/tools/gopls@latest
go install golang.org/x/tools/cmd/goimports@latest
go install github.com/go-delve/delve/cmd/dlv@latest
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

Rust Development

# Install Rust via rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Add Rust to PATH
source "$HOME/.cargo/env"

# Install additional Rust tools
rustup component add rustfmt
rustup component add clippy
rustup component add rust-src
rustup component add rust-analyzer

# Install useful cargo extensions
cargo install cargo-edit
cargo install cargo-watch
cargo install cargo-audit
cargo install cargo-outdated

Java Development

# Install OpenJDK versions
sudo dnf install -y \
    java-11-openjdk-devel \
    java-17-openjdk-devel \
    java-21-openjdk-devel

# Install Maven
sudo dnf install -y maven

# Install Gradle
GRADLE_VERSION="8.5"
wget https://services.gradle.org/distributions/gradle-${GRADLE_VERSION}-bin.zip
sudo unzip -d /opt gradle-${GRADLE_VERSION}-bin.zip
sudo ln -s /opt/gradle-${GRADLE_VERSION} /opt/gradle
rm gradle-${GRADLE_VERSION}-bin.zip

# Configure JAVA_HOME and Gradle
cat >> ~/.bashrc << 'EOF'
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk
export GRADLE_HOME=/opt/gradle
export PATH=$GRADLE_HOME/bin:$PATH
EOF

source ~/.bashrc

C/C++ Development

# Install C/C++ compilers and tools
sudo dnf install -y \
    gcc \
    gcc-c++ \
    clang \
    clang-tools-extra \
    llvm \
    llvm-devel \
    gdb \
    valgrind \
    cmake \
    ninja-build \
    ccache

# Install C/C++ libraries
sudo dnf install -y \
    boost-devel \
    gtest-devel \
    benchmark-devel

Integrated Development Environments

Visual Studio Code

# Import Microsoft GPG key
sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc

# Add VS Code repository
sudo sh -c 'echo -e "[code]\nname=Visual Studio Code\nbaseurl=https://packages.microsoft.com/yumrepos/vscode\nenabled=1\ngpgcheck=1\ngpgkey=https://packages.microsoft.com/keys/microsoft.asc" > /etc/yum.repos.d/vscode.repo'

# Install VS Code
sudo dnf check-update
sudo dnf install -y code

# Install essential extensions via command line
code --install-extension ms-python.python
code --install-extension ms-vscode.cpptools
code --install-extension golang.go
code --install-extension rust-lang.rust-analyzer
code --install-extension redhat.java
code --install-extension vscjava.vscode-java-pack
code --install-extension ms-vscode-remote.remote-ssh
code --install-extension ms-azuretools.vscode-docker
code --install-extension eamodio.gitlens
code --install-extension esbenp.prettier-vscode
code --install-extension dbaeumer.vscode-eslint

JetBrains Toolbox

# Download JetBrains Toolbox
wget -O jetbrains-toolbox.tar.gz "https://data.services.jetbrains.com/products/download?platform=linux&code=TBA"

# Extract and install
sudo tar -xzf jetbrains-toolbox.tar.gz -C /opt
sudo ln -s /opt/jetbrains-toolbox-*/jetbrains-toolbox /usr/local/bin/jetbrains-toolbox

# Clean up
rm jetbrains-toolbox.tar.gz

# Run JetBrains Toolbox to install IDEs
jetbrains-toolbox

Vim/Neovim Configuration

# Install Neovim
sudo dnf install -y neovim

# Install vim-plug for Neovim
sh -c 'curl -fLo "${XDG_DATA_HOME:-$HOME/.local/share}"/nvim/site/autoload/plug.vim --create-dirs \
       https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'

# Create Neovim configuration
mkdir -p ~/.config/nvim
cat > ~/.config/nvim/init.vim << 'EOF'
" Plugins
call plug#begin('~/.vim/plugged')
Plug 'neoclide/coc.nvim', {'branch': 'release'}
Plug 'preservim/nerdtree'
Plug 'vim-airline/vim-airline'
Plug 'tpope/vim-fugitive'
Plug 'airblade/vim-gitgutter'
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'
Plug 'morhetz/gruvbox'
call plug#end()

" Basic settings
set number
set relativenumber
set expandtab
set tabstop=4
set shiftwidth=4
set smartindent
set wrap
set ignorecase
set smartcase
set hlsearch
set incsearch
set termguicolors
set scrolloff=8
set updatetime=50

" Theme
colorscheme gruvbox
set background=dark

" Key mappings
let mapleader = " "
nnoremap <leader>pv :NERDTreeToggle<CR>
nnoremap <leader>pf :Files<CR>
nnoremap <leader>pg :Rg<CR>
EOF

# Install plugins
nvim +PlugInstall +qall

Version Control Systems

Git Configuration

# Install Git and related tools
sudo dnf install -y git git-lfs gitk git-gui

# Configure Git
git config --global user.name "Your Name"
git config --global user.email "[email protected]"
git config --global init.defaultBranch main
git config --global core.editor "vim"
git config --global color.ui auto

# Set up useful Git aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual '!gitk'

# Configure Git credentials
git config --global credential.helper store

# Install GitHub CLI
sudo dnf install -y gh

# Install GitLab CLI
curl -L "https://gitlab.com/gitlab-org/cli/-/releases/v1.36.0/downloads/glab_1.36.0_Linux_x86_64.tar.gz" | tar xz
sudo mv bin/glab /usr/local/bin/

Git Flow and Tools

# Install git-flow
sudo dnf install -y gitflow

# Install tig (text-mode interface for Git)
sudo dnf install -y tig

# Install lazygit
LAZYGIT_VERSION=$(curl -s "https://api.github.com/repos/jesseduffield/lazygit/releases/latest" | grep -Po '"tag_name": "v\K[^"]*')
curl -Lo lazygit.tar.gz "https://github.com/jesseduffield/lazygit/releases/latest/download/lazygit_${LAZYGIT_VERSION}_Linux_x86_64.tar.gz"
tar xf lazygit.tar.gz lazygit
sudo install lazygit /usr/local/bin
rm lazygit.tar.gz lazygit

Database Systems

PostgreSQL

# Install PostgreSQL
sudo dnf install -y postgresql postgresql-server postgresql-contrib postgresql-devel

# Initialize database
sudo postgresql-setup --initdb

# Enable and start PostgreSQL
sudo systemctl enable postgresql
sudo systemctl start postgresql

# Configure PostgreSQL for development
sudo -u postgres psql -c "CREATE USER developer WITH PASSWORD 'devpass';"
sudo -u postgres psql -c "ALTER USER developer CREATEDB;"
sudo -u postgres psql -c "CREATE DATABASE devdb OWNER developer;"

# Install pgAdmin4
sudo dnf install -y pgadmin4

MySQL/MariaDB

# Install MariaDB
sudo dnf install -y mariadb mariadb-server mariadb-devel

# Enable and start MariaDB
sudo systemctl enable mariadb
sudo systemctl start mariadb

# Secure MariaDB installation
sudo mysql_secure_installation

# Create development database and user
sudo mysql -e "CREATE DATABASE devdb;"
sudo mysql -e "CREATE USER 'developer'@'localhost' IDENTIFIED BY 'devpass';"
sudo mysql -e "GRANT ALL PRIVILEGES ON devdb.* TO 'developer'@'localhost';"
sudo mysql -e "FLUSH PRIVILEGES;"

Redis

# Install Redis
sudo dnf install -y redis

# Enable and start Redis
sudo systemctl enable redis
sudo systemctl start redis

# Install Redis tools
pip install --user redis-cli-tool

MongoDB

# Add MongoDB repository
cat > /etc/yum.repos.d/mongodb-org-7.0.repo << 'EOF'
[mongodb-org-7.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/9/mongodb-org/7.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://pgp.mongodb.com/server-7.0.asc
EOF

# Install MongoDB
sudo dnf install -y mongodb-org

# Enable and start MongoDB
sudo systemctl enable mongod
sudo systemctl start mongod

# Install MongoDB Compass (GUI)
wget https://downloads.mongodb.com/compass/mongodb-compass-1.41.0.x86_64.rpm
sudo dnf install -y mongodb-compass-1.41.0.x86_64.rpm
rm mongodb-compass-1.41.0.x86_64.rpm

Container and Virtualization Tools

Docker

# Install Docker
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Enable and start Docker
sudo systemctl enable docker
sudo systemctl start docker

# Add user to docker group
sudo usermod -aG docker $USER
newgrp docker

# Install Docker Compose v2
sudo dnf install -y docker-compose-plugin

# Test Docker installation
docker run hello-world

Podman

# Install Podman and tools
sudo dnf install -y podman podman-compose podman-docker buildah skopeo

# Configure Podman for rootless operation
podman system migrate

# Install container tools
sudo dnf install -y container-tools

Kubernetes Tools

# Install kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
rm kubectl

# Install minikube
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube
rm minikube-linux-amd64

# Install Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Install k9s (Kubernetes CLI)
wget https://github.com/derailed/k9s/releases/latest/download/k9s_Linux_amd64.tar.gz
tar xf k9s_Linux_amd64.tar.gz
sudo mv k9s /usr/local/bin/
rm k9s_Linux_amd64.tar.gz

Vagrant

# Install Vagrant
sudo dnf install -y vagrant

# Install VirtualBox (for Vagrant)
sudo dnf config-manager --add-repo https://download.virtualbox.org/virtualbox/rpm/el/virtualbox.repo
sudo dnf install -y VirtualBox-7.0

# Add user to vboxusers group
sudo usermod -aG vboxusers $USER

Web Development Tools

Web Servers

# Install Apache
sudo dnf install -y httpd httpd-devel mod_ssl

# Install Nginx
sudo dnf install -y nginx

# Install Caddy
sudo dnf copr enable @caddy/caddy -y
sudo dnf install -y caddy

Frontend Tools

# Install Sass
sudo npm install -g sass

# Install Webpack and related tools
sudo npm install -g \
    webpack \
    webpack-cli \
    webpack-dev-server \
    parcel \
    @parcel/transformer-sass

# Install testing frameworks
sudo npm install -g \
    jest \
    mocha \
    karma-cli \
    cypress \
    @testing-library/react

# Install build tools
sudo npm install -g \
    gulp-cli \
    grunt-cli \
    bower

API Development Tools

# Install Postman
wget -O postman.tar.gz "https://dl.pstmn.io/download/latest/linux64"
sudo tar -xzf postman.tar.gz -C /opt
sudo ln -s /opt/Postman/Postman /usr/local/bin/postman
rm postman.tar.gz

# Install Insomnia
wget -O insomnia.rpm "https://updates.insomnia.rest/downloads/ubuntu/latest?&app=com.insomnia.app&source=website"
sudo dnf install -y insomnia.rpm
rm insomnia.rpm

# Install httpie
sudo dnf install -y httpie

DevOps and Cloud Tools

Infrastructure as Code

# Install Terraform
sudo dnf install -y dnf-plugins-core
sudo dnf config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo
sudo dnf install -y terraform

# Install Ansible
sudo dnf install -y ansible ansible-lint

# Install Packer
sudo dnf install -y packer

Cloud CLI Tools

# Install AWS CLI
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
rm -rf awscliv2.zip aws/

# Install Azure CLI
sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
sudo dnf install -y https://packages.microsoft.com/config/rhel/9.0/packages-microsoft-prod.rpm
sudo dnf install -y azure-cli

# Install Google Cloud SDK
sudo tee -a /etc/yum.repos.d/google-cloud-sdk.repo << EOM
[google-cloud-cli]
name=Google Cloud CLI
baseurl=https://packages.cloud.google.com/yum/repos/cloud-sdk-el9-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=0
gpgkey=https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOM

sudo dnf install -y google-cloud-cli

CI/CD Tools

# Install Jenkins (optional - for local testing)
sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key
sudo dnf install -y jenkins

# Install act (run GitHub Actions locally)
curl -s https://raw.githubusercontent.com/nektos/act/master/install.sh | sudo bash

# Install GitLab Runner
curl -L "https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.rpm.sh" | sudo bash
sudo dnf install -y gitlab-runner

System Optimization for Development

Performance Tuning

# Increase file watchers for development
echo "fs.inotify.max_user_watches=524288" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# Configure swappiness for better performance
echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# Set up zRAM for better memory management
sudo dnf install -y zram-generator
echo "[zram0]" | sudo tee /etc/systemd/zram-generator.conf
sudo systemctl daemon-reload
sudo systemctl start /dev/zram0

Development Services

# Create systemd service for development databases
sudo tee /etc/systemd/system/dev-services.target << EOF
[Unit]
Description=Development Services
Requires=multi-user.target
After=multi-user.target
AllowIsolate=yes

[Install]
WantedBy=multi-user.target
EOF

# Configure services to start with dev-services target
sudo systemctl enable postgresql --now
sudo systemctl enable mariadb --now
sudo systemctl enable redis --now
sudo systemctl enable mongod --now
sudo systemctl enable docker --now

Backup Configuration

# Create backup script for development environment
cat > ~/Development/scripts/backup-dev-env.sh << 'EOF'
#!/bin/bash
# Backup development environment

BACKUP_DIR="$HOME/Backups/dev-env-$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# Backup configurations
cp -r ~/.config "$BACKUP_DIR/"
cp ~/.bashrc "$BACKUP_DIR/"
cp ~/.zshrc "$BACKUP_DIR/" 2>/dev/null
cp ~/.gitconfig "$BACKUP_DIR/"

# Backup SSH keys
cp -r ~/.ssh "$BACKUP_DIR/"

# Backup project list
ls ~/Development/projects > "$BACKUP_DIR/project-list.txt"

# Create tarball
tar -czf "$HOME/Backups/dev-env-$(date +%Y%m%d).tar.gz" -C "$HOME/Backups" "dev-env-$(date +%Y%m%d)"
rm -rf "$BACKUP_DIR"

echo "Backup completed: $HOME/Backups/dev-env-$(date +%Y%m%d).tar.gz"
EOF

chmod +x ~/Development/scripts/backup-dev-env.sh

Security Considerations

Development Security

# Install security tools
sudo dnf install -y \
    fail2ban \
    rkhunter \
    lynis \
    clamav \
    clamav-update

# Configure firewall for development
sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --permanent --add-port=3000/tcp  # Node.js
sudo firewall-cmd --permanent --add-port=8080/tcp  # Common dev port
sudo firewall-cmd --permanent --add-port=5432/tcp  # PostgreSQL
sudo firewall-cmd --permanent --add-port=3306/tcp  # MySQL
sudo firewall-cmd --reload

# Set up SSH key authentication
ssh-keygen -t ed25519 -C "[email protected]"
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Secret Management

# Install password managers
sudo dnf install -y keepassxc

# Install secret management tools
pip install --user python-dotenv
npm install -g dotenv-cli

# Create secure environment file template
cat > ~/Development/projects/.env.template << 'EOF'
# Database
DB_HOST=localhost
DB_PORT=5432
DB_NAME=devdb
DB_USER=developer
DB_PASS=

# API Keys
API_KEY=
SECRET_KEY=

# Cloud Services
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
EOF

Productivity Tools and Utilities

Communication Tools

# Install Slack (via Flatpak)
sudo dnf install -y flatpak
sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
sudo flatpak install -y flathub com.slack.Slack

# Install Discord
sudo flatpak install -y flathub com.discordapp.Discord

Documentation Tools

# Install documentation generators
pip install --user sphinx mkdocs
npm install -g jsdoc typedoc vuepress

# Install diagram tools
sudo dnf install -y plantuml graphviz

# Install Markdown editors
sudo flatpak install -y flathub com.github.marktext.marktext

Monitoring Tools

# Install system monitoring
sudo dnf install -y \
    htop \
    iotop \
    nethogs \
    ncdu \
    dstat \
    glances

# Install container monitoring
docker pull portainer/portainer-ce:latest
docker run -d -p 9000:9000 \
    --name=portainer \
    --restart=always \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v portainer_data:/data \
    portainer/portainer-ce:latest

Terminal Multiplexers and Tools

# Configure tmux for development
cat > ~/.tmux.conf << 'EOF'
# Enable mouse
set -g mouse on

# Start windows and panes at 1
set -g base-index 1
setw -g pane-base-index 1

# Split panes with | and -
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# Reload config with r
bind r source-file ~/.tmux.conf \; display "Config reloaded!"

# Theme
set -g status-bg black
set -g status-fg white
set -g status-interval 60
set -g status-left-length 30
set -g status-left '#[fg=green](#S) #(whoami) '
set -g status-right '#[fg=yellow]#(cut -d " " -f 1-3 /proc/loadavg)#[default] #[fg=white]%H:%M#[default]'
EOF

# Install tmux plugin manager
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

Post-Installation Steps

Verify Installations

# Create verification script
cat > ~/Development/scripts/verify-dev-env.sh << 'EOF'
#!/bin/bash

echo "=== Development Environment Verification ==="

# Check programming languages
echo -e "\n--- Programming Languages ---"
command -v python3 >/dev/null && echo "✓ Python: $(python3 --version)"
command -v node >/dev/null && echo "✓ Node.js: $(node --version)"
command -v go >/dev/null && echo "✓ Go: $(go version)"
command -v rustc >/dev/null && echo "✓ Rust: $(rustc --version)"
command -v java >/dev/null && echo "✓ Java: $(java -version 2>&1 | head -1)"
command -v gcc >/dev/null && echo "✓ GCC: $(gcc --version | head -1)"

# Check tools
echo -e "\n--- Development Tools ---"
command -v git >/dev/null && echo "✓ Git: $(git --version)"
command -v docker >/dev/null && echo "✓ Docker: $(docker --version)"
command -v code >/dev/null && echo "✓ VS Code: installed"
command -v vim >/dev/null && echo "✓ Vim: $(vim --version | head -1)"

# Check databases
echo -e "\n--- Databases ---"
systemctl is-active postgresql &>/dev/null && echo "✓ PostgreSQL: running"
systemctl is-active mariadb &>/dev/null && echo "✓ MariaDB: running"
systemctl is-active redis &>/dev/null && echo "✓ Redis: running"
systemctl is-active mongod &>/dev/null && echo "✓ MongoDB: running"
EOF

chmod +x ~/Development/scripts/verify-dev-env.sh
~/Development/scripts/verify-dev-env.sh

Create Project Template

# Create project initialization script
cat > ~/Development/scripts/init-project.sh << 'EOF'
#!/bin/bash

if [ $# -eq 0 ]; then
    echo "Usage: $0 <project-name> [project-type]"
    echo "Project types: node, python, go, rust, java"
    exit 1
fi

PROJECT_NAME=$1
PROJECT_TYPE=${2:-general}
PROJECT_DIR="$HOME/Development/projects/$PROJECT_NAME"

mkdir -p "$PROJECT_DIR"
cd "$PROJECT_DIR"

# Initialize Git
git init

# Create common files
touch README.md
echo "# $PROJECT_NAME" > README.md
echo "node_modules/" > .gitignore
echo ".env" >> .gitignore
echo "*.log" >> .gitignore

# Project-specific initialization
case $PROJECT_TYPE in
    node)
        npm init -y
        echo "dist/" >> .gitignore
        ;;
    python)
        python3 -m venv venv
        echo "venv/" >> .gitignore
        echo "__pycache__/" >> .gitignore
        echo "*.pyc" >> .gitignore
        touch requirements.txt
        ;;
    go)
        go mod init "$PROJECT_NAME"
        ;;
    rust)
        cargo init
        ;;
    java)
        mkdir -p src/main/java src/test/java
        echo "target/" >> .gitignore
        echo "*.class" >> .gitignore
        ;;
esac

echo "Project $PROJECT_NAME initialized in $PROJECT_DIR"
EOF

chmod +x ~/Development/scripts/init-project.sh

Conclusion

You now have a fully-equipped development workstation on Rocky Linux, ready for modern software development across multiple languages and platforms. This setup includes:

Multiple programming languages with version management
Professional IDEs and text editors
Database systems for various use cases
Container and orchestration tools
DevOps and cloud development tools
Security and productivity enhancements

Next Steps

Customize your environment: Adjust configurations to match your workflow
Set up dotfiles repository: Version control your configurations
Configure IDE settings: Import your preferred IDE configurations
Create project templates: Set up boilerplate for common project types
Automate repetitive tasks: Create scripts for common operations
Regular maintenance: Keep tools and dependencies updated

Maintenance Commands

# Update all system packages
sudo dnf update -y

# Update programming language packages
pip install --user --upgrade pip setuptools wheel
npm update -g
rustup update
go get -u all

# Clean up system
sudo dnf autoremove
sudo dnf clean all
docker system prune -a

Remember to regularly backup your development environment and keep your tools updated for the best development experience on Rocky Linux.