I like this phase. The project stops being “what I imagined in my setup” and becomes “what breaks on somebody else’s machine.” Then Windows shows up. macOS. Arch. AUR. Weird paths. Tokens saved somewhere else. Different shell. Different terminal. Annoying? Yes. Necessary? Also yes.

But today’s main dish is not ai-jail or ai-memory. It’s TUI. More specifically, my recent habit of writing small terminal tools in Rust with Ratatui, while wanting them to look like Bubble Tea.

The app I won’t open

Over the last few weeks I also worked on a private project I do not plan to open source. It’s a TUI to track my US bank account, investments, assets, positions, covered calls, open calls, all that boring grown-up stuff. I won’t publish the code because this tool was born glued to my financial workflow, my spreadsheets, my statements, and my internal hacks. Opening it would turn a tool for myself into free support for other people’s bank bugs. No thanks.

But I can show the general look. I censored what needed censoring:

Obvious note, but I’ll make it explicit: every value, ticker, position, and date shown in the screenshot is bogus demonstration data. It is not real account data, not my real portfolio, and not investment advice.

Every time I build a small TUI, the same question comes back: what stack should I use?

If I were writing everything by hand, I would probably pick Python or Go. They are more comfortable for this kind of small utility. Python because it is direct, full of libraries, great for scripts that talk to APIs and parse JSON. Go because it produces simple binaries, cross-platform support is sane, and the CLI ergonomics are good.

But today I rarely write all that code by hand. I orchestrate Claude, Codex, OpenCode, ask for reviews, ask for refactors, ask for tests. In that setup, Rust’s lack of ergonomics hurts less, because the LLM is the one fighting the borrow checker, trait bounds, and annoying lifetimes. I stay closer to reviewer and end user. And then Rust starts looking very attractive.

Good tooling. cargo is great. Tests are easy to run. Cross compile is manageable. The final binary is clean. Dumb memory bugs mostly disappear. I am not saying Rust is magically better than Go or Python for every TUI. It isn’t. But with an LLM writing most of it, the cost that would usually make me avoid Rust drops a lot. And current models are surprisingly competent with Rust, as long as you make them run tests, fix warnings, and you don’t accept the first version as if Moses brought it down from the mountain.

Ratatui is good, but I wanted the Charm look

Ratatui is a Rust library for building full terminal interfaces: dashboards, interactive apps, tables, lists, gauges, layouts, the whole thing we used to call “modern ncurses.” It grew out of tui-rs, and today it is probably the obvious path if you want to build a serious TUI in Rust.

Ratatui works well. My problem is taste: by default, I don’t find it pretty. Not ugly in the “this looks like a DOS program from 1993” sense. You can build good-looking stuff with it. But many Ratatui TUIs fall into that square, gray, functional look, like a datacenter admin panel.

I like the Charmbracelet vibe more. gum, for example, is a collection of commands that make shell scripts interactive without turning them into a festival of read -p and case. Prompt, select, filter, spinner, table, pager, styling. You can make a bash script feel like a decent app in minutes.

And then there is Bubble Tea, in Go, inspired by Elm architecture. You have a model, receive messages, update state, render a view. Simple idea, very good fit for terminal apps: state comes in, event comes in, view goes out. Charm also has visual taste I like: good colors, decent spacing, light components, nothing that looks like a WinForms form thrown into a terminal.

So I wanted this: stay in Rust with Ratatui, but steal the feeling of Bubble Tea. Not the whole runtime. Not a perfect clone. Just the visual direction and a few components.

That is how ratatui-bubbletea was born.

The project does not replace Ratatui. It sits on top. The idea is to offer a theme and component layer inspired by Bubble Tea/Bubbles, while still rendering through Ratatui.

Right now it is split into crates:

• ratatui-bubbletea-theme, with palette, helpers, and shared styles.
• ratatui-bubbletea-components, with ready-made components like select list, spinner, progress, table, text input, viewport, and help.
• ratatui-tea, optional, for people who want ergonomics closer to Model, Msg, and Cmd, without pretending Rust became Go.

The README has the full examples and documentation for what exists today. For now, I treat it as a small toolkit. It serves my apps, and if it serves somebody else, fine. If it doesn’t, no drama either. The goal was to stop reimplementing the same theme and the same widgets every time I started a new TUI.

ai-usagebar as the public example

Since I won’t open the financial app, I needed a public example using this aesthetic. So I updated my ai-usagebar.

If you don’t remember it, I explained the project in “I Built a Waybar Widget for Omarchy to Monitor LLM Plan Usage: ai-usagebar”. It started as a Waybar widget to show LLM plan usage: Claude, OpenAI Codex/ChatGPT, Z.AI, OpenRouter. One glance at the bar and I know whether I am close to the limit and which vendor to use next.

Later it also became a standalone TUI. And thanks to contributions, it now supports Windows too. That is funny because its origin is completely Linux/Omarchy/Waybar. But that is open source: somebody uses it in another environment, finds friction, sends a PR, and now the project is a little less provincial.

In ai-usagebar, the visual change will not alter anybody’s life. It is a simple screen. Tabs, gauges, text, shortcuts. But it is a good example because it is small, real, tested, packaged, and does not depend on my private app. You can look at the code and see how I applied the theme layer.

The scratch-my-own-itch apps

All these projects follow the same logic: I have an itch, I make a small tool, I use it, adjust it, package it. No startup roadmap. No manifesto. Just a tool that fixes something annoying in my own setup.

One recent example is clock-tui. It did not start with me. It was an old Rust project, tclock, that looked abandoned. I wanted a big clock on my second vertical monitor. That monitor sits on the side, and I like having a huge desk clock taking up part of the screen. I used the original clock-tui for a while.

But an entire vertical screen just to show the time is wasteful. I already had ghpending, which lists open issues and PRs across all my projects. It is my “is anybody waiting for an answer?” in CLI form. I also wanted to see my agenda.

So I made another small app: google-calendar-tui. It uses the Gmail accounts already registered in GNOME Online Accounts and summarizes my upcoming appointments in the terminal. Read-only. No new OAuth ritual. No extra secret config scattered somewhere weird.

With those two pieces, I modernized clock-tui and added auto-refreshing widget layout support. Now the clock takes the screen the way I wanted, but around it I also get GitHub pending work and Google Calendar appointments.

This is exactly the kind of thing I would never build if it cost me an entire weekend. But with an LLM, it becomes a sequence of small tasks: read the old project, modernize dependencies, run tests, add a widget module, call ghpending, call google-calendar-tui, organize layout, fix bugs, package. It still takes work. But it is supervision and refinement work, not fighting boilerplate.

Tweaking Geary without a fork

Another itch came from GNOME.

Since I wanted to centralize my accounts in GNOME Online Accounts, I started using Geary and GNOME Calendar on the second monitor too. I like the idea: accounts configured once, desktop apps reusing the same infrastructure, no tiny program inventing its own login flow.

The problem is that Geary has a fixed three-column layout. On a normal screen, fine. On a vertical monitor, it gets cramped. The folder column, message list, and email body fight for space. I did not want to maintain a Geary fork just to hide a sidebar. Forking a large GTK app is debt. You blink and spend the rest of your life resolving merge conflicts.

So I made a GTK module: geary-hide-sidebar-module. It injects behavior into Geary at runtime and lets me collapse/expand the sidebar, with a shortcut and auto-collapse for narrow windows. No rebuilding Geary. No fork to maintain. Just a small module with one very specific job.

This is a good lesson: sometimes you do not need to fork the whole application. You can adjust it from the outside. GTK_MODULES exists. Wrappers exist. Config exists. CSS exists. Scripts exist. Not every customization has to become eternal maintenance of somebody else’s code.

Small code got cheap

That is why I keep insisting on this idea of small apps. With current LLMs, it became very easy to implement a specific idea to make your environment fit your needs. No waiting for someone else to have the exact same pain. No searching GitHub for three hours for a tool that does 80% of what you want and 40% of what you don’t want.

You describe the itch, create a repo, ask for a prototype, test it, ask for refactoring, ask for tests, ask for packaging. If it sucks, throw it away. If it works, install it and use it.

I do not let this turn into random junk dumped in ~/bin with no owner. My apps have tests. They have automated builds. Many have GitHub releases, AUR packages, normal installation with yay on Arch. They use XDG paths, so config goes to ~/.config, cache goes to ~/.cache, data goes to ~/.local/share. Organized. Upgradable. Removable. Something another person can clone and contribute to.

Here are all the links in one place:

• ratatui-bubbletea
• ai-usagebar
• clock-tui
• ghpending
• google-calendar-tui
• geary-hide-sidebar-module
• ai-jail
• ai-memory

If you use any of them and it breaks in your setup, open an issue. If you know how to fix it, send a PR. I actually use these tools, so useful bug reports tend to turn into fixes fast.

My practical rule is this: customize your environment without turning everything into duct tape. Build small tools. Test them. Package them. Document them. Let the LLM carry the boring weight and use your brain to decide what is worth keeping.

That is the fun part of programming that had gone missing for a bit. Now it is back.

The problem with juggling several plans is keeping track of how much I’ve burned on each. I’d been using claudebar, a Waybar widget that shows your Anthropic plan usage. I like it, but I wanted to see all my vendors in one place, glance at it and know where I stand. And I didn’t want to clutter my Waybar with a separate widget per vendor. So I built my own: ai-usagebar.

It’s a Rust port of claudebar, drop-in compatible, extended to four vendors: Anthropic Claude, OpenAI Codex/ChatGPT, Z.AI (GLM), and OpenRouter. It keeps the same flags (--icon, --format, --tooltip-format, etc.), the same minimalist Pango-bordered tooltip, and the same Omarchy theme auto-detection. The difference is that now all four vendors show up in the same place, instead of 865 lines of bash babysitting just one.

How it authenticates with each vendor

This is the part worth explaining, because each vendor does it differently. Claude and Codex use OAuth: their official CLIs (claude and codex) already wrote the credentials to disk when you logged in, and ai-usagebar reads those same files. No environment variable needed, the token even refreshes itself.

Z.AI and OpenRouter use API keys, so for those you need to set a key (via env var or inline in the config).

The interface beyond Waybar

Besides the widget on the bar, there’s a tabbed TUI (ai-usagebar-tui) to see everything at once. Navigate with Tab / h / l between vendors, auto-refresh every 60s. You can open it by clicking the Waybar widget, or run it straight from the terminal (more on that in the next section).

The OpenRouter tab shows credit balance, today/week/month spend, and the tier:

And there’s a settings overlay to pick the primary vendor and paste the API keys without editing the config by hand:

Not on Omarchy or Hyprland? Run it as a standalone TUI

The Waybar widget is optional. The two binaries are independent, so if you don’t run Omarchy, or Hyprland, or Waybar (or you just prefer to check usage now and then instead of having it on the bar all the time), ai-usagebar-tui works as a fully standalone terminal app:

ai-usagebar-tui    # opens in your current terminal

It runs in any terminal emulator (Kitty, Alacritty, Foot, Ghostty, etc.), works even over a plain SSH session, and doesn’t depend on a compositor or any window-manager feature. All the controls and the settings overlay work the same. Same four vendors, same tabs:

Typical use off Omarchy: a quick check before starting a long session (“am I close to my Claude weekly limit?”), a monitor in a tmux pane while you code, or a shell-only tool on a remote machine (install the binary and that’s it, no Waybar or Hyprland dependency). The TUI is the canonical way to see all four vendors at once, whether or not you ever set up the widget.

Install

On Arch there’s an AUR package, two flavors:

yay -S ai-usagebar-bin    # prebuilt binary from GitHub Releases (~5s)
yay -S ai-usagebar        # compiles from source (~30-60s)

Or straight from source:

cargo build --release
sudo make install                  # → /usr/local/bin
# or
make install PREFIX=$HOME/.local   # → ~/.local/bin

The recommended Waybar config is a single module you scroll to cycle through vendors, with click to open the TUI:

"custom/aibar": {
    "exec": "ai-usagebar --format '{vendor_short} {session_pct}% · {session_reset}'",
    "return-type": "json",
    "interval": 300,
    "signal": 13,
    "tooltip": true,
    "on-click": "ai-usagebar-tui",
    "on-scroll-up":   "ai-usagebar --cycle-next",
    "on-scroll-down": "ai-usagebar --cycle-prev"
}

If you’d rather see all four vendors at once, you can use one module per vendor. The README has the full config detail, format placeholders, and the variations.

Why I built it

This looked like a Saturday-night little project, so I just did it. And it was: porting claudebar to Rust and adding the extra vendors I wanted was painless. I came out of one night with a widget that does exactly what I needed and is more reliable (tested, modular) than the original shell script.

If you use other vendors I didn’t cover, or you hit a bug, send an issue or pull request: github.com/akitaonrails/ai-usagebar. It’s MIT.

I know there are plenty of tools that solve this. But I wanted something dead simple and fast to run in the terminal so I can see pending work across all my projects at once. So I built it: ghpending.

Runs on Linux and macOS. I tested on Linux (Arch + Omarchy) but haven’t run it on macOS yet. If you try it there and hit a bug, file an issue at github.com/akitaonrails/ghpending/issues.

Install

Three paths, pick whichever fits your setup.

Via Homebrew (macOS or Linux):

brew tap akitaonrails/tap && brew install ghpending

Via Cargo:

cargo install ghpending

Via mise:

mise use -g github:akitaonrails/ghpending

Upgrading

# Homebrew
brew upgrade ghpending

# Cargo
cargo install ghpending --force

# mise
mise upgrade ghpending

# From source
cd ghpending && git pull && cargo install --path .

Usage

Four commands. The normal flow is to run ghpending add once to set up which repos you want to track, then just ghpending whenever you want to see the digest.

ghpending add    # pick repos from a GitHub user or org to track
ghpending        # print the digest of open issues and PRs
ghpending list   # show tracked repos
ghpending rm     # remove repos from tracking via interactive menu

add asks for a user or organization, lists their public repos, and lets you check off the ones you want to follow. The username gets saved, so re-running add skips that prompt.

The main command (ghpending with no args) fetches every tracked repo concurrently and prints the table with open issues and PRs.

GitHub token (optional)

It works without auth, but GitHub caps anonymous traffic at 60 requests per hour. To raise that ceiling to 5,000 req/h, export a token:

GITHUB_TOKEN=$(gh auth token) ghpending

It’s read silently at startup, no config needed.

Where the config lives

• Linux: ~/.config/ghpending/config.toml
• macOS: ~/Library/Application Support/ghpending/config.toml

You can edit it directly if you want to reorder repos or change the user. Shape:

user = "akitaonrails"
repos = ["akitaonrails/ai-memory", "akitaonrails/ai-jail"]

Why this CLI exists

The honest answer: tools I build for myself, I use. Tools written by other people always come with some friction (web login, a different architectural opinion, a feature I wanted missing or one I didn’t want included). Since the goal was to reduce the friction of checking 30 repos a week, 200 lines of Rust on a Saturday afternoon beat learning a new stack.

Now I’m hoping I can respond to contributors faster. If you find it useful, it’s MIT licensed, PRs are welcome.

I still don’t fully understand how much of a difference it makes, but both OpenCode and Crush support Language Servers (LSPs), so I thought it’d be cool to have it configured. Here’s my ~/.config/crush/crush.json:

{
  "$schema": "https://charm.land/crush.json",
  "default_provider": "openrouter",
  "providers": {
    "openrouter": {
      "api_key": "sk-..."
    },
    "lmstudio": {
      "name": "LM Studio",
      "base_url": "http://localhost:1234/v1/",
      "type": "openai",
      "models": [
        {
          "name": "gpt-oss-120b",
          "id": "gpt-oss:120b",
          "context_window": 100000,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "name": "gpt-oss-20b",
          "id": "gpt-oss:20b",
          "context_window": 130000,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "name": "zai-org/glm-4.6v-flash",
          "id": "glm-4.6v-flash",
          "context_window": 130000,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "name": "deepseek-coder-v2-lite-instruct",
          "id": "deepseek-coder-v2-lite-instruct",
          "context_window": 64000,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "id": "qwen/qwen3-coder-30b",
          "name": "qwen3-coder-30b",
          "context_window": 120000,
          "default_max_tokens": -1,
          "supports_tools": true
        }
      ]
    },
    "ollama": {
      "type": "openai-compat",
      "base_url": "http://127.0.0.1:11434/v1",
      "api_key": "ollama",
      "models": [
        {
          "name": "glm-4.7-flash",
          "id": "glm-4.7-flash",
          "context_window": 65536,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "name": "gpt-oss-20b",
          "id": "gpt-oss:20b",
          "context_window": 64000,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "id": "qwen3-nuclear",
          "name": "qwen3-nuclear",
          "context_window": 120000,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "id": "qwen3-coder:30b",
          "name": "qwen3-coder:30b",
          "context_window": 120000,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "id": "qwen2.5-coder:32b",
          "name": "qwen2.5-coder:32b",
          "context_window": 32768,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "id": "deepseek-coder-v2:16b",
          "name": "deepseek-coder-v2:16b",
          "context_window": 128000,
          "default_max_tokens": -1,
          "supports_tools": true
        },
        {
          "id": "glm-4.7:cloud",
          "name": "glm-4.7:cloud",
          "context_window": 128000,
          "default_max_tokens": -1,
          "supports_tools": true
        }
      ]
    }
  },
  "lsp": {
    "gopls": {
      "command": "gopls"
    },
    "rust-analyzer": {
      "command": "rust-analyzer"
    },
    "ruby-lsp": {
      "command": "ruby-lsp"
    },
    "solargraph": {
      "command": "solargraph",
      "args": [
        "stdio"
      ]
    },
    "pylsp": {
      "command": "pylsp"
    },
    "pyright": {
      "command": "pyright-langserver",
      "args": [
        "--stdio"
      ]
    },
    "elixir-ls": {
      "command": "elixir-ls"
    },
    "docker-langserver": {
      "command": "docker-langserver",
      "args": [
        "--stdio"
      ],
      "languages": [
        "dockerfile"
      ]
    },
    "bash-language-server": {
      "command": "bash-language-server",
      "args": [
        "start"
      ]
    },
    "marksman": {
      "command": "marksman",
      "args": [
        "server"
      ]
    },
    "typescript-language-server": {
      "command": "typescript-language-server",
      "args": [
        "--stdio"
      ]
    },
    "vscode-html-language-server": {
      "command": "vscode-html-language-server",
      "args": [
        "--stdio"
      ]
    },
    "vscode-css-language-server": {
      "command": "vscode-css-language-server",
      "args": [
        "--stdio"
      ]
    },
    "vscode-json-language-server": {
      "command": "vscode-json-language-server",
      "args": [
        "--stdio"
      ]
    },
    "yaml-language-server": {
      "command": "yaml-language-server",
      "args": [
        "--stdio"
      ]
    },
    "taplo": {
      "command": "taplo",
      "args": [
        "lsp",
        "stdio"
      ]
    }
  },
  "mcp": {
    "blender": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "blender-mcp"
      ]
    }
  }
}

Note that I primarily use Claude Opus 4.5 via OpenRouter and I have LM Studio and Ollama configured as providers for testing other open source models.

I also use Mise to organize the programming languages I use.

But now you need to install the LSPs for each language. I don’t know of a better way to manage this the same way Mason does in Neovim. So I made a script to install everything for me (on my Arch Linux). For that I created this script ~/.local/bin/install-lsps.sh:

#!/usr/bin/env bash
set -euo pipefail

# LSP Installer for Arch Linux with Mise
# Installs major LSPs using native package managers or yay
# Only installs LSPs for languages that are already installed

GREEN='\033[0;32m'
BLUE='\033[0;34m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m'

info() { echo -e "${BLUE}[INFO]${NC} $1"; }
success() { echo -e "${GREEN}[OK]${NC} $1"; }
warn() { echo -e "${YELLOW}[SKIP]${NC} $1"; }
skip_lang() { echo -e "${RED}[LANG]${NC} $1 not installed, skipping LSPs"; }

command_exists() { command -v "$1" &>/dev/null; }

# ─────────────────────────────────────────────────────────────
# Language detection helpers
# ─────────────────────────────────────────────────────────────
has_c()       { command_exists gcc || command_exists clang; }
has_rust()    { command_exists rustc || command_exists cargo; }
has_go()      { command_exists go; }
has_python()  { command_exists python || command_exists python3; }
has_node()    { command_exists node || command_exists npm; }
has_java()    { command_exists java || command_exists javac; }
has_kotlin()  { command_exists kotlin || command_exists kotlinc; }
has_ruby()    { command_exists ruby; }
has_php()     { command_exists php; }
has_lua()     { command_exists lua || command_exists luajit; }
has_zig()     { command_exists zig; }
has_haskell() { command_exists ghc || command_exists stack || command_exists cabal; }
has_elixir()  { command_exists elixir || command_exists iex; }
has_scala()   { command_exists scala || command_exists sbt; }
has_dotnet()  { command_exists dotnet; }
has_ocaml()   { command_exists ocaml || command_exists opam; }
has_clojure() { command_exists clojure || command_exists clj || command_exists lein; }
has_nix()     { command_exists nix; }
has_terraform() { command_exists terraform || command_exists tofu; }
has_latex()   { command_exists latex || command_exists pdflatex || command_exists xelatex; }
has_docker()  { command_exists docker || command_exists podman; }
has_ansible() { command_exists ansible; }
has_sql()     { command_exists psql || command_exists mysql || command_exists sqlite3; }
has_bash()    { command_exists bash; }

# ─────────────────────────────────────────────────────────────
# Package installation helpers
# ─────────────────────────────────────────────────────────────
install_pacman() {
    local pkg="$1"
    if pacman -Qi "$pkg" &>/dev/null; then
        warn "$pkg already installed"
    else
        sudo pacman -S --noconfirm --needed "$pkg" && success "$pkg" || warn "Failed: $pkg"
    fi
}

install_yay() {
    local pkg="$1"
    if ! command_exists yay; then
        warn "yay not found, skipping $pkg"
        return
    fi
    if yay -Qi "$pkg" &>/dev/null; then
        warn "$pkg already installed"
    else
        yay -S --noconfirm --needed "$pkg" && success "$pkg" || warn "Failed: $pkg"
    fi
}

install_npm() {
    local pkg="$1"
    if npm list -g "$pkg" &>/dev/null 2>&1; then
        warn "$pkg already installed"
    else
        npm install -g "$pkg" && success "$pkg" || warn "Failed: $pkg"
    fi
}

install_pipx() {
    local pkg="$1"
    if ! command_exists pipx; then
        pip install --user pipx 2>/dev/null || {
            pip install --user "$pkg" && success "$pkg" || warn "Failed: $pkg"
            return
        }
    fi
    if pipx list 2>/dev/null | grep -q "$pkg"; then
        warn "$pkg already installed"
    else
        pipx install "$pkg" && success "$pkg" || warn "Failed: $pkg"
    fi
}

install_go() {
    local pkg="$1"
    local name="${pkg##*/}"
    name="${name%%@*}"
    
    # Check if binary already exists in GOPATH/bin
    local gobin="${GOBIN:-${GOPATH:-$HOME/go}/bin}"
    if [[ -x "$gobin/$name" ]]; then
        warn "$name already installed"
        return
    fi
    
    go install "$pkg" && success "$name" || warn "Failed: $name"
}

install_gem() {
    local pkg="$1"
    if gem list -i "^${pkg}$" &>/dev/null; then
        warn "$pkg already installed"
    else
        gem install "$pkg" && success "$pkg" || warn "Failed: $pkg"
    fi
}

# ─────────────────────────────────────────────────────────────
# C/C++ LSPs
# ─────────────────────────────────────────────────────────────
install_c_lsps() {
    if ! has_c; then
        skip_lang "C/C++ (gcc/clang)"
        return
    fi
    info "Installing C/C++ LSPs..."
    install_pacman clang  # includes clangd
}

# ─────────────────────────────────────────────────────────────
# Rust LSPs
# ─────────────────────────────────────────────────────────────
install_rust_lsps() {
    if ! has_rust; then
        skip_lang "Rust"
        return
    fi
    info "Installing Rust LSPs..."
    
    if command_exists rustup; then
        rustup component add rust-analyzer 2>/dev/null && success "rust-analyzer (rustup)" || install_pacman rust-analyzer
    else
        install_pacman rust-analyzer
    fi
}

# ─────────────────────────────────────────────────────────────
# Go LSPs
# ─────────────────────────────────────────────────────────────
install_go_lsps() {
    if ! has_go; then
        skip_lang "Go"
        return
    fi
    info "Installing Go LSPs..."
    
    install_go golang.org/x/tools/gopls@latest
    install_go github.com/go-delve/delve/cmd/dlv@latest
    install_go github.com/nametake/golangci-lint-langserver@latest
}

# ─────────────────────────────────────────────────────────────
# Python LSPs
# ─────────────────────────────────────────────────────────────
install_python_lsps() {
    if ! has_python; then
        skip_lang "Python"
        return
    fi
    info "Installing Python LSPs..."
    
    # Prefer npm pyright (faster updates) if node available
    if has_node; then
        install_npm pyright
    else
        install_pipx pyright
    fi
    
    install_pipx python-lsp-server
    install_pipx ruff-lsp
}

# ─────────────────────────────────────────────────────────────
# Node.js/TypeScript LSPs
# ─────────────────────────────────────────────────────────────
install_node_lsps() {
    if ! has_node; then
        skip_lang "Node.js"
        return
    fi
    info "Installing Node.js/TypeScript LSPs..."
    
    install_npm typescript
    install_npm typescript-language-server
    install_npm vscode-langservers-extracted  # HTML, CSS, JSON, ESLint
    install_npm "@tailwindcss/language-server"
    install_npm "@vue/language-server"
    install_npm svelte-language-server
    install_npm graphql-language-service-cli
    install_npm "@prisma/language-server"
    install_npm emmet-ls
}

# ─────────────────────────────────────────────────────────────
# Java LSPs
# ─────────────────────────────────────────────────────────────
install_java_lsps() {
    if ! has_java; then
        skip_lang "Java"
        return
    fi
    info "Installing Java LSPs..."
    install_yay jdtls
}

# ─────────────────────────────────────────────────────────────
# Kotlin LSPs
# ─────────────────────────────────────────────────────────────
install_kotlin_lsps() {
    if ! has_kotlin; then
        skip_lang "Kotlin"
        return
    fi
    info "Installing Kotlin LSPs..."
    install_yay kotlin-language-server
}

# ─────────────────────────────────────────────────────────────
# Ruby LSPs
# ─────────────────────────────────────────────────────────────
install_ruby_lsps() {
    if ! has_ruby; then
        skip_lang "Ruby"
        return
    fi
    info "Installing Ruby LSPs..."
    install_gem solargraph
    install_gem ruby-lsp
}

# ─────────────────────────────────────────────────────────────
# PHP LSPs
# ─────────────────────────────────────────────────────────────
install_php_lsps() {
    if ! has_php; then
        skip_lang "PHP"
        return
    fi
    if ! has_node; then
        warn "PHP LSP (intelephense) requires npm, skipping"
        return
    fi
    info "Installing PHP LSPs..."
    install_npm intelephense
}

# ─────────────────────────────────────────────────────────────
# Lua LSPs
# ─────────────────────────────────────────────────────────────
install_lua_lsps() {
    if ! has_lua; then
        skip_lang "Lua"
        return
    fi
    info "Installing Lua LSPs..."
    install_pacman lua-language-server
}

# ─────────────────────────────────────────────────────────────
# Zig LSPs
# ─────────────────────────────────────────────────────────────
install_zig_lsps() {
    if ! has_zig; then
        skip_lang "Zig"
        return
    fi
    info "Installing Zig LSPs..."
    install_pacman zls
}

# ─────────────────────────────────────────────────────────────
# Haskell LSPs
# ─────────────────────────────────────────────────────────────
install_haskell_lsps() {
    if ! has_haskell; then
        skip_lang "Haskell"
        return
    fi
    info "Installing Haskell LSPs..."
    install_yay haskell-language-server
}

# ─────────────────────────────────────────────────────────────
# Elixir LSPs
# ─────────────────────────────────────────────────────────────
install_elixir_lsps() {
    if ! has_elixir; then
        skip_lang "Elixir"
        return
    fi
    info "Installing Elixir LSPs..."
    install_yay elixir-ls
}

# ─────────────────────────────────────────────────────────────
# Scala LSPs
# ─────────────────────────────────────────────────────────────
install_scala_lsps() {
    if ! has_scala; then
        skip_lang "Scala"
        return
    fi
    info "Installing Scala LSPs..."
    install_yay metals
}

# ─────────────────────────────────────────────────────────────
# C# / F# (.NET) LSPs
# ─────────────────────────────────────────────────────────────
install_dotnet_lsps() {
    if ! has_dotnet; then
        skip_lang ".NET (C#/F#)"
        return
    fi
    info "Installing .NET LSPs..."
    install_yay omnisharp-roslyn
    install_yay fsautocomplete
}

# ─────────────────────────────────────────────────────────────
# OCaml LSPs
# ─────────────────────────────────────────────────────────────
install_ocaml_lsps() {
    if ! has_ocaml; then
        skip_lang "OCaml"
        return
    fi
    info "Installing OCaml LSPs..."
    if command_exists opam; then
        opam install ocaml-lsp-server -y && success "ocaml-lsp-server" || warn "Failed"
    else
        install_yay ocaml-lsp-server
    fi
}

# ─────────────────────────────────────────────────────────────
# Clojure LSPs
# ─────────────────────────────────────────────────────────────
install_clojure_lsps() {
    if ! has_clojure; then
        skip_lang "Clojure"
        return
    fi
    info "Installing Clojure LSPs..."
    install_yay clojure-lsp-bin
}

# ─────────────────────────────────────────────────────────────
# Nix LSPs
# ─────────────────────────────────────────────────────────────
install_nix_lsps() {
    if ! has_nix; then
        skip_lang "Nix"
        return
    fi
    info "Installing Nix LSPs..."
    install_pacman nil
}

# ─────────────────────────────────────────────────────────────
# Bash LSPs
# ─────────────────────────────────────────────────────────────
install_bash_lsps() {
    if ! has_bash; then
        skip_lang "Bash"
        return
    fi
    info "Installing Bash LSPs..."
    install_pacman bash-language-server
}

# ─────────────────────────────────────────────────────────────
# Terraform LSPs
# ─────────────────────────────────────────────────────────────
install_terraform_lsps() {
    if ! has_terraform; then
        skip_lang "Terraform"
        return
    fi
    info "Installing Terraform LSPs..."
    install_pacman terraform-ls
}

# ─────────────────────────────────────────────────────────────
# LaTeX LSPs
# ─────────────────────────────────────────────────────────────
install_latex_lsps() {
    if ! has_latex; then
        skip_lang "LaTeX"
        return
    fi
    info "Installing LaTeX LSPs..."
    install_pacman texlab
}

# ─────────────────────────────────────────────────────────────
# Docker LSPs
# ─────────────────────────────────────────────────────────────
install_docker_lsps() {
    if ! has_docker; then
        skip_lang "Docker"
        return
    fi
    info "Installing Docker LSPs..."
    install_yay dockerfile-language-server
}

# ─────────────────────────────────────────────────────────────
# Ansible LSPs
# ─────────────────────────────────────────────────────────────
install_ansible_lsps() {
    if ! has_ansible; then
        skip_lang "Ansible"
        return
    fi
    if ! has_node; then
        warn "Ansible LSP requires npm, skipping"
        return
    fi
    info "Installing Ansible LSPs..."
    install_npm "@ansible/ansible-language-server"
}

# ─────────────────────────────────────────────────────────────
# SQL LSPs
# ─────────────────────────────────────────────────────────────
install_sql_lsps() {
    if ! has_sql; then
        skip_lang "SQL (psql/mysql/sqlite)"
        return
    fi
    info "Installing SQL LSPs..."
    install_pacman sqls
}

# ─────────────────────────────────────────────────────────────
# Generic config file LSPs (always install)
# ─────────────────────────────────────────────────────────────
install_generic_lsps() {
    info "Installing generic config LSPs (YAML, TOML, JSON, Markdown, XML)..."
    install_pacman yaml-language-server
    install_pacman taplo               # TOML
    install_pacman marksman            # Markdown
    install_yay lemminx                # XML
}

# ─────────────────────────────────────────────────────────────
# Main
# ─────────────────────────────────────────────────────────────
main() {
    echo "═══════════════════════════════════════════════════════════"
    echo "         LSP Installer for Arch Linux + Mise"
    echo "    (Only installs LSPs for detected languages)"
    echo "═══════════════════════════════════════════════════════════"
    echo
    
    # Language-specific LSPs
    install_c_lsps
    install_rust_lsps
    install_go_lsps
    install_python_lsps
    install_node_lsps
    install_java_lsps
    install_kotlin_lsps
    install_ruby_lsps
    install_php_lsps
    install_lua_lsps
    install_zig_lsps
    install_haskell_lsps
    install_elixir_lsps
    install_scala_lsps
    install_dotnet_lsps
    install_ocaml_lsps
    install_clojure_lsps
    install_nix_lsps
    install_bash_lsps
    install_terraform_lsps
    install_latex_lsps
    install_docker_lsps
    install_ansible_lsps
    install_sql_lsps
    
    echo
    # Always-useful LSPs for config files
    install_generic_lsps
    
    echo
    echo "═══════════════════════════════════════════════════════════"
    success "LSP installation complete!"
    echo "═══════════════════════════════════════════════════════════"
}

main "$@"

In theory that’s all there is to it. If anyone knows a better way, drop it in the comments below.

I’ll do only this one article about it and I don’t intend to cover more than the tip of the iceberg. The idea is to serve whoever is coming from other editors like Sublime Text or VS Code and can’t even start navigating or even quit Vim lol 🤣.

Initial Commands

As I said in the previous post about LazyVim, I’ll assume you already understand at least how to install support for your language with LazyExtras and already learned to version things using Mise.

Without even getting into LazyVim, the first thing to know is that it installs all the relevant configurations in the ~/.config/nvim directory. Normally you don’t need to touch anything there. Leave files like lazyvim.json alone. Notice that it does the same thing as any NPM out there: there’s a lazy-lock.json file that declares the version/commit of each installed plugin. LazyVim does something similar to an npm install. Just a curiosity so you know how it organizes itself.

If you need to customize something, it’s usually going to be in the ~/.config/nvim/lua/config directory. That’s where I added Mise support, for example:

~/.config/nvim
❯ cat lua/config/mise.lua
-- Prepend mise shims to PATH
vim.env.PATH = vim.env.HOME .. "/.local/share/mise/shims:" .. vim.env.PATH

They’ll always be scripts written in Lua. And you don’t even need to know Lua deeply. At a glance it’s a very simple language, not very different from Python or Javascript and any programmer should be able to read any snippet without any problem. Besides, in most cases you’ll be copying configurations you got from the documentation, wiki or ChatGPT itself, so you just need to know that things go in this location.

Understand that NeoVim has the concept of the “Leader” key, a key that precedes hotkeys for other commands (there’s also localleader which is backslash \). This is configurable but in LazyVim the Leader is the “Space” key. In a lot of documentation we’ll see people saying “press Leader-w”, which means Space+w and now you know what that means.

To open a file there are at least 3 different ways, 2 of them shown in the image above:

Space+E opens NeoTree, which is that sidebar on the left that looks like Windows Explorer. You can navigate with the keyboard or even with the mouse. Find your file and press “Enter” to open it, then “Space+E” again to hide the sidebar. If you want to know how to create a new file, a new subdirectory, rename things and so on, type ? (question mark) to see this help:

The third way is manually with the :e command followed by the file name in the local directory. It has autocomplete too, this is the fastest way, if you know what you’re looking for.

Whenever you want to cancel anything or close “floating windows” (pop-ups, dialog boxes). Just press “Esc”. Esc is fundamental in NeoVim.

Once a file is open, it sits in the Buffer. Think of Buffer as “Open Tabs” in your VS Code. To navigate through Buffers (like alt+tab between your already-opened files) it’s simple:

• ]+b for next “tab” (next Buffer)
• [+b previous Buffer
• Space+bd to “close the tab” (close the Buffer)
• Space+bo to stay where you are and close the other buffers

Open as many files as you want. If one of them is one of those huge logs you opened by accident, Space+bd to close it and done.

Speaking of closing, how do you exit NeoVim? There are several ways:

• Space+q
• :q
• :q!

The difference: the first is the custom way in LazyVim. The second is the standard way using the “commands” feature that always starts with “colon”. And the third is if you modified something in the file but want to cancel, exit without saving anything, hence the exclamation mark.

Normally I use :wq which means “write” and “quit”. So it first saves the changes to the file and then quits the program. It’s useful when I’m just quickly editing a config file.

Basic Navigation

Now I have a file open. How do I navigate through it? First, how do I go to the end of the file and then back to the beginning? This is something I use a lot, just type Shift+g to go to the end of the file and then gg to go back to the beginning. Simple as that.

Now let’s learn several commands at once:

• Type v. This starts the “visual mode” which, in practice, means starting to select from wherever your cursor is.
• Type j. Which is the equivalent of “arrow down” to go to the line below. You’ve probably heard that in Vim you navigate with “hjkl” which are, respectively, left, down, up, right.
• Type x. Which is the equivalent of “cut” and putting the content in the clipboard. Having done that, typing p gives you “paste”.
• Type u. Which is the most-used command: Undo or undoing the last modification.

All of this works in what’s called “command mode”, which is the default mode Vim opens every file in. In this mode you can’t type any text. As you can see, each letter by itself is a command, like “x” for cut or “p” for paste.

To type, you first need to press i (just the lowercase “i” letter), which then switches from command mode to “edit mode”. Now just type your text normally, like in any editor. When you want some command, just press ESC to go back to command mode. We’ll be doing this all the time, which is why a lot of people remap the “caps lock” key on the keyboard to be ESC so it’s easy to just tap with your left pinky.

Combining Commands

Still in command mode, how do we navigate through the file more easily?

Beyond the “hjkl” keys, we can navigate more easily using b for “previous word” or w for next word:

Command mode lets you combine commands, so we can do:

• dw to delete the next word
• db to delete the previous word
• d4w to delete the next 4 words
• d4j to delete the next 4 lines down

Primeagen’s tutorial has several exercises for this kind of navigation, I recommend practicing. In VS Code everyone is used to first grabbing the mouse, marking the block they want to delete visually, then pressing delete or backspace. In Vim, we look at where the cursor is, press ESC to be in command mode, and type the operation and the location. Test all the combinations you can imagine.

This is the paradigm shift that bothers the lazy. But once you’ve learned this, you’ll find it annoying to use an editor that forces you to use the mouse for basic things.

Now it gets more interesting: what if instead of deleting a word, I want to replace the word where my cursor is with another word?

In a normal editor, you’d mark it with the mouse (or use some combination like “ctrl+shift+arrow”), and type over it or delete the word.

In LazyVim there are plugins configured for more interesting things. In the video above see how I’m replacing words “in-place”. You do this with the ciw command.

• ciw deletes the entire word under the cursor and opens edit mode for you to type the replacement
• ce deletes from the cursor to the end of the word (preserves the beginning of the word) and also opens for you to type in its place
• Shift-c (capital C) deletes everything from your cursor to the end of the entire line and opens for you to type.

But that still doesn’t look thaaaat cool. What if you want to change only the first letter of several lines at the same time, for example, in the text of the video above, I want to change only the hyphen ("-") of each tag line?

I said before that pressing v in command mode starts visual mode and you can select from there. But there’s Ctrl+v which opens vertical block selection mode.

In this mode we use the “hjkl” keys normally, like j to go down, but instead of marking the next entire line, it marks only the character right below your cursor. Now I can delete with d and type Shift-i (capital “I”) to enter edit mode at the beginning of the block and replace with whatever I want.

LazyVim has plugins for comments, but this is another alternative if you want to add “//” or “#” at the beginning of several lines to comment out, for example. In this case, read about the ts-comments plugin for better options for commenting. To start a new comment block, type gco to add a comment below.

“Block mode” as I showed above, is one of the things I use the most in code.

But only that is very little. What if you want to replace ALL IDENTICAL WORDS in the text at once. In the example video above, I want to replace “domínio” with “DOMAIN” and “Cloudflare” with “AWS Amazon”, how do I do that? This is “Search and Replace” that exists in every editor and in Vim it’s very easy:

We type :%s/domínio/DOMAIN/.

If you’re a programmer you’ve probably seen this syntax before. It’s the REGEX MATCH syntax. Yes, you have to know Regex (and no, it’s not PCRE nor Unicode, it’s NeoVim’s own Regex dialect, but it’s similar).

As I said before, “colon” opens the command-typing box, "%s" starts “search with regex” and between the slashes “//” first goes what you’re looking for and then what you want to replace it with.

But that’s the way in pure NeoVim; in LazyVim, there’s the grug-far plugin and you activate it with the SPACE+sr command:

Now yes, more like VS Code, right? Use whichever you find easier.

Conclusion

As I said, this is only the tip of the tip of the iceberg, the bare minimum of the bare minimum to at least start editing simple config files without opening Nano or VS Code just for that.

Read the LazyVim documentation. Check out the keymaps to discover other commands. Pay attention to every letter you press in command mode, LazyVim shows the available options. For example, let’s say I pressed g (goto), it will show a help in the bottom-right corner:

This way you can always discover new commands or remember commands you rarely use. That’s why I recommend LazyVim, which comes well configured to help you. The plugin that provides this feature is which-key, in case you want the same thing in a NeoVim you configured from scratch.

There are several Cheatsheets out there with tables of important command combinations. Worth exploring.

And there’s more: LazyVim comes with dozens of plugins for formatting, linting, integrated LSP, integrated GIT, and much more. There’s no way I can document each one here. Each of them has its own documentation on the LazyVim.org plugins page.

Again, don’t forget to call :LazyExtras and install the optional plugins for your languages.

The more “modern” apps are basically canned web front-ends wrapped inside Electron. The problem? They’re HEAVY and chew through RAM like there’s no tomorrow. Start opening Discord, Spotify, and a handful of these and see if your old 8GB notebook can keep up.

But, especially if you’re a programmer, you should pay more attention to TUIs. At first, some will turn their nose up: “terminal apps are ugly, black and white, boxy, blegh”

Twenty years ago, they’d be right. But it’s 2025 and today’s terminals support 256 colors (more than enough), various resolutions and, most importantly, fonts, in particular Nerd Fonts, fonts that have icons inside. That’s how a tool like eza works, which I use every day aliased to ls and looks like this:

And there’s more: there are modern libraries, for several languages, like BubbleTea, a framework for building TUIs. Check their GitHub but they have the tools to make interfaces like this:

And if you just want a simple widget to complement a Bash script you’re writing, they have Gum, which lets you do interfaces like this:

And to use it just install the binary and put lines like this in your script:

# Gum examples
gum choose "fix" "feat" "docs" "style" "refactor" "test" "chore" "revert"

gum input --placeholder "scope"

gum confirm "Commit changes?" && git commit -m "$SUMMARY" -m "$DESCRIPTION"

And if you use Omarchy they ship an extra feature for TUIs. Just hit “SUPER+ALT+SPACE” to bring up the main menu, then pick “INSTALL” and “TUI”. Or simply open the terminal and run:

$OMARCHY_PATH/bin/omarchy-tui-install

It’ll ask for a name for the App and the command line to run. You can also pick icons at Dashboard Icons. Once registered that way, when you call the Rofi launcher with “SUPER+SPACE” and type “lazy”, LazyDocker shows up as if it were a regular app:

And since Hyprland has no title bar or anything, TUI apps or web apps (there’s omarchy-webapp-install too) open as if they were “native” apps:

Read the TUIs and Web-Apps sections in the Omarchy manual.

Obviously, this is only for those who prefer the feeling of running “Apps”, but it’s the same thing as opening a Terminal and simply typing lazydocker on the command line - which is my preference. What these Omarchy scripts do is create a .desktop file at ~/.local/share/applications. The LazyDocker.desktop example generates this:

❯ cat ~/.local/share/applications/LazyDocker.desktop
[Desktop Entry]
Version=1.0
Name=LazyDocker
Comment=LazyDocker
Exec=alacritty --class TUI.tile -e lazydocker
Terminal=false
Type=Application
Icon=/home/akitaonrails/.local/share/applications/icons/LazyDocker.png
StartupNotify=true

If you don’t want this launcher anymore, just delete the file or call the $OMARCHY_PATH/bin/omarchy-tui-remove script.

This feature is particularly interesting in Hyprland because, unlike GNOME or KDE, the window has no top title bar, so it doesn’t give away that you’re just opening a terminal or web browser. That’s how it ships pre-configured with things like ChatGPT or Grok looking like “native” apps, when they’re really just Chromium windows opening each one’s URLs directly:

Some TUIs I like

In my opinion, since there are no pretty GUI apps for Linux, it’s really better to use the respective web apps like Canva or ChatGPT that way, but more interesting is having actual TUIs. As I said, these days it’s not hard to make pretty TUIs. For a programmer, the advantage is that you don’t have to deal with front-end frameworks first, and second, you don’t have to deploy anywhere on the internet.

TUIs are lightweight, use few machine resources, they’re easy for any programmer to build, and you can have a home server or a server in some cloud, SSH in, and access the TUI, without having to deal with X11 or RDP or anything heavier just to get a GUI.

Some TUIs are obvious: in the previous post I already talked about LazyVim and how it’s a text editor as competent and complete as VS Code, using only a fraction of the machine’s resources. Everyone should know tools like HTOP or BTOP. Plus LazyGit or LazyDocker. All of these already come in Omarchy.

But there’s much more, for example, dblab which is a TUI database client for MySQL or Postgres:

Another similar one is LazySQL, written in Go:

Or if you prefer tools written in Rust, there’s rainfrog:

For those who can’t use CURL on the command line and prefer Postman to call and explore APIs, there’s the TUI Posting that does the same thing:

For those of us who run lots of Docker containers, I already mentioned LazyDocker, but there’s also oxker:

If you use Discord, there’s discordo:

Anyone who does a lot of Linux ricing has had to burn ISOs to USB sticks dozens of times; for that there’s dd on the command line, but there’s a cooler TUI called Caligula:

If your SSD is filling up and you have no idea where the hell all that space is going, there are several tools to analyze and show you. One of them is gdu:

And the last one I thought was cool out of nostalgia is sc-im; think Excel as a TUI or - for those of us who came from the 80s - think Lotus 1-2-3 but with Vim keybindings:

Why open Google Spreadsheets just to make a Todo list if you can do it in the Terminal?? TUIs are exceptional!

If you want to discover more TUIs check out awesome-tuis on GitHub:

Again: zero need for heavy web front-ends for simple things. Nothing beats the simplicity of a command line. And with libraries like BubbleTea or Gum, it’s now very easy for anyone to make a pretty app. And with Hyprland and Omarchy, everything stays integrated side-by-side with any other GUI app.

Getting a bit philosophical, the history of GUIs starts with skeuomorphic graphical interfaces that try to imitate objects from our daily life, particularly looking pseudo-3D, like Windows 95 was. The 2000s arrived and they started migrating to flat or minimalist interfaces, completely removing the skeuomorphism, making everything flat. That came mainly from Windows 8’s Metro. And I think that’s converging toward a more TUI-like style, coming full circle, going back to how it was on 70s terminals. Personally, I find that fascinating.

But you don’t need to use these menus. Let me explain.

On a regular Arch Linux or Ubuntu, an amateur would install ruby or python doing something like this:

# arch
yay -S ruby python3
# ubuntu
apt install ruby python3

This is the WRONG way.

These commands will install the latest version of each language, and every time you update the system with yay -Syu or apt upgrade, they’ll pull in even newer versions.

The thing is, if you develop real projects, you don’t want the versions to change.

The version deployed on the cloud server and the version on your local machine MUST BE THE SAME.

If you’re using Ruby v3.0.7 and Node.js 22.19.0, you can’t be held hostage to the fact that when you update your system, out of nowhere Ruby 3.4.5 and Node 24.7.0 show up. Everything will start breaking and you’ll be super confused without knowing why. This is the most basic mistake a junior developer makes.

To avoid this, every project you’re working on MUST BE LOCKED TO FIXED VERSIONS.

The easiest way to do this in 2025 is using MISE. As I said, it already comes installed and activated on Omarchy, but if you’re using another distro just install Mise manually:

yay -S mise

# .bashrc
eval $(mise activate bash)

Adapt this for ZSH, Fish or whatever shell you’re using, read the documentation

Now navigate to your project directory, for example:

cd ~/Projects/AkitaOnRails.com

And lock the versions:

mise use ruby@3.2.3
mise use node@14.21.3

This will create a .tool-versions file that you should add to your repository’s git:

❯ cat .tool-versions
ruby 3.2.3
nodejs 14.21.3

❯ git add .tool-versions

And done, every time you cd into the directory, Mise will activate exactly the right version for that project. Look:

AkitaOnRails.com [ master][$!?⇡][ v24.7.0][💎 v3.2.3]
❯ ruby -v
ruby 3.2.3 (2024-01-18 revision 52bb2ac0a6) [x86_64-linux]

AkitaOnRails.com [ master][$!?⇡][ v24.7.0][💎 v3.2.3]
❯ which ruby
/home/akitaonrails/.local/share/mise/installs/ruby/3.2.3/bin/ruby

Notice that, if you’re using the Starship prompt I explained in the previous post, with a preset like Pure Prompt, it shows the version of each language in the prompt so it’s easy to see if you’re on the wrong version.

In this case, if you read carefully, you’ve probably already noticed that YES, I’M ON THE WRONG VERSION of Node.js. Look how the prompt says I’m using Node 24.7.0 but the .tool-versions file asks for 14.21.3.

The reason it’s “missing” is because this machine was recently installed, but the project is old.

So let’s check:

AkitaOnRails.com [ master][$!?⇡][ v24.7.0][💎 v3.2.3]
❯ mise list
Tool    Version            Source                                              Requested
go      1.25.0             ~/.config/mise/config.toml                          latest
node    14.21.3 (missing)  /mnt/data/Projects/AkitaOnRails.com/.tool-versions  14.21.3
node    22.18.0
python  3.13.7
ruby    3.2.3              /mnt/data/Projects/AkitaOnRails.com/.tool-versions  3.2.3
ruby    3.4.5

See how in the mise list output it says 14.21.3 is “missing”. So let’s install it:

AkitaOnRails.com [ master][$!?⇡][ v24.7.0][💎 v3.2.3]
❯ mise use node@14.21.3
mise /mnt/data/Projects/AkitaOnRails.com/.tool-versions tools: node@14.21.3

AkitaOnRails.com [ master][$!?⇡][ v14.21.3][💎 v3.2.3]
❯

With the mise use command we can ask it to install and use a particular version. If it’s not already installed, it will install it. Notice how after that the Starship prompt changed to reflect that we’re now using 14.21.3. That’s the right way.

If you’re not necessarily in a project directory with locked versions, you can still run commands using a specific version, like this:

mise exec ruby@3.2.1 -- ruby ...

Say you want to generate a Rails project on a specific Ruby version:

mise exec ruby@3.2.3 -- rails new todo-exercise

The same goes for generators in Node, like Next.js or any other framework.

I haven’t checked whether LazyVim on Omarchy comes configured this way, but in case it doesn’t, for NeoVim to support Mise you need to add this:

-- Prepend mise shims to PATH
vim.env.PATH = vim.env.HOME .. "/.local/share/mise/shims:" .. vim.env.PATH

Just put this in ~/.config/nvim/lua/config/mise.lua and it should load the correct path. To integrate with other editors, check this documentation. There are TONS of advanced options and it’s worth reading about them in the Dev-Tools section, but the basics are what I listed here.

And databases??

The same goes for databases. Every project should be locked to a specific version identical to what’s running on the production server and should never depend on operating system packages. You can use mise for this but the most recommended option is to use Docker. Every project MUST have a docker-compose.yml to spin up only the databases. You don’t need to spin up containers for languages, for that it’s better to use Mise.

If you don’t understand Docker, I made videos teaching it:

Adding up Mise + Docker Compose + LazyVim, that’s everything you need to be a productive web developer, while also using your machine’s resources efficiently. Every developer NEEDS to learn this combo of options. Omarchy already brings it all pre-installed, which is why it’s been my recommendation for every beginner.

Don’t worry: Arch Linux (with archinstall) is as easy to install as an Ubuntu or Linux Mint, and Omarchy’s Hyprland is much prettier and smoother than MacOS. The best of both worlds. Learn it today!

Even if you don’t use Omarchy, I recommend installing LazyVim. Just do this:

# required
mv ~/.config/nvim{,.bak}

# optional but recommended
mv ~/.local/share/nvim{,.bak}
mv ~/.local/state/nvim{,.bak}
mv ~/.cache/nvim{,.bak}

git clone https://github.com/LazyVim/starter ~/.config/nvim

rm -rf ~/.config/nvim/.git

nvim

That’s it. For those who don’t know, NeoVim is a more modern fork of the old Vim (hence the command is nvim, leaving vim reserved for the old one). It replaces the old VimScript with Lua scripts and has many optimizations and better quality-of-life features. These days, there’s no reason to keep using old Vim.

Using Lua, you can configure Nvim any way you want. But configuring everything from scratch is a lot of work. It’s a good exercise, but practically speaking, it’s not worth it day to day. Better to install a pre-configured setup like the old LunarVim, which I used before and even recommended in some Linux videos on my channel, or AstroNvim, or LazyVim, which is currently my favorite. Any of them is a good start and it comes down to personal preference.

Each plugin they install has many features and its own key combinations (hotkeys) that you need to read in the documentation to know what does what. I recommend going to the plugins section of the official site and reading them one by one. There’s a lot of stuff you wouldn’t even expect, and all of it is very useful.

LazyVim on its own already helps a lot because it opens pop-ups documenting some of the hotkeys. For example, what’s called the Leader command in LazyVim is the “space bar”. When you press it, this context menu appears:

From here, if you type, say, “b”, another context menu shows up:

And if you type “b” again, it switches to the next file already open in the Buffer. Buffer is the Vim name for where already-opened files live. Deleting from the Buffer is the equivalent of “closing the file”.

Next time, you won’t need to look at the menus. Just type quickly in one go: “Space+b+b”. That’s how you memorize the commands you use the most.

Some commands worth learning right away: Space+Space (twice), which opens the menu for opening files. Type a few letters of the file name and it filters dynamically:

Or “Space+e” to open the NeoTree Explorer. Type “?” to open a popup with the commands you can use to create new subdirectories or files within the subdirectory:

Once you learn the other commands and plugins, you’ll notice you don’t even need to open NeoTree. It’s more for when you want to explore visually. For day-to-day work, commands like “:e” should be enough. By the way, “:” (colon) is the command for executing NeoVim functions. For example “:q” is quit, “:w” is write, and “:wq” is write and quit at the same time.

If you want to learn NeoVim more deeply, I recommend the YouTube channel of my friend Eustáquio Rangel, a Linux, Rails, and Vim veteran who teaches NeoVim from scratch (without LazyVim).

Now, let’s say you’ve already learned the basics of NeoVim and LazyVim, and now you want to start working on your PHP, Java, C#, Ruby, Python, or whatever projects. You’ll notice that LazyVim doesn’t have any functionality for any of them.

What do you do now? Install VS Code?? NO!!

That’s because you haven’t run :LazyExtras yet.

Type it exactly like that and watch this:

This window looks complicated but it’s just a list of plugins split into sections. At the top you see the plugins already installed and enabled. If you don’t want any of them, just use the arrows to move the cursor down to one of them and press “x” to unmark it. But leave that section as is. Let’s scroll down to the “Languages” section:

This is the section where all the languages you can enable support for live. Just scroll down with the arrows and mark with “x” which ones you want to install. And there’s everything: Angular, Vue, Erlang, Elixir, Rust, Zig, Haskell, and much more.

Next to each language is the group of individual plugins it will install. To know what each one does, type their names into Google and find the documentation page, where you’ll find hotkeys and extra configurations you can set.

With this you gain things like Linters, syntax highlighting, LSP, snippets, and much more.

And if you want to install additional plugins that aren’t listed, you can add them manually. Read the Adding Plugins section in the documentation.

LazyVim + LazyExtras covers 90% of everything you need for day-to-day software development. It’s lighter and faster than VS Code, uses way less memory, and will be much better especially on older machines. Don’t be lazy about learning Vim. A real programmer shouldn’t stick with VS Code just because they’re too lazy to learn a few extra hotkeys.

If you want to switch to ZSH, it’s easy, just do this:

yay -S zsh zoxide
chsh -s $(which zsh)

Logout, login, and done. But now your shell will be empty. To grab my config do this:

git clone https://github.com/akitaonrails/omarchy-zsh.git ~/.config/zsh
ln -s ~/.config/zsh/.zshrc ~/.zshrc 

There are two things you need to change. In .zshrc remove this line:

source ~/.config/zsh/mounts

That’s just for me to check my NFS mounts to my NAS. It’s useless to you so you can remove it.

The second thing is to create a new file for secrets:

touch ~/.config/zsh/secrets
chmod 600 ~/.config/zsh/secrets

This is where you put stuff like your OpenAI or Google Cloud keys or anything like that. For example:

# ~/.config/zsh/secrets
export OPENAI_API_KEY="sk-xx-v1-xxx...xxxxx"

That way your secrets stay separated from your configs and we can git push to a repository without worrying that something might leak in the future. Always keep secrets, passwords, and keys separated locally. This is already in .gitignore so you’re safe.

As a bonus, in ~/.config/init I added support for Atuin, a tool that syncs all the command history you ran in your shell to a “cloud” repository (read the docs, you can create your own local server too). The repository is encrypted, so it’s safe even if your history contains secret keys in the commands.

Install it like this:

yay -S atuin
atuin register -u <your username> -e <your email>
atuin import auto
atuin sync

As soon as you register, Atuin will generate a random encryption key. Make sure you store this key somewhere safe like 1Password, Bitwarden or another secure vault!! Without it you won’t be able to decrypt on a new installation. If you forget, you can still view it before reinstalling, like:

atuin key

If you reinstall your machine or set up a new one and want your history back, just install Atuin and run:

atuin login -u <your username>
atuin sync

It will ask for your password and encryption key and bring all your history back.

With my config, just hit Ctrl+R to bring up the history search (which from now on will live in a sqlite on your machine). Read the documentation for more features.

DHH set up the Starship prompt using the old PS1 variable style. But Starship already has several nice prompts that are easy to use as “presets”. I picked Pure Prompt, which I like, but there are plenty of others. If you want something flashier and more colorful, there’s this Pastel Powerline:

Pick your favorite on the Presets page and change ~/.config/zsh/prompt on this line:

starship preset bracketed-segments -o ~/.config/starship.toml

Finally, I left some ENVs in ~/.config/zsh/envs that work for my Ollama tests and things like that, but it’s good for you to know they’re there so you don’t find it weird if your Ollama is behaving strangely. Edit the ~/.config/zsh/envs file to set the envs you prefer:

# envs
export OPENAI_API_BASE="https://openrouter.ai/api/v1"
export DEFAULT_MODEL="o1-mini";
export OLLAMA_API_BASE=http://127.0.0.1:11434
export OLLAMA_HOME=http://127.0.0.1:11434
export OLLAMA_MODELS=/mnt/gigachad/ollama/models

Also modify the ~/.config/zsh/aliases file to include aliases you prefer:

# aliases
alias monhd="sudo ddcutil -d 1 setvcp 60 0x12"
alias mondp="sudo ddcutil -d 1 setvcp 60 0x0F"

alias sgpt='docker run --rm -e OPENAI_API_BASE=${OPENAI_API_BASE} -e OPENAI_API_KEY=${OPENROUTER_API_KEY} ghcr.io/tbckr/sgpt:latest txt '

alias git='nocorrect git'
git config --global alias.a 'add'
git config --global alias.ps 'push'
git config --global alias.pl 'pull'
git config --global alias.l 'log'
git config --global alias.c 'commit -m'
git config --global alias.s 'status'
git config --global alias.co 'checkout'
git config --global alias.b 'branch'

The first two aliases are for my dual monitor setup where one of the monitors receives signal from both the HDMI input and the DisplayPort input (I have 2 GPUs). If you didn’t know, you can control that from the shell. Read this post about ddcutil

Next you get the sgpt command. Omarchy already ships with Docker installed. Now from the shell you can ask ChatGPT without having to open a web browser for it:

sgpt "what is the rsync syntax to sync two directories?"

Read the SGPT documentation to learn about other features or which LLMs you can choose.

At the end we have aliases for Git. Omarchy already has an alias making “g” mean “git” and with this one I added you can do:

git add . # old
g a . # new

git commit -m "initial commit" # old
g c "initial commit" # new

git commit --amend -m "initial commit"
g ca "initial commit"

git push origin master
g ps origin master

git pull origin master
g pl origin master

git log
g l

# and so on

More practical and less verbose. Add more aliases as your workflow demands in ~/.config/aliases.

And I think that’s it, now my Omarchy is organized the way I like. Make your own tweaks so everything fits your style too!

I am also still very much intrigued by the idea of Windows Subsystem for Linux (or WSL) which properly debuted in the Windows 10 Anniversary Edition back in mid-2016.

It’s been almost 2 years and we’re expecting some significant updates to WSL compatibility and performance for the next Spring Creators Update (or version 1803) scheduled to arrive on April 30, 2018. This brings it closer to making WSL actually usable for professional programmers. Just to give you an idea, right now you will have orders of magnitude better performance if you run your favorite Linux distro inside Virtualbox or VMWare Workstation.

Moreover, out of the box the “Bash for Windows” proper only officially supports Ubuntu, Fedora, and OpenSuse I guess. Most people will just install Ubuntu. And it works ok. For toy and cool demonstration purposes, it works. But it really frustrates me that I can do so much but I can’t actually use it as my daily driver. It’s like being able to carry the fully built prototype of the next iPhone but no 4G support yet. So it’s just a toy.

Bear with me here, if you just want to see how the performance compares to my VMWare setup, go straight to the end of the article.

Anyway, in the case of distros. Serious Linux users would prefer better alternatives. Enter this GitHub repository:

You just download this zip file, unzip it and run the included Arch.exe. And that’s about it!

Now, you can go ahead and open the Windows version of “Bash” and we can bootstrap the rest of the installation setup from there.

We must get Pacman and some AUR manager. To start Pacman, we must do this:

pacman-key --init
pacman-key --populate
pacman -Syu

Hell yeah, Pacman running natively on Windows!! Who would’ve known??

This will bring everything up to date. Next up, we must create a non-root user:

useradd -m your_user
passwd your_user
EDITOR=nano visudo

Look for the line that says root ALL=(ALL) ALL and add your user right on the next line like this:

your_user   ALL=(ALL) ALL

Finally, we should login as this user:

su your_user

Next up, let’s install Yaourt so we can use it to install Pacaur (this is a personal preference, you can just use Yaourt. I think Yaourt prompts too much, that’s why I prefer Pacaur).

Start by editing your /etc/pacman.conf file with your favorite editor like vim or nano.

Just add the following section to the very bottom of the file:

[archlinuxfr]
SigLevel = Never
Server = http://repo.archlinux.fr/$arch

Before we can proceed, we have one small problem. WSL still has no support for SYSV IPC. This is required for fakeroot, which is required by makepkg (which cannot run as root).

To overcome this problem, this is what we’ll have to do:

wget https://github.com/yuk7/arch-prebuilt/releases/download/17121600/fakeroot-tcp-1.22-1-x86_64.pkg.tar.xz
sudo pacman -U fakeroot-tcp-1.22-1-x86_64.pkg.tar.xz

And that’s it for now! Until WSL adds proper support for SYSV IPC, we can use this. Yaourt itself will probably prompt you to install fakeroot-tcp on top of it, just let it.

As I said, Yaourt is quite verbose in its many prompts for confirmations. Rule of thumb, whenever it prompts if you want to edit anything, just say “N”(o). Whenever it prompts you if you want to build or install something, just say “Y”(es). If you got annoyed with me, do this:

yaourt -S pacaur

From now on, I will assume you have Pacaur.

Graphical User Interface Support

Now, let’s install some of the basics for a development environment:

sudo pacman -S base base-devel gvim git

It will prompt you sometimes “default: all”, just install everything. Hard disk space should not be a concern in 2018.

I prefer to have a full-on GNOME 3 environment, so I just do:

sudo pacman -S gnome

Again, let it install everything it wants. Everybody has a different taste when it comes to GUIs, some prefer KDE5, others prefer XFCE4. Some even go as far as using the tile-based GUI i3.

That requires some serious adapting. It’s for people that like to do stuff like using a tenkeyless keyboard with nothing written in the keycaps and using an alien layout like DVORAK or Colemak (yikes!). Taste is taste. And I dare you to become a touch typist using Maltron, I double dare ya! :-D

But, I digress. Now, you can add this to your /etc/.bashrc file or the global /etc/environment file:

echo "export LIBGL_ALWAYS_INDIRECT=1" >> /etc/.bashrc
echo "export DISPLAY=:0" >> /etc/.bashrc

Export those to your current shell, or just close and reopen Bash.

We can have a full GUI environment by installing a local X Server. You have 2 options, Xming and VcXSrv. I am having trouble resizing windows in Xming, so I am recommending VcXSrv instead. Just download and install it as you would with any Windows application and start it up. It will add a Desktop shortcut named “XLaunch”, just fire it up.

And finally, we can install a PROPER usable terminal instead of that poor contraption derived from old cmd.exe that WSL provides you out of the box.

pacaur -S tilix-bin
tilix

If you’ve been a Mac user, you probably know iTerm2, which is possibly the best Terminal emulator I’ve ever used. There is nothing else that comes close. Nothing, except possibly Tilix (previously known as Terminix).

Just for having “Ctrl-Alt-D” to split the terminal horizontally down and “Ctrl-Alt-R” to split it vertically to the right, and using “Alt-1”, “Alt-2”, and so on to switch between the terminals, it’s great for me. It also comes pre-installed with very nice themes such as the now classic Solarized Dark or my current favorite Monokai Dark.

Don’t curse me, I know. Some will prefer the default terminal app and just add TMUX. Again, taste (it’s more useful if I were working on a remote server).

Add the Hack monotype font to make everything more pleasing to the eye:

sudo pacman -S ttf-hack

Programming Languages

Let’s see if the most important languages out there install correctly. As I always say, look no further than ASDF for that task.

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.4.3
echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.bashrc
echo -e '\n. $HOME/.asdf/completions/asdf.bash' >> ~/.bashrc

Restart your terminal and continue:

asdf plugin-add nodejs
addf plugin-add ruby

For Node.js you must add the proper GPG keys and only then you can install:

bash ~/.asdf/plugins/nodejs/bin/import-release-team-keyring
asdf install nodejs 10.0.0
asdf global nodejs 10.0.0

Ruby benefits from jemalloc to allocate less system memory. I have no idea if it impacts WSL but let’s do it anyway:

sudo pacman -S jemalloc
RUBY_EXTRA_CONFIGURE_OPTIONS="--with-jemalloc" asdf install ruby 2.5.1
asdf global ruby 2.5.1
gem install bundler

So far so good, if you need to install an old Ruby (< 2.4) for legacy projects, you must do:

pacaur -S openssl-1.0
PKG_CONFIG_PATH=/usr/lib/openssl-1.0/pkgconfig RUBY_EXTRA_CONFIGURE_OPTIONS="--with-openssl-dir=/usr/lib/openssl-1.0" asdf install ruby 2.3.3

Unfortunately it needs a version of OpenSSL that you should not be using due to security problems. We all moved on to 1.1. But Ruby 2.3.x reached its EOL (end of line). So it’s at your own risk to keep using it.

Well, so far so good. Can we install Go as well? Let’s see:

asdf plugin-add golang
asdf install golang 1.9.5
asdf global goland 1.9.5

We can keep going, but I think you got the idea. It just works!

Background Jobs

Again, another current limitation of WSL (that we expect to see fixed on the Spring Creators Update) is the ability to start and keep running background jobs (daemons).

Just doing sudo systemctl enable postgresql and restarting won’t automatically start Postgresql in the background as it should. This Arch.exe thing we’re using won’t even have systemd.

Fortunately, servers such as Postgresql or Redis do work normally, they can be started as user-level processes, and they do properly bind to their respective TCP ports. But, you will have to manually start them in every session. Close your Bash terminal and they are all killed off.

For example, Postgresql:

[your_user]# sudo pacman -S postgresql
[your_user]# sudo mkdir -p /run/postgresql
[your_user]# sudo chown -R postgres:postgres /run/postgresql

[your_user]# sudo -u postgres -i
[postgresql]# initdb --locale $LANG -E UTF8 -D '/var/lib/postgres/data'

[postgresql]# pg_ctl -D /var/lib/postgres/data start
waiting for server to start....2018-04-29 23:30:35.483 UTC [1064] LOG:  listening on IPv4 address "127.0.0.1", port 5432
2018-04-29 23:30:35.505 UTC [1064] LOG:  listening on Unix socket "/run/postgresql/.s.PGSQL.5432"
2018-04-29 23:30:35.583 UTC [1065] LOG:  database system was shut down at 2018-04-29 23:23:48 UTC
2018-04-29 23:30:35.660 UTC [1064] LOG:  database system is ready to accept connections

[postgresql]# createuser --interactive
Enter name of role to add: your_user
Shall the new role be a superuser? (y/n) y

[postgresql]# exit
[your_user]#

See what I did here? There is a small problem in the install under WSL where the /run/postgresql is not created with the correct permissions. Fixing that we can start the server. We can exit out of the su session and the postgresql server will keep running. But when we close the first Bash window/session, it will die.

And another very annoying thing? The mkdir and chown fixes above? I have to do it every single time I close the Bash for Windows app and start it again!! Super duper annoying if you ask me!

But, we can live with it for now. Hopefully, this will be fixed tomorrow (April 30) or in an upcoming upgrade.

In a Rails development environment, we can take advantage of Foreman to help us out. Just edit some Procfile.dev file:

web: bundle exec puma -C config/puma.rb -p 3000
db: su postgres -c 'pg_ctl start -D /var/lib/postgres/data'
redis: redis-server /usr/local/etc/redis.conf
mailcatcher: mailcatcher -f

Now we can do: foreman start -f Procfile.dev and all services will start properly at once.

Real World Performance

My daily driver is Manjaro GNOME under VMWare Workstation Pro on my Surface Book 2. I give it 6 threads out of the 8 and a hefty 12GB of RAM out of the total 16GB (damn Microsoft, we need more RAM nowadays that the cool kids deploy stupid ass Apps with heavy JS/CSS coating that eats up all available RAM).

In the project I am currently working on, my full RSpec suite is a bit on the slow side. For this comparison, I am skipping all my feature specs as I am in no mood to tweak chrome-driver to work in WSL (probably runs, but let’s have it another day).

Finished in 12 minutes 8 seconds (files took 14.58 seconds to load)
1493 examples, 0 failures, 35 pending

531,34s user 127,56s system 88% cpu 12:24,99 total

In this comparable WSL environment I have just installed, I am running the exact same RSpec suite, and this is what I get:

Finished in 13 minutes 43 seconds (files took 3 minutes 16.8 seconds to load)
1474 examples, 0 failures, 35 pending


455.80s user 399.14s system 83% cpu 17:04.96 total

For some reason, my WSL environment is skipping a few examples (seems more like an RSpec counter bug of some sort though), but I think this shouldn’t pose too much of a difference in the grand scheme of things here. WSL is losing even if the counter is correct and it’s running fewer examples.

When we start to really exercise the WSL a whole lot of issues start to show up. For example, PostgreSQL goes crazy and keeps stdout’ing “could not flush dirty data: Function not implemented”, which is due to this documented issue from the WSL! So what ends up happening is that sometimes the RSpec runner just pauses while PG tries to figure out what to do.

You can clearly see that under VMWare files took less than 15 seconds to load. On WSL they took over 3 minutes just on file I/O! It’s orders of magnitude slower. This is the bad part. When it’s just CPU vs CPU, they are pretty comparable actually.

On paper, the total time is actually quite close. And CPU-wise I think WSL has an edge, which is why it’s able to recover in the totals even though the I/O is clearly sluggish.

In practice what happens in a normal programming situation is that you fire up Vim, or any other text editor of your choice. Any programmer has to keep opening files and going back and forth between a lot of files. Now, I/O being super slow, every file you try to open pauses your action for a split second. And this adds up.

Within VMWare, Vim is super responsive, whenever I need to open a file, it’s almost instantaneous.

The benchmark may be hard to account for this situation. But in a normal scenario, you will end up annoyed. Moreover, running a GUI over X (VcXsrv in my case) slows things down a bit as well. From within VMWare, the normal Xorg can take advantage of being GPU accelerated. So the entire rasterization pipeline is faster.

You “can” use WSL as your daily driver. But if I can have a smoother experience from within VMWare, that’s where I will be for now.

Conclusion

I will actually hold my conclusions until tomorrow (April 30) or later this week, because if the Spring Creators Update actually fixes some performance issues, then I can see myself using this instead of my VMWare Workstation install of Manjaro GNOME.

It may not come in this big update, but I have word that they are working on the outstanding I/O performance issues. So it’s right around the corner.

Everything I need just works. Tilix, Vim, Git, Zsh, Ruby, Node.js. Everything installs as expected from Pacman and AUR. Pure Arch Linux glory! So sad the bad performance spoils it.

It’s close, it’s very close! For the first time in almost 15 years, I can almost see myself returning to 100% Windows (with no VMWare support) and still be able to be fully productive with real, professional, open source tools that “Just Works”.

Keep an eye on this blog post for updates this week!

I’ve been using asdf as my main Ruby version manager for a long while now and I am confident that I can recommend it in place of the more well recognized RVM or Rbenv.

Moreover, it not only can manage Ruby versions, but it can manage almost all languages you might want. With just one command set. So you don’t even need virtualenv for Python or NVM for Node.js. Just use ASDF.

Installing it couldn’t be easier. Just follow the README from the project page.

Don’t forget to install the base development tools for your environment. You can follow ruby-build’s wiki page for example:

## For OS X
# optional, but recommended:
brew install openssl libyaml libffi

# required for building Ruby <= 1.9.3-p0:
brew tap homebrew/dupes && brew install apple-gcc42

## For Ubuntu
sudo apt-get install gcc-6 autoconf bison build-essential libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libncurses5-dev libffi-dev libgdbm3 libgdbm-dev

## For Arch
sudo pacman -S --needed gcc5 base-devel libffi libyaml openssl zlib

Then you can install ASDF itself:

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.4.0

Then add the proper environment configuration for Path and auto-completion.

# For Ubuntu or other linux distros
echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.bashrc
echo -e '\n. $HOME/.asdf/completions/asdf.bash' >> ~/.bashrc

# OR for Mac OSX
echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.bash_profile
echo -e '\n. $HOME/.asdf/completions/asdf.bash' >> ~/.bash_profile

Finally, you must install one of the dozens of plugins. In my case, I have these installed:

asdf plugin-add clojure https://github.com/vic/asdf-clojure.git
asdf plugin-add elixir https://github.com/asdf-vm/asdf-elixir.git
asdf plugin-add erlang https://github.com/asdf-vm/asdf-erlang.git
asdf plugin-add golang https://github.com/kennyp/asdf-golang.git
asdf plugin-add python https://github.com/tuvistavie/asdf-python.git
asdf plugin-add ruby https://github.com/asdf-vm/asdf-ruby.git

# Imports Node.js release team's OpenPGP keys to main keyring
bash ~/.asdf/plugins/nodejs/bin/import-release-team-keyring

asdf plugin-add nodejs https://github.com/asdf-vm/asdf-nodejs.git

You can update the plugins all at once with this simple command:

asdf plugin-update --all

You can see what versions are available for a particular language like this:

asdf list-all ruby
asdf list-all clojure
asdf list-all python

Then you can install any version you need like this:

asdf install ruby 2.4.2
asdf install nodejs 8.7.0
asdf install erlang 20.1

After you install a particular language version, I always set one as the system default like this:

asdf global ruby 2.4.2
asdf global elixir 1.5.2

And in a particular project directory, I can set it to use any other version, just for that project:

asdf local ruby 2.3.4

The command above will write a .tool-versions file to the directory you’re at when you ran it. It will contain the language and version you chose, so whenever you go back to that directory ASDF will set the correct version for the language you need. The previous asdf global <language> command is actually writing a .tool-versions file to your home directory. The local config overrides the home directory version.

Another important thing to remember, whenever you install libraries which have executable scripts that need to be in the PATH, you must reshim them. For example:

npm install -g phantomjs # will install phantomjs
asdf reshim nodejs # will put the shim for the phantomjs executable in the PATH
phantomjs # will properly execute it

If you try to install Ruby versions prior to 2.4 you will find compilation problems as it depends on gcc5 and openssl-1.0. So you should use the following command (assuming you have already installed the obsolete openssl-1.0 and gcc5):

CC=gcc-5 PKG_CONFIG_PATH=/usr/lib/openssl-1.0/pkgconfig \
RUBY_EXTRA_CONFIGURE_OPTIONS="--with-openssl-dir=/usr/lib/openssl-1.0" \
asdf install ruby 2.3.4

Sometimes, if a dependency is missing and an install fails, you must manually remove it before attempting to reinstall, so you have to do:

asdf remove <language> <version>

Finally, if you’re used to add something to your bash or zsh files to show the current language version in the command line, you’re probably using something like rvm-prompt. In the case of ASDF you will need something a bit longer like this:

asdf current ruby | awk -F' ' '{print $1}'

This will get only the version (the asdf current command states which .tool-versions file it is using, so this is a longer result).

Other than that, you’re all set. One version manager to rule them all. No more RVM, no more Virtualenv, no more NVM, etc. You can live happily ever after!

I’ve been a long time Ubuntu user. Whenever I need to set up a Linux box I go straight to the latest LTS. Muscle memory, can’t avoid it.

But to replace my macOS, Unity is damn ugly, honest. I tried to customize Cinnamon and I almost liked it, and don’t even get me started on KDE or XFCE.

GNOME 3.22, on the other hand, is very handsome. I don’t need to tweak it or hack it to make it look good. The default set of global shortcuts are spot on if you’re a long term macOS user. I like almost everything about it.

I’ve been curious about all the fuss surrounding the phase out of X.org into Wayland so I wanted to check it out.

The best distro I could find with those in mind is good old Fedora. RedHat (4) was the second Linux distro I tried after Slackware 1 back in the mid-90’s. I come back and leave every couple of years. It’s a good time to try it again.

The TL;DR is that I am quite delighted with Fedora 25. It does almost everything I need right out of the box.

I dusted off a 4-year-old Lenovo ThinkCentre Edge 71z Tower desktop and Lenovo IdeaPad G400s notebook. They are, respectively, a 2nd generation Core i5 SandyBridge 2.5Ghz and Core i3 2.4Ghz, with 8GB of RAM in the Tower and 4GB of RAM in the notebook. For a developer’s routine, they are quite good enough. A better CPU wouldn’t do a whole lot.

I was very happy to see that this old tower has an old Intel graphics card with a DVI port. Fortunately I had an old DVI-to-HDMI cable around and I was able to hook it up to my ultrawide LG monitor 21:9 (2560x180) and it properly scaled everything (macOS Sierra had a regression that required a hack to make it work!)

What hurts a lot are the super slow mechanical hard drives (7200rpm and 5400rpm). I just ordered a RAM upgrade and 2 Crucial MX300 compatible SSD drives. When those arrive, I will have the snappiness I need.

That being said, when you have a fresh Fedora 25 install, what to do next?

for Ubuntu users

Just remember this: instead of apt-get you get dnf. Fedora prior to version 22 used to have yum, but dnf supercedes it with basically the same command options.

You don’t have the equivalent of apt-get update because it auto-updates. The rest is pretty much the same: dnf install package instead of apt-get install package, dnf search package instead of apt-cache search package, and so on. For a global upgrade, do dnf upgrade instead of apt-get update && apt-get upgrade.

For services, instead of doing sudo service restart memcached you can do sudo systemctl restart memcached.

That’s pretty much it for the most part. Read this wiki page for more command differences.

Crystal Language support

Let’s say you want to learn this brand new language called “Crystal”: Ruby-like familiar syntax and standard libraries but Go-like native binary generation, with fast concurrency primitives and all the benefits of an LLVM optimized binary.

You should follow their wiki page but this is what you need:

sudo dnf -y install \
  gmp-devel \
  libbsd-devel \
  libedit-devel \
  libevent-devel \
  libxml2-devel \
  libyaml-devel \
  llvm-static \
  openssl-devel \
  readline-devel

sudo dnf -y install fedora-repos-rawhide
sudo dnf -y install gc gc-devel # get all dependencies from Fedora 25
sudo dnf -y install gc gc-devel --enablerepo=rawhide --best --allowerasing

sudo dnf -y install crystal

And that’s it, a lot of dependencies but as it’s pre-1.0 I believe they will improve this in the future.

Ruby and Node.js support

Rubyists have a number of Ruby version managers, but I personally like RVM. First, we need to install some other requirements and go on with it:

sudo dnf -y install patch autoconf gcc-c++ patch libffi-devel automake libtool bison sqlite-devel ImageMagick-devel nodejs git gitg
curl -sSL https://rvm.io/mpapis.asc | gpg2 --import
curl -L https://get.rvm.io | bash -s stable --ruby

sudo npm -g install brunch phantomjs

There you go, you should have the latest stable Ruby, Node, Npm and useful tools such as Brunch (required if you want to build Elixir-Phoenix web apps) and PhantomJS for automated acceptance tests in many languages.

Notice that we’re installing Git, the optional GitG which is a fantastic companion to your Git routine.

Postgresql, Redis, Memcached support

What’s a web app without proper databases and cache services? Let’s install them:

sudo dnf -y install postgresql-server postgresql-contrib postgresql-devel memcached redis

sudo postgresql-setup --initdb
sudo sed -i.bak 's/ident/trust/' /var/lib/pgsql/data/pg_hba.conf # NEVER do this in production servers
sudo systemctl start postgresql

sudo su - postgres
createuser youruser -p
createdb youruser --owner=youruser

Change youruser for the username of your current user account, of course.

Java support

This is easy, let’s install the latest OpenJDK 8 and web browser plugins.

sudo dnf -y install java-1.8.0-openjdk icedtea-web

Go Support

Even easier:

sudo dnf -y install go

Do not forget to edit your profile, such as $HOME/.profile and add the proper environment variables:

export GOROOT=$HOME/go
export PATH=$PATH:$GOROOT/bin

Elixir Support

There is an easy way, and a more complicated and time consuming one. Let’s start with the easy one:

sudo dnf -y install erlang elixir
mix local.hex
mix local.rebar
mix archive.install https://github.com/phoenixframework/archives/raw/master/phoenix_new.ez

The problem is that packages for distros such as Fedora can take time to come out. For example, Elixir 1.4 has been out for a couple of days, but no upgrades for Fedora yet.

Another problem if you’re professionally developing Elixir projects is that you will need an Elixir version manager, because you will end up getting client projects in different Elixir versions and you need to setup your environment accordingly. That’s where asdf comes in. You can follow this gist but I will paste the important bits here:

sudo dnf -y install make automake gcc gcc-c++ kernel-devel git wget openssl-devel ncurses-devel wxBase3 wxGTK3-devel m4

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.2.1

# For Ubuntu or other linux distros
echo '. $HOME/.asdf/asdf.sh' >> ~/.bashrc
echo '. $HOME/.asdf/completions/asdf.bash' >> ~/.bashrc

# restart your terminal or source the file above:
source ~/.bashrc

asdf plugin-add erlang https://github.com/asdf-vm/asdf-erlang.git
asdf plugin-add elixir https://github.com/asdf-vm/asdf-elixir.git

asdf install erlang 19.0
asdf install elixir 1.4.0

asdf global erlang 19.0
asdf global elixir 1.4.0

Compiling Erlang from source will take a humongous amount of time, especially if you’re using old CPUs like me. But this is how you both have access to the latest and greatest Elixir while also having the ability to choose older versions for client projects.

By the way, you can install additional asdf plugins to manage versions of other platforms such as Go, Rust, Node, Julia and many others. Check out their project page for more details.

Docker Support

You will probably want to have access to Docker as well, so let’s do this:

sudo dnf -y install docker docker-compose

# you can test if everything went ok with the infamous hello world
sudo docker run --rm hello-world

Desktop Apps

Once you have everything in place, let’s configure the non-terminal aspects for a better experience.

Terminator (and Terminix)

Speaking of terminals, you will want to install Terminator. I really don’t like using screen or tmux in my local machine (I can’t get around those key bindings). I am more used to iTerm2 on macOS and Terminator is pretty much the same thing with similar key bindings. You definitely need to replace the default terminal for this one.

sudo dnf -y install terminator

You will also want to edit ~/.config/terminator/config and add the following to make it better:

[global_config]
  title_transmit_bg_color = "#d30102"
  focus = system
[keybindings]
[layouts]
  [[default]]
    [[[child1]]]
      parent = window0
      type = Terminal
      profile = default
    [[[window0]]]
      parent = ""
      type = Window
[plugins]
[profiles]
  [[default]]
    use_system_font = false
    font = Hack 12
    scrollback_lines = 2000
    palette = "#073642:#dc322f:#859900:#b58900:#268bd2:#d33682:#2aa198:#eee8d5:#586e75:#cb4b16:#586e75:#657b83:#839496:#6c71c4:#93a1a1:#fdf6e3"
    foreground_color = "#eee8d5"
    background_color = "#002b36"
    cursor_color = "#eee8d5"

Another great option that was recommended to me is Terminix. This is how you install it:

sudo dnf copr enable heikoada/terminix
sudo dnf -y install terminix

Hack font

You will want to have a nicer font such as Hack around as well:

dnf -y install dnf-plugins-core
dnf copr enable heliocastro/hack-fonts
dnf -y install hack-fonts

Gnome Tweak Tool

Now you will want to install Gnome Tweak Tool to be able to setup Hack as the default monospace font:

sudo dnf -y install gnome-tweak-tool

Vim, Zsh, Yadr

I really like to use Vim so you can install it like this:

sudo dnf -y install vim-enhanced vim-X11

And I really like to use YADR to customize all aspects of my ZSH and Vim:

sh -c "`curl -fsSL https://raw.githubusercontent.com/skwp/dotfiles/master/install.sh `"

I recommend you have Zsh, Vim, Ruby pre-installed before running the script above. Once you finish, I had to tweak the settings a bit:

sed 's/gtk2/gtk3' ~/.vim/settings/yadr-appearance.vim

You’d want to tweak that file as well, to add new fonts such as Hack, and right now I am more in the mood of “gruvbox” instead of “solarized” as Vim theme.

GIMP Photoshop

If you’re a web developer you will have to edit a couple of images sometimes. And if you’re like me, Gimp is a freaking usability nightmare. But there are ways to make it a bit more palatable.

sudo dnf -y install gimp
sh -c "$(curl -fsSL https://raw.githubusercontent.com/doctormo/GimpPs/master/tools/install.sh)"

There you go, a Photoshop-like theme for Gimp to make it less ugly.

Spotify

What would we, developers, be without music to concentrate?

dnf config-manager --add-repo=http://negativo17.org/repos/fedora-spotify.repo
dnf -y install spotify-client

CoreBird

I am so glad that someone built a very competent and elegant Twitter client for Linux. Install CoreBird:

dnf -y install corebird

It’s probably even better than the official Mac version.

Tweaking the title bar

I found this hack to try to make the Gnome title bars a bit less fat, which is about the only complaint I have for the look-and-feel so far:

tee ~/.config/gtk-3.0/gtk.css <<-EOF
.header-bar.default-decoration {
 padding-top: 3px;
 padding-bottom: 3px;
 font-size: 0.8em;
}

.header-bar.default-decoration .button.titlebutton {
 padding: 0px;
}
EOF

Conclusion

Most of everything you need is web based, so Gmail, Slack, all work just fine. Fire up Chromium, Firefox or install Franz or WMail if you have to. Unfortunately everything that is web based consumes a lot of RAM, and this is really bad. I do miss good old, slim, native apps. Web-based apps are a huge hassle.

They “work”, but I’d rather have a good native app. On the other hand, Dropbox and Skype have really terrible client apps. They are very poorly maintained, full of bugs, and terrible support. I’d rather not have them.

I was trying to get used to Thunderbird while on Ubuntu. Geary is still not good enough. But I was surprised when I tried Evolution again. It has the only thing I really want from any email client: a damn shortcut to move emails to folders: Ctrl-Shift-V (!!) How hard can that be??

Gnome 3 has a global Online Accounts repository in the Settings where you can register social networks such as Facebook and Google, but the Google support is buggy. It expires every time, so don’t use Evolution with it. Add the Imap/Smtp information manually instead. Email and Calendar data is properly synced that way.

You should have all your passwords in a LastPass account by now. Authy is a Chrome extension, so your multi-factor authentication should also just work.

My personal bank and investment companies, with their ugly Java applets, work just fine with Chromium and IcedTea, so I’m ok there too.

I just have to figure out the easiest backup strategy to have everything really secure. On the installation process, do not forget to choose the encrypted partition option - and if you do, definitely back up your data regularly as I’ve heard of bugs during upgrades that made the encrypted partitions inaccessible. Be secure and also be careful.

As usual, from my macOS the only 2 things I will really miss are Apple Keynote (it’s really amazing as no one was able to make a slick and fast presentation tool as good as Keynote) and iMovie for quick video editing (although Kdenlive is a very good alternative).

You even have built-in shortcuts to screen capture a window or an area and record a screencast!

Compared to my Ubuntu configuration, this Fedora 25 is really a pleasure to use. A competent macOS replacement. I highly recommend it!

And as I said at the update in the beginning of the post. Do check out Arch Linux and how to optimize your distro to be more responsive, particularly on old hardware.

I like to keep a Vagrant box around, because no matter how messy an OS upgrade can go (looking at ya macOS), I know my development box will just work.

But even with everything virtualized and isolated, things can still go wrong. I am currently using Vagrant 1.8.5, with the vagrant-vmware-fusion plugin 4.0.11 and Vmware Fusion 8.5 on El Capitan (even though macOS Sierra just launched, I will wait at least 1 month before upgrading, there is nothing there that is worth the risk).

If you’re installing a brand new box for the first time, this is the bare-bones Vagrantfile configuration I am using:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure(2) do |config|
  config.vm.box = "bento/ubuntu-16.04"

  config.vm.network :forwarded_port, guest: 8080, host: 8080
  config.vm.network :forwarded_port, guest: 3000, host: 3000
  config.vm.network :forwarded_port, guest: 3001, host: 3001
  config.vm.network :forwarded_port, guest: 4000, host: 4000
  config.vm.network :forwarded_port, guest: 5555, host: 5555
  config.vm.network :forwarded_port, guest: 5556, host: 5556
  config.vm.network :forwarded_port, guest: 3808, host: 3808

  config.vm.network "private_network", ip: "192.168.0.100"

  config.vm.synced_folder "/Users/akitaonrails/Sites", "/vagrant", nfs: true

  config.vm.provider :vmware_fusion do |v|
    v.vmx["memsize"] = "2048"
  end
end

I usually go in the Vmware settings for the virtual machine and enable an extra processor (as my Macbook has 8 virtual cores to share) and enable hypervisor (support for Intel’s VT-x/EPT).

As a rule of thumb, the very first thing I always do is set the locale to en_US.UTF-8:

sudo locale-gen "en_US.UTF-8"
sudo dpkg-reconfigure locales
sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8

And just to make sure, add the following to /etc/environment:

LC_ALL=en_US.UTF-8
LANG=en_US.UTF-8

You must set UTF-8 before you install packages such as Postgresql.

Then I upgrade packages and install the basics:

sudo apt-get update && sudo apt-get upgrade
sudo apt-get install open-vm-tools build-essential libssl-dev exuberant-ctags ncurses-term ack-grep silversearcher-ag fontconfig imagemagick libmagickwand-dev python-software-properties redis-server libhiredis-dev memcached libmemcached-dev

This will install important tools such as Imagemagick, Memcached and Redis for us.

Now, to install Postgresql:

sudo apt-get install postgresql-9.5 postgresql-contrib postgresql-server-dev-9.5

Create the superuser for vagrant:

sudo -i -u postgres
createuser --interactive

Enter name of role to add: vagrant
Shall the new role be a superuser? (y/n) y

And only for the development environment edit /etc/postgresql/9.5/main/pg_hba.conf and change the following:

# "local" is for Unix domain socket connections only
local   all             all                                     trust
# IPv4 local connections:
host    all             all             127.0.0.1/32            trust
# IPv6 local connections:
host    all             all             ::1/128                 trust

This makes your life easier while programming. If you did everything right until now, you will have your PG with proper unicode encoding and without bothering with passwords when you do bin/rails db:create. If you didn’t configure your locale properly before, you can follow this gist to manually set PG’s locale to UTF-8.

Installing Ruby is still better done through RVM:

gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3
\curl -sSL https://get.rvm.io | bash
source $HOME/.rvm/scripts/rvm
rvm install 2.3.1
rvm use 2.3.1 --default

And I prefer using YADR as my default dotfiles, replacing Bash with ZSH. Compared to other dotfiles, I like this one because I usually don’t have to tweak it at all. I won’t even configure anything about RVM after installing because YADR takes care of that already.

sh -c "`curl -fsSL https://raw.githubusercontent.com/skwp/dotfiles/master/install.sh `"

To update it (or resume in case it breaks for some reason):

cd .yadr
rake update

The only 2 tweaks I have to do are changing my iTerm2 profile to use Solarized, and adding the following 2 lines to the top of the .vimrc file:

scriptencoding utf-8
set encoding=utf-8

Next step, install NodeJS:

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

Next step, install Java. You can choose Oracle’s installer, but I believe the openjdk should be enough:

sudo apt-get install default-jdk

We will need Java for Elasticsearch 2.4.0:

wget https://download.elastic.co/elasticsearch/release/org/elasticsearch/distribution/deb/elasticsearch/2.4.0/elasticsearch-2.4.0.deb && sudo dpkg -i elasticsearch-2.4.0.deb

Now you can start it manually with sudo /etc/init.d/elasticsearch start, and you want to leave it that way because it consumes a lot of RAM, so you should only start it when you really need it.

With Java in place, we can also install Leiningen to have Clojure ready.

echo "PATH=$PATH:~/bin" >> ~/.zsh.after/bin.zsh
mkdir ~/bin && cd ~/bin
wget https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein
chmod a+x lein
lein

Leiningen will install its dependencies and you can follow its tutorial to get started.

Installing Rust is as easy:

curl -sSf https://static.rust-lang.org/rustup.sh | sh

Installing Crystal, also easy:

curl https://dist.crystal-lang.org/apt/setup.sh | sudo bash
sudo apt-get install crystal

Installing Go is not difficult, but more manual:

wget https://storage.googleapis.com/golang/go1.7.1.linux-amd64.tar.gz
tar xvfz go1.7.1.linux-amd64.tar.gz
chown -R root:root .go
sudo mv go /usr/local
touch ~/.zsh.after/go.zsh
echo "export GOPATH=$HOME/go" >> ~/.zsh.after/go.zsh
echo "export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin" >> ~/.zsh.after/go.zsh

Once you install go and set its work path, we can install some useful tools such as forego and goon (that Elixir’s Hex can optionally use):

go get -u github.com/ddollar/forego
go get -u github.com/alco/goon

And speaking of Elixir, we saved the best for last:

wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb && sudo dpkg -i erlang-solutions_1.0_all.deb
sudo apt-get update
sudo apt-get install esl-erlang elixir

And this is it, a very straightforward tutorial to have a modern development environment ready to go. These are the basic software development tools that I believe should be in everybody’s toolbelt for the following years.

Honestly, I am not so much into Clojure and Go as I think I should be. And I didn’t give .NET Core a lot of time yet, but I will explore those in more detail in the future.

It’s been 3 months since I posted my initial impressions on Windows 10 Anniversary Edition’s most important feature: Bash on Windows. My conclusion at the time was that it was not ready for prime time yet.

My conclusion as of right now, on July 26th is that it’s finally usable enough for web developers, particularly for Ruby developers who always suffered through lack of Windows support.

Installation process is the same. You must be signed up to the Windows Insider program, wait at least one day if this is your first time. Enable the Fast ring of updates, install the Preview edition from normal Windows Update and then turn on the “Windows Subsystem for Linux (Beta)” feature.

Last time I was testing Windows 10 over Virtualbox over Ubuntu 14.04 on a Dell Inspiron notebook (8 cores i7 with 16GB of RAM). It was super slow, I don’t recommend it at all. Now I am back on my trustworthy Macbook Pro 2013 with 16GB of RAM and SSD running VMWare Fusion, and Windows 10 flies here. Super recommended.

Once you do all that, you can start the “Bash on Ubuntu on Windows” (a mouthful). The first good surprise is that it prompts you to register a new username instead of just falling back to Root. As I said in my previous post, it’s good practice to create a new user and add it to the sudoers group, and this is what it does. So you can install packages using “sudo apt-get install”.

You should follow my previous post for all the packages and configurations I normally do in a development Linux box.

RVM now works! I was able to install Ruby 2.3.1 through RVM without any problems whatsoever.

I was able to git clone a small Rails project and properly bundle install. All gems were downloaded, native extensions compiled without any flaws.

Some things still don’t work. For example, you won’t be able to finish the Postgresql 9.3 installation. It will download and install but the cluster setup fails as you can follow through this issue thread.

But you don’t need to have everything installed under Ubuntu, you can just fall back to the native Postgresql for Windows and edit your config/database.yml to point to server 127.0.0.1 and port 5432. On the Ubuntu side you just need to install libpq-dev so the pg gem can compile its native extensions and that’s it.

Smaller services such as Memcached or Redis install properly with apt-get but they won’t auto-start through Upstart. But you can start them up manually and use something like Foreman to control the processes. They both start and work well enough, so you can test caching in your Rails projects and also test Sidekiq workers.

I know this is still a Preview, so more bug fixes and possibly new features are still coming before the final release in August. What bugs me the most is that every command I run with sudo takes a few seconds to start. It’s annoying, but it works in the end.

Node.js 6.3.1 successfully installs and runs. I was able to npm i and node server.js on Openshift’s Node example repository.

Crystal 0.18.7 installs successfully and properly compiled my Manga Downloader project. It ran my built-in performance test in 15 minutes. The performance is modest, but it runs correctly to the end. (And yes, Crystal runs on Windows now too!).

Go 1.6 works. I just did a go get to install Martini and just ran the simple “Hello World” server. Compiles, starts and executes very fast as expected.

Unfortunately, Elixir 1.3.1 crashes, I don’t know why yet.

$ iex
Crash dump is being written to: erl_crash.dump...done
erl_child_setup closed

Actually, Erlang itself crashes by just trying to run erl. None of the Elixir tools work as a result. No iex, no mix. The funny thing is that it was working in the initial Preview. So either it’s something in the new Preview or something in the newest Erlang releases. There are open issues regarding this problem, so let’s hope it gets fixed soon.

“The Best Environment for Rails on Windows”

I have this very old 2009 post to guide developers that are locked on Windows to implement Rails projects. The first advice is to avoid Ruby for Windows. I really commend the efforts of great developers such as Luis Lavena, who invested a lot of time to make it work well enough. But unfortunately the reality is that Ruby is made for Linux environments, it binds to native extensions in C that have lots of dependencies that are not easy to make available on Windows.

So the best option up until now was to install Vagrant (through Virtualbox or, even better, VMWare) as the runtime and use Windows-available editors such as Sublime Text 3 or Atom.

Now you can avoid the Vagrant/virtualization part and directly use “Bash on Ubuntu on Windows”. It’s so complete that I can even use ZSH and install complex dotfiles such as YADR. You can run Postgresql for Windows and connect to localhost:5432 in your Rails application or any web application that requires Postgresql for example.

You can install ConEmu as a better terminal emulator than the stupidly bad cmd.exe default console. Follow this article to get news on its support of Bash on Windows. Right now you have to edit the “Ctrl-V” hotkey to something else (“Ctrl-Shift-V”), arrow keys don’t work well on Vim, and you can add a Default Task for Bash like this: %windir%\system32\bash.exe ~ -cur_console:p

Conclusion

So, yes, at least from this version I tested (installed on July 25th) this is a usable “Bash on Ubuntu on Windows” and web developers from Ruby to Javascript to Crystal to Go can really start testing and trying to make Windows 10 Anniversary their primary platform for serious Linux-based development.

Add Sublime Text or Atom (or Visual Studio, if that’s your thing) and you should be good to go. I expect the next releases to fix some of the bugs and performance issues, but compared to what we saw in April, it’s a huge improvement.

Kudos to Microsoft for that!

And if you want to know more hardcore details on how the Windows Subsystem for Linux is actually implemented, I recommend this series of blog posts from MSDN itself:

• Windows Subsystem for Linux Overview
• Pico Process Overview
• WSL System Calls
• WSL File System Support

To get it, you must have the following requirements:

• Have an activated Windows 10 64-bits
• Sign up for the Windows Insider Program. If it’s your first time it can take up to 24 hours to activate
• In your Windows Update Settings, Advanced Options, you must choose to “Get Started” in the Insider option and also choose the “Fast” Ring option. Now, when you Check for Updates, the Preview 14316 should show up. If not, wait until your account is refreshed by Microsoft.

You must have, at the very least, 10GB of available space in your main partition, so keep that in mind. Another caveat: if you’re like me and you’re testing under Virtualbox, also bear in mind that to resize a virtual drive you must delete your snapshots, and the merging process can take a ridiculously long time.

Once it’s installed, you must go to the Developer options in the “Update & Security” Control Panel and change your profile to “Developer Mode”. This “Bash on Windows” feature will show up under the Windows Features list. It’s intended for developers only, not to be used in production servers.

Once you have the Preview installed you must be able to fire up the old cmd.exe console (or any other better console such as ConEmu) and type in “bash”; it will prompt you to install the userland Canonical packaged for Ubuntu. This takes another while. The whole process takes a lot of time, by the way, so make sure you reserve half a day at least. Don’t do it at work :-)

One problem I stumbled upon right away is that networking was not working properly. Someone narrowed it down to DNS not being added to /etc/resolv.conf so you must add it manually. Just add the Google DNS (8.8.8.8 and 8.8.4.4) to the resolv.conf file and you’re up.

Finally, you land inside bash as the root user. If you’re a Windows user, know right now that running as root is insecure and a bad practice. Don’t do it.

The very first thing you must do is manually create an unprivileged Linux user and add it to the sudo group as Andrew Malton blogged first:

useradd new_username -m -s /bin/bash 
passwd new_username
usermod -aG sudo new_username

Then you can log into this user shell with su - [your user] every time!

From here, we can assume it’s a plain Ubuntu 14.04 and you should be able to follow my very old post on how to setup a developer Ubuntu environment, or any other tutorial you can find over Google. These basic development packages that I always install first all run:

sudo apt-get install curl build-essential openssl libcurl4-openssl-dev libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt-dev libgmp-dev autoconf libc6-dev ncurses-dev automake libtool bison subversion redis-server libhiredis-dev memcached libmemcached-dev imagemagick libmagickwand-dev exuberant-ctags ncurses-term ack-grep git git-svn gitk ssh libssh-dev

sudo dpkg-divert --local --divert /usr/bin/ack --rename --add /usr/bin/ack-grep

This should give you all the compilation toolchain essentials as well as some well known command line tools such as ack (way better than grep). It also adds Redis and Memcached. They all run.

As good practice you should add the following to your /etc/bash.bashrc configuration file:

export LANGUAGE=en_US.UTF-8
export LANG=en_US.UTF-8
export LC_ALL=en_US.UTF-8

And after that you should also configure locale to UTF-8:

sudo locale-gen en_US.UTF-8
sudo dpkg-reconfigure locales

Just to warm up a little bit, we can start with one of the things that were impossible in Windows: getting a stable Ruby installation. For that, RVM is said to not work (as ZSH is also not working due to /dev/pts and symlink problems in this preview, see more below). But RBENV is working! You must install it first and then the ruby-build plugin:

Interestingly, it takes a lot of time to complete and during the process CPU usage goes through the roof. Installing Go is even longer! Something is still unstable underneath as it shouldn’t take the CPU to 100% for so long.

If I check how much memory I have in the system it becomes clearer:

root@localhost:/mnt/c/Users/fabio# free -h
             total       used       free     shared    buffers     cached
Mem:          1.0G       342M       664M         0B         0B         0B
-/+ buffers/cache:       342M       664M
Swap:           0B         0B         0B

I am not sure if this is somehow just a “hard-coded” value for memory as many people are reporting the same “664M” free regardless of what we are running. But something is incomplete here. Swap is also zero and you can’t add any as far as I can tell. Swapon, fallocate, none of those work yet.

root@localhost:/mnt/c/Users/fabio# swapon -s
swapon: /proc/swaps: open failed: No such file or directory

root@localhost:/mnt/c/Users/fabio# fallocate -l 4G swapfile
fallocate: swapfile: fallocate failed: Invalid argument

I actually tried to create a swap file using dd instead of fallocate and add it to the /etc/fstab but it didn’t work:

root@localhost:/mnt/c/Users/fabio# free -m
             total       used       free     shared    buffers     cached
Mem:          1006        342        664          0          0          0
-/+ buffers/cache:        342        664
Swap:            0          0          0

root@localhost:/mnt/c/Users/fabio# cat /etc/fstab
LABEL=cloudimg-rootfs   /        ext4   defaults        0 0
/swapfile       none    swap    sw      0 0

So it sounds like memory is “hard-coded”. Follow this issue #92 if you want to know how it develops.

But worse than that, shared memory has very low limits and strange behavior. Postgresql will install but won’t start up at all:

root@localhost:/mnt/c/Users/fabio# pg_createcluster 9.3 main --start
Creating new cluster 9.3/main ...
  config /etc/postgresql/9.3/main
  data   /var/lib/postgresql/9.3/main
  locale en_US.UTF-8
FATAL:  could not create shared memory segment: Invalid argument
DETAIL:  Failed system call was shmget(key=1, size=48, 03600).
HINT:  This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter, or possibly that it is less than your kernel's SHMMIN parameter.
        The PostgreSQL documentation contains more information about shared memory configuration.
child process exited with exit code 1
initdb: removing contents of data directory "/var/lib/postgresql/9.3/main"
Error: initdb failed

And if we try to expand the SHMMAX limit this is what we get:

root@localhost:/mnt/c/Users/fabio# sysctl -w kernel.shmmax=134217728
sysctl: cannot stat /proc/sys/kernel/shmmax: No such file or directory

root@localhost:/mnt/c/Users/fabio# echo 134217728 >/proc/sys/kernel/shmmax
bash: /proc/sys/kernel/shmmax: Operation not permitted

So, no Postgresql for the time being. Some people who were able to complete the Go Lang installation (I gave up after a very, very long time waiting for apt-get to finish) complained that Go also crashed on shared memory requirements. Follow Issue #32 and Issue #146 to see if anyone can make it work.

I also tried to install Node.js. No luck with package installs:

curl -sL https://deb.nodesource.com/setup_5.x | sudo -E bash -
...
E: dpkg was interrupted, you must manually run 'sudo dpkg --configure -a' to correct the problem.
Error executing command, exiting

NVM installs, sort of, with many errors in git:

...
error: unable to create file test/slow/nvm run/Running "nvm run 0.x" should work (No such file or directory)
error: unable to create file test/slow/nvm run/Running "nvm run" should pick up .nvmrc version (No such file or directory)
error: unable to create file test/slow/nvm use/Running "nvm use iojs" uses latest io.js version (No such file or directory)
error: unable to create file test/slow/nvm use/Running "nvm use node" uses latest stable node version (No such file or directory)
error: unable to create file test/slow/nvm use/Running "nvm use v1.0.0" uses iojs-v1.0.0 iojs version (No such file or directory)
error: unable to create file test/slow/nvm use/Running "nvm use" calls "nvm_die_on_prefix" (No such file or directory)

And this is what happens if I try to install the most recent version:

akitaonrails@localhost:~/.nvm$ nvm install 5.10.1
Downloading https://nodejs.org/dist/v5.10.1/node-v5.10.1-linux-x64.tar.xz...
######################################################################## 100.0%
tar: bin/npm: Cannot create symlink to '../lib/node_modules/npm/bin/npm-cli.js': Invalid argument
tar: Exiting with failure status due to previous errors
Binary download failed, trying source.
######################################################################## 100.0%
Checksums empty
tar: bin/npm: Cannot create symlink to '../lib/node_modules/npm/bin/npm-cli.js': Invalid argument
tar: Exiting with failure status due to previous errors
Binary download failed, trying source.
Detected that you have 1 CPU thread(s)
Number of CPU thread(s) less or equal to 2 will have only one job a time for 'make'
Installing node v1.0 and greater from source is not currently supported

Issue #9 points to non-implemented symlink support.

Another very annoying thing is the lack of Pseudo-Terminals (/dev/pts), which is possibly one of the reasons ZSH won’t work. Follow Issue #80.

You should also be able to copy over your SSH private keys to “.ssh” and start git cloning from Github or git push-ing to Heroku in no time.

akitaonrails@localhost:~$ ssh-keygen  -t rsa
Generating public/private rsa key pair.
Created directory '/home/akitaonrails/.ssh'.kitaonrails/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/akitaonrails/.ssh/id_rsa.
Your public key has been saved in /home/akitaonrails/.ssh/id_rsa.pub.
The key fingerprint is:
f8:16:b1:be:85:31:0c:71:f8:c2:d3:72:ab:48:42:9a akitaonrails@localhost
The key's randomart image is:
+--[ RSA 2048]----+
|      ...        |
|      .o         |
|     ..o.        |
|  .   =++o       |
| +    .=S.       |
|E . .  o.=       |
|   o . .= .      |
|    . .. o       |
|        .        |
+-----------------+

At least, Elixir does seem to work:

akitaonrails@localhost:~$ iex
Erlang/OTP 18 [erts-7.3] [source-d2a6d81] [64-bit] [async-threads:10] [hipe] [kernel-poll:false]

Interactive Elixir (1.2.3) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> defmodule HelloWorld do; def say(name) do; IO.puts("Hello #{name}"); end; end
iex:1: warning: redefining module HelloWorld
{:module, HelloWorld,
 <<70, 79, 82, 49, 0, 0, 5, 240, 66, 69, 65, 77, 69, 120, 68, 99, 0, 0, 0, 147, 131, 104, 2, 100, 0, 14, 101, 108, 105, 120, 105, 114, 95, 100, 111, 99, 115, 95, 118, 49, 108, 0, 0, 0, 4, 104, 2, ...>>,
 {:say, 1}}
iex(2)> HelloWorld.say("Fabio")
Hello Fabio
:ok

Not so fast…

akitaonrails@localhost:~$ mix new ex_test
** (ErlangError) erlang error: :terminated
    (stdlib) :io.put_chars(#PID<0.25.0>, :unicode, [[[[[[[] | "\e[32m"], "* creating "] | "\e[0m"], ".gitignore"] | "\e[0m"], 10])
    (mix) lib/mix/generator.ex:26: Mix.Generator.create_file/3
    (mix) lib/mix/tasks/new.ex:76: Mix.Tasks.New.do_generate/4
    (elixir) lib/file.ex:1138: File.cd!/2
    (mix) lib/mix/cli.ex:58: Mix.CLI.run_task/2

You will find more information on the pseudo-project Microsoft opened over Github to keep track of Issues from testers like me. You can follow the list of opened and closed issues there. You will see many things that work, but also many other things that won’t work until a new release is available to fix everything I mentioned here.

Conclusion

So, is “Bash on Windows” a good development environment for Linux users to have over Windows?

As far as Preview 14316, not yet. The keyword here is “yet”. It’s shaping up nicely, and if they can actually fix all the issues opened so far, it will be very usable very fast.

We still need decent memory controls, well-implemented pseudo-terminal support, configurable shared memory limits, and working symlinks. We also need Ubuntu’s upstart, so services like Redis or Memcached (which I installed and run) come up on their own when I start the environment. Right now they don’t come back after I reboot the machine.

Some people went as far as being able to trick X11 and run GUI apps such as Firefox and even XFCE over this environment already, so it’s really promising. This idea does work.

Once those issues are ironed out, yes, I believe we are closer than ever to finally using Windows as a viable and full-featured development environment. Let’s see if by the Windows 10 Anniversary Release in June we will have a stable Ubuntu installation.

One thing that I think they did very wrong was to tie the Linux Subsystem to the Windows 10 installation. It should’ve been a separate installer, so the team could release build updates without having to bundle it all together with the entire Windows OS.

If you were intending to move to Windows for your Linux-based developments, not yet. Hold your horses a bit longer.

Yesterday was a historic day for Microsoft. From my personal perspective, it may have been a watershed. Ever since, I’ve been trying to figure out how to register the moment for posterity.

Prologue - 1995 to 2005, the 1st Decade

I mean this for us, software developers. We’ve been through moments like this before: the release of Turbo Pascal in 1983, Visual Basic in 1991, Java in 1995, the first Linux distros like Slackware from 1993 on, the release of OS X in 2000, and the PowerPC-to-Intel transition in 2005.

The 80s and 90s were convoluted, an era of accelerated growth where everything went obsolete fast. In one decade, from 1989 to 1999, I went from Basic to dBase, Clipper, Fox Pro, Visual Basic, Delphi, Java, multimedia (Flash, Director/Shockwave), and the Internet (HTML, Javascript, ASP, PHP, Perl). I’ve never seen a decade move so fast. I went from a 4 MHz XT to a Pentium III at almost 1 GHz in those ten years.

We reached the end of the century at the peak of the Internet Bubble, had 9/11 in 2001 and the crash. But the Internet came to stay, and personal devices started showing up with the Palms and iPods. In 2001 Microsoft launched Windows XP and would spend the next decade carrying that legacy on its back.

A year earlier, the small Apple had started its comeback with the new iMac, iBook, and iPod, plus the BSD-UNIX-based OS X. One step at a time, it was building a system meant for both consumers and developers, the NeXT promise taking shape a decade after its inception.

Then, in 2005, Apple forged an alliance with one of Microsoft’s oldest partners, Intel, and Macs would finally run on the same processor as Windows, a stratospheric leap in adoption. And that opened another door: since OS X was built processor-agnostic, it was a matter of time before it ran on smaller, more efficient ARM chips. That’s what happened in 2007 with the iPhone. The rest is history.

2005 to 2015 - 2nd Decade

Meanwhile, Microsoft fell behind. It failed the Windows Vista promise, shipped a competent Windows 7, and followed it with the controversial Windows 8. Only with Windows 10, unveiled at the end of 2014, did things start to change. And the effects of Steve Jobs’s death, at the end of 2011, were getting more obvious: Apple had stopped.

From 2011 to today, all we got were new versions. Nothing significant, nothing new. The last big iPhone was the 5, from 2012. The last big OS X feline was Mountain Lion, from 2011. In the meantime Google pulled ahead in mobile when KitKat shipped in 2013, in my view the first Android release on equal footing with iOS.

From 1999 to 2005, broadly, the enterprise software developer had two options: Java and .NET. PHP had solid adoption, but mostly for customizing Wordpress and Magento, far from the same league as Java or .NET; the rest was niche. From 2006 on, a new generation of developers rose for the so-called Web 2.0, the post-Google world of SEO, UX, fast iterations, and Agility with a capital “A”. That’s where Ruby, Python, and then Node took off exponentially.

From 2010, the mobile world sped up, and one kind of integrated development in particular: the “Cloud” variety, where a native “app” talks to services on remote servers, mostly Amazon AWS, which had debuted not long before, in 2006.

Microsoft stayed out of that move and spent the next ten years playing catch-up, nursing the Vista hangover. It kept its lead in purely enterprise markets, with SQL Server and Office licenses, but on the margins of cutting-edge software development.

Actually, I’d say the watershed came in 2013, with Ballmer’s exit and the end of the “Extended Gates Era”, opening the door for Satya Nadella to step in. Microsoft is a giant, plenty of its brains had been researching this for years, and a lot of it only surfaced now. But I mean “Eras” in a symbolic sense: the end of Microsoft’s Highlander culture, the “there can only be one”.

The 1995 prophecy that the Internet would destroy the Windows hegemony came true. And we reached the post-Moore world, where computing became accessible and ubiquitous. Think about it: in 1995, having a cluster of “super” computers for high-throughput distributed computing was for universities or big corporations. Today, you spin up a cluster of as many dozens of machines as you want on EC2 for a month at the price of a video game console.

I was a DOS user from 1988, switched to Windows 95 as soon as it launched, and spent almost ten years developing primarily on Windows, in the corporate world. I went from Visual Basic to ASP to .NET while also doing Java and PHP. But I wanted to run Perl, PHP, Python, and Ruby native on Linux, without giving up Office and Photoshop.

The answer we were waiting for was OS X. With the release of Tiger, things got serious. I tried it myself on a Mac Mini G4 in 2004. It was exceptional to have usability far better than Windows XP and access to all the UNIX I wanted on a single machine.

When Intel launched the Core Duo and then the 64-bit Core 2 Duo, and Tiger started running on Intel in 2005, there was nothing to think about: it was time to migrate. I’d spend the next decade in a pure OS X environment, developing on a different kind of platform, with different tools and a different culture. That was my whole story with Ruby and OS X over these ten years, which you know well if you follow this blog.

2015 on forward, Epilogue

2015 arrived, four years after Steve Jobs’s death. It was an important gap, because it gave the non-Mac platforms time to catch up and surpass OS X in many areas. We’re firmly in the Software as a Service Era. We don’t “buy” anything anymore, we “subscribe” to services.

We’re past the Post-PC Era. We’re past the Smartphone Era. We’re in the Services Era, where everything is a service. Our identity is a Facebook profile, our voice is WhatsApp, and everything we do generates data. We’re in the Big Data Era, a pile of useless data that no SQL Server in the world can keep up with.

We need new things to handle this paradigm: Cassandra, Riak, Hadoop, HBase, Spark, Elasticsearch, Go, Rust, Elixir. They all “run” on Windows, but someone has to spend time doing ports, writing compatibility patches, and packaging installers. And the main thing: most of the developers behind these technologies are on Linux or OS X, almost nobody builds this new generation of tools inside Windows. They all use Emacs, Vim, or Sublime Text, hardly anyone wants Visual Studio.

And this brings me back to the start of the post: it’s a new Era for Microsoft. It spent the last ten years playing catch-up and, for the first time, it looks like it has a real shot at turning things around and becoming relevant to the non-.NET developer again.

For that, two things happened yesterday.

2016 - The Year of Linux on the Desktop

First, the announcement that “Bash is coming to Windows”. Which in practice is much more than Bash: it’s a partnership with Canonical, one that had been taking shape since the announcement of SQL Server running on Linux. In practice, it’s a Linux subsystem running alongside the Windows kernel, translating Linux syscalls into Windows syscalls.

The original idea came from the deceased Project Astoria, or Windows Bridge for Android, which back then wanted to let Android apps run on Windows. Technically, Android is a flavor of Linux, so the jump to yesterday was a short one.

So it’ll be possible to take a binary built for Ubuntu and run it on Windows without changing a thing.

Ever since we started developing with Ruby, a lot of Windows users wanted to run Ruby natively. There’s a distribution, but it’s not good, and that’s not the maintainers’ fault. Ruby, like Python and PHP, was built to work on Linux.

To port it to Windows you have to write “wrappers”, and you still lack an environment with compilers like GCC to build extension packages. All of that is trivial on Linux and a headache on Windows. It wasn’t worth the trouble, so the only way out was to run a virtual machine (like VirtualBox) with something like Vagrant to make it easier and use the real Linux Ruby.

Everything from Linux that “works” on Windows, whether Python or PHP, never worked 100%, and we just got used to it.

What Microsoft is shipping in the Anniversary Update is a very thin translation layer at the lowest level, and not a virtual machine or a hypervisor: from a “virtual” Linux kernel to the Windows kernel. Everything will think it’s running on Linux. It’s what the Wine project tries to do to run Windows applications on Linux, only in reverse. It’s also different from Cygwin, which requires recompiling everything from Linux to get a semi-Linux environment on top of Windows.

There probably won’t be a secondary graphical environment at first, so no X, no GNOME or KDE. And there’s no need: we’re in a Web world, our graphical environment now is HTML and Javascript, and Chrome and Firefox already run native on Windows. For things like compiling gems with native extensions, even GCC will work. It’s the exact same binary, in the same environment, with everything we’re used to on UNIX. Having Bash and SSH on Windows is just the tip of the iceberg.

The second announcement is the release of the Xamarin tools for free and as open source! Microsoft acquired Xamarin, Miguel de Icaza’s company, not long ago. They built open-source .NET through pure reverse engineering, reimplementing everything as open source, and now Microsoft did the smart thing: on top of buying them, it opened the tools. The last thing still keeping a developer on the Mac was needing Xcode, which ships with OS X, to develop for iOS. Now you can do that on Windows for free.

So the math got much simpler. Windows 10 is the first respectable Windows version since the brief window of 7. Let’s forget Windows 8 existed, the same way we already forgot Vista. XP is finally dead, it took over a decade, along with the hideous Internet Explorer 6, 7, and 8. Google did us the favor of making Chrome ubiquitous, and services like Facebook forced users to migrate faster.

With the Windows 10 Anniversary Update, we’ll probably be able to do:

apt-get install build-essential
\curl -sSL https://get.rvm.io | bash
rvm install 2.3.0
bundle install

And it should just work.

In the same environment, we’ll still be able to use Xamarin Studio and, with a little effort to jog the C# muscle memory, build iOS and Android apps. We’ll be able to use native Office 365, all the latest Adobe CS6 tools, and even play The Division, all on the same machine.

In one shot, Windows 10 becomes the best value choice: convenience of use, development options, and competent hardware in the form of the Surface Book, Lenovo Yoga 3, and Razer Blade Stealth, which finally caught up to and passed the legendary finish of the MacBook.

2016 is finally the infamous Year of Linux on the Desktop, just not the way the Free Software crowd wanted. You can’t have everything.

If you’re learning Japanese this will definitely prove to be an invaluable tool. I am Japanese but I didn’t pay attention to proper Kanji training when I was a child. It shows now, as I can read Kanji only to what would be considered below high-school level in Japan. Still very useful, but it means I can’t read most websites in Japanese fast enough.

I’ve known of a Firefox add-on I’m very fond of for a long time now called Rikaichan. When enabled, you hover your mouse over the kanji text and it will popup a box with the translation. You install the Firefox add-on in the previous link and a proper dictionary to your native language from Rikaichan’s webpage. And that’s it.

But if you like to read Manga (Japanese Comics), you’re probably familiar with Furigana. It’s kind of like “subtitling” over the Kanjis with Hiragana or Katakana, the Japanese syllabaries (the first for Japanese only words, the second for foreign words).

That makes reading the more difficult Kanjis way easier and faster than hovering over each one or looking manually into the dictionary ideogram by ideogram.

A normal snippet of a Japanese webpage looks like this:

But with Furigana Inserter the same snippet looks like this:

To install it, first you install the add-on. Then you install the HTML Ruby add-on as well. Finally, you install this dictionary. It’s a 7-zip file you must decompress and manually drag it over Firefox to install.

If you’re on a Mac, I’m assuming you know what Homebrew is and already have that installed. Because then you can install Mecab like this:

brew install mecab
brew install mecab-ipadic

Finally, it seems like you must manually make Furigana Inserter aware of Mecab by adding a symlink into its extension folder:

ln -s /usr/local/lib/libmecab.dylib ~/Library/Application\ Support/Firefox/Profiles/454dy2eg.default/extensions/furiganainserter@zorkzero.net/mecab/libmecab.dylib

Understand that the Firefox Profile folder will have a different name on your computer. The one in the example is in my Mac. Open the terminal and tab to autocomplete each folder as you type and it should work just fine.

Restart Firefox, right-click in Japanese pages and you will have an “Enable Furigana” option waiting for you. Rikaichan seems to misbehave when hovering over Furigana enabled Kanji, so you may need to disable Furigana to use Rikaichan. But it’s a good compromise and may open a whole lot of new content in Japanese for us to consume.

One more reason to use Firefox.

You’re a “switcher”: you’ve decided to take the big leap, step away from the Windows world a bit, and buy your first Mac. The timing is good and prices are accessible, especially if you can buy from someone abroad. Keep one thing in mind from the start: this is a paradigm shift.

The first week or two are the worst. You’ll always have that nagging thought, “On Windows I did this more easily…” or “On my Linux I did this more easily…”. The temptation to go back is strong the first time you leave your comfort zone, same as with any change. Push yourself to learn the new tricks instead of falling back on the old ones.

As soon as you log in to the Mac for the first time, it arrives in a state where you need to configure very little. A few important things to get you started:

• The first difference is that application menus are all centralized. The bar at the top is the only menu, and it changes according to the application that currently has focus. The first option is the icon, which gives access to global system options like “About,” where you can view details of your hardware; “Software Update,” the equivalent of Windows Update; and options like Shutdown. By the way, the very first thing to do when starting your Mac is to run Software Update and install the latest updates. Unlike Windows, you tend to get large packages rather than dozens of small updates.

• The second option is always the name of the focused application. Initially it will always be “Finder,” the equivalent of Windows Explorer. This menu always gives access to things like “Preferences,” which on Windows usually lives under the “Edit” or “Tools” menus.

• Some shortcuts are global and constant. To start, understand that there is the Ctrl (control, as on a PC) key and a special one called Command ⌘. They are different, and although it isn’t a strict rule, things done on a PC with Ctrl are done on a Mac with ⌘. For example, copying text to the clipboard is ⌘+C, not Ctrl+C. Pasting is ⌘+V. Every application closes with ⌘+Q. The “Preferences” option is always ⌘+, (comma). The “Help” menu is always ⌘+Shift+?. A tip on that last Help option: use it to discover menu items whose shortcut you don’t remember or whose submenu you can’t find. Just type a few letters and Mac OS will open the menu and highlight the right item for you.

• Unlike Windows, the Mac paradigm is based on one window per document rather than a single application window with embedded document windows. ⌘+W closes the application’s current window. ⌘+N or ⌘+Shift+N usually opens a new window. We don’t normally close applications very often; they tend to stay open. That’s indicated in the Dock, at the bottom of the screen, by a glowing circle below the icon of an open application.

• Also unlike Windows windows, the red circle at the top of each window closes only that window, not the entire application. It’s the equivalent of ⌘+W. Another thing: you can move a window from the title bar or the footer bar, when there is one. So even if a window is partly off the physical desktop, you can still move it. On the other hand, the only way to resize a window is from the lower-right corner, not from any edge.

• In the title bar of applications that manipulate files, like Finder, Pages, and most apps that show the filename with an icon next to it, the icon is “normally” draggable. You can drag it to a folder and the file being edited moves there. You can also click while holding ⌘ (Command) and it will show the parent folders, letting you navigate them.

• Another thing that doesn’t exist on Windows: “Hide Windows.” Get used to ⌘-H to hide all windows of an application. It isn’t the same as minimizing, since hidden windows don’t appear in the Dock. A hidden application keeps a transparent icon in the Dock. Even better: if you have dozens of applications open in a mess of windows behind windows, use ⌘-⌥-H (Command-Option-H) to hide every window except the one currently in focus. It’s a very satisfying way to clean up your workspace and focus on what you’re doing.

• To switch between applications, on Windows we’re used to Alt-Tab. On the Mac the near equivalent is ⌘-Tab. But it switches between Applications, not between Windows like on Windows. It’s a subtle difference. If you have Photoshop with 4 windows and Word with 3 windows open, ⌘-Tab shows only 2 icons, one per application. To switch between windows of the same application, use ⌘-` (Command-Backtick). Or, more commonly, use Exposé to pick between windows.

• Note the icons on the F1 through F12 keys; they clearly show the functions you get when you press them. F1 and F2 are screen brightness. F3 is Exposé. F4 is the Dashboard, where you install Widgets. F11 and F12 are volume. Those are the main ones. Don’t forget that on newer MacBooks with a Multitouch Trackpad you have options like swiping 4 fingers down to activate Exposé or up to show the Desktop.

• Spotlight is very useful. ⌘+Space activates the search field. If you use external hard drives or USB drives and don’t want to waste time indexing their files, open “System Preferences,” option “Spotlight,” and drag the volumes that should be excluded.

• If you’re used to Explorer, you’ll miss a lot of things in Finder. You can copy and paste folders and files, but there’s no cut. You move items to different volumes by dragging and dropping while holding ⌘. To force a copy, use the Option/Alt (⌥) key. You’ll end up using drag-and-drop far more than on Windows. You also get different ways to organize your files, especially since ⌘+I opens the Info window, where you can add metadata like keywords for searching and colors (yes, you can even search for files and folders by color in Spotlight).

• Another difference between Finder and Explorer is how you rename files and run programs. In Explorer you press “Enter” to run a file and a single mouse click to rename. On the Mac you press “Enter” to edit the name of a file or folder and ⌘+O to run a program. That avoids the situation where you select dozens of files, accidentally hit Enter, and set off a cascade of programs opening. On the Mac that accident basically never happens.

• The Dock gives you quick access to your favorite applications. You can drag an icon out to remove it, or drag anything onto it to add it. If you open an application that wasn’t there, its icon appears anyway, because the Dock also shows every running application, with a glowing indicator below it. To keep an application in the Dock, drag it there or, while it’s open, use the context menu (right-click) on its icon and choose “Keep in Dock.” If you want that application to launch every time you log in, use “Open at Login.”

• Mac OS Leopard (10.5) doesn’t ship with the US International keyboard layout that’s common on Windows for non-ABNT-2 keyboards (which lack the cedilla). The Mac default is to use shortcuts like ⌥+c for cedilla, ⌥+e for acute accent, ⌥+` for grave accent, ⌥+n for tilde. But if you want the traditional way, download the US International layout for Mac from Brazilian developer Rainer Brokerhoff’s site and follow his instructions. From Snow Leopard (10.6) onward, this is no longer necessary.

• As on Windows and other systems, the Mac’s default key repeat rate is somewhat slow. Open any text editor and use the arrow keys to move the cursor and you’ll notice the lag. I prefer maximum speed. Go to “System Preferences, Keyboard” and set “Key Repeat” to “Fast” and “Delay Until Repeat” to “Short.” You’ll thank me:

• Say you have hundreds of files, like photos from your digital camera, sitting in JPG, and you want to rename them all to another convention and convert them from JPG to PNG. You can do this and much more with a feature called “Automator.” In Finder, select the files, right-click (on the Trackpad, place two fingers in the middle and use your thumb to click once at the bottom), then choose “More,” “Automator,” “Create Workflow.” That opens the selected items in Automator, a linear flow of “filters” where you chain the output of one filter as input to the next, like “Change Type of Images,” then “Rename Finder Items,” and even “Add attachments to Front Messages,” and so on. It’s an extremely powerful way to chain actions, a lot like Unix/Linux command-line pipes, but far more intuitive.

• Few people figure out how to take screenshots at first, since there’s no “Print Screen” key on a Mac. But there’s something far better: ⌘+Shift+3 takes a full-screen shot and saves it as a PNG on your Desktop. If you don’t want the file, ⌘+Ctrl+Shift+3 sends the shot to the clipboard so you can paste it into another application. Even more useful, ⌘+Shift+4 turns your cursor into a crosshair for capturing just the small area you select. Position the crosshair over any window and press “Space” and it captures that whole window. For clipboard-only, use ⌘+Ctrl+Shift+4.

• Another important thing: every print dialog opens with ⌘+P, and it always has the option to generate a PDF instead of sending to a printer. That’s extremely useful if you don’t have a printer or want to save a receipt from the web or something like that. Beyond that, the “Preview” application that opens images and PDFs can also do simple editing: resizing images, cropping, copying pages between PDF files, reordering pages, deleting pages. In other words, PDFs are quite editable on a Mac without a commercial Adobe product.

• Speaking of “Preview,” learn to use “Quick Look.” To view images, videos, audio, PDFs, Office files, iWork files, and so on, just select the file (or a set of files) and press “Space.” A floating window opens where you can quickly view the file. “Space” again closes it. You can preview most major file formats without opening their respective programs.

• On PCs we tend to create custom folders for videos, photos, and the like. On the Mac, try to use the default folders it already gives you. More than that, get in the habit of using iTunes to organize your music and videos, iPhoto for your photos, and iMovie to edit your videos. That keeps your Mac tidy, makes backups easier, simplifies searches, and keeps everything more accessible. Many Apple applications integrate with the iLife suite (iTunes, iPhoto, GarageBand, iMovie, iWeb), so it’s simpler to let these apps manage your files. Watch the screencasts on Apple’s website if you don’t know how they work yet; they’re simple, intuitive, and powerful.

• Installing applications on a Mac usually trips people up at first. You normally download one of two formats: DMG or MPKG. The first stands for (D)isk i(M)a(G)e and is similar to an ISO. When you double-click it, the DMG “mounts” inside /Volumes. The application is usually already there, and you just drag it to the “Applications” folder on your Mac. Then you “eject” the DMG with the ⏏ icon or with ⌘+E. The second format, (M)ac (P)ac(K)a(G)e, is the equivalent of Windows’ MSI: you double-click it and it runs like a standard installer. Usually only programs that need to install a lot of system components use MPKG, like Microsoft Office and Adobe CS4. Sometimes you download a ZIP that contains a DMG or an MPKG. The important part: if it’s a DMG with no MPKG inside, always drag the application to Applications before running it. Safari does an extra step: it downloads the DMG, mounts it, extracts the application, and deletes the DMG, so you drag it from the Downloads folder. A technical detail: MPKGs come with a BOM (Bill of Materials) that works as a recipe of the original system file permissions for scripts that adjust permissions. The same BOM helps uninstall, since it records everything that was installed.

• All application preferences are stored in your directory (/Users/your_login), then Library/Preferences. They’re files in plist format, which is XML stored in binary. Regardless of where the application is copied, it saves preferences in that location. Don’t confuse the “Library” local to your home folder with the global “Library” at the root of the system, since you’ll rarely need to touch the latter. On the Mac there’s no Registry, and so no nightmare of maintaining one. When an application starts behaving strangely, the first thing to try is deleting its .plist file.

• On the Mac, Finder doesn’t show every directory. Most are hidden, like /usr, /bin, /tmp, /dev, /var, /etc, and others that Unix or Linux users will recognize. Some important ones like System and Library at the root of your Mac are rarely accessed. User accounts live in the Users folder and applications in the Applications folder. Inside your “Home” folder are folders like Desktop, Documents, Downloads, Music, Movies, Pictures, Sites, Public, and Library. In that Library are things like “Application Support,” where plugins and other application dependencies live, and “Preferences,” which I explained earlier. Poke around these folders; the naming is fairly obvious.

• Inside the “Applications” folder there’s another called “Utilities” (also accessible via ⌘+Shift+U) with things like “Activity Monitor,” similar to the Windows Task Manager. There’s also “Console,” an easy way to review system log files. Another important one is “Disk Utility,” which does advanced things like repartitioning your disk non-destructively, creating DMG files including encrypted volumes, burning DMGs to DVDs, and more.

• Another difference from Windows: Macs don’t have drive letters (C:, D:, E:, and so on). The Mac, being a BSD Unix, behaves more like Unix/Linux, where DMG and ISO files are “mounted” inside the /Volumes directory and show up normally as disks in Finder that can be ejected. The Mac is very flexible with disk images: you can use Disk Utility to create bootable USB drives, create multiple boot partitions, copy DVDs into DMGs, and such. Network shared folders are also mounted in /Volumes. The behavior is consistent and fast, and Finder, unlike Windows Explorer, rarely crashes and almost never returns to an inconsistent state.

• A technical detail you’ll notice: Finder (including the top menu and Desktop), the Dock, and applications are very independent. On Windows, especially XP, you’ll remember an application sometimes getting sluggish, hard even to drag, making it difficult to click the Start menu or taskbar. On the Mac, even when Finder crashes or gets slow, the Dock behaves independently. Other applications aren’t affected either, including their window refresh. Another tip: if an application truly freezes, use ⌘+⌥+⎋ (Command+Option+Esc) to open a window where you can force-quit it. And ⌘+Shift+Q forces the current user to log out.

• Speaking of deleting: select files and use ⌘+Shift+⌫. That ⌫ key is called “Delete” but it’s the Mac equivalent of the PC’s “Backspace.” The Mac equivalent of the PC’s “Delete” key is Shift+⌫. You can also do more, like ⌥+⌫ to delete the whole word to the left of your cursor, or ⌘+⌫ to delete to the beginning of the line.

• For navigating text, get used to combinations like ⌘+← and ⌘+→ to go to the beginning or end of the line, ⌘+↑ or ⌘+↓ for the equivalents of Page Up and Page Down, and ⌥+← and ⌥+→ to move by word left or right. These keys become second nature because you use them constantly.

• If you’re in a text editor (Mail.app, Safari, TextEdit, and so on) and the text is too small to read comfortably, use ⌘-Shift-’+’ to increase the font size and ⌘-Shift-’-’ to decrease it. To zoom in on an image or small detail, hold Ctrl and drag two fingers up on the trackpad to zoom in, or two fingers down to zoom out.

• Still on text: if you select a passage in any application, you can drag it to the desktop or another folder in Finder. It’s saved as a “snippet,” like a persistent clipboard item you can drag back into another text editor or leave on the desktop until you decide what to do with it.

• All MacBooks, including older ones, have always had a two-finger multi-touch action for scrolling. Just slide two fingers, without clicking, up or down on the trackpad to scroll, for example in Safari.

• Before Lion, there was a feature to encrypt your files in real time. It was called FileVault and was bad enough to ignore. But from Lion onward, FileVault 2 arrived, completely different and this time so good it would be foolish not to use it. Open “System Preferences, Security & Privacy,” the “FileVault” tab, and enable full disk encryption. VERY IMPORTANT: it generates secure keys that allow decryption of your data. Write them down somewhere safe and never lose them. One tip: grab your iPhone or any smartphone with a camera and take a photo of the screen when it shows you the keys.

• From Lion onward there’s Mission Control, which you activate by placing four fingers on the trackpad and swiping up. It’s a replacement for the old Exposé and genuinely handy once you get used to it. When “maximized,” applications become their own parallel “Space,” and you navigate between them by swiping 3 fingers left or right. The default, though, has these Spaces rearranging automatically based on usage. I don’t like that, because I prefer my applications and desktops always in the same position (in Mission Control you can drag Spaces to wherever you like). To disable the forced rearrangement, go to “System Preferences, Mission Control” and turn off “Automatically rearrange spaces based on most recent use.”

• Also from Lion onward, the way you save files changed a lot. There’s now an “Auto Save” feature. So if an unexpected crash happens, or you have to force-shutdown the machine, or any drastic situation where you’d lose what you were editing, don’t worry, because Lion is saving automatically. There is one annoyance, though: the file sometimes gets a “Lock” that prevents you from editing it. You can unlock it manually, but it’s a hassle. I prefer to turn it off by going to “System Preferences, Time Machine,” clicking the “options” button, and disabling “Lock documents.” While you’re there, check the photo below for how to do that, and also what I keep on my Time Machine exclusion list, things I’d rather not back up either because they don’t matter (Software Images, for example) or because I prefer to back them up manually (iPhoto).

• Still on the new Lion way of handling documents and versions: in new applications you now have a “Save a version” option in the menu, so you can save moments in time in case you need to go back and recover an earlier state. Think of it as a mini Time Machine or granular backup. One option that no longer exists is “Save As,” which let you save the same file under a different name. Instead the operation is a bit more annoying: first “Duplicate” (all in the same main “File” menu) and then “Save” to store it under a different name. Get used to it; it’s annoying at first but becomes trivial.

• The Mac has plenty of unexpected surprises. In the main menu, the item with the application’s name always has a sub-item called “Services.” Try selecting a block of text in any application, then go to the “Services” menu, then “Speech,” then “Start Speaking Text,” and the Mac reads the selected text aloud. Unfortunately there’s no option in Portuguese.

• In Finder you have the “Go” menu, then “Connect to Server,” or the shortcut ⌘+K, to connect to shared folders on other Macs or on your company’s Windows file server. For a Windows server you’re used to typing something like \server\folder. On the Mac you type something like smb://server.domain/folder. If your server is Windows 2000 or later, include the full server name, including the root domain of your directory. Usually that’s all you need.

• There’s no shortcut to force-lock your computer so nobody can access it while you’re away. One way is the screen saver. First, open “System Preferences” and “Security” and enable “Require password to wake this computer from sleep or screen saver.” Now, still in “System Preferences,” choose “Desktop & Screen Saver,” then “Screen Saver.” On that screen there’s a “Hot Corners” option where you can pick a corner that starts the screensaver when you move the mouse there. That gives you a quick way to lock your computer.

• Every time you download a program from the internet, the first time you run it the Mac shows you the URL it was downloaded from and asks for confirmation. To be prompted whenever you or something tries to modify a system setting, go to “System Preferences,” “Security,” and enable “Require password to unlock each System Preferences pane.” The Mac warns you whenever something tries to escalate authority, and you enter your administrator password to confirm. For Linux users, it’s like using “sudo” in the Terminal. The Mac is quite secure: its architecture keeps trivial malware from taking over the machine the way it does on Windows, and that has nothing to do with market share, since the user has to explicitly do something foolish to get compromised. Antivirus is only useful to make sure you don’t forward someone an infected attachment you received. Your machine stays fine, but you might pass the virus along by accident.

• You’ll miss programs like Norton Utilities because you simply don’t need them. For a defragmenter, for example, Mac OS defragments automatically for you. Also understand that your filesystem is HFS+, not FAT or NTFS. One quirk is that HFS+ has Resource Forks, so when you copy Mac files to FAT USB drives you end up with what look like “duplicate” files with an underscore at the start of the name, which is the resource fork representation on filesystems that don’t support it. Also understand that every Mac “application” is actually a folder with a “.app” extension and an icon. When transporting applications, don’t copy them straight to a FAT USB drive; first put them in a DMG or just zip them (the “Archive” option in the context menu), then copy. Remember too that Unix files have permissions and FAT doesn’t preserve them.

• The equivalent of Windows Startup Items is in “System Preferences,” “Accounts,” your user, “Login Items.”

• The Mac is a BSD Unix. As such, it has a Terminal application in the Utilities folder. Use Spotlight to reach it easily. It opens a BASH shell, and from there you can manipulate files and programs easily in a POSIX environment. If you come from Linux, you’ll feel right at home.

• Speaking of Linux, one weak spot is the lack of a good package manager. On Ubuntu/Debian we have apt-get; on Redhat/Fedora/CentOS we have Yum. On the Mac there’s no standard. My recommendation is HomeBrew, a system for installing and maintaining open source projects. It’s not as powerful or robust as Aptitude on Ubuntu, but it does its job well. You’ll also come across others like MacPorts and Fink, but they’re either outdated or more hassle, so I don’t recommend them. See the next tip.

• HomeBrew is the best installer for open-source software like MySQL, PostgreSQL, Redis, Git, Android SDK, and much more. In some cases it downloads the Mac binary directly, but usually it downloads the source code, applies necessary patches, and compiles. For that you need compilers and other tools. The simplest way is to use the App Store to buy and download XCode. This tip is more for software developers; if you’re not one, you can ignore it.

• Every Mac comes with Apache 2 pre-installed. It’s hidden under the name “Web Sharing.” You’ll find it in System Preferences, “Sharing,” then “Web Sharing.” When you turn this on or off, you’re dealing with Apache 2, which by default looks at the “Sites” folder in your Users/Home directory. Another option, “Remote Login,” enables or disables OpenSSH access. “Screen Sharing,” in turn, activates a VNC server, so a VNC client on Windows can also share the screen of your Mac.

• One weakness fixed from Snow Leopard onward is the Firewall. On Leopard and earlier it ships disabled. Open System Preferences again, option “Security,” then “Firewall.” It comes set to “Allow all incoming connections.” Change it at minimum to “Allow only essential services” or, better, “Set access for specific services and applications,” which works as a whitelist. Everything is blocked by default, and only the applications you select in the box below get open ports.

• Lion is the most practical version for disaster recovery. There’s no more boot DVD. Every Mac now has a hidden partition with the installer, for when you need to reinstall, check disks, or do other things. Just boot while holding (Command-R) ⌘-R, or hold the (Option) ⌥ key during boot to get a menu with the available partitions and choose “Recovery HD.”

• Finally, to impress your friends: when you minimize a window, use Exposé, or activate the Dashboard, all these actions have animated transitions. Hold the “Shift” key at the same time and the animation plays in slow motion, showing every step of the transition at slow speed :-)

Applications

Some of the applications below are on the Mac App Store, and I always recommend checking there first. Otherwise, follow the links and download manually. At the end of this section I have a tip on keeping your applications up to date.

• If you have an iPad, you can use it as a second monitor connected to your Mac over Wi-Fi (both need to be on the same network). For this, buy Air Display.

• If you have a new Apple TV (the small black model), you can mirror the screen of your iPhone 4S, iPad 2, or later over Wi-Fi using the Air Play feature on iOS. The next version of Mac, Mountain Lion, will let you do the same from your Mac. Until then, you can still mirror your Mac to an HDTV via Apple TV by buying Air Parrot. It’s the simplest way to watch movies and videos from your Mac straight on your TV.

• I personally love reading a lot of RSS and Atom feeds in my Google Reader account, and the best Mac and iOS app for that is easily Reeder.

• With so much internet content, you download a lot but don’t always know which files are eating the most disk space. To find them (tip: most of the time it’s your video podcasts in iTunes) there are excellent paid apps like DaisyDisk, but I still like the free GrandPerspective.

• OS X handles compressed formats like zip and gz on its own. But to decompress more interesting formats like 7-zip and rar, be sure to install The Unarchiver.

• For applications, use sites like Apple’s own to see what’s most popular. To start, you’ll want Perian for more video codecs, Flip4Mac for Windows codecs, and VLC for a player that handles all the strangest codecs.

• To rip DVDs and create mp4 files, use the freeware HandBrake. To convert videos for iPod and iPhone, use iSquint. To create, edit, and convert subtitle files, use Miyu and Submerge.

• For presentations, forget Powerpoint. It’s very worth buying iWork to use the famous Keynote. The iLife and iWork suites are all on the App Store, so buy them there.

• For communication, use Adium, a client for Jabber, Messenger, Yahoo, AIM, and more, one of the best around, though it doesn’t yet support video chat for Messenger. The classic Skype is another great option. If you like IRC, one of the best clients is Colloquy.

• You want to run Windows or some Linux distro. The option that comes with the Mac is Bootcamp (in Utilities), to repartition your HD and install a second operating system. Before that, though, I recommend virtualization products like the open-source VirtualBox, or the commercial Parallels Desktop or VMWare Fusion. They’re all very good. With them you can run Windows XP or Windows 7 (I don’t recommend Vista unless you have a desktop Mac with more than 4GB of RAM), Ubuntu, Fedora, and so on. In most cases, even heavy stuff like SQL Server with Visual Studio works great. For games, no, better to dual-boot, or better yet, buy a PlayStation 3 or Xbox 360.

• The Mac is quite secure. Things like saving passwords in Safari go into an infrastructure called Keychain, an encrypted, secure storage. You can even encrypt your entire Home folder if you want. For other things, like sharing authentication data across multiple browsers or just storing notes securely, I suggest 1Password, one of the best out there.

• Macs normally don’t need uninstallers. For the vast majority of programs you just drag them to the Applications folder, so you delete them from there. They do leave behind a few artifacts, like files in the Library/Preferences directory. Normally it’s fine to leave them; they’re tiny and don’t corrupt anything like a Registry. But if you’re the paranoid type who needs to remove everything, use AppZapper, which does it for you.

• Anyone who’s watched Mac screencasts online might wonder, “How do they do that?” One of the secrets is the commercial ScreenFlow, by far one of the best, most performant, and easiest to use. Worth every cent. To record the keyboard shortcuts you’re using as a layer on top of your video, use KeyCastr. For mouse effects like focus and others, use OmniDazzle.

• The Mac needs very little maintenance, and most tools are already built into the operating system. As a visual shell to reach them more easily, use Onyx, which runs all the maintenance scripts at once. Sometimes, when your Mac starts behaving strangely, running Onyx helps a lot, though that situation is very rare.

• As a text editor there’s no getting around it: after 3 years my favorite is still TextMate. If you’re more of a Linux purist, you might prefer MacVim, especially with my Ruby snippets package :-) Beyond those, there are dozens of other editors, but none really appealed to me. A plugin that makes TextMate even nicer is MissingDrawer, which I recommend trying. If you’re a developer, follow my vimfiles repository to get your Vim pre-configured with the best of what’s available.

• For downloaders, Mozilla Firefox has various extensions, or if you’re a solid Linux user you’ll know how to use good old curl. But if you want something more visual, an excellent commercial alternative is Speed Download, which has options for parallel downloads, resuming interrupted downloads, and so on. Still on downloads, if you’re into BitTorrent, one of the best clients is Transmission.

• For burning DVDs, the Mac handles it reasonably well on its own. But if you want more control and detail, one of the most traditional and best commercial options is Toast by Roxio, the equivalent of Nero on Windows. For something simpler there’s Disco, one of the most visually beautiful, with a feature that keeps a database of DVDs you’ve burned to make searches easier. And a decent freeware is Burn.

• Even though Time Machine already does an excellent job of backup, SuperDuper! remains an excellent alternative. It makes a bit-for-bit image of your system, supports delta updates, and lets you create bootable external hard drives. It’s a good thing to do before anything drastic, like installing a new version of Mac OS. It’s the equivalent of Norton Ghost on Windows.

• If you’re a developer using Git with Gitk, you can install Git via HomeBrew (with HomeBrew installed, just open a Terminal and use “brew install git”) and then use Gitx instead of the ugly Gitk. It uses Cocoa components, so it has the look and feel of a native Mac app.

• If you have an iPod, know that it can play Audiobooks. Unlike mp3 and aac, the standard audiobook format is m4b, or mpeg-4 with bookmark support. That’s very important because mp3 has no bookmarks, and when a book is 20 hours long it’s painful if your iPod loses your place, or worse, if you want to navigate between chapters of a 40-hour book. If you have audiobooks in mp3, use Audiobook Builder, which compiles all the mp3s into a single m4b that your iTunes syncs to your iPod.

• You were a Windows developer with dozens of e-books in Microsoft’s CHM (compiled HTML) format. Fortunately, on the Mac you have the open-source reader Chmox.

• Say you have two computers, or some external hard drives, and you need to keep some folders in sync. Again, if you’re a solid Linux user, you can comfortably use “rsync” from the command line. But if you want a visual shell for rsync, a great option is ChronoSync, which allows bi-directional synchronization and much more. It’s how I keep two 500GB external hard drives synced through my Mac Mini, a poor man’s RAID 1 :-)

• A well-known subsystem is Growl, a notification infrastructure. For example, when an application like Transmission finishes a download, it sends a message to Growl, which pops up on your desktop to notify you. Adium also uses it to show who came online, and so on. Growl ships with plugins for iTunes and Mail.app, plus a command-line tool to integrate with other applications.

• Mail.app is organized with a list of emails on top and a view of the selected email below. Some prefer vertical bars instead of horizontal, more like Outlook. In that case use the LetterBox plugin for Mail.app.

• A famous but more advanced application is the legendary QuickSilver, which some see only as a fast way to find applications, but which is really a sophisticated environment for chaining functionality. You can, for example, find and select several files, attach them to an email, and send it to an address in your Address Book. It has dozens of plugins and themes for customization. It’s interesting at first, and there are various clones with the same idea, but in the end you’ll notice you mostly use it just to find applications. And for that, the simplest thing is Command ⌘ + Space to activate Spotlight (the magnifying glass in the upper-right corner) and type the application’s name. Same for finding documents. I find it more practical and faster.

• Those coming from Windows might still need to reach their old machine, or at the office deal with Windows programs. Fortunately, Windows has RDP (Remote Desktop Protocol) for remote access. On the Mac the best option is CoRD, the equivalent of a Terminal Client.

• A very useful utility for monitoring your CPU, RAM, disk, and network usage is iStat Pro, which has a widget version for the Dashboard, or iStat Menu for the top menu bar. I personally prefer the second, but both are very good.

• A well-known benchmarker in the Mac world is XBench, which tests your Mac and lets you compare results on their website against other Macs.

• The last tip is to create an account on MacUpdate and then download the MacUpdate Desktop software. Open it occasionally and it tells you everything that’s outdated on your machine, letting you pick what to update:

History

To understand Mac OS X, you need to understand its history. For that, the best set of articles are the ones ArsTechnica has written since 2000:

• Mac OS X DP2: A Preview

• Mac OS X Update: Quartz & Aqua

• Mac OS X DP3: Trial by Water

• Mac OS X DP4

• Mac OS X Q & A

• Mac OS X Public Beta

• MWSF: Mac OS X Post-Beta

• Mac OS X 10.0 Cheetah

• Mac OS X 10.1 Puma

• Mac OS X 10.2 Jaguar

• Mac OS X 10.3 Panther

• Mac OS X 10.4 Tiger

• Mac OS X 10.5 Leopard: the Ars Technica review

• Mac OS X 10.6 Snow Leopard: the Ars Technica review

• Mac OS X 10.6 Lion: the Ars Technica review

Also understand that Mac OS X is completely different from its predecessor, the Mac OS, which ended its life at version 9. When Steve Jobs was forced out of Apple in 1985, he founded the company Next and built the NextStep operating system, a 32-bit, multitasking OS with a Mach-based kernel. Watch Steve Jobs himself demonstrating NextStep version 3. NextStep was later opened as a standard together with Sun as OpenStep. The WindowMaker window manager is inspired by OpenStep and supports its open-source implementation, GNUStep. Later, in 1997, Apple reacquired Next, and NextStep became the foundation for Mac OS X. Its development framework was renamed Cocoa, which is why the development APIs have names like NSString and NSWindow, where “NS” stands for “NextStep.”