Dotfiles
About
Dotfiles is a collection of configuration files that provides a consistent development environment across different machines. It follows the "spilled coffee principle," "snowball method," and "versioning mindset" to ensure reproducibility, continuous improvement, and iterative…
Explore
The actual implementation of features follows these principles:
1. Detection over Assumption: Scripts detect hardware capabilities rather than assuming specific use cases
2. Composability: Features can be mixed and matched based on user needs
3. Automatic Optimization: Hardware-specific optimizations are applied automatically
4. Clear Documentation: Each feature documents its purpose and requirements
This multi-level organizational approach allows us to maintain a clean repository structure while providing flexibility for different use cases.
This repository uses a modular approach to shell configuration:
git clone https://github.com/atxtechbro/dotfiles.git ~/ppv/pillars/dotfiles
cd ~/ppv/pillars/dotfiles
./setup.sh
The setup script will:
- Create all necessary symlinks
- Set up your secrets file from the template
- Apply configurations immediately
The script will NOT install packages for you or make assumptions about your package manager.
> Note: The setup script requires git and curl. Most systems have these installed by default, but if you encounter errors, see the package installation section below.
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install git gh jq tmux curl wget
</details>
sudo apt update
sudo apt install -y google-chrome-stable
Chrome will automatically update when you run sudo apt update and sudo apt upgrade as part of your regular system maintenance.
./utils/install-go.sh
go version
The installation script:
- Detects your operating system and architecture
- Attempts to install Go using your system's package manager
- Falls back to manual installation from official binaries if needed
- Sets up proper environment variables
- Creates necessary workspace directories
This script follows the "spilled coffee principle" - it ensures Go is available without manual intervention, making your environment fully operational after a fresh setup.
sudo apt install -y tmux
ln -sf ~/ppv/pillars/dotfiles/.tmux.conf ~/.tmux.conf
Basic usage:
- Start a new session: tmux
- Split pane horizontally: Ctrl+a -
- Split pane vertically: Ctrl+a |
- Navigate between panes: Alt+Arrow Keys
- Close current pane: Ctrl+a x
- Detach from session: Ctrl+a d
- Reattach to session: tmux attach
sudo apt-get install ninja-build gettext cmake unzip curl
make CMAKE_BUILD_TYPE=RelWithDebInfo
sudo make install
This ensures you get the latest version with all features, rather than the potentially outdated version from package repositories.
For more build options, see the official build instructions.
cd ~/ppv/pillars/dotfiles/mcp
./setup-clojure-mcp.sh
This dotfiles repository uses a modular approach to Git configuration, allowing you to enable specific features as needed without cluttering your main configuration.
- .gitconfig.signing - Commit signing configuration with SSH keys
- (Add more modules as they are created)
To include a module in your Git configuration:
[include]
path = ~/ppv/pillars/dotfiles/.gitconfig.signing
```
A collection of configuration files for a consistent development environment across different machines.
Dotfiles Philosophy
Our dotfiles repository follows three core principles that guide our approach to configuration management:
The Spilled Coffee Principle
The "spilled coffee principle" states that anyone should be able to destroy their machine and be fully operational again that afternoon. This principle emphasizes:
- All configuration changes should be reproducible across machines
- Setup scripts should handle file operations instead of manual commands
- Installation scripts should detect and create required directories
- Symlinks should be managed by setup scripts rather than manual linking
- Dependencies and installation steps should be well-documented
This principle ensures resilience and quick recovery from system failures or when setting up new environments.
The Snowball Method
The "snowball method" focuses on continuous knowledge accumulation and compounding improvements. Like a snowball rolling downhill, gathering more snow and momentum, this principle emphasizes:
- Persistent context: Each development session builds on accumulated knowledge from previous sessions
- Virtuous cycle: Tools and systems become more effective the more they're used
- Knowledge persistence: Documentation, configuration, and context are preserved and enhanced over time
- Compounding returns: Small improvements accumulate and multiply rather than remaining isolated
- Reduced cognitive load: Less need to "re-learn" or "re-discover" previous solutions
This principle ensures that our development environment continuously improves over time.
The Versioning Mindset
The "versioning mindset" is the principle that progress happens through iteration rather than reinvention, where small strategic changes compound over time through active feedback loops. It emphasizes:
- Logging what worked and what didn't, then rolling forward with improvements
- Creating feedback loops across domains so gains in one area reinforce others
- Focusing on incremental improvements rather than complete rewrites
- Building on previous knowledge rather than starting from scratch
- Maintaining history and context to inform future decisions
This principle ensures sustainable, continuous improvement across all aspects of our development environment.
Modular Shell Configuration
This repository uses a modular approach to shell configuration:
```bash
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
